Foro de elhacker.net

Programación => Programación C/C++ => Mensaje iniciado por: deibenK en 28 Marzo 2014, 06:47 am


Título: LLENAR UNA MATRIZ DISPERSA LISTA TRIPL
Publicado por: deibenK en 28 Marzo 2014, 06:47 am
Que tal gente resulta que ando haciendo un programa para llenar, sumar, multiplicar, sacar el prom,etc. y cuando intento llenar los datos con sus columna y filas al finalizar antes de entrar al menú me saca del programa, me ayudan?

Código
  1. #include<iostream>
  2. #include<conio2.h>
  3. #include<stdio.h>
  4.  
  5. using namespace std;
  6. //parametrización
  7. void LLENAR_f(int [3][100],int ,int ,int );
  8. void SUAMAR_f(int [3][100]);
  9. void MULTIPLICAR_f(int [3][100]);
  10. void REDIMENCIONAR_f(int [3][100]);
  11. void PROM_FILA_f(int[3][100]);
  12. void CANTIDAD_IMPARES_f(int [3][100]);
  13.  
  14. int main()
  15. {   
  16.     int MDlistrip[3][100]={0};
  17.     float R[3][100]={0};
  18.     int NF,NC,ND;
  19.     short op;
  20.     cout<<"\nIngrese numero de Filas";
  21.     cin>>NF;
  22.     cout<<"\nIngrese numero de Columnas";
  23.     cin>>NC;
  24.     cout<<"\nIngrese numero de Datos";
  25.     cin>>ND;
  26.     LLENAR_f(MDlistrip,NF,NC,ND);
  27.     do
  28.     { 
  29.         gotoxy(15,1);
  30.         cout<<"Menu Principal";
  31.         cout<<"\nSumar dos matrices dispersas 1:"; 
  32.         cout<<"\nMultiplicar dos matrices dispersas 2:"; 
  33.         cout<<"\nEncontrar la traspuesta de ambas matrices dispersas 3:"; 
  34.         cout<<"\nMostrar el promedio de cada fila 4:"; 
  35.         cout<<"\nMostrar la cantidad de impares de cada columna 5:";
  36.         cout<<"\nMostrar las matrices dispersas 6:";  
  37.         cout<<"\nIngrese dato del menu:"; 
  38.         cin>>op; 
  39.         switch(op) 
  40.         { 
  41.             case 1 : SUAMAR_f(MDlistrip) ;break; 
  42.             case 2 : MULTIPLICAR_f(MDlistrip);break; 
  43.            // case 3 : TRASPUESTAS_f();break; 
  44.             case 4 : PROM_FILA_f(MDlistrip);break; 
  45.             case 5 : CANTIDAD_IMPARES_f(MDlistrip);break;
  46.             case 6 : ;break;  
  47.         } 
  48.      }while(op>=1||op<=6);
  49.     system("PAUSE");
  50.  
  51.     return EXIT_SUCCESS;
  52. }
  53.  
  54. void LLENAR_f(int MDlistrip[3][100],int NF,int NC,int ND)
  55. {
  56.      float dat;
  57.      int f,c;
  58.      short i,j;
  59.      MDlistrip[0][0]=NF;
  60.      MDlistrip[0][1]=NC;
  61.      MDlistrip[0][3]=ND;
  62.      for(i=1;i<=MDlistrip[0][3]+1;i++)
  63.      {
  64.             cout<<"\nIngrese Filas";
  65.             cin>>MDlistrip[i][0];
  66.             cout<<"\nIngrese Columnas";
  67.             cin>>MDlistrip[i][1];
  68.             cout<<"\nIngrese Dato";
  69.             cin>>MDlistrip[i][2];  
  70.      }
  71. }
  72. void SUAMAR_f(int MDlistrip[3][100])
  73. {
  74.     int MDlistripB[3][100]={0};
  75.     int MDlistripR[3][100]={0};
  76.     int NF,NC,ND;
  77.     short k=1;
  78.     cout<<"\nIngrese numero de Filas de la matriz B";
  79.     cin>>NF;
  80.     cout<<"\nIngrese numero de Columnas de la matriz B";
  81.     cin>>NC;
  82.     cout<<"\nIngrese numero de Datos de la matriz B";
  83.     cin>>ND;
  84.     LLENAR_f(MDlistripB,NF,NC,ND);
  85.     while ((k<= MDlistripB[0][2]+1)&&(k<=MDlistrip[0][2]+1))
  86.     {
  87.           if((MDlistripB[k][0]==MDlistrip[k][0])&&(MDlistripB[k][1]==MDlistrip[k][1]))
  88.           {
  89.              MDlistripR[k][0]=MDlistrip[k][0];
  90.              MDlistripR[k][0]=MDlistrip[k][0];
  91.              MDlistripR[k][2]=MDlistrip[k][2]+MDlistripB[k][2];
  92.              k++;
  93.           }
  94.           else
  95.           {
  96.               if(MDlistrip[k][0]<MDlistripB[k][0])
  97.               {
  98.                    MDlistripR[k][0]=MDlistripB[k][0];
  99.                    MDlistripR[k][0]=MDlistripB[k][1];
  100.                    MDlistripR[k][0]=MDlistripB[k][2];
  101.                    k++;
  102.                    MDlistripR[k][0]=MDlistripB[k][0];
  103.                    MDlistripR[k][0]=MDlistripB[k][1];
  104.                    MDlistripR[k][0]=MDlistripB[k][2];
  105.                    k++;
  106.               }
  107.               else if (MDlistrip[k][0]>MDlistripB[k][0])
  108.               {
  109.                    MDlistripR[k][0]=MDlistripB[k][0];
  110.                    MDlistripR[k][0]=MDlistripB[k][1];
  111.                    MDlistripR[k][0]=MDlistripB[k][2];
  112.                    k++;
  113.                    MDlistripR[k][0]=MDlistripB[k][0];
  114.                    MDlistripR[k][0]=MDlistripB[k][1];
  115.                    MDlistripR[k][0]=MDlistripB[k][2];
  116.                    k++;
  117.               }
  118.           }
  119.  
  120.     }
  121. }
  122. void MULTIPLICAR_f(int MDlistrip[3][100])
  123. {
  124.     int MDlistripB[3][100]={0};
  125.     int MDlistripR[3][100]={0};
  126.     int NF,NC,ND;
  127.     short k=1;
  128.     cout<<"\nIngrese numero de Filas de la matriz B";
  129.     cin>>NF;
  130.     cout<<"\nIngrese numero de Columnas de la matriz B";
  131.     cin>>NC;
  132.     cout<<"\nIngrese numero de Datos de la matriz B";
  133.     cin>>ND;
  134.     LLENAR_f(MDlistripB,NF,NC,ND);
  135.     if ((MDlistripB[0][0]==MDlistripB[0][0])&&(MDlistripB[0][0]==MDlistripB[0][0]))
  136.     {
  137.         if((MDlistripB[k][0]==MDlistrip[k][0])&&(MDlistripB[k][1]==MDlistrip[k][1]))
  138.           {
  139.              MDlistripR[k][0]=MDlistrip[k][0];
  140.              MDlistripR[k][0]=MDlistrip[k][0];
  141.              MDlistripR[k][2]=MDlistrip[k][2]*MDlistripB[k][2];
  142.              k++;
  143.           }
  144.           else
  145.           {
  146.  
  147.           }
  148.     }
  149.     else
  150.     {
  151.         cout<<"\nNo se puede multiplicar las matrices";
  152.     }
  153. }
  154. void REDIMENCIONAR_f(int MDlistripR[3][100])
  155. {
  156.      int k;
  157.      float aux[3][100];
  158.      for (k=0;k<=(MDlistripR[0][2]+1);k++)
  159.      {
  160.          aux[k][0]=MDlistripR[k][0];
  161.          aux[k][1]=MDlistripR[k][1];
  162.          aux[k][2]=MDlistripR[k][2];
  163.      }
  164. }
  165.  
  166.  
  167. void PROM_FILA_f(int MDlistrip[3][100])
  168. {
  169.      int f;
  170.      short i,k;
  171.      float prom,ac=0;
  172.      cout<<"\nQue fila desea sacar el promedio?:\t";
  173.      cin>>f;
  174.      for (i=1;i<=(MDlistrip[0][2]+1);i++)
  175.      {
  176.          if(MDlistrip[i][0]=f)
  177.          {
  178.              for(k=i;k<=f;k++)
  179.              {
  180.                 ac=ac+MDlistrip[i][2];
  181.              }
  182.  
  183.          }
  184.      }
  185.      prom=ac/MDlistrip[0][1];
  186.      cout<<prom;
  187. }
  188.  
  189. void CANTIDAD_IMPARES_f(int MDlistrip[3][100])
  190. {
  191.      int c, ac=0;
  192.      short i,k;     
  193.      cout<<"\nQue columna quiere ver impares?:\t";
  194.      cin>>c;
  195.      for (i=1;i<=(MDlistrip[0][2]+1);i++)
  196.      {
  197.          if(MDlistrip[i][1]=c)
  198.          {
  199.              for(k=i;k<=c;k++)
  200.              {
  201.                 if(MDlistrip[k][2] %2 !=0 )
  202.                 {
  203.                     ac=ac+1;
  204.                 }
  205.              }
  206.  
  207.          }
  208.      }
  209.      cout<<"\nHay",ac,"impares en la columna",c;
  210.  
  211. }
  212. void MOSTRAR_f(int MDlistrip[3][100])
  213. {
  214.      short k;
  215.      for (k=0;k<=(MDlistrip[0][2]+1);k++)
  216.      {
  217.          cout<<MDlistrip[k][0],"\n";
  218.          cout<<MDlistrip[k][1],"\n";
  219.          cout<<MDlistrip[k][2],"\n";
  220.  
  221.      }
  222. }
  223.  

