Mensajes

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

En tu código, a no ser que sólo sea una parte, te sobran una librería: <fstream> y si quieres hacer uso de getchar en lugar de system, sobraría la librería <csdtlib> y faltaría la <cstdio>.

Yo soy más partidario de que el usuario, que normalmente no tiene pajorera idea de informática, introduzca los índices como se hace en mates, es decir el primer elemento de la matriz es el (1,1) y así sucesivamente así como llamar a las matrices con el nombre con que se declaran las variables, si no al final se puede uno liar de quién es quién. Y no queda mal una impresión final en forma de matriz de la matriz suma.

Y por último, sería partidario de declarar como macros el número de filas y columnas, no sea que tengas que cambiar esas dimensiones. Te ahorrarías ir por todo el código cambiando el 3 y el 4 por los nuevos valores en cambio con las macros sólo tienes que cambiarlos a ellos en un solo sitio:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include<cstdio>

#define FILAS     3
#define COLUMNAS  4

using namespace std;
int main()
{
   int A[FILAS][COLUMNAS];
   int B[FILAS][COLUMNAS];
   int SUMA[FILAS][COLUMNAS];
   int i, j;

   for (i=0; i<FILAS; i++){
       for (j=0; j<COLUMNAS; j++){
           cout<<"A["<<i<<"]["<<j<<"] = ";
           cin>> A[i][j];
       }
   }
   for (i=0; i<FILAS; i++){
       for (j=0; j<COLUMNAS; j++){
           cout<<"B["<<i<<"]["<<j<<"] = ";
           cin>> B[i][j];
       }
   }
   for (i=0; i<FILAS; i++) {
     for (j=0; j<COLUMNAS; j++) {
       SUMA[i][j]= A[i][j] + B[i][j];
       cout<< "SUMA" <<"["<< i <<"]["<<j<<"]= "<< SUMA[i][j]<<endl;
     }
   }
   for (i=0; i<FILAS; i++){
     for (j=0; j<COLUMNAS; j++){
       cout<<SUMA[i][j]<<"  ";
     }
     cout<< endl;
   }
   getchar();
   return 0;
}

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

["calcular para cada columna el ancho"]

La idea es sencilla a la vez que ingeniosa.

Se trata de "calcular para cada columna el ancho" o largo de la mayor cadena de dicha columna. Esto hay que hacerlo para cada una de las 8 columnas por lo que uso un array para guardar esos largos y/o anchos, "ancho[8]".

Una vez calculados los anchos uso una opción de printf, "%-*s" donde el signo menos es para que alinee a la izquierda y el "*" es para incluir el ancho que se introduce como primer argumento del printf y así cada columna ocupa un ancho especifico, añadiendo +2 a ancho[j] en el printf para que ademas deje dos espacios en blanco.

Calculé el ancho haciendo uso del "operador condicional o ternario", más que nada porque es una de las primeras cosas que se ve al empezar el C, al menos a mi me paso, y que sin embargo no se le suele dar mucha utilidad. Suele acortar los códigos aunque reconozco que para los que se inician en el lenguaje es más fácil no usarlo y hacer uso de "if" y compañía.

Aquí dejo una versión de lo mismo sin el mencionado operador condicional y espero que ahora haya quedado clara la idea básica del método que, como comenté al principio, me pareció ingeniosa a la vez que sencilla, de ahí que el código resultante fuera tan "cortito" .

Código (cpp) [Seleccionar] Expandir

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

int main() {
int i, j,mayor=0 ,ancho[8]={0};
 char *tabla[2][8] = {{"Hacker", "Perro", "Labrador", "Macho", "Cafe", "3", "Servicio Simple", "600"},
     {"Fugi", "Camaleon", "Silvestre", "Hembra", "Muticolor", "8",  "Servicio Premium", "1200"}};
 char *titulos[8] = {"Nombre", "Animal", "Raza", "Sexo", "Color", "Edad", "Servicio", "Costo"};
 for ( i = 0; i < 1; i++ )
   for ( j = 0; j < 8; j++ ){
     if (strlen(tabla[i][j])>mayor)
         mayor = strlen(tabla[i][j]);
     if (strlen(tabla[i+1][j])>mayor)
         mayor = strlen(tabla[i+1][j]);
     if (strlen(titulos[j])>mayor)
         mayor = strlen(titulos[j]);
     ancho[j] = mayor;
     mayor=0;
   }
 for ( j = 0; j < 8; j++ )
   printf( "%-*s", ancho[j]+2, titulos[j]);
 printf( "\n\n" );
 for ( i = 0; i < 2; i++ ) {
   for ( j = 0; j < 8; j++ ) {
   printf( "%-*s", ancho[j]+2,tabla[i][j] );
   }
   printf( "\n\n" );
 }
  return 0;
}

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

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

Por simple curiosidad lo he probado, tanto en Dev-C++ como en Code::Blocks, y sin problemas. Y con el antivirus y firewall activado.

En tu caso, como logras compilar y ejecutar la primera vez, todo parece indicar que al ejecutar por segunda vez y actuar el .exe algún programa de los que tienes instalado lo  bloquea. ¿Y cuál es?. Mejor que tu nadie puede saberlo. Mira bien los programas de seguridad que tienes instalados y trastea un poco.

Pero, en resumen, no es problema ni del Dev-C++ ni del Code::Blocks.

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

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

Con ancho variable pero haciendo uso de las opciones de la función printf:

Código (cpp) [Seleccionar] Expandir


Nombre  Animal    Raza       Sexo    Color      Edad  Servicio          Costo

Hacker  Perro     Labrador   Macho   Cafe       3     Servicio Simple   600

Fugi    Camaleon  Silvestre  Hembra  Muticolor  8     Servicio Premium  1200


Process returned 0 (0x0)   execution time :  0.023 s
Press any key to continue.


Código (cpp) [Seleccionar] Expandir

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

int main() {
int i, j,mayor ,ancho[8]={0};
 char *tabla[2][8] = {{"Hacker", "Perro", "Labrador", "Macho", "Cafe", "3", "Servicio Simple", "600"},
     {"Fugi", "Camaleon", "Silvestre", "Hembra", "Muticolor", "8",  "Servicio Premium", "1200"}};
 char *titulos[8] = {"Nombre", "Animal", "Raza", "Sexo", "Color", "Edad", "Servicio", "Costo"};
 for ( i = 0; i < 1; i++ )
   for ( j = 0; j < 8; j++ ){
     if ((mayor= strlen(tabla[i][j])>strlen(tabla[i+1][j]) ? strlen(tabla[i][j]):strlen(tabla[i+1][j]))>(strlen(titulos[j])))
       ancho[j]=mayor;
     else
       ancho[j]=strlen(titulos[j]);
   }
 for ( j = 0; j < 8; j++ )
 printf( "%-*s", ancho[j]+2, titulos[j]);
 printf( "\n\n" );
 for ( i = 0; i < 2; i++ ) {
   for ( j = 0; j < 8; j++ ) {
   printf( "%-*s", ancho[j]+2,tabla[i][j] );
   }
   printf( "\n\n" );
 }
  return 0;
}

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

.............................................................
Bueno, regresando a mi cruda realidad, me gustaría que me echaras un cable para ayudarme a detectar el/los problema/s que pueda tener mi programa.
......................................................
Pero veo mi ejercicio y la declaración de variables que hay que hacer por narices y no se cómo continuar
.............................................

Si tienes en cuenta la relacion intima entre punteros y arrays no te pasaria esto:

Código (cpp) [Seleccionar] Expandir

*(pv+2))=vocales[2]=0

Y lo que quieres hacer es incrementar vocales[2] que lo harias como
vocales[2]++;

Pues con el puntero lo mismo:

(*(pv+2))++;


Con esta idea sale el siguiente código:

Código (cpp) [Seleccionar] Expandir

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

//Prototipo
void cuentavocales(char v[5]);

int main()
{
  char frase[256],*pf=frase;
  cuentavocales(frase);
  system("PAUSE");
  return 0;
}

//Función que cuenta las vocales de la frase
void cuentavocales(char frase[5])
{
     int i=0,vocales[5]={0};
     int * pv,pv0;
     pv = &vocales[0];

    pv0=pv;
     printf("Introduce una frase: \n");
     gets(frase);
     for(i=0;i<strlen(frase);i++){
       if(frase[i]=='a'|| frase[i]=='A')
        (*(pv+0))++;
      else if(frase[i]=='e' || frase[i]=='E')
        (*(pv+1))++;
      else if(frase[i]=='i' || frase[i]=='I')
       (*(pv+2))++;
       else if(frase[i]=='o' || frase[i]=='O')
        (*(pv+3))++;
      else if(frase[i]=='u' || frase[i]=='U')
        (*(pv+4))++;
    }

//Mostramos los resultados por pantalla
printf("Estadistica \n");
printf("a: %d \n",*pv);
printf("e: %d \n",*(pv+1));
printf("i: %d \n",*(pv+2));
printf("o: %d \n",*(pv+3));
printf("u: %d \n",*(pv+4));
printf("\n TOTAL: %d\n",*pv+*(pv+1)+*(pv+2)+*(pv+3)+*(pv+4));
}

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

