metodo de recursividad

[piyor6]

buenaas tardes a todos amigos hoy vengo con una duda que tengo en un ejercicio que me pusieron en la universidad y trata de hacer una figura gemotrica con asteriscos(*) un rombo para ser mas exacto y hasta donde yo se una funcion recursiva es una funcion que se llama a si misma, ya hice un ejercicio de sacar la serie fibonacci con recursividad y lo hice pero este no lo entiendo y no he sido capaz.
yo hice un codigo que hace lo que necesito pero sin recurisividad para que ustedes vean que es exactamente que es lo que necesito con gusto pueden copilar el codigo que funciona a la perfecion

Código (cpp) [Seleccionar] Expandir


#include <stdlib.h>
#include <stdio.h>

int main(){
    int n,i,j;
printf("FIGURA GEOMETRICA\n");
printf("ingrese el la altura: ");
scanf("%d",&n);
for(i=1;n-1>=i;i++){
for(j=n;j>=i;j--){

    printf(" ");
}
for(int k=1;2*i-1>=k;k++){

  printf("*");
}
printf("\n");
}
for(i=1;n>=i;i++){
    for(j=1;j<=i;j++){
        printf(" ");
    }
for(int k=2*n-1;2*i-1<=k;k--){

  printf("*");
}
printf("\n");
}




    return 0;
}




necesito exactamente eso pero en recursividad muchas gracias espero respondan rapido 

[MAFUS]

Para que te funcione de forma recursiva se debe guardar el estado de unas cuantas cosas, podrías pasarlas por los argumentos pero eso implicaría complicar la firma de tu función de forma innecesaria, ya que C dispone de herramientas para eso: las variables estáticas.

Esta podría ser una solución elegante

Código (c) [Seleccionar] Expandir

#include <stdio.h>

void rombo(unsigned altura) {
    static unsigned h; // Height, altura
    static unsigned w; // Width, ancho
    static unsigned i; // Iteration, el escalon actual

    if(altura) {
        if(altura%2 == 0) // Para que quede bien cuadrado
            ++altura;     // altura debe ser impar
        h = altura;
        w = 1;
        i = 0;
    }

    if(i<h) { // Mientras el reglón no ha llegado a la altura del rombo
        int j;
        for(j=0; j<=h/2-w/2; ++j) // Calculo los espacios por escalon
            putchar(' ');         //    y los imprimo
        for(j=0; j<w; ++j) // Imprimo
            putchar('*');  //    los asteriscos
        putchar('\n'); // Al siguiente reglón
        if(i<h/2) w += 2; // Calculo los asteriscos que
        else w -= 2;      //    habrá en el siguiente reglon
        ++i; // Voy al siguiente reglón
        rombo(0); // Llamo de nuevo a rombo indicando que siga con los datos que hay (0)
    }
}

int main() {
    rombo(6);
}

[dijsktra]

Esta podría ser una solución elegante

Código (c) [Seleccionar] Expandir

#include <stdio.h>

void rombo(unsigned altura) {
...
    if(i<h) { // Mientras el reglón no ha llegado a la altura del rombo
        int j;
        for(j=0; j<=h/2-w/2; ++j) // Calculo los espacios por escalon
            putchar(' ');         //    y los imprimo
        for(j=0; j<w; ++j) // Imprimo
            putchar('*');  //    los asteriscos
        putchar('\n'); // Al siguiente reglón
...}

int main() {
    rombo(6);
}

hmmm... por lo general, si se meten bucles, se pierde la recursividad (caso base, caso recursivo, funcion de avance...

Mi propuesta

Código [Seleccionar] Expandir


height: 0
*
height: 2
*
***
*
height: 4
  * 
***
*****
***
  * 
height: 6
   *   
  *** 
*****
*******
*****
  *** 
   *   
height: 8
    *   
   ***   
  ***** 
*******
*********
*******
  ***** 
   ***   
    *   
height: 10
     *     
    ***   
   *****   
  ******* 
*********
***********
*********
  ******* 
   *****   
    ***   
     *     
height: 12
      *     
     ***     
    *****   
   *******   
  ********* 
***********
*************
***********
  ********* 
   *******   
    *****   
     ***     
      *     
height: 14
       *       
      ***     
     *****     
    *******   
   *********   
  *********** 
*************
***************
*************
  *********** 
   *********   
    *******   
     *****     
      ***     
       *       
height: 16
        *       
       ***       
      *****     
     *******     
    *********   
   ***********   
  ************* 
***************
*****************
***************
  ************* 
   ***********   
    *********   
     *******     
      *****     
       ***       
        *       
height: 18
         *         
        ***       
       *****       
      *******     
     *********     
    ***********   
   *************   
  *************** 
*****************
*******************
*****************
  *************** 
   *************   
    ***********   
     *********     
      *******     
       *****       
        ***       
         *         
height: 20
          *         
         ***         
        *****       
       *******       
      *********     
     ***********     
    *************   
   ***************   
  ***************** 
*******************
*********************
*******************
  ***************** 
   ***************   
    *************   
     ***********     
      *********     
       *******       
        *****       
         ***         
          *         
height: 22
           *           
          ***         
         *****         
        *******       
       *********       
      ***********     
     *************     
    ***************   
   *****************   
  ******************* 
*********************
***********************
*********************
  ******************* 
   *****************   
    ***************   
     *************     
      ***********     
       *********       
        *******       
         *****         
          ***         
           *           
height: 24
            *           
           ***           
          *****         
         *******         
        *********       
       ***********       
      *************     
     ***************     
    *****************   
   *******************   
  ********************* 
***********************
*************************
***********************
  ********************* 
   *******************   
    *****************   
     ***************     
      *************     
       ***********       
        *********       
         *******         
          *****         
           ***           
            *         




Código (c) [Seleccionar] Expandir


#include <stdio.h>

void printLineR(const int N, const int n,const int start)
{
  if (start==N+1) return;
  else
    {
      const int nn = n<=(N/2)?n:N-n;
      if (start < (N/2) - nn ) printf(" ");
      if ((((N/2) - nn)<=start) && (start <= (N/2 + nn))) printf("*");
      if ((start > (N/2 + nn))) printf(" ");
      printLineR(N,n<=(N/2)?n:N-n,start+1);
    }
}

void printLine(const int N,const int n)
{
  printLineR(N,n,0);
  printf("\n");
}


void diamondR(const int N, const int n)
{
  if (n == N+1)  return;
  else
    {
      printLine(N,n);
      diamondR(N,n+1);
    }

}
/* 0 <= N */
void diamond(const int N)
{
  diamondR(N,0);
}

int main()
{
  int N=25;
  for (int n=0; n<N ; n+=2 )
    {
      printf("height: %d\n",n);
      diamond(n);
    }
}