Test Foro de elhacker.net SMF 2.1

Buenas de nuevo, aqui os vengo otra vez con una duda, Esta vez he solucionado el problema que tengo pero de una manera poco ortodoxa ya que la segunda parte del problema la he ido rellenando por prueba y error.

Asi que no me quedo conforme con ello y os pido ayuda haber que es lo que se me escapa.

El problema es facil, imprimir un rombo tal como este


     *
    ***
   *****
  *******
*********
  *******
   *****
    ***
     *


Aqui sale torcido, pero ya os haceis una idea xD.

Aqui el codigo que tengo, que funcionar funciona


#include <stdio.h>

int main()
{
int a, n, n1;
int contador = 1;

for (a = 5; a >= 1; a--){
for (n = 0; n <= a; n++){
printf(" ");
}
for (n1 = 1; n1 <= contador; n1++){
printf("*");
}
printf("\n");                          /*Triangulo superior*/
contador += 2;           /*Asta aqui dominado mas o menos :) */
}
for (a = 4; a >= 1; a--){      /*De aqui en adelante a sido una loteria :( */
for (n = 6; n >= a; n--){        /*Triangulo inferior*/
printf(" ");
}
for (n1 = 2; n1 <= contador-3; n1 ++){
printf("*");
}
printf("\n");
contador -= 2;
}
return 0;

}



Pero como os digo he tenido que ir rellenando esta linea
for (n1 = 2; n1 <= contador-3; n1 ++){

y esta otra

contador -= 2;

haciendo prueba y error asta ajustarlo, un metodo un poco guarro creo, ya que realmente no lo he dominado.

Bueno, pues eso, si alguien me orienta en donde pierdo el control, se lo agradeceria.

Un saludo

Sin más comentarios que los que te pongo en el código:


#include<stdio.h>
int main()
{
  int n,i,j;
  printf("\nTama\xA4o de la mitad superior: \n");
  scanf ("%d",&n);
  printf("\n\n");
  for(i=1;i<=n;i++){  /** fijate que aqui i aumenta **/
    printf("\t\t");
    for(j=1;j<=n-i;j++)/** cada vez un espacio menos **/
        printf(" ");
    for(j=1;j<=2*i-1;j++)/** cada vez dos "*" mas **/
      printf("*");     /** despues de los espacios **/
  printf("\n");
  }

  for(i=n-1;i>=1;i--){  /** fijate que aqui i disminuye **/
    printf("\t\t");
    for(j=1;j<=n-i;j++)/** cada vez un espacio mas **/
      printf(" ");
    for(j=1;j<=2*i-1;j++)/** cada vez dos "*" menos **/
      printf("*");     /** despues de los espacios **/
  printf("\n");
  }
  return 0;
}


Para imprimir las secuencias de espacios y asteriscos se puede desarrollar una función, por ejemplo:
#include <stdio.h>
#include <stdlib.h>

#define LADO  5

void repetir(int reps, char ch);

int main(void)
{
  int i;
 
  for (i = 1; i < LADO * 2; i += 2){ /* 1, 3, 5, 7, 9 */
     repetir((LADO - 1) - i/2, ' ');
     repetir(i, '*');
     putchar('\n');
  }
 
  for (i -= 4; i > 0; i -= 2){ /* 7, 5, 3, 1 */
     repetir((LADO - 1) - i/2, ' ');
     repetir(i, '*');
     putchar('\n');
  }
 
  return EXIT_SUCCESS;
}

void repetir(int reps, char ch)
{
  int i;
 
  for (i = 0; i < reps; i++)
     putchar(ch);
}

Otra forma de imprimir ese rombo en particular es:

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

int main(void)
{
  char ch[] = "*********";
  int i;
 
  for (i = -4; i < 5; i++)
     printf("%*c%.*s\n", 1 + abs(i), ' ', 1 + (4 - abs(i)) * 2, ch);
 
  return EXIT_SUCCESS;
}

La primera es clara y flexible, la segunda es breve y esta bien para practicar con la biblioteca estándar de C pero es muy limitada (eso es evidente si se trata de modificar para el manejo de casos generales).

----

Editado: una forma ligeramente mas corta donde se evita imprimir si o si un espacio:
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
   char ch[] = "*********";
   int i;
   
   for (i = -4; i < 5; i++)
      printf("%*.*s\n", 9 - abs(i), 1 + (4 - abs(i)) * 2, ch);
   
   return EXIT_SUCCESS;
}

Un saludo

Siguiendo los pasos del "maestro==rir3760" por usar funciones que no quede:


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

int main()
{
 int i,n;
 printf("\n\n");
 printf("\nTama\xA4o de la mitad superior: \n");
 scanf ("%d",&n);

 for(i=1;i<=n;i++)
   repetir (n-i,' ',2*i-1,'*');
 for(i=n-1;i>=1;i--)
   repetir (n-i,' ',2*i-1,'*');
 return EXIT_SUCCESS;
}

void repetir(int reps, char ch,int reps1, char ch1)
{
 int j,k;
 printf("\t\t");
 for (j = 1; j <=reps; j++)
   putchar(ch);
 for (k = 1; k <=reps1; k++)
   putchar(ch1);
 putchar('\n');
}


Ante el "otro" código, el del printf, tan solo mirar boquiabierto y, como siempre, aprender de sus aportaciones, todo un lujo para el foro.

Cita de: rir3760 en  2 Marzo 2014, 18:59 PM
la segunda es breve y esta bien para practicar con la biblioteca estándar de C pero es muy limitada (eso es evidente si se trata de modificar para el manejo de casos generales).

Solo breve?  :o  :rolleyes:

Gracias a todos por responder, aun no llegue al tema de las funciones, pero en un par de dias llego.

Veo que me hago aún un lio con estas cosas, espero que con la practica vaya mejorando.

Con lo que me habeis puesto ya tengo trabajo donde comparar y aprender.

rir3760 si  que lo hicistes escueto, casi fugaz diria yo xD


Un saludo

Buenos días, lamento llegar un poco tarde, tampoco ser entrometido (como me acusaron en otro post  >:()

Inspirándome un poco en el enfoque de rir7360 que "centró" el rombo, es decir tomó los índices de -N a N, en lugar de 0 a 2*N, quiero aportar una función que dibuja un rombo general con cualquier número de líneas (impar positivo) dado.

El main() pide al usuario la cantidad de líneas del rombo, pero esto esta interfaz se puede modificar. Lo importante es el código de la función rombo() que gracias al enfoque de "centrar" los valores no requiere dividir entre la parte de arriba y la parte de abajo, ni entre derecha e izquierda, jeje.

Resultado, con 9 líneas:

    *   
   ***   
  ***** 
*******
*********
*******
  ***** 
   ***   
    *   


Básicamente lo que hacemos es calcular el "punto medio" p de N (redondeo por exceso de N/2), para el caso N=9 sería p=5. Luego recorremos tanto i como j desde -p+1 hasta p-1, o sea, desde -4 hasta 4. El asterisco se imprime si abs(j) < p - abs(i), y esto dibuja el rombo de manera correcta, tanto en su parte superior como la inferior. El código:


#include <stdio.h>
#include <stdlib.h>
 
void rombo (int N);
 
int main(void) {

int N;

printf("Ancho del rombo: ");
scanf("%d", &N);

/* limpia la entrada estandar por caracteres no leidos */
while ( getchar() != '\n' )
;

/* comprueba N impar y positivo */
if ( N > 0 && (N % 2) == 1)
rombo( N );
else
printf("N debe ser impar positivo\n");

return 0;
}

/* Imprime un rombo de N lineas */
void rombo (int N) {

int i, j, p;

p = (int) N / 2 + 1; /* punto medio ente 1 y N */
for (i = -p + 1; i <= p - 1; i++) {
for (j = -p + 1; j <= p - 1; j++)
if ( abs(j) < p - abs(i) )
putchar('*');
else
putchar(' ');
putchar('\n');
}
}

Es de cachondeo.

Pero el uso de una cadena por parte de rir3760 me ha hecho pensar una forma alternativa:parto de una cadena con un solo  asterisco en medio y a medida que bajo añado dos asteriscos por escalón, mientras en la parte inferior los voy quitando. Curioso, ¿verdad?:


#include <stdio.h>
int main(void){
 int i,n,p;
 do{
   printf("\nBase del rombo(numero impar positivo): \n");
   scanf("%d", &n);
 }while ( n <=0 || (n % 2) == 0);
 char asteriscos[n];
 for (i=0;i<n;i++)
   asteriscos[i]=' ';
 asteriscos[i]='\0';
 p=n/2;
 asteriscos[p]='*';
 for (i=1;i<p+1;i++){
   printf ("\t\t%s\n",asteriscos);
   asteriscos[p-i]=asteriscos[p+i]='*';
 }
 printf ("\t\t%s\n",asteriscos);
 for (i=0;i<=p;i++){
   asteriscos[i]=asteriscos[n-1-i]=' ';
   printf ("\t\t%s\n",asteriscos);
 }
 return 0;
}

O con un solo for:


#include <stdio.h>
int main(void){
 int i,j,n,p;
 do{
   printf("\nBase del rombo(numero impar): \n");
   scanf("%d", &n);
 }while ( n <=0 || (n % 2) == 0);
 char asteriscos[n];
 for (i=0;i<n;i++)
   asteriscos[i]=' ';
 asteriscos[i]='\0';
 p=n/2;
 asteriscos[p]='*';
 for (i=-p;i<=p;i++){
   if (i<=0){
     printf ("\t\t%s\n",asteriscos);
     if (i<0)
     asteriscos[-i-1]=asteriscos[n+i]='*';
   }
   else{
     j=-i;
     asteriscos[-j-1]=asteriscos[n+j]=' ';
     printf ("\t\t%s\n",asteriscos);
   }
 }
 return 0;
}

Aunque nada supera al printf de rir3760.

Cita de: yoel_alejandro en  5 Marzo 2014, 21:23 PMBásicamente lo que hacemos es calcular el "punto medio" p de N (redondeo por exceso de N/2), para el caso N=9 sería p=5. Luego recorremos tanto i como j desde -p+1 hasta p-1, o sea, desde -4 hasta 4. El asterisco se imprime si abs(j) < p - abs(i), y esto dibuja el rombo de manera correcta, tanto en su parte superior como la inferior.

Solo un comentario: no es necesario imprimir los espacios al final de cada linea, por cada una basta con los primeros "N - abs(i)" caracteres.

La función con esa y otras modificaciones (todas ellas menores):
void rombo(int N)
{
   int i;
   int j;
   
   for (i = -N/2; i <= N/2; i++){
      for (j = 0; j < N - abs(i); j++)
         putchar(j < abs(i) ? ' ' : '*');
     
      putchar('\n');
   }
}

----

Ya por ultimo la biblioteca estándar de C no incluye una función que permita imprimir N veces un determinado carácter. Las únicas dos excepciones (forzadas, por supuesto) son el espacio y el cero. Un ejemplo de ello es otra versión (mas) del bendito rombo:
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
   int i;
   
   for (i = -4; i < 5; i++)
      printf("%*c%0*d\n", 1 + abs(i), ' ', 1 + (4 - abs(i)) * 2, 0);
   
   return EXIT_SUCCESS;
}

Produciendo la salida:
     0
    000
   00000
  0000000
000000000
  0000000
   00000
    000
     0

Un saludo

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  :laugh:

Cita de: yoel_alejandro en  6 Marzo 2014, 16:37 PM
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  :laugh:

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:


#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;
}

¡Buenas!

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

#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;
}


Otra solución recursiva pero forzada (ya que parte de la información se codifica en la cadena a imprimir) es:
#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

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


#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 );
 }
}

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


#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":



#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:


#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);
}

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

Cita de: dmacias en  7 Marzo 2014, 22:57 PM

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:


#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;
}

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


#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:

#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.



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!

Vamos, con matrices.

Ahí va una con el borde:



/** 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:



#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? (http://st.forocoches.com/foro/images/smilies/simba1.gif)

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

Cita de: yoel_alejandro en  9 Marzo 2014, 17:28 PM

Acepto el reto, jeje (claro, en un nuevo post) ...

[/b]

Pues a por él, pero eso sí en forma de triángulo isósceles. La forma clásica, vamos.

Ya que te lanzo el guante te dejo que elijas "armas", es decir que empieces el tema cuando te "sientas preparado". ..... es broma, ¿ehh..?.

Perdonen que vuelva a la carga, pero creo que esto no está terminado :laugh:.

Antes que nada poner un caso que se me traspapelo entre tanto rombo. Es el caso de distinguir entre el borde y el interior:




#include <stdio.h>

int main(){
 int i=0,j,k=1,l,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]=254;
   i=1;
   while (i<=a/2){
     l=i;
     for ( j=(a/2)-i;j<=i+(a/2);j++){
       if (j==(a/2)-l || j==l+(a/2))
         A[i][j]=254;
       else
         A[i][j]='*';
     }
     i++;
   }
   k=i;
   while (i>=(a/2) && i<=a){
     --k;
     l=k;
     for ( j=(a/2)+1-k;j<(a/2)+k;j++)
       if (j==(a/2)+1-l || j==(a/2)+l-1)
         A[i][j]=254;
       else
         A[i][j]='*';
     i++;
   }
   if (a>20){
     for ( i=(a/2)-8,k=0;i<(a/2)+10;i++,k++)
       A[i][a+1]=cad[k];
   }
   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');
   }
   putchar ('\n');
   return 0;
}


A ver si se animan a colgar algo de código en C++.

Yo en dicho lenguaje soy un total neófito, pero por lo menos se traducir algo de C  a C++. Así me salió esto:


#include <iostream>
using namespace std;
int main()
{
int n,fila,col;
cout<<"Introduce un numero IMPAR: "<<endl;
cin >> n;
   for(fila=1;fila<=n;fila++){
       for(col=1;col<=n-fila;col++)
          cout<<(" ");
       for(col=1;col<=2*fila-1;col++)
         cout<<("*");
   cout<<endl;
   }
   for(fila=n-1;fila>=1;fila--) {
       for(col=1;col<=n-fila;col++)
         cout<<(" ");
       for(col=1;col<=2*fila-1;col++)
       cout<<("*");
   cout<<endl;
   }
}

Pero claro, yo espero más de los expertos en C++, que haberlos hay los, todo está en que se animen con nuevas aportaciones.

Y todavía estoy a la espera que yoel_alejandro intervenga, que me dijo me iba a sorprender. No lo dejes estar mucho tiempo que se enfría el tema.

Y dedicado precisamente a yoel_alejandro al que rete en mi anterior mensaje, le dejo una versión "made in leosansan" del triángulo de Pascal, en este caso para que sea más a tono con el tema que se trata, de la pirámide de Pascal .... si ya sé que me acabo de inventar el término, pero ¿a qué queda bien? ...

Vaya leosansan, siq ue le has cojido el gusto al rombo jijijijjii
haber si me dejan un poco mas de tiempo libre e intento el triangulo de pascal ese, haber que sale

Huy, a mi dibujar formas en ASCII me da un dolor de cabeza... Es de los ejercicios que no puedo xD

Solo decir que las llamadas a printf/cout tienen mucho retraso, es más eficiente pintar línea a línea que caracter a caracter.

Pero vamos, son detallitos. Para que empezases a notar la diferencia tendría que ser rombos de más de 1000 o cosa así.

PD: El triangulo de pascal... ¿Recursivo?

Cita de: amchacon en 14 Marzo 2014, 01:39 AM

Huy, a mi dibujar formas en ASCII me da un dolor de cabeza... Es de los ejercicios que no puedo xD
..............................................................................

PD: El triangulo de pascal... ¿Recursivo?

¡¡¡Vamos hombre!!!, que no se trata de crear retratos o figuras complejas, además si te animas con el triángulo de Pascal, ya que tienes que crear la forma de triángulo, te será fácil dibujar la parte inferior y así ya tienes el rombo.

Hablando del triángulo de Pascal, me da igual como se obtenga,con recursión o sin ella,  la idea es que la gente aporte soluciones variadas, como un reto, ni más ni menos. Ya luego podremos comenta rentre todos  cual ha sido el más eficiente y cosas así.

Y para que no decaiga el tema yo aporto otro granito de arena al tema de los rombos en C++, que repito soy un pardillo total. Me cuesta horrores porque no controlo las salidas por pantalla, en C tengo los printf pero en C++ ..... sólo conozco cout, pero no sus posibilidades que me imagino tendrá, y setw. Y con este último me ha salido otro código con recursividad incluida:


#include <iostream>
#include <iomanip>
using namespace std;
int dibuja_arriba (int a,int cont);
int dibuja_abajo (int a,int cont);

int main()
{
    int cont=25,a=0;
    /*cout << "Introduce un numero IMPAR: "<<endl;
    cin >> a;
    cout <<endl ;*/
    dibuja_arriba (a,cont);
    cout <<  "  ";
    dibuja_abajo (cont-2,a+1);
    return 0;
}

int dibuja_arriba (int a,int cont){
    if (cont<=0)
      return 1;
    cout <<setw((cont/2)+1) << " ";
    for (int i=0;i<=a;i++)
      cout<< "*";
    cout << endl;
    dibuja_arriba (a+2,cont-2);
}

int dibuja_abajo (int a,int cont){
    if (a<=0)
      return 1;
    for (int i=1;i<=a;i++)
      cout<<"*";
    cout << endl << setw(cont+2) << " ";
    dibuja_abajo (a-2,cont+1);
}

Tuve que hacer algún ajuste "extraño" pero sale bien la pirámide.

Bueno que no se diga, dibujare señales cuadradas. Aquí teneís varias a distintas escalas:

(https://dl.dropboxusercontent.com/u/69551225/Sin%20t%C3%ADtulo.png)

#include <iostream>
#include <fstream>
#include <cmath>
using namespace std;

void DibujarSenyalCuadrada(const int frecuencia = 1,char caracter = '*',ostream &fout = cout);

int main()
{
    int frecuencia;
    //cout<<"Introduca frecuencia: ";
    //cin>>frecuencia;
    for (int i = 3; i < 20;i++)
    {
        DibujarSenyalCuadrada(i);
        cout<<endl;
    }
    return 0;
}

void DibujarSenyalCuadrada(const int frecuencia,char caracter,ostream &fout)
{
    const int max_asci = 50;
    int j = 0;
    string separador(frecuencia-2,' ');
    string escalon(frecuencia,caracter);

    while (j < max_asci)
    {
        fout<<escalon;
        fout<<separador;
        j += 2*frecuencia;
    }

    fout<<endl;
    // escalones de bajada

    for (int i = 0; i < frecuencia;i++)
    {
        j = 0;
        fout<<' ';
        while (j < max_asci)
        {
            fout<<separador;
            fout<<caracter;
            j += frecuencia;
        }
        fout<<endl;
    }

    // barreras inferiores
   
    fout<<separador;
    fout<<' ';
    j = 0;

    while (j < max_asci)
    {
        fout<<escalon;
        fout<<separador;
        j += 2*frecuencia;
    }
    fout<<endl;
}

Notese que escribo en fout en vez de cout. De esa forma puedo decirle a la función que escriba en un fichero externo en vez de la pantalla:

int main()
{
   ofstream fichero("cuadrada.txt");

   for (int i = 3; i < 20;i++)
   {
       DibujarSenyalCuadrada(i,'*',fichero);
       fichero<<endl;
   }
   return 0;
}

Cita de: amchacon en 14 Marzo 2014, 22:58 PM

Bueno que no se diga, dibujare señales cuadradas.

Pero bueno, para que no se diga, sin array, strings ni funciones. Solamente con el misero pero potente printf y mucha imaginación:




#include <stdio.h>

int main(){
  int i,j,k,l=0,cont=0,cont1=0,tam,MAX=40;
  for (tam=3;tam<=15;tam++){
    cont=cont1=0;
    for (i=0,j=0;i<MAX-1;i++,j++){
      putchar('*');
      if (j==tam-1)
        printf ("%*c", tam-2, ' ');
       if (i%tam==0){
         cont++;
         j=0;
       }
    }
    putchar ('\n');
    for (k=0;k<tam;k++){
      for (i=0,j=0;i<2*MAX/tam-1;i++,j++){
        if (cont1==cont-1)
          break;
        if (j==0)
          printf ("%*c", tam, '*');
        else
            printf ("%*c", tam-1, '*');
        if (k==tam-1  && i<(2*MAX/tam-1)/2+1){
          cont1++;
          for (l=0;l<tam-1;l++){
            putchar('*');
          }
        }
        if (i%(tam+1)==0)
          j=0;
      }
      putchar ('\n');
    }
  putchar ('\n');
  }
return 0;
}

Pero esque las piramides ya las hecho ;D

Pensé en hacer un circulo, pero hacer un circulo en una consola ASCII no es trivial. Para que te quedara bien habría que hacer "anti-alising" con alguna letra más redondita.

Cita de: leosansan en 15 Marzo 2014, 14:29 PMDe todas formas sería más fácil usando una función matemática. ¿Te animas?.[/center]

¿Más fácil? De eso nada xD

Para empezar rompe el enfoque arriba-abajo, además para sacarla tendrías que hacer unas series de fourier muy divertidas... Y probablemente alguna casilla te salga mal ya que no es exacta y las casillas no admiten decimales.

Cita de: amchacon en 15 Marzo 2014, 16:53 PM

Pero es que las pirámides ya las hecho ;D

.......................................

Pero apenas en C++, ya te digo que no sé muy bien como imprimir de  forma avanzada. No obstante continuo con mis aportaciones, para que vean lo que puede dar de sí este tema:



#include <iostream>

using namespace std;
/*********************************/
void entrar_num_base (int &n){
  /*cout << "Introduce un numero IMPAR: "<<endl;
   cin >> n;
   cout <<endl ;*/
}
/*********************************/
void asteriscos (int &i){
 for(int j=1;j<=i;j++)
   cout<<'*'<<" ";
 cout<<endl;
}

/*********************************/
void parte_superor (int i, int n){
 for(i=1;i<=n;i+=2){
   for(int b=n-i;b>0;b--)
     cout<<" ";
   asteriscos(i);
 }
}
/*********************************/
void parte_inferior(int i,int n){
 for(i=n-2;i>=1;i-=2){
   for(int b=n-i;b>0;b--)
     cout<<" ";
   asteriscos(i);
 }
}
/*********************************/

int main(){
 int i=0,num_base=25;
 ///entrar_num_base (num_base);
 parte_superor (i,num_base);
 parte_inferior(i,num_base);
 return 0;
}

Cita de: amchacon en 15 Marzo 2014, 16:53 PM
...................................................
¿Más fácil? De eso nada xD

Para empezar rompe el enfoque arriba-abajo, además para sacarla tendrías que hacer unas series de fourier muy divertidas... Y probablemente alguna casilla te salga mal ya que no es exacta y las casillas no admiten decimales.

¡No hombre!, no pensaba en ese sistema, para eso ya tengo el Mathematica y el Matlab.

Pensaba en esta idea:

Citar

f(x)=a/2 ......    0<=x<=a/2

f(x)=-a/2 ...... -a/2<x<a

Para ello me apoyo en el uso del gotoxy, bien mediante la librería de conio, más exactamente la conio2.h:


#include <stdio.h>
#include <conio2.h>

int main(){
 int  i,j,k,l,a;
 for (a=2,l=1;a<19;a++,l+=2*a+2){
   for (k=1;k<=50;k+=2*a) {
     for (i=0;i<=a;i++){
       gotoxy(i+k,0+l);
       putchar('*');
       for (j=0;j<=a;j++){
         gotoxy(a+k,j+l);
         putchar('*');
       }
       gotoxy(i+a+k,a+l);
       putchar('*');
       for (j=0;j<=a;j++){
         gotoxy(2*a+k,j+l);
         putchar('*');
       }
     }
   }
 }
 return 0;
}



#include <stdio.h>
#include <windows.h>

int gotoxy(int x, int y);

int main(){
 int  i,j,k,l,a;
 for (a=2,l=0;a<20;a++,l+=2*a+2){
   for (k=0;k<=50;k+=2*a) {
     for (i=0;i<=a;i++){
       gotoxy(i+k,0+l);
       putchar('*');
       for (j=0;j<=a;j++){
         gotoxy(a+k,j+l);
         putchar('*');
       }
       gotoxy(i+a+k,a+l);
       putchar('*');
       for (j=0;j<=a;j++){
         gotoxy(2*a+k,j+l);
         putchar('*');
       }
     }
   }
 }
 return 0;
}


int gotoxy(int x, int y)
{
  COORD coord;
  HANDLE h_stdout;
  coord.X = x;
  coord.Y = y;
  if ((h_stdout = GetStdHandle(STD_OUTPUT_HANDLE)) == INVALID_HANDLE_VALUE)
     return 0;
  if (SetConsoleCursorPosition(h_stdout, coord) == 0)
     return 0;
  return 1;
}


No he puesto los ejes por pereza xD. ;)

Esta vez, en vista de que "no cabe" en la página todas las funciones que genero, de 3 a 19 o 20, las metí en un vídeo, ..... tranquilos, dura menos de un minutito: :o

Chachi ^^. Un paso curioso sería hacerlas animadas (borrando y reescribiendola con otra posición cada x tiempo).

Yo de florituras en la pantalla, ni se me dan bien ni me gustan mucho. Por no dejar el tema a medias he hecho algo más de mi gusto: Una class Triangulo_Pascal:

/** Resumen de los metodos públicos:

- Constructor(int n = 0): Genera un triangulo de pascal de tamanyo N
- Constructor(triangulo_pascal): Constructor copia.
- getPosicion(int x,int y): Devuelve el valor en la posicion en la posicion x,y. Lanza una excepcion si es una posición incorrecta
- getSize(): Devuelve el tamanyo actual del triangulo
- resize(int n): Reconstruye el triangulo para un ancho n
- clear(): Borra el triangulo dejandolo con un tamanyo 0.
- toString(): Obtiene una expresion escrita del triangulo.

Operadores:

triangulo_pascal = triangulo_pascal   /** asignacion *
triangulo_pascal == triangulo_pascal  /** iguales? *
triangulo_pascal != triangulo_pascal  /** diferentes? *
**/

class triangulo_pascal
{
   int** Matriz;
   int TAM;
   string texto;

   int contar_cifras() const
   {
       int cifras = 1;
       int aux = Matriz[TAM-1][TAM/2];

       while (aux > 9)
       {
           cifras++;
           aux /= 10;
       }

       return cifras;
   }

   void generar(const int n)
   {
       TAM = n;
       Matriz = new int*[n];
       Matriz[0] = new int[1];
       Matriz[0][0] = 1;

       for (int i = 1; i < n;i++)
       {
           Matriz[i] = new int[i+1];

           Matriz[i][0] = 1;
           for (int j = 1; j < i;j++)
           {
               Matriz[i][j] = Matriz[i-1][j-1]+Matriz[i-1][j];
           }
           Matriz[i][i] = 1;
       }

       generarString();
   }

   void generarString()
   {
       stringstream ss;

       const int size = contar_cifras();

       for (int i = 0; i < TAM;i++)
       {
           for (int k = 0; k <= (TAM-i-2);k++)
               ss<<" ";

           ss<<Matriz[i][0];

           for (int j = 1; j <= i;j++)
           {
               ss<<" ";

               ss<<setw(size)<<Matriz[i][j];
           }

           ss<<endl;
       }

       texto = ss.str();
   }
public:
   triangulo_pascal(int n = 0)
   {
       if (n != 0)
       {
           generar(n);
       }
       else Matriz = NULL;
   }

   triangulo_pascal(const triangulo_pascal &a)
   {
       if (a.getSize() != 0)
           generar(a.getSize());
       else Matriz = NULL;
   }

   triangulo_pascal& operator=(const triangulo_pascal &a)
   {
       if (a.getSize() != 0)
           generar(a.getSize());
       else Matriz = NULL;
   }

   bool operator==(const triangulo_pascal &b)
   {
       return TAM == b.TAM;
   }

   bool operator!=(const triangulo_pascal &c)
   {
       return TAM != c.TAM;
   }

   int getPosicion(int x,int y) const
   {
       if (y < TAM || (x > y)) throw "Error, fuera de rango";
       return Matriz[x][y];
   }

   int getSize() const { return TAM;}

   void resize(int n)
   {
       if (n < 0) throw "Error, tamanyo negativo";

       clear();

       if (n == 0){return;}

       generar(n);
   }

   void clear()
   {
       if (Matriz == NULL) return;

       for (int i = 0; i < TAM;i++)
           delete[] Matriz[i];

       delete[] Matriz;

       Matriz = NULL;
       TAM = 0;
   }

   string toString() const
   {
       return texto;
   }

   operator string()
   {
       return toString();
   }

   ~triangulo_pascal()
   {
       clear();
   }
};


De la cual, podemos hacer algunas pruebas:

int main()
{
   triangulo_pascal mi_triangulo(5);

   cout<<mi_triangulo.toString()<<endl;
   mi_triangulo.resize(4);
   cout<<mi_triangulo.toString()<<endl;

   triangulo_pascal segundo(1);

   if (mi_triangulo != segundo)
   {
       cout<<"Son diferentes :("<<endl<<endl;
   }

   cout<<(string)segundo<<endl; // otra forma de pasarlo a string es usando los casts
   return 0;
}


El mayor fallo que tiene es la función para pasarlo a string, que aunque siempre genera el triangulo, lo hace un poco "raro" para algunos valores de N.

Cita de: amchacon en 16 Marzo 2014, 14:02 PM

...........AMCHACON..................

Espero que no te tomes a mal la licencia que me he tomado al colgar este código en el nuevo tema del binomio de Newton y triángulo de Pascal. Me pareció más oportuno.

Así dejaremos este para las ondas y continuar con la pirámide de asteriscos.

Y no quiero dejar de pasar la ocasión de brindar un homenaje a un antiguo "maestro" aunque de otro foro, pero creo que su punto de vista es "rompedor" con todo lo visto hasta ahora. Es un maestro en lo que yo he dado por llamar "códigos raritos y cortitos": el amigo Pantalàimon.

Conste que yo lo único que he hecho en este caso es "traducir" el código de C++ a C e implementar el que sólo salgan los impares. Ahí va:


#include <stdio.h>
#include <stdbool.h>

bool en_rombo( int n, int i, int j ){
  if ((((i+j+n)%2) && i + j > n && i + j < 3*n
      && i - j < n && i - j >  -n))
   return true;
 else
   return false;
}

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

Viendo otros códigos, con la excepción del aportado por rir3760 , este se sale. Lo repito, es todo un homenaje a  Pantalàimon al que desde aquí le reitero mis gracias por lo mucho que me ayudo en los inicios, junto a rir3760, Cheroky , untio y Sorancio. GRACIAS.