Mensajes

[¡¡¡¡ Saluditos! ..... !!!!]

Conviértelo a base64 y así no habrá problemas con el código cifrado... total, el que quiera descifrarlo únicamente tiene que añadir la decodificación de base 64 antes de ponerse a decodificar en serio.

La base que elijo la tomo para cada mensaje de forma aleatoria, pero pero después de aplicarle otro módulo de cifrado que son varios según el nivel de exigencia de cifrado que se requiera.

Entre los módulos está, por ejemplo, un desplazamiento con un array del mismo tamaño que el mensaje, lo que le da mucha fuerza, obtenido en cada ocasión de forma aleatoria y combinado con otro desplazamiento con otro array aleatorio, también distinto para cada mensaje, en base a números primos tomados a su vez de un intervalo diferente y aleatorio en cada ocasión. Y por supuesto utilizo todos los caracteres ASCII disponibles, ¡y más!, no me limito al abecedario y los números.

Y hay otros 12 módulos adicionales, aunque cada cierto tiempo añado alguno nuevo, cuestión de no aburrirse.

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

[array[0][0]]

No era necesario para cualquier tamaño, sólo necesitaba de 8x8   volviendo a una pregunta que surgió por ahí: ¿cómo hago el primer bloque de tres fichas se almacene en la posición array[0][0], el segundo bloque en la posición array[0][1], etc? ¿Debería guardar un string que contenga tres char(219)? La verdad es que veo que esto no es difícil, pero no logro tener las ideas claras. Disculpadme.

Disculpad@ estás y a la espera de que pongas el enunciado, te adelanto una posible solución, en el supuesto de que el problema radique en cómo extraer una matriz de 8x8 a partir de las matrices iniciales, estando esta matriz de 8x8 constituida por cadenas de tres cuadraditos. Aunque otra forma sería obtenerla directamente.

Te explico el proceso:

* la matriz inicial a usar debe ser de 8x8x4, sí, tridimensional. Esto es debido en que para generarla hemos de recorrer, además de las 8 filas y 8 columnas,también  hemos de tener en cuenta que cada elemento almacenado en esa matriz de 8x8 es  de cuatro caracteres .....sí, cuatro, los tres cuadraditos y el caracter nulo. Necesitaremos por lo tanto:

* 1 * un primer for:1->8 para recorrer la matriz en filas.

* 2 * un segundo for:1->8  para recorre la matriz en columnas.

* 3 * un tercer for:1->tam para el for anterior recorrerlo internamente, ya que se compone de los caracteres extremos más los intermedios, tanto cuadraditos como líneas verticales.

Y hemos de quedarnos en este último for con los cuadraditos. ¿Cómo?. Teniendo en cuenta el hecho de cómo se componen las filas LV=línea vertical=179 y de cuadraditos = C=219=\xdb:

    LV     C    LV    C   LV    C   LV    C   LV    C   LV    C   LV    C   .....  
     0      1    2     3    4     5     6    7    8     9    10   11  12   13......
k =          0          1           2          0           1           2          0 .....

Observa que para "pillar" sólo los cuadraditos, que son los números impares, en el último for se empieza desde uno y se avanza con paso 2: i+=2.

Pero además tienes que usar una variable auxiliar k tal que cada tres cuadraditos "pillados", y después de añadirle el caracter nulo, se inicie a cero y se incremente el array.  ES decir empiezas en array[0][0] y una vez que k haya llegado a dos, pasará a valer otra vez cero y empezarás a rellenar el array[0][1] y así sucesivamente.

No te pongo ahora mismo la respuesta porque me has pedido expresamente que tan sólo te lo explicara para tú intentar sacarlo.

Espero que la explicación te encamine hacia la solución.

Por respeto a los seguidores de este tema, que no son pocos, pondré en un día o dos la respuesta.

Ahora te adelanto el código que imprime la matriz, para que veas que es efectivamente de 8x8, y una salida del programa:

Código (cpp) [Seleccionar] Expandir

for (i=0;i<8;i++){
   printf("\t\t");
   for (j=0;j<8;j++){
     printf("%s  ",c[i][j]);
   }
   puts ("\n");
 }

             
 A PARTIR DE LA MATRIZ DE 8X8



               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███



               DE FORMA DIRECTA

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

               ███  ███  ███  ███  ███  ███  ███  ███

