[C] Rombo con asteriscos

[leosansan]

Bueno ..... creo que ya hemos dado una tremenda cantidad de opciones al autor del post sobre cómo resolver su problema.

Lástima que él no haya seguido escribiendo, y al final terminamos agarrándonos el tema para nosotros, jeje  

Me quedó un mal regusto al tener que usar un array en la última versión, así que ahí va una sin un array de caracteres:

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>

int main(){
 int i=0, j, a;
 do{
   printf("\nBase del rombo(numero impar positivo): \n");
   scanf("%d", &a);
   }while ( a <=0 || (a % 2) == 0);
   for ( i=2*(a/2);i>=0;i-=2){
     printf("%*c",i/2+a/2,'*');
     for ( j=0;j<=2*(a/2)-1-i;j++)
       putchar('*');
     putchar ('\n');
   }
   for ( i=1;i<2*(a/2);i+=2){
     printf("%*c",i/2+a/2+1,'*');
     for ( j=0;j<=2*(a/2)-2-i;j++)
       putchar('*');
     putchar ('\n');
   }
   return 0;
}

¡¡¡¡ Saluditos! ..... !!!!

[do-while]

¡Buenas!

Como aun no había ninguna solución recursiva, aquí os dejo una 

Código (c) [Seleccionar] Expandir


#include <stdio.h>
#include <stdio.h>
#include <string.h>

/* n == numero total de filas del rombo (no puede ser par) y el segundo parametro siempre es cero:
   ejemplos: rombo(3,0);
             rombo(11,0);
*/
void rombo(int n,int paso)
{
    char *str = malloc(n / 2 + paso + 4);

    if(!(n & 1))
        return;

    memset(str,' ',n / 2 - paso + 1);
    memset(str + n / 2 - paso + 1 , '*' , 2 * paso + 1);
    memcpy(str + n / 2 + paso + 2 ,"\n\0",2);

    printf("%s",str);

    if(paso == n / 2)
    {
        free(str);
        return;
    }

    rombo(n,paso+1);

    printf("%s",str);

    free(str);
}

int main(int argc, char *argv[])
{
    rombo(5,0);
    rombo(4,0);
    return 0;
}


[rir3760]

Otra solución recursiva pero forzada (ya que parte de la información se codifica en la cadena a imprimir) es:

Código (c) [Seleccionar] Expandir

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

void f(char *ch);

int main(void)
{
   char ch[] = "    *\0*******";
   
   f(ch);
   
   return EXIT_SUCCESS;
}

void f(char *ch)
{
   int i = printf("%s\n", ch) - 1;
   
   if (*ch == ' '){
      ch[i] = '*';
      ch[i + 2] = '\0';
      f(ch + 1);
     
      printf("%.*s\n", i, ch);
   }
}

Un saludo

[eferion]

Venga va, yo también aporto un código con recursividad.

Código (c) [Seleccionar] Expandir


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

void paso( int max_filas, int fila, int col );

int main()
{
 paso( 11, 0, 0 );
 return EXIT_SUCCESS;
}

void paso( int max_filas, int fila, int col )
{
 const char* chars = " *";
 if( fila < max_filas )
 {
   int num_sp = abs( max_filas/2 - fila);
   int end = max_filas - num_sp;
   if ( col == end )
   {
     printf( "\n" );
     col = -1;
     fila++;
   }
   else
     printf( "%c", chars[ col >= num_sp ] );

   paso( max_filas, fila, ++col );
 }
}

[leosansan]

Sin arrays, sólo printf y un par de for menos que antes:

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>

int main(){
 int i=0,j,k,a;
 do{
   printf("\nBase del rombo(numero impar positivo): \n");
   scanf("%d",&a);
   }while ( a <=0 || (a % 2) == 0);
   for ( i=-2*(a/2);i<=2*(a/2);i+=2){
     k=i;
     if (i>0)
       k=-i;
     printf("%*c",-k/2+a/2,'*');
     for ( j=0;j<=2*(a/2)-1+k;j++)
       putchar('*');
     putchar ('\n');
   }
   return 0;
}

Y por qué no dibujar el rombo "vacio":

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>

int main(){
 int i=0,j,k,a;
 do{
   printf("\nBase del rombo(numero impar positivo): \n");
   scanf("%d",&a);
   }while ( a <=0 || (a % 2) == 0);
   for ( i=-2*(a/2);i<=2*(a/2);i+=2){
     k=i;
     if (i>0)
       k=-i;
     if (k==-2*(a/2) || k==2*(a/2))
       printf("%*c",-k/2+a/2,'*');
     else
       printf("%*c%*c",-k/2+a/2,'*',2*(a/2)+k,'*');
     putchar ('\n');
   }
   return 0;
}