hola tengo una duda sobre las funciones.
yo tengo una funcion llamada mifuncion() que devuekve -1 en caso de producirse un error.
mi duda: yo hago la siguiente asignacion:
   if(mifuncion() == -1){
      perror("Error");
   }

¿estaría bien el código o habría que asignarle previamente el valor devuelto por la función a una variable?:
if((variable=mifuncion()) == -1){
  perror("Error");
}

yo creo que con la primera opción seria suficiente para saber si en la función se produce error.

¿alguien me aclara la duda?

Sí, la primera sería suficiente, pero la segunda como la tienes parece una repetición de la primera. Supongo que lo que querías poner es:

Código (cpp) [Seleccionar] Expandir

variable=mifuncion();
if((variable== -1){
    perror("Error");
}

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

[stdlib]

tengo un problema, quisiera por favor si me pueden ayudar, me he quedado atascado
.............................................
porque en un printf me escribe una cosa diferente del otro printf?

Porque los valores se los has pasado a la función por valor por lo que su valor al volver a main no varían respecto a los que ya tenían en dicha función main  y como no los habías inicializados contienen basura o valores indeterminados.

Para actualizar los valores en main con los obtenidos en la función tendrás que pasarlos por referencia mediante el uso de punteros ... y de esta forma no es necesario inicializar las variables, aunque siempre es aconsejable hacerlo:

EN LA FUNCION FECHA:24-3-2014
EN MAIN: 24-3-2014
Presione una tecla para continuar . . .

Process returned 0 (0x0)   execution time : 0.435 s
Press any key to continue.

Por cierto, te falta la librería stdlib para el uso de system y de EXIT_SUCCESS:

Código (cpp) [Seleccionar] Expandir

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
/*-------------prototipo de funcion--------------*/
void fecha(int *d, int *m, int *a);
/*-------------algoritmo principal----------------*/

int main()
{
   int dia, mes, anho;
   fecha(&dia, &mes, &anho);
   printf("EN MAIN: %d-%d-%d\n", dia, mes, anho);
   system("PAUSE");
   return EXIT_SUCCESS;
}
void fecha(int *d, int *m, int *a)
{
   time_t ahora;
   struct tm *fecha;
   time(&ahora);
   fecha = localtime(&ahora);
   *d = fecha->tm_mday;
   *m = fecha->tm_mon+1;
   *a = fecha->tm_year+1900;
   printf("EN LA FUNCION FECHA:%d-%d-%d\n", *d, *m, *a);
}

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

[leosansan]

Me ha molado mucho ver esas dos ultimas formas de hacerlo, sobre todo la que propone leosansan, deduzco que

Código (cpp) [Seleccionar] Expandir

variable = variable + algo. /* Es lo mismo que*/ variable += algo
Lo de las librerias tengo que tener cuidado por lo que veo.


Gracias un saludo!!
 

Gracias, gracias, me alegra que te haya gustado el "mas_menos". 

Y sí, son formas equivalentes y más usuales:

Código (cpp) [Seleccionar] Expandir

variable = variable + algo. /* Es lo mismo que*/ variable += algo

Código (cpp) [Seleccionar] Expandir

variable = variable * algo. /* Es lo mismo que*/ variable *= algo

Código (cpp) [Seleccionar] Expandir

variable = variable - algo. /* Es lo mismo que*/ variable -= algo

Código (cpp) [Seleccionar] Expandir

variable = variable / algo. /* Es lo mismo que*/ variable /= algo

Y alguna más.

Y lo de las librerías no estaba mal en si, sólo que sobraban y es un "cante" para si te corrige algún profesor darse cuenta de tus lagunas, que tenerlas las tendrás, como todos, pero una máxima del estudiante es que al menos no se noten.

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

[amchacon]

No recomiendo para nada usar pow aquí, es muy mala práctica ya que pow es una función relativamente costosa y aquí no la necesitas.
....................................

Totalmente de acuerdo.

Antes que nada, le sobraban dos librerías,  <fstream>, <string> y le habría faltado tal como lo tenía  <cstdlib> para el system. Ahora con getchar faltaría <cstdio> y sin pow sobraría <cmath>.

Me apunto al no uso de pow y, como simple variante al método de amchacon, ya que creo que "*" es menos costosa como operación que "%":

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <cstdio>

using namespace std;

int main () {
  double pi,serie=0.0;
  int n,i,mas_menos=1 ;
  cout << "Entre el numero de terminos a tomar: ";
  cin >> n;
  for(i=0; i< n; i++){
     serie+=(1./(2*i+1))*mas_menos;
     mas_menos*=-1;
  }
  pi=4*serie;
  cout << pi<< endl;
  getchar();
  return 0;
}

Yen mi código es" i<", no" i<=" ya que en dicho caso tomaría un sumando de más.

Observar el 1. en 1./(2*i+1) ya que de poner sólo 1/(2*i+1) la operación sería entre enteros y no daría el resultado esperado de double.

Y Feynmann para cuando cuelgues  código elige las etiquetas GeSHi y toma la C++ y en medio de las etiquetas Code que aparecen "pegas" tu código. Al no hacerlo de esta manera parte del código no sale correcta, especialmente las matrices.

[....xD PEDAZO DE CÓDIGOS....................para este viaje no hacen falta tantas alforjas...............]

....xD PEDAZO DE CÓDIGOS.....

...............para este viaje no hacen falta tantas alforjas...............

Amigo ivancea96 para obtener esta salida:

1
1   1
1   2   1
1   3   3   1
1   4   6   4   1
1   5  10  10   5   1
1   6  15  20  15   6   1
1   7  21  35  35  21   7   1
1   8  28  56  70  56  28   8   1
1   9  36  84 126 126  84  36   9   1
1  10  45 120 210 252 210 120  45  10   1
1  11  55 165 330 462 462 330 165  55  11   1
1  12  66 220 495 792 924 792 495 220  66  12   1
1  13  78 286 715 1287 1716 1716 1287 715 286  78  13   1
1  14  91 364 1001 2002 3003 3432 3003 2002 1001 364  91  14   1
1  15 105 455 1365 3003 5005 6435 6435 5005 3003 1365 455 105  15   1
1  16 120 560 1820 4368 8008 11440 12870 11440 8008 4368 1820 560 120  16   1

aunque podrías haber hecho trampas, cosa que no has hecho, usando [ center ] para que saliera el triángulo isósceles que pedimos en este reto:

1
1   1
1   2   1
1   3   3   1
1   4   6   4   1
1   5  10  10   5   1
1   6  15  20  15   6   1
1   7  21  35  35  21   7   1
1   8  28  56  70  56  28   8   1
1   9  36  84 126 126  84  36   9   1
1  10  45 120 210 252 210 120  45  10   1
1  11  55 165 330 462 462 330 165  55  11   1
1  12  66 220 495 792 924 792 495 220  66  12   1
1  13  78 286 715 1287 1716 1716 1287 715 286  78  13   1
1  14  91 364 1001 2002 3003 3432 3003 2002 1001 364  91  14   1
1  15 105 455 1365 3003 5005 6435 6435 5005 3003 1365 455 105  15   1
1  16 120 560 1820 4368 8008 11440 12870 11440 8008 4368 1820 560 120  16   1

Como decía, para obtener esa salida creo que no hace falta un código tan extenso/complejo. Este que te pongo a continuación hace lo mismo que el tuyo y es considerablemente más "cortito", exactamente una décima parte:

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
int main(void){
 unsigned  int a,b,k,n,filas=16;
 for(n = 0; n <= filas; n++){
   putchar ('1');
   for(k = b = 1, a = n; b <= n; b++, a--)
     printf("%3u " ,k = k * a / b);
   putchar('\n');
 }
 return 0;
}




¡Ah!, que tenía que tener esta forma:

                   1
                 1   1
               1   2   1
             1   3   3   1
           1   4   6   4   1
         1   5  10  10   5   1
       1   6  15  20  15   6   1
     1   7  21  35  35  21   7   1
   1   8  28  56  70  56  28   8   1
 1   9  36  84 126 126  84  36   9   1

Conste que con las etiquetas quote sale algo deformado, pero al ejecutarlo en consola sale perfecto:

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
int main(void){
 unsigned  int i,a,b,k,n,filas=13;
 for(n = 0; n <= filas; n++){
   for (i=0;i<filas-n;i++)
     printf("   ");
     putchar ('1');
   for(k = b = 1, a = n; b <= n; b++, a--)
     printf("%5u " ,k = k * a / b);
   putchar('\n');
 }
 return 0;
}


Bueno está bien, tú usabas un array. Pues yo también:

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
#define N   16
int main(void){
 unsigned  int a,b,k,n,comb[N+1][N+1];
 for(a = 0; a <= N; a++)
   for(b = 0; b <= N; b++)
     (b==0) ? (comb[a][b]=1) :(comb[a][b]=0);
 for(n = 0; n <= N; n++)
   for(k = b = 1, a = n; b <= n; b++, a--){
     k = k * a / b;
     comb[n][b]=k ;
   }
 for(a = 0; a <= N; a++){
   for(b = 0; b <= N; b++)
     if (comb[a][b]!=0)
       printf("%3u " ,comb[a][b]);
   putchar('\n');
 }
  return 0;
}

Como ves sigue siendo "cortito".

Dándole vueltas al triángulo de Pascal y viendo que el "cálculo directo" con factoriales tiene el inconveniente de los mencionados factoriales, se observa que los números combinatorios que forman el triángulo son, por ejemplo:

(7 0)=1  

(7 0)=1  

(7 1)=7/1
 
(7 2)=7/1 *6/2 =7*6/1*2

(7 3)=/1 *6/2* 5/3 =7*6*5/1*2*3

(7 4)=7/1 *6/2* 5/3* 4/4= 7*6*5*4/1*2*3*4 =7*6*5/1*2*3 = (7 3)

(7 5)=7/1 *6/2* 5/3 *4/4* 3/5= 7*6*5*4*3/1*2*3*4*5 = 7*6/1*2= (7 2)

(7 6)=7/1 *6/2*5/3*4/4*3/5*2/6= 7*6*5*4*3*2/1*2*3*4*5*6= 7/1= (7 1)

(7 7) = 1 = (7 0)=1

es decir, 1*n/i, donde n va disminuyendo e i aumentando, de manera que se evita el cálculo de los factoriales. Además son simétricos con lo que se puede, y debe  por eficiencia, calcular la segunda mitad directamente y obtenerlos  de acuerdo a otra propiedad de los números combinatorios:

Con esta idea
salen los siguientes códigos, con array y sin él::

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
#define N   13
int main(void){
 unsigned  int i,a,b,k,n,comb[N+1][N+1];
 for(a = 0; a <= N; a++)
   for(b = 0; b <= N; b++)
     (b==0) ? (comb[a][b]=1) :(comb[a][b]=0);
 for(n = 0; n <= N; n++)
   for(k = b = 1, a = n; b <= n; b++, a--){
     if (b>N/2)
       comb[n][b]=comb[n][n-b];
      else {
       k = k * a / b;
       comb[n][b]=k ;
      }
   }
 for(a = 0; a <= N; a++){
   for(i = 0; i < N-a; i++)
     printf("  " );
   for(b = 0; b <= N; b++)
     if (comb[a][b]!=0)
       printf("%3u " ,comb[a][b]);
   putchar('\n');
 }
  return 0;
}

Código (cpp) [Seleccionar] Expandir

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

int comb(int n,int k);

int main(){
 int i,j,k;
 int n = 11;
 /*do{
   printf("\nIntroduzca la potencia a calcular (mayor que cero): \n");
   scanf("%d",&n);
   }while ( n < 0 );
   n++;*/
   char tamanyo_consola[80];
   sprintf(tamanyo_consola, "MODE %d,%d", n*6+10+1,40);
   system(tamanyo_consola);
   for (i = 0; i < n; i++){
     for ( j = 1; j <n-i; j++)
     printf ("   ")  ;
     for (k = 0; k <= i; k++)
       printf ("%6d",comb(i,k));
     printf ("\n");
   }
   return 0;
}
int comb(int n,int k){
 if (n < 0 || k < 0 || k > n)
   return 0;
 if (k>n/2)
   k=n-k;
 int c = 1;
 for ( k; k>=1; k--,n--)
   c*=n/k;
 return c;
}

Como en otros códigos anteriores hago uso del system (MODE)  para que la ventana de la consola se ajuste de forma automática al tamaño del triángulo. Y como no podía ser menos, al menos una imagen, sí ya sé que empieza a estar muy vista pero es que" me fascina la belleza de los números", con color o sin ellos:

Y sólo quedan 24 horas para obtener el triángulo a partir de un array unidimensional. ¡¡¡Vamos Ánimo!!!

El caso es que en programación, al menos hasta donde yo alcanzo, por recursividad se entiende al proceso mediante el cual una función o algoritmo se llama a sí mismo para obtener un resultado.

Reutilizar valores anteriores, al menos en programación, no se entiende por recursividad.
..............................

Totalmente de acuerdo, y en Cálculo/Matemáticas tampoco se llama a eso recursividad sino recurrencia, como bien recordó amchacon,  cuando los valores de un término se obtienen a partir de otros anteriores. Otra cosa es cuando la ley o fórmula de recurrencia la apliques de forma iterada, entonces si podemos hablar, incluso matemáticamente, de recursividad. Todo es cuestión de semántica y saber emplear las palabras adecuadas.

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