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
#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
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
#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
for(j=0; j<w; ++j) // Imprimo
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);
}
Esta podría ser una solución elegante
#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
for(j=0; j<w; ++j) // Imprimo
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
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
*
***
*****
*******
*********
***********
*************
***************
*****************
*******************
*********************
***********************
*************************
***********************
*********************
*******************
*****************
***************
*************
***********
*********
*******
*****
***
*
#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);
}
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 )
{
diamond(n);
}
}