Y para que no falte, uno con recursividad:

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>

int rellenar (int A,int a);
int main(){
 int a;
 do{
   printf("\nBase del rombo(numero impar positivo): \n");
   scanf("%d",&a);
   }while ( a <=0 || (a % 2) == 0);
   rellenar (-2*(a/2),a);
   return 0;
}

int rellenar (int A,int a){
 int j,k;
 if (A==2*(a/2)+2)
   return 1;
 k=A;
 if (A>0)
   k=-A;
 printf("%*c",-k/2+a/2,'*');
 for ( j=0;j<=2*(a/2)-1+k;j++)
   putchar('*');
 putchar ('\n');
 rellenar (A+2,a);
}

¡¡¡¡ Saluditos! ..... !!!!

[dmacias]

Vaya, si que os entreteneis con esto jajajajaja.
He estado liado, de trabajo asta las cejas asi que llevo unos dias parado con los estudios, pero en unos dias me pongo a ello de nuevo.

De todo lo que habeis puesto, de la mayoria hay cosas que no entiendo, soy muy nuevo y solo llevo 4 temas del libro vistos, pero de todos modos les hechare un vistazo.

Gracias a todos por ponerme tantos ejemplos, asi tengo donde elegir y comparar las logicas de cada uno.

Un saludo

[leosansan]

Vaya, si que os entreteneis con esto jajajajaja.
...............................................................

Gracias a todos por ponerme tantos ejemplos, asi tengo donde elegir y comparar las lógicas de cada uno.

Un saludo

Pues si que ha sido entretenido.

Y aunque do-while me lo piso, no me resisto a poner el caso con memset. Es ligeramente diferente al suyo ya que no uso recurrencia y es ligeramente más cortito:

Código (cpp) [Seleccionar] Expandir


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

int main(void){
  int i,j,a;
  do{
    printf("\nBase del rombo(numero impar positivo): \n");
    scanf("%d",&a);
    }while ( a <=0 || (a % 2) == 0);
  char *str = malloc(2*a+1);
  for (i = -a/2; i <= a/2; i++){
    j=i;
  if (i>0)
    j=-i;
    memset (str,' ',(a/2)-j);/** relleno izquierda con espacios **/
    memset (str+(a/2)-j, '*',2*((a/2)+j)+1); /** relleno derecha con asteriscos **/
    printf ("%s\n",str);
    memset (str,0,2*a+1);/** hago nula la cadena para volver a usarla **/
  }
  free(str);
  return EXIT_SUCCESS;
}

¡¡¡¡ Saluditos! ..... !!!!

[do-while]

Otra forma mas. Esta considerando la pantalla una matriz de 20X80 caracteres y dibujando así sobre la matriz el rombo.

Código (c) [Seleccionar] Expandir



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

#define MAX_FILAS 20
#define MAX_COLUMNAS 80

void dibujar_borde(char pantalla[][MAX_COLUMNAS],int n_filas)
{
   int i;

   for(i = 0 ; i < n_filas ; i++)
       pantalla[i][abs(n_filas / 2 - i)] = pantalla[i][n_filas - abs(n_filas / 2 - i) - 1] = '*';
}

void rellenar(char pantalla[][MAX_COLUMNAS], int fila, int columna)
{
   if(pantalla[fila][columna] == '*' || fila < 0 || fila >= MAX_FILAS || columna < 0 || columna >= MAX_COLUMNAS)
       return;

   pantalla[fila][columna] = '*';

   rellenar(pantalla, fila - 1, columna);
   rellenar(pantalla, fila + 1, columna);
   rellenar(pantalla, fila, columna - 1);
   rellenar(pantalla, fila, columna + 1);
}

void imprimir(char pantalla[][MAX_COLUMNAS])
{
   int i;

   for(i = 0 ; i < MAX_FILAS ; i++)
       printf("%.*s\n",MAX_COLUMNAS - 1 , pantalla[i]);
}

void rombo_2(int n_filas)
{
   char pantalla[MAX_FILAS][MAX_COLUMNAS];
   int i;

   if(!(n_filas & 1))
       return;

   for(i = 0 ; i < MAX_FILAS ; i++)
       memset(pantalla[i],' ',MAX_COLUMNAS);

   dibujar_borde(pantalla,n_filas);
   rellenar(pantalla , n_filas / 2 , n_filas / 2);
   imprimir(pantalla);
}

int main(int argc, char *argv[])
{
   rombo_2(11);

   return 0;
}


No es tan corta como las otras pero bueno, primero dibuja el perimetro y luego rellena el interior. Si rellenais el exterior tendreis el dibujo en "negativo".

¡Saludos!

Y ahora complicandolo un poco mas:

Código (c) [Seleccionar] Expandir


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