Título: Re: LLENAR UNA MATRIZ DISPERSA LISTA TRIPL
Publicado por: leosansan en 28 Marzo 2014, 08:28 am

A simple vista observo varios errores:

* Declaras las dimensiones de las matrices antes de introducir sus dimensiones, NF y NC.

* Pides ingresar el número de dato ND cuando éste está fijado por las dimensiones de la matriz: NFxNC. Lo que tendrías es que introducir los datos.

* En la función LLENAR para introducir los datos tienes que usar dos bucles o for para ir llenando filas y columnas. El for que tienes ahí es una locura.

* Antes de sumar o multiplicar deberías comprobar si las dimensiones de las dos matrices permiten esa operación.

****** Vete arreglando esas cosas y luego hablamos.

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


(http://st.forocoches.com/foro/images/smilies/aaaaa.gif)


Título: Re: LLENAR UNA MATRIZ DISPERSA LISTA TRIPL
Publicado por: eferion en 28 Marzo 2014, 08:51 am
* Si usas C++ no pongas includes de C ( los que acaban en .h) y más aún si estos includes no son necesarios.

* Deberías utilizar el mismo tipo de dato en las diferentes matrices:

Código
  1. void REDIMENCIONAR_f(int MDlistripR[3][100])
  2. {
  3.      int k;
  4.      float aux[3][100];
  5.      for (k=0;k<=(MDlistripR[0][2]+1);k++)
  6.      {
  7.          aux[k][0]=MDlistripR[k][0];
  8.          aux[k][1]=MDlistripR[k][1];
  9.          aux[k][2]=MDlistripR[k][2];
  10.      }
  11. }

Ahí recibes una matriz de tipo int y la copias en... una matriz de tipo float?? además, aux se pierde una vez sales de la función. Esta función por ejemplo no hace nada productivo.

* La definición de matriz es valores=cifras*columnas. Dicho esto, no tiene ningún sentido el tratamiento que le das en partes del código como:

Código
  1.     cout<<"\nIngrese numero de Filas";
  2.     cin>>NF;
  3.     cout<<"\nIngrese numero de Columnas";
  4.     cin>>NC;
  5.     cout<<"\nIngrese numero de Datos";
  6.     cin>>ND;

o:

Código
  1.  for(i=1;i<=MDlistrip[0][3]+1;i++)
  2.      {
  3.             cout<<"\nIngrese Filas";
  4.             cin>>MDlistrip[i][0];
  5.             cout<<"\nIngrese Columnas";
  6.             cin>>MDlistrip[i][1];
  7.             cout<<"\nIngrese Dato";
  8.             cin>>MDlistrip[i][2];  
  9.      }

Si tu programa maneja dos matrices deberías diseñar una estructura que gestione la matriz y utilizarla para manejar las dos matrices. No se, algo tal que:

Código
  1. struct Matriz
  2. {
  3.   int filas;
  4.   int columnas;
  5.   int* datos;
  6. };
  7.  
  8. // Sin memoria dinámica
  9. struct Matriz2
  10. {
  11.   int filas;
  12.   int columnas;
  13.   int datos[MAX_FILAS][MAX_COLUMNAS];
  14.  

O, si quieres aprovechar un poco las capacidades de programación orientada a objetos:

Código
  1. class Matriz
  2. {
  3.   public:
  4.     Matriz( int filas, int columnas );
  5.  
  6.     ~Matriz( );
  7.  
  8.     void SetDato( int fila, int columna, int dato );
  9.  
  10.     int Dato( int fila, int columna ) const;
  11.  
  12.     int Filas( ) const;
  13.  
  14.     int Columnas( ) const;
  15.  
  16.   private:
  17.  
  18.     int _filas;
  19.     int _columnas;
  20.  
  21.     // Esta se puede sustituir por una matriz fija para evitar el uso de memoria dinamica
  22.     int* _datos;
  23. };

Tú estás creando una matriz de una forma muy extraña que no te garantiza celdas duplicadas o inexistentes y que, además, no te permite trabajar con dos matrices para hacer las operaciones básicas.

En serio, no termino de entender por qué generas una terna( fila, columna, dato ). ¿Qué sucede si el usuario repite los valores de fila y columna? ¿Y si hay una dupla fila-columna que se olvida de indicar? ¿Y si tengo, por ejemplo, una matriz de 2x2 e intento rellenar un dato de la fila 4, columna 20? ¿Y si indico una fila / columna negativa?

El modelo que propones es demasiado propenso a errores y es bastante complejo de gestionar y de usar. Hay formas mucho más sencillas:

Código
  1. #include <iostream>
  2.  
  3. #define MAX_FILAS 20
  4. #define MAX_COLUMNAS 20
  5.  
  6. struct Matriz
  7. {
  8.   int filas;
  9.   int columnas;
  10.   int datos[MAX_FILAS][MAX_COLUMNAS];
  11.  
  12.   Matriz( ) : filas( 0 ), columnas( 0 )
  13.   { }
  14. };
  15.  
  16. Matriz Sumar( const Matriz& matriz1, const Matriz& matriz2 )
  17. {
  18.   Matriz resultado;
  19.  
  20.   if ( matriz1.filas == matriz2.filas && matriz1.columnas == matriz2.columnas )
  21.   {
  22.     resultado.filas = matriz1.filas;
  23.     resultado.columnas = matriz1.columnas;
  24.  
  25.     for ( int i=0; i<resultado.filas; i++ )
  26.     {
  27.       for ( int j=0; j<resultado.columnas; j++ )
  28.         resultado.datos[ i ][ j ] = matriz1.datos[ i ][ j ] + matriz2.datos[ i ][ j ];
  29.     }
  30.   }
  31.  
  32.   return resultado;
  33. }
  34.  
  35. void Imprimir( const Matriz& matriz )
  36. {
  37.   for ( int i = 0; i < matriz.filas; i++ )
  38.   {
  39.     for ( int j = 0; j < matriz.columnas; j++ )
  40.       std::cout << matriz.datos[ i ][ j ] << " ";
  41.  
  42.     std::cout << std::endl;
  43.   }
  44. }
  45.  
  46. int main( )
  47. {
  48.   Matriz matriz1, matriz2;
  49.  
  50.   matriz1.filas = 2;
  51.   matriz1.columnas = 2;
  52.  
  53.   for ( int i=0; i<matriz1.filas; i++ )
  54.   {
  55.     for ( int j=0; j<matriz1.columnas; j++ )
  56.       matriz1.datos[ i ][ j ] = j - i;
  57.   }
  58.  
  59.   matriz2.filas = 2;
  60.   matriz2.columnas = 2;
  61.   for ( int i=0; i<matriz1.filas; i++ )
  62.   {
  63.     for ( int j=0; j<matriz2.columnas; j++ )
  64.       matriz2.datos[ i ][ j ] = 2* i + j;
  65.   }
  66.  
  67.   // Sumamos las matrices
  68.   if ( matriz1.filas == matriz2.filas && matriz1.columnas == matriz2.columnas )
  69.   {
  70.     Matriz resultado;
  71.     resultado.filas = matriz1.filas;
  72.     resultado.columnas = matriz1.columnas;
  73.  
  74.     for ( int i=0; i<resultado.filas; i++ )
  75.     {
  76.       for ( int j=0; j<resultado.columnas; j++ )
  77.         resultado.datos[ i ][ j ] = matriz1.datos[ i ][ j ] + matriz2.datos[ i ][ j ];
  78.     }
  79.   }
  80.  
  81.   Matriz resultado = Sumar( matriz1, matriz2 );
  82.  
  83.   std::cout << "Matriz1:" << std::endl;
  84.   Imprimir( matriz1 );
  85.  
  86.   std::cout << "Matriz2:" << std::endl;
  87.   Imprimir( matriz2 );
  88.  
  89.   std::cout << "Resultado:" << std::endl;
  90.   Imprimir( resultado );
  91.   return 0;
  92. }

Aún así, insisto, queda mejor con clases que con estructuras... pero creo que es preferible que te manches un poco las manos y no dártelo todo hecho ;)

Título: Re: LLENAR UNA MATRIZ DISPERSA LISTA TRIPL
Publicado por: Eternal Idol en 28 Marzo 2014, 11:14 am
Por favor traten de mantener el codigo al minimo, que lo escriban los que tienen el problema y no los demas participantes del foro.


Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines