Mensajes

En el caso que plantea leosansan, supongo que dependerá del compilador. Probablemente cualquier compilador moderno tomará previsiones adecuadas si la cadena de origen excede en longitud a la cadena de destino.

Sin embargo la filosofía de C es que "los programadores saben lo que están haciendo", por eso pienso que a pesar de la ayuda que pueda proporcionar el compilador, un buen programador de C debe garantizarse por sí mismo la consistencia de este tipo de operaciones. Así que al autor del post: pues, ya lo sabes!!!

Interesante un detalle adicional de la cita de cplusplus y que se me había pasado por alto: Las cadenas origen y destino no deben solaparse. Esta es otra consideración a tener en cuenta, no se debe intentar escribir una cadena sobre sí misma.

NOTA: Estas dificultades se evitan cómodamente usando la clase string de C++. Pero personalmente creo que quién se quiera formar como un verdadero programador debería pasar primero por C (con todas sus dificultades asociadas), y luego ir a C++. Hay que "ensuciarse" primero para aprender bien. Bueno, al menos es mi criterio, no se qué opinen los demás (?)

Hace un tiempo un usuario me rcomendó escribir y compartir un programa que trabaje sobre el triángulo de Pascal. La verdad no es difícil generar el triángulo, así que para añadir más gusto decidí ir más allá y generar el binomio de Newton de un exponente arbitario. Pero antes de proseguir en este tema vamos a señalar algunas consideraciones teóricas (tal vez para quiénes ya olvidaron sus clases de mate, jeje).

En álgebra, al desarrollar (a+b)^2, obtenemos:

a^2 + 2ab + b^2

y para (a+b)^3:

a^3 + 3a^2b + 3ab^2 + b^3

Pues bien, lo que se quiere es el desarrollo para una potencia entera positiva cualquiera, y que lo imprima "con formato". Es decir, una línea para la base y otra para los exponentes:

3     2       2    3
a  + 3a b + 3ab  + b