#define MAX_FILAS 20
#define MAX_COLUMNAS 80

int correcto(int fila,int columna)
{
   return fila >= 0 && fila < MAX_FILAS && columna >=0 && columna < MAX_COLUMNAS;
}

void dibujar_borde(char pantalla[][MAX_COLUMNAS],int n_filas , int fila_centro, int columna_centro)
{
   int i;

   for(i = 0 ; i < n_filas ; i++)
   {
       if(correcto(fila_centro - n_filas / 2 + i , columna_centro - n_filas / 2 + abs(n_filas / 2 - i)))
           pantalla[fila_centro - n_filas / 2 + i][columna_centro - n_filas / 2 + abs(n_filas / 2 - i)] = '*';

       if(correcto(fila_centro - n_filas / 2 + i , columna_centro + n_filas / 2 - abs(n_filas / 2 - i)))
           pantalla[fila_centro - n_filas / 2 + i][columna_centro + n_filas / 2 - abs(n_filas / 2 - i)] = '*';
   }
}

void rellenar(char pantalla[][MAX_COLUMNAS], int fila, int columna)
{
   if(pantalla[fila][columna] == '*' || fila < 0 || fila >= MAX_FILAS || columna < 0 || columna > MAX_COLUMNAS)
       return;

   pantalla[fila][columna] = '*';

   rellenar(pantalla, fila - 1, columna);
   rellenar(pantalla, fila + 1, columna);
   rellenar(pantalla, fila, columna - 1);
   rellenar(pantalla, fila, columna + 1);
}

void imprimir(char pantalla[][MAX_COLUMNAS])
{
   int i;

   for(i = 0 ; i < MAX_FILAS ; i++)
       printf("%.*s\n",MAX_COLUMNAS - 1 , pantalla[i]);
}

void rombo_3(char pantalla[][MAX_COLUMNAS], int n_filas, int fila_centro, int columna_centro)
{
   int i;

   if(!(n_filas & 1))
       return;

   dibujar_borde(pantalla , n_filas, fila_centro , columna_centro);
   rellenar(pantalla , fila_centro, columna_centro);
}

int main(int argc, char *argv[])
{
   char pantalla[MAX_FILAS][MAX_COLUMNAS];
   int i;
   char cad[] = "QUEDA BONITO";

   for(i = 0 ; i < MAX_FILAS ; i++)
       memset(pantalla[i],' ',MAX_COLUMNAS);

   rombo_3(pantalla, 11 , 10, 11/2);
   rombo_3(pantalla, 17 , 10 , 11 + 17/2);
   rombo_3(pantalla, 19 , 10 , 28 + 19 / 2);

   for(i = 0 ; cad[i] ; i++)
       pantalla[5 + i][50] = cad[i];

   imprimir(pantalla);
}


¡Saludos!

Y en esta tercera versión, podéis jugar con los caracteres que forman el borde y los rellenos.

Código (c) [Seleccionar] Expandir




int correcto(int fila,int columna)
{
    return fila >= 0 && fila < MAX_FILAS && columna >=0 && columna < MAX_COLUMNAS;
}

void dibujar_borde(char pantalla[][MAX_COLUMNAS],int n_filas , int fila_centro, int columna_centro,char ch)
{
    int i;

    for(i = 0 ; i < n_filas ; i++)
    {
        if(correcto(fila_centro - n_filas / 2 + i , columna_centro - n_filas / 2 + abs(n_filas / 2 - i)))
            pantalla[fila_centro - n_filas / 2 + i][columna_centro - n_filas / 2 + abs(n_filas / 2 - i)] = ch;

        if(correcto(fila_centro - n_filas / 2 + i , columna_centro + n_filas / 2 - abs(n_filas / 2 - i)))
            pantalla[fila_centro - n_filas / 2 + i][columna_centro + n_filas / 2 - abs(n_filas / 2 - i)] = ch;
    }
}

void rellenar(char pantalla[][MAX_COLUMNAS], int fila, int columna, char relleno)
{
    char actual;

    if(!correcto(fila,columna))
        return;

    actual = pantalla[fila][columna];

    if(relleno == actual)
        return;

    pantalla[fila][columna] = relleno;

    if(correcto(fila - 1,columna) && actual == pantalla[fila - 1][columna])
        rellenar(pantalla, fila - 1, columna,relleno);

    if(correcto(fila + 1,columna) && actual == pantalla[fila + 1][columna])
        rellenar(pantalla, fila + 1, columna,relleno);

    if(correcto(fila,columna + 1) && actual == pantalla[fila][columna + 1])
        rellenar(pantalla, fila, columna + 1,relleno);

    if(correcto(fila,columna - 1) && actual == pantalla[fila][columna - 1])
        rellenar(pantalla, fila, columna - 1,relleno);

    pantalla[fila][columna] = relleno;
}