Y para los que estén aburridos y le peguen a la criptografía, aquí pongo el código solución cifrado. He usado un método propio, pero no lo he querido hacer totalmente indescifrable por si se animan ..... pero tranquilos, como comenté próximamente pondré la solución, no es plan de dejar a nadie colgado en este tema:

Cifrado es:

Æ¿å| æâyiàX¼ÇD¿wD1  lÜ╗ aø`5_}QbM┤^muÄ`;    ê╝x anVåUæG_Hòpp3ñU>      m║© *ÿFrxè
e┐ŪHøYêEz┼]N        sê«┐d,xc▬        ¬ç 9tïkG╬;☼          ö{ìï¡ëë®®ÜCJgöÜu3]Öc│
ïes?6▼          «?àå↕+        Ö♫↓        û¡Åkæ▲)          ⌂Åî®Øo_Ññ½]Zt:CeKA
     skIe_♀        ╣VP      ×E\    è7E  ©?↑H9  æçºtìÉà [üx║OOm ((M  á⌂ú NÅê3T╗c
fiÁnÇyº#4    ¡┐«x|~?[óøêùDvs\↕    ÿ¡║ /àZOKîLlQ£2Xv┤+D      Ö¥┐┐øöK.|©  YSqvóuñü
¼9è]8    Ê(W    üæî╩ A$á|ixoF↓  ø@¶  î╗úvu╗s u3øÅtsé┴Ñ╝í<í♣E

Aunque me temo que el procesador de esta página "baile" algunos símbolos extraños para él.

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

[Pues a mí me da bien:]

Pues a mí me da bien:

6
36
536
5536
65536
[65536]

Process returned 0 (0x0)   execution ti
Press any key to continue.

Pero en principio lo que he hecho es prescindir de pow y de la librería math y lo he calculado directamente:

Código (cpp) [Seleccionar] Expandir

int obtenerNumero(char *operando,int base)
{
   int i,potencia,num_decimal = 0,lon,entero=0,x = 1;
   lon = strlen(operando);
   for(i = lon-1,potencia = 1;operando[i];i--,potencia*=10)
   {
       /*if(esLetraBase16(operando[i]))
          entero = hexadecimal(operando[i]);
       else*/
          entero = operando[i]-'0';
       num_decimal+= potencia*entero;
       printf("%d\n",num_decimal);
   }
   printf("[%d]",num_decimal);
   return num_decimal;
}
int main(){
 obtenerNumero("65536",10);

 return 0;
}

Pero me quedé con el "mosqueo" de lo que te ocurría. Casi no lo pillo, pero sí, lo he pillado.

El problema radica que el uso de pow implica que la variable sea de tipo float o double y si se usa un int pasan cosas raras, cosa que no sucede con mi método. Es decir, la solución a tu código:

Código (cpp) [Seleccionar] Expandir

int obtenerNumero(char *operando,int base)
{
   int i,potencia,lon,entero=0,x = 1;
   float num_decimal = 0; /*<== AQUI ::::::*/
   lon = strlen(operando);
   for(i = lon-1,potencia = 0;operando[i];i--,potencia++)
   {
       /*if(esLetraBase16(operando[i]))
          entero = hexadecimal(operando[i]);
       else*/
          entero = operando[i]-'0';
       num_decimal+= pow(base,potencia)*entero;
       printf("%g\n",num_decimal);
   }
    printf("[%d]",num_decimal);
   return num_decimal;
}
int main(){
 obtenerNumero("65536",10);

 return 0;
}

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

[¡¡¡¡ Saluditos! ..... !!!!]

Buuuueno, vale.

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

[array[0][0]]

No era necesario para cualquier tamaño, sólo necesitaba de 8x8  volviendo a una pregunta que surgió por ahí: ¿cómo hago el primer bloque de tres fichas se almacene en la posición array[0][0], el segundo bloque en la posición array[0][1], etc? ¿Debería guardar un string que contenga tres char(219)? La verdad es que veo que esto no es difícil, pero no logro tener las ideas claras. Disculpadme.

Mira que te lo dije: pon el enunciado exacto. El no hacerlo nos lleva a nosotros a tener que especular y, la verdad, tenemos poco de adivinos y lo único que consigues es  hacernos perder el tiempo en elucubraciones psico-mentales inútiles que acaban cabreando al más pintado.

Es la última hasta que aclares lo del enunciado:

■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│█│
└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
█  █  █  █  █  █  █  █
█  █  █  █  █  █  █  █
█  █  █  █  █  █  █  █
█  █  █  █  █  █  █  █
█  █  █  █  █  █  █  █
█  █  █  █  █  █  █  █
█  █  █  █  █  █  █  █
█  █  █  █  █  █  █  █

■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■
■  ■  ■  ■  ■  ■  ■  ■

Código (cpp) [Seleccionar] Expandir


/**
a0=linea superior
a1=lineas intermedias
a2=linea inferior
a3=lineas laterales
**/
/**
a0=linea superior
a1=lineas intermedias
a2=linea inferior
a3=lineas laterales
**/

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

#define CUADRADITOS 179,219,179,219,179,219
#define CUADRADITOS1 "\xdb "
#define CUADRADITOS2 "\xfe "
#define ULCORNER 218,196,196,196,196,196    /* upper-left corner, esquina superior izquierda y tres guiones*/
#define RTEE     195,196,196,196,196,196   /*right-tee, letra 'T' apuntando hacia la derecha y tres guiones*/
#define CROSS    197,196,196,196,196,196    /* crossover, cruz grande (de mayor tamaño que el signo '+' y tres guiones) */
#define LTEE     180                /* left-tee, letra 'T' apuntando hacia la izquierda */
#define BTEE     194,196,196,196,196,196   /* bottom-tee, letra 'T' apuntando hacia abajo y tres guiones*/
#define URCORNER 191                /* upper-right corner, esquina superior derecha */
#define LLCORNER 192,196,196,196,196,196   /* lower-left corner, esquina inferior izquierda y tres guiones */
#define TTEE     193,196,196,196,196,196    /* top-tee, letra 'T' apuntando hacia arriba y tres guiones */
#define LRCORNER 217                /* lower-right corner, esquina inferior izquierda */
#define VLINE    CUADRADITOS      /*vertical line, linea vertical y tres espacios*/
#define VLINE_   179                /* vertical line, linea vertical */
#define TOKEN    219                /* ficha o pieza */

int main(){
  int i,j,tam;
  char a[]="\xfe ";
  char b[8][8][6];

/******* AQUI MATRIZ CUADRADITOS=254=xfe 8X8 *******/
/** SOLO CUADRADITOS SIN LINEAS INTERMEDIAS **/

  for (i=0;i<8;i++)
    for (j=0;j<8;j++)
      strcpy( b[i][j], a );

  for (i=0;i<8;i++){
    for (j=0;j<8;j++){
      printf("%s ",b[i][j]);
    }
    putchar ('\n');
  }
  int a1[]={RTEE,CROSS,CROSS,CROSS,CROSS,CROSS,CROSS,CROSS,LTEE},
      a0[]={ULCORNER,BTEE,BTEE,BTEE,BTEE,BTEE,BTEE,BTEE,URCORNER},
      a2[]={LLCORNER,TTEE,TTEE,TTEE,TTEE,TTEE,TTEE,TTEE,LRCORNER},
      a3[]={CUADRADITOS,CUADRADITOS,CUADRADITOS,CUADRADITOS,CUADRADITOS,CUADRADITOS,CUADRADITOS,CUADRADITOS,CUADRADITOS};
  tam=sizeof (a1)/sizeof (a1[0]);
  /** linea superior **/
  for (j=0;j<tam;j++)
    printf("%c",a0[j]);
  putchar ('\n');
  /** linea lateral **/
  for (j=0;j<tam;j++)
    printf("%c",a3[j]);
  /** salto de linea...  **/
  /** y dibujo intermedias y laterales  **/
  for (i=0;i<7;i++){
    putchar ('\n');
    for (j=0;j<tam;j++)
        printf("%c",a1[j]);
      putchar ('\n');
      for (j=0;j<tam;j++)
          printf("%c",a3[j]);
  }
  /** linea inferior **/
  putchar ('\n');
  for (j=0;j<tam;j++)
    printf("%c",a2[j]);
  putchar ('\n');

/******* AQUI MATRIZ SOLA DE CUADRADITOS=219=xdb 8X8 *******/

  for (i=0;i<8;i++){
    for (j=0;j<8;j++){
      printf("%s ",CUADRADITOS1);
    }
    putchar ('\n');
  }
  putchar ('\n');

/******* AQUI UNA MATRIZ SOLA DE CUADRADITOS=254=xfe 8X8 *******/

  for (i=0;i<8;i++){
    for (j=0;j<8;j++){
      printf("%s ",CUADRADITOS2);
    }
    putchar ('\n');
  }
  putchar ('\n');

  return 0;
}

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

[CHACHO]

¡¡¡CHACHO, menudos pedazos de código!!!

Si planteé un reto es porque los códigos que me imaginaba pondrían no sobrepasarían las 50 o 60 lineas, pero más de 200 es una pasada para el objetivo propuesto. Pero todo hay que decirlo: os lo habéis currado de lo lindo.

Yo me esperaba lo que denomino "códigos cortitos e imaginativos".

Por ahora no hemos logrado ni lo uno ni lo otro.

Voy a corregir lo primero, cortito y más eficiente.

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
int main(){
 unsigned int i,j,n=21,N;
 char tamanyo_consola[80];
 /*do{
   printf("\nIntroduzca la potencia a calcular (0-23): \n");
   fflush( stdout );
   scanf("%u",&n);
   }while ( n < 0  || n > 23);*/
 N = 2 *(++n)  - 1; /* numero de columnas*/
 sprintf(tamanyo_consola, "MODE %d,%d",(int) (4.5*N+1),2*N);
 system(tamanyo_consola);
 unsigned int a[n][N+1];
 for (i=0;i<=n-1;i++)
   for (j=0;j<=(N);j++)
     a[i][j] = 0;
 a[0][n-1] =  1;
 for (i=1;i<=n-1;i++)
   for (j=n-1-i;j<=n-1+i;j+=2)
       a[i][j] = a[i-1][j-1] + a[i-1][j+1];
 for (i=0;i<=n-1;i++){
   for (j=0;j<=n-1+i;j++){
     if (a[i][j]==0)
       printf("    ");
     else
       printf("%4u",a[i][j]);
   }
   putchar ('\n');
 }
 return 0;
}

Para hacer el código más potente a la hora de representar el triángulo he introducido el system MODE que ajusta el tamaño de la consola al tamaño del triángulo, al menos para el intervalo considerado y de acuerdo al tamaño de mi monitor. Si estáis en Linux el tamaño del triángulo máximo que se vería bien en consola creo que es 13:

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
int main(){
 unsigned int i,j,n=13,N;
 /*do{
   printf("\nIntroduzca la potencia a calcular (0-13): \n");
   fflush( stdout );
   scanf("%u",&n);
   }while ( n < 0  || n > 13);*/
 N = 2 *(++n)  - 1; /* numero de columnas*/
 unsigned int a[n][N+1];
 for (i=0;i<=n-1;i++)
   for (j=0;j<=(N);j++)
     a[i][j] = 0;
 a[0][n-1] =  1;
 for (i=1;i<=n-1;i++)
   for (j=n-1-i;j<=n-1+i;j++)
       a[i][j] = a[i-1][j-1] + a[i-1][j+1];
 for (i=0;i<=n-1;i++){
   for (j=0;j<=n-1+i;j++){
     if (a[i][j]==0)
       printf("    ");
     else
       printf("%4u",a[i][j]);
   }
   putchar ('\n');
 }
 return 0;
}

Y una muestra de la salida para 15:

Observad bien el triángulo anterior, es fundamental para que entendáis lo que sigue.

* 1*
En mi código veréis la linea:

Código (cpp) [Seleccionar] Expandir

a[0][n-1] =  1;

increíble pero cierto sólo hace falta definir "un elemento como uno", ya la ley de recurrencia se encarga de los demás. Esta es la primera diferencia con respecto a los otros códigos. Lo veo más sencillo y eficiente.

* 2 *
No es necesario aplicar la ley de recurrencia a todos los elementos de la matriz, basta con aplicarlo a los elementos a derecha e izquierda de la linea vertical que pasa por el vértice y de dos en dos para no aplicarlo a los ceros intermedios. Ello está considerado en la linea:

Código (cpp) [Seleccionar] Expandir

for (j=n-1-i;j<=n-1+i;j+=2)

El ahorro de operaciones es considerable y aumenta dicho ahorro con el tamaño del triángulo.

En concreto, y puestos a hacer números, el total de números a aplicar la ley de recurrencia teniendo en cuenta ese detalle es de (n+1)*(n+2)/2, mientras que si no se tiene en cuenta el total de operaciones a realizar es (2*n+1)*(n+1) lo que da una diferencia entre ambos métodos de (n+1)*n*3/2.

Aplicado al caso concreto de 15:

---> teniendo en cuenta la simetría se aplica la ley de recurrencia 136 veces.

---> sin tenerlo en cuenta se aplica la ley de recurrencia "496" veces.

Una diferencia de 360 veces de más. Por eso mi comentario de que el método que propongo, además de ser bastante más cortito, es más eficiente.

Pero, ¿realmente es necesario usar un array bidimensional?. En realidad es poco eficiente ya que desaprovechamos de él muchas de las posiciones, todos los ceros que no se usan.

Y es el reto que lanzo: conseguir el triángulo con un array unidimensional, así no desaprovechamos ningún elemento del array. ¡Ánimo!, no es tan difícil .... y lo de dibujarlo es lo de menos, lo realmente interesante es como conseguir ese array unidimensional.

Y por último una petición: los códigos "cortitos", porfi.

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

[¡¡¡¡ Saluditos! ..... !!!!]

Jajajajaja
....................................
PD.: dejarle la media en float no crees que dejarlo demasiado mascado??

¿Y crees que con los no conocimientos que demuestra sería capaz de hacer un cast?

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

[¡¡¡¡ Saluditos! ..... !!!!]

Y esto mismo aplicado a tu código...

Código (cpp) [Seleccionar] Expandir


#include<iostream>
#include<cstdlib>
#include<fstream> <== ESTA CREO ESTA DE MAS

using namespace std;

int main ()
{
 int num,numeros[num]; <==DECLARAS EL ARRAY ANTES DE INTRODUCIR LA DIMENSION num
<== falta declarar las otras variables
   ....................................................
}

Ah si, procura tabular bien el código... si no es bastante molesto leerlo y le quitas a la gente las ganas de ayudarte ( si no leen tu código porque les parece incomprensible no te van a responder ).

Totalmente de acuerdo en lo último.

El código corregido:

Código (cpp) [Seleccionar] Expandir


#include<iostream>
#include<cstdlib>

using namespace std;

int main (){
    int num;
    float media,suma=0;
    cout << "Cuantos numeros va a introducir: ";
    cin >> num;
    int numeros[num];
    if (num > 2){
    for (int i = 0; i < num;i++){
      cout << "numero "<< i+1<<" de "<< num<<": ";
      cin>>numeros[i];
      suma+=numeros[i];
    }
    media=suma/num;
    cout << "La media es: "<< media<< endl;
    }
    else
      cout << "Debe introducir mas de 2 numeros."<<endl;
    system ("pause");
    return 0;
}

Supongo que lo has hecho a posta para que él trabaje algo.

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

[...........AMCHACON..................]

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

Código (cpp) [Seleccionar] Expandir


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

   

[ivancea96]

Muy buena aportación ivancea96.

Pero permite me un par de observaciones:

* por qué usar uint64_t , que creo que es para números grandes. corrígeme si estoy en in error, please.. Si es lo que digo al no hacer uso de los factoriales los números combinatorios son más bien "normalitos", a no er que "n" sea muy alto.

* Si te fijas haces casi el doble de operaciones de las que son necesarias. Observa que la matriz o triángulo es simétrico respecto de la línea que pasa por su centro con lo que podrías "calcular" la mitad izquierda y por "igualación" respecto de sus simétricos obtener la mitad derecha.

Y a ver si te animas y cuelgas un código que dibuje el triángulo, ese es el aunténtico reto de este tema.

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

APORTACIÓN DE AMCHACON

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:

Código (cpp) [Seleccionar] Expandir

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

Código (cpp) [Seleccionar] Expandir

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.