Para obtener el desarrollo general necesitamos el triángulo de Pascal (http://es.wikipedia.org/wiki/Tri%C3%A1ngulo_de_Pascal). Las tres primeras líneas del triángulo son:

  1
1 1
1 2 1

y se construye de esta manera: todas las filas empiezan y terminan con 1, además de la tercera filas en adelante cada elemento se obtiene sumando los dos que tiene directamente arriba, uno a la derecha y otro a la izquierda. En la tercera fila, el "2" se obtuvo sumando 1 + 1 de este modo. Vamos con 4 filas:

   1
  1 1
1 2 1
1 3 3 1

y ahora el primer "3" de la 4ta fila es la suma 1 + 2 de los elementos que tiene arriba suyo, el otro "3" es la suma 2 + 1, y así sucesivamente.

Pues bien, el j-ésimo elemento de la i-ésima fila del triángulo (empezando los índices en cero) se llama coeficiente binomial que por falta de una mejor simbología en este portal representaré como <i,j>. Con ésto, el binomio (a + b)^N se desarrolla como la suma desde i=0 hasta i=N de los términos de la forma <N,i> * a^(N-i) * b^i. O sea, por ejemplo:

(a + b)^3 = <3,0>*a^3 + <3,1>*a^2*b + <3,2>*a*b^2 + <3,3>*b^3

los coeficientes binomiales <3,j> no son más que los elementos de la cuarta fila del triángulo:

   1
  1 1
1 2 1
1 3 3 1

por tanto

(a + b)^3 = 1*a^3 + 3*a^2*b + 3*a*b^2 + 1*b^3
          = a^3 + 3a^2b + 3ab^2 + b^3

y por supuesto, para desarrollar el binomio de orden N necesitamos construir el triángulo de N+1 filas.

Bueno, y ya  . La parte de hacer todos los cálculos no encierra nada que no se pueda comprender leyendo el código fuente, y sus respectivos comentarios. Lo más desafiante (para mí) fue hacer la presentación "formateada" que expliqué antes. Usando algúun tipo de función gotoxy() o su equivalente es fácil, pues nos movemos a la línea de arriba para escribir los exponentes, y a la de abajo para el resto de la expresión. Sin embargo esta función no es portable por lo que decidí no usarla.

En su lugar pensé hacer algo similar a cómo las pantallas LCD que los aparatitos electrónicos. Una matriz de celdas donde cada celda permite representar un carácter. Un programa debe calcular todas las letras y mandar a imprimirlas. Bueno, ..... creo que la idea quedó clara, se debe disponer una matriz "board" o tablero de dos filas, e ir rellenando los caracteres adecuados. Luego que se tenga toda la expresión formada, se imprimen con funciones estándares.

El problema es que se debe calcular en tiempo de ejecución el ancho total de las líneas, dependiendo de la potencia del binomio que se quiera. Tomar en cuenta también que los números ocupan un ancho fijo, porque para potencias grandes pueden ser de una, dos, tres cifras, etc. También tener presente que los coeficientes iguales a 1 no se imprimen, como tampoco los exponentes iguales a 1. Este programa, tal como está desarrollado, está limitado a expresiones cuyo ancho sea menor o igual que la pantall (no hace "salto" de línea).

Otra dificultad fue hacerlo enteramente en C (sin usar clases), por eso malloc() y free() por varias partes, jeje. El argumento (potencia del binomio) está pasado como argumento de la línea de comandos. Así que probándolo con potencia 3:

./binomio 3

nos da:

(a + b)^3 es:

3     2       2    3
a  + 3a b + 3ab  + b

y para divertirnos un poco, con potencia 7:

(a + b)^7 es:

7     6       5 2      4 3      3 4      2 5      6    7
a  + 7a b + 21a b  + 35a b  + 35a b  + 21a b  + 7ab  + b


Vamos con el código:

Código (cpp) [Seleccionar] Expandir


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

int ** pascal( const int );
int ** tartaglia( const int );
void destroy_pascal( int **, const int );
void destroy_tartaglia( int **, const int );
int digits( int );

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

   int **A, N;
   int i;
   int width, col;
   char *board[2];

   /* Verificando integridad de los datos */
   if ( argc < 2 )
      return -1;
   N = atoi( argv[1] );

   if ( N < 0 ) {
      printf("Solo para N >= 0\n");
      return -1;
   }
   if ( N == 0 ) {
      printf("a + b\n");
      return -1;
   }

   /* Coeficientes de pascal */
   A = pascal( N );

   /* Calculamos el ancho total de la cadena */
   width = 0;
   for ( i = 0; i <= (float)N/2; i++ ) {
      if ( i == 0 ) /* terminos a^N, y b^N */
         width += 2 * ( 1 + digits(N) );
      if ( i == 1 ) /* terminos a^(N-1)*b, y a*b^(N-1) */
         width += 2 * ( 2 + digits(A[N][i]) + digits(N-1) );
      if ( i > 1 ) /* terminos a^(N-i)*b^i */
         if ( !(N % 2) && i == (float)N/2 )
            /* termino central se suma solo una vez */
            width += 2 + digits(A[N][i]) + digits(N-1) + digits(i);
         else
            /* y los restantes, dos veces */
            width += 2 * ( 2 + digits(A[N][i]) + digits(N-1) + digits(i) );
   }
   /* cadenas " + " */
   width += 3 * N;

   /* Representacion final */
   if ( ( board[0] = malloc( (width + 1) * sizeof(char) ) ) == NULL )
      return -1;
   if ( ( board[1] = malloc( (width + 1) * sizeof(char) ) ) == NULL )
      return -1;

   memset( board[0], ' ', width + 1);
   memset( board[1], ' ', width + 1);
   col = 0;
   for ( i = 0; i <= N; i++) {
      if ( A[N][i] != 1 ) { /* binomial N sobre i */
         col += sprintf( board[1] + col, "%d", A[N][i] );
         board[1][col] = ' ';
      }
      if ( N - i > 0 ) /* base 'a' */
         board[1][col++] = 'a';
      if ( N - i > 1 ) { /* exponente N - i */
         col += sprintf( board[0] + col, "%d", N - i);
         board[0][col] = ' ';
      }
      if ( i > 0 ) /* base 'b' */
         board[1][col++] = 'b';
      if ( i > 1 ) { /* exponente i */
         col += sprintf( board[0] + col, "%d", i);
         board[0][col] = ' ';
      }
      if ( i < N ) {
         col += sprintf( board[1] + col, " + ");
         board[1][col] = ' ';
      }
   }
   board[0][width] = '\0';
   board[1][width] = '\0';
   printf( "(a + b)^%d es:\n\n%s\n%s\n", N, board[0], board[1] );

   /* Liberando memoria, y saliendo */
   free( board[0] );
   free( board[1] );
   destroy_pascal( A, N);
   return 0;
}