void imprimir(char pantalla[][MAX_COLUMNAS])
{
    int i;

    for(i = 0 ; i < MAX_FILAS ; i++)
        printf("%.*s\n",MAX_COLUMNAS - 1 , pantalla[i]);
}

int main(int argc, char *argv[])
{
    char pantalla[MAX_FILAS][MAX_COLUMNAS];
    int i;
    char cad[] = "QUEDA BONITO",interior = '*', exterior = ' ';

    for(i = 0 ; i < MAX_FILAS ; i++)
        memset(pantalla[i],' ',MAX_COLUMNAS);

    dibujar_borde(pantalla, 11 , 10, 11/2 , interior);
    rellenar(pantalla,10,11/2,interior);

    dibujar_borde(pantalla, 17 , 10, 10 + 17/2, interior);
    rellenar(pantalla, 10 , 10 + 17 / 2, interior);

    dibujar_borde(pantalla, 11 , 10, 26 + 11 / 2, interior);
    rellenar(pantalla, 10 , 26 + 11 / 2 , interior);

    rellenar(pantalla,0,0,exterior);

    for(i = 0 ; cad[i] ; i++)
        pantalla[5 + i][50] = cad[i];

    imprimir(pantalla);

    return 0;
}


¡Saludos de nuevo!

[leosansan]

Vamos, con matrices.

Ahí va una con el borde:

Código (cpp) [Seleccionar] Expandir


/** BORDES **/
#include <stdio.h>

int main(){
  int i=0,j,k=1,a=21;

  /*do{
    printf("\nBase del rombo(numero impar positivo): \n");
    scanf("%d",&a);
    }while ( a <=0 || (a % 2) == 0);*/
    char A[a+4][a+4],cad[]="L E O S A N S A N";
    for ( i=0;i<=a+4;i++)
      for ( j=0;j<=a+4;j++)
        A[i][j]='0';
    A[0][a/2]='*';
    i=1;
    while (i<=a/2){
      A[i][(a/2)-i]=A[i][i+(a/2)]='*';
      i++;
    }
    k=i;
    while (i>=(a/2)+1 && i<=a){
      k--;
      A[i][(a/2)+1-k]=A[i][(a/2)+k-1]='*';
      i++;
    }
    if (a>20){
      for ( i=(a/2)-8,k=0;i<(a/2)+10;i++,k++)
        A[i][22]=cad[k];
    }

    putchar ('\n');
    for ( i=0;i<a;i++){
      printf("\t\t");
      for ( j=0;j<a+2;j++){
         if (A[i][j]=='0' )
            printf("%c",' ');
          else
            printf("%c",A[i][j]);
      }
      putchar ('\n');
    }
    return 0;
}

Y por qué no en positivo y negativo:

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>

int main(){
  int i=0,j,k=1,a=21;
  /*do{
    printf("\nBase del rombo(numero impar positivo): \n");
    scanf("%d",&a);
    }while ( a <=0 || (a % 2) == 0);*/
    char A[a+1][a+1];
    for ( i=0;i<=a;i++)
      for ( j=0;j<=a;j++)
        A[i][j]='0';
    A[0][a/2]='*';
    i=1;
    while (i<=a/2){
      for ( j=(a/2)-i;j<=i+(a/2);j++){
        A[i][j]='*';
      }
      i++;
    }
    k=i;
    while (i>=(a/2) && i<=a){
      --k;
      for ( j=(a/2)+1-k;j<(a/2)+k;j++)
        A[i][j]='*';
      i++;
    }
    /** EN POSITIVO **/
    for ( i=0;i<=a;i++){
      printf("\t\t");
      for ( j=0;j<a;j++){
         if (A[i][j]=='0')
            printf("%c",' ');
          else
            printf("%c",A[i][j]);
      }
      putchar ('\n');
    }
    putchar ('\n');
    /** EN NEGATIVO **/
    for ( i=0;i<=a;i++){
      printf("\t\t");
      for ( j=0;j<a;j++){
         if (A[i][j]=='0')
            printf("%c",'*');
          else
            printf("%c",' ');
      }
      putchar ('\n');
    }
    return 0;
}

He preferido hacer dos códigos en lugar de uno con funciones para los posibles seguidores de este tema .... y paso de traslaciones, empiezo a estar saturado de tanto rombo. ¿Alguien se anima a empezar un nuevo tema con el triángulo de Pascal o Tartaglia?

¡¡¡¡ Saluditos! ..... !!!!

[Yoel Alejandro]

Ok, el triángulo de Pascal, pero exactamente qué se te ocurre hacer?? Acepto el reto, jeje (claro, en un nuevo post) ...