/* Construye una matriz que contiene los numeros del triangulo
* de Pascal o Tartaglia de orden N > = 0, con N + 1 filas.
* La matriz es tal que A[i][j] corresponde al binomial (i : j).
* Se devolverá NULL si N < 0, o si no se pudo asignar memoria
* para construir la matriz.
*/
int ** pascal( const int N ) {

   int **A;
   int i, j;

   if ( N < 0 ) return NULL;

   if ( ( A = malloc( (N + 1) * sizeof(int *) ) ) == NULL ) return NULL;
   for ( i = 0; i < N + 1; i++ )
      if ( ( A[i] = malloc( (i + 1) * sizeof(int) ) ) == NULL ) return NULL;

   for ( i = 0; i < N + 1; i++ ) {
      A[i][0] = 1;
      A[i][i] = 1;
      /* solo se ejecuta si i > 1 */
      for ( j = 1; j < i; j++ )
         A[i][j] = A[i-1][j-1] + A[i-1][j];
   }

   return A;
}

/* Destruye el objeto creado por la función pascal() */
void destroy_pascal( int ** A, const int N ) {

   int i;

   if ( N < 0 ) return;

   for ( i = N; i >= 0; i-- ) {
      free( A[i] );
      A[i] = NULL;
   }
   free( A );
   A = NULL;
}

/* Un sinónimo de pascal( N ) */
int ** tartaglia( const int N ) {

   return pascal( N );
}

/* Un sinónimo de destroy_pascal( N ) */
void destroy_tartaglia( int ** A, const int N ) {

   return destroy_pascal( A, N );
}

/* Calcula la cantidad de cifras o digitos que conforman un
* numero entero no negativo;
*/
int digits( int N ) {

   int count = 1;

   if ( N < 0 ) return 0;
   if ( N == 0 ) return 1;

   while ( ( N = (N / 10) ) > 0 )
      count++;

   return count;
}

Ok, hay varios aspectos implícitos en tu pregunta. La función

strcpy( char *s1, const char *s2)

copia el contenido de s2 en s1, añadiendo al final de s1 un carácter nulo de terminación '\0'. La única consideración es que s1 contenga el suficiente espacio disponible para copiar todos los caracteres (al menos la longitud de s2 más uno).

Esto por supuesto requiere que se pueda escribir en el espacio asignado a s1. Si declaras

char *cadena = "hola mundo";

entonces cadena se considerará un string constante y ya no podrás escribir nada nuevo en él. Pero la declaración:

char cadena[] = "hola mundo";

sí permite rescribir el contenido de cadena (siempre y cuando la nueva cadena sea de longitud menor o igual a la que tenías primero, de lo contrario no habrá espacio disponible suficiente). Por ejemplo, puedes poner:

strcpy( cadena, "Pepe");
puts( cadena );

y verás como ahora escribe "Pepe".

----------------------------------------------------------------------------------
NOTA. En cuánto a la declaración de string constantes no se con exactitud si la forma de interpretar la sentencia depende del compilador o de la versión de C, o de si es en C ó en C++. Que alguno de los usuarios más versados en el tema por favor nos complemente.

Sólo digo que me parece bien raro ese lenguaje. ¿Quién lo usa? ¿Es algo parecido a los sms?

Aunque ya está solucionado, sólo para mostrar una alternativa un poco bizarra pero que se reduce a un único sscanf(). La idea es leer ambos, el entero y el float como flotantes, y de ser necesario convertir el primero a entero. Lo probé y parece funcionar correctamente:

Código (cpp) [Seleccionar] Expandir


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

int main(void)
{
   char *linea[] = {
      "1970-01-01 1 2.3",
      "1970-01-01 4.5",
      "1980-01-01 1 2.3",
      "1980-01-01 4.5",
      "1990-01-01 1 2.3",
      "1990-01-01 4.5",
   };
   size_t num_elem = sizeof linea / sizeof linea[0];
   size_t i;

   unsigned a;
   unsigned m;
   unsigned d;
   int num_ent;
   double num_pf;

   int n_args;
   float M, N;

   for (i = 0; i < num_elem; i++)
      switch ( n_args = sscanf(linea[i], "%u-%u-%u %f%*[ ]%f", &a, &m, &d, &M, &N) ) {
      case 5:
         num_ent = (int)M;
         num_pf = N;
         printf("%u-%02u-%02u: %d, %.2f\n", a, m, d, num_ent, num_pf);
         break;
      case 4:
         num_pf = M;
         printf("%u-%02u-%02u: %.2f\n", a, m, d, num_pf);
         break;
      default:
         puts("Error");
      }

   return EXIT_SUCCESS;
}


Salida:

1970-01-01: 1, 2.30
1970-01-01: 4.50
1980-01-01: 1, 2.30
1980-01-01: 4.50
1990-01-01: 1, 2.30
1990-01-01: 4.50

[leosansan]

Ah bueno leosansan tienes razón, ya eso depende de la interpretación que demos de palíndromo, si bien la definición formal RAE (que es la oficial de nuestro idioma), o bien una definición más relajada.

A veces en determinada ciencia tomamos definiciones más amplias (o más estrictas) que las lingüísticas, y podría ser ese el caso de la informática. Está bien tu aporte y el de todos, porque así contamos con un abanico de soluciones, adaptadas a las distintas interpretaciones del problema.

Un buen proyecto sería construir una función "múltiple", con un argumento option adicional que especifique el tipo de interpretación que será hecho (omitiendo o no los espacios, diferenciando mayúsculas, etc). Así sería más flexible, amplio y práctico  .

Ah ok, no problem! 

También me pareción extraño que no eligió fprintf(). Creo que no se puede usar porque el problema dice "no se pueden usar cadenas", y como fprintf() dirige una salida formateada, de cierta forma está creando una cadena. Está obligado a trabajar "en bruto", o al menos eso es lo que pareciera.

De todos modos, que el autor del post aclare ...

Lo que dijo englex, y además, ¿por qué escribes 12 bytes con el fread()? Si vas a escribir un dígito a la vez, basta con poner un solo carácter. Quedaría:

Código (cpp) [Seleccionar] Expandir


void escribirNumero(long long int numero, FILE *fd)
{
long long int cociente,residuo;
for(cociente = numero; cociente != 0; cociente = cociente/10)
{
  residuo = cociente % 10;
  residuo += 48; /* convertido a ASCII */
  fwrite( &residuo, sizeof(char), 1, fd);
}
}
Eso sí, va escribiendo el número empezando con la cifra menos significativa, y terminando por la más significativa. Por ejemplo para el número 54.780 lo probé y me escribe 08745 lo cual está bien pero al revés. Tendrías que hacer una rutina para invertir las cifras.

Si la intención es procesar la primera mitad de un array incluyendo el elemento pivote (si existe) me parece mas sencillo utilizar la expresión "i < (N + 1) / 2" para controlar el bucle.

Es otra manera, gracias.

Para do-while, la solución que presenté considera que la palabra no contiene espacios, y fue así para mantenerme fiel al enfoque dado inicialmente al tema por parte de su autor. Luego él mencionó el problema de los espacios, y creo que después presentó en un programa capaz de manejar ese problema.

Leosansan ya va tranquilo, calma. Por supuesto que el elemento central de una sucesión de cinco elementos no es el 2.5, sino el 2 (o sea, de índice 2). Se trataba de una condición que pudiera discernir los valores correctos de i a tomar. Al redondear a enteros, la condición i < 2.5 se reduce a i = 0, 1, 2, como queríamos.

O más precisamente, tal como rir3760 y tú dicen la condición i< N/2 es la apropiada si para el caso impar no se toma el elemento central (el caso nuestro), y la condición i < (float)N / 2, o bien i < (N+1)/2 si el elemento central fuera tomado (que no es nuestro caso).

Pero yo tuve un lapsus y por alguna razón incluí el elemento central o pivote, de donde surgió toda la discusión. Conste que incluir este pivote no afecta el resultado del programa, por cuánto estaría comparando dicho elemento consigo mismo y a lo peor incurre en una pequeña falta de eficiencia.