Foros del Web » Programación para mayores de 30 ;) » C/C++ »

Reimprimir Matriz bidimensional modificada

Estas en el tema de Reimprimir Matriz bidimensional modificada en el foro de C/C++ en Foros del Web. Hola buenas, lo que pasa es que tengo esta tarea final, y me dan una matriz bidimensional con letras, me asignan las siguientes palabras Palabras: ...
  #1 (permalink)  
Antiguo 23/11/2014, 02:52
 
Fecha de Ingreso: noviembre-2014
Mensajes: 5
Antigüedad: 9 años, 5 meses
Puntos: 0
Exclamación Reimprimir Matriz bidimensional modificada

Hola buenas, lo que pasa es que tengo esta tarea final, y me dan una matriz bidimensional con letras, me asignan las siguientes palabras

Palabras: RATONES, PILON, HILAR, ZAPATO, ANCIANO, TUERCA, CAMPO

Las cuales estan dentro de la matriz lo que yo debo hacer es encontrarlas y cambiarlas a minusculas ya tengo la idea planteada, en el codigo que tengo empece como si no se supiera en que direccion estaba la primer palabra para que buscara y fuera descartando(creo que borrare eso, ustedes que dicen?) pero ya luego hice que se buscara en la direccion que yo ya sé, se encuentran las palabras. (esta opcion es mejor no? me deja mas corto el programa)

Lo que pasa es que ya no se como mandar a reimprimir la matriz ya cambiada, ya tengo en el caso de que se cruzen que se considere que si ya estan en minus que se deje como esta. Por favor espero me ayuden y me iluminen con su sabiduria

Código:
#include <iostream>
#include<stdio.h>
#include<stdlib.h>

char matriz[9][10];

int main()
{
    char letra[12];
    int k,R;
    char matriz[9][10]=
    {
        {'E','R','U','Q','R','I','M','M','Z','T'},
        {'O','A','E','Q','I','T','Z','T','Q','M'},
        {'P','T','U','E','R','C','A','Q','O','L'},
        {'Q','O','M','V','V','O','P','M','A','C'},
        {'O','N','A','I','C','N','A','M','G','E'},
        {'M','E','Y','B','O','T','T','Q','I','N'},
        {'N','S','Q','L','R','E','O','M','D','T'},
        {'E','H','I','L','A','R','J','J','N','O'},
        {'O','P','O','C','L','M','U','M','I','C'}
    };
    for(int i=0; i<9; i++)//imprime matriz sopa de letras
        {
            for(int j=0; j<10; j++)
            {
            printf(" %c\t", matriz[i][j]);
            printf("\n");
            }
            
        }

        for(int p=0; p<9; p++)
        {
            for(int q=0; q<10; q++)
            {
                if(matriz[p][q]='R')
                {
                    if (q<4)// buscar hacia la derecha
                    {
                       letra[p*10+q]=matriz[p][q];
                       letra[R]=letra[p*10+q];
                       if(letra[R+1]='A' && letra[R+2]='T' && letra[R+3]='O' && letra[R+4]='N' && letra[R+5]='E' && letra[R+6]='S')
                       {
                           for(int k=R; k<R+7; k++)
                           {
                               if(letra[k]>=65 && letra[k]<=90)
                                letra[k]=letra[k]+32;
                                else letra[k]=letra[k];
                           }
                       }
                    }
                    else
                        if(p<3 && q<4)//esquina inferior derecha
                        {
                            letra[p*10+q]=matriz[p][q];
                            letra[R]=letra[p*10+q];
                            if(letra[R+11]='A' && letra[R+22]='T' && letra[R+33]='O' && letra[R+44]='N' && letra[R+55]='E' && letra[R+66]='S')
                            {
                                for(int k=R; k<R+77; k=k+11)
                                    {
                                        if(letra[k]>=65 && letra[k]<=90)
                                        letra[k]=letra[k]+32;
                                        else letra[k]=letra[k];
                                    }
                            }
                        }
                else
                    if(p<3)//hacia abajo
                    {
                        letra[p*10+q]=matriz[p][q];
                        letra[R]=letra[p*10+q];
                        if(letra[R+10]='A' && letra[R+20]='T' || letra[R+20]='t' && letra[R+30]='O' && letra[R+40]='N' || letra[R+40)='n' && letra[R+50]='E' && letra[R+60]='S')
                       {
                           for(int k=R; k<R+70; k=k+10)
                           {
                               if(letra[k]>=65 && letra[k]<=90)
                                letra[k]=letra[k]+32;
                               else letra[k]=letra[k];
                           }
                       }
                    }
                else
                    if(p<3 && q>5)//hacia esquina inferior izquierda
                    {
                        letra[p*10+q]=matriz[p][q];
                        letra[R]=letra[p*10+q];
                        if(letra[R+9]='A' && letra[R+18]='T' && letra[R+27]='O' && letra[R+36]='N' && letra[R+45]='E' && letra[R+54]='S')
                       {
                           for(int k=R; k<R+63; k=k+9)
                           {
                               if(letra[k]>=65 && letra[k]<=90)
                                letra[k]=letra[k]+32;
                               else letra[k]=letra[k];
                           }
                       }
                    }
                 else
                    if(q>5)//hacia izquierda
                    {
                        letra[p*10+q]=matriz[p][q];
                        letra[R]=letra[p*10+q];
                        if(letra[R-1]='A' && letra[R-2]='T' && letra[R-3]='O' && letra[R-4]='N' && letra[R-5]='E' && letra[R-6]='S')
                       {
                           for(int k=R; k<R-7; k--)
                           {
                               if(letra[k]>=65 && letra[k]<=90)
                                letra[k]=letra[k]+32;
                               else letra[k]=letra[k];
                           }
                       }
                    }
                else//hacia esquina superior izquierda
                    if(p>5 && q>5)
                    {
                        letra[p*10+q]=matriz[p][q];
                        letra[R]=letra[p*10+q];
                        if(letra[R-11]='A' && letra[R-22]='T' && letra[R-33]='O' && letra[R-44]='N' && letra[R-55]='E' && letra[R-66]='S')
                       {
                           for(int k=R; k<R-77; k=k-11)
                           {
                               if(letra[k]>=65 && letra[k]<=90)
                                letra[k]=letra[k]+32;
                               else letra[k]=letra[k];
                           }
                       }
                    }
                
                }
            }
        }
            for(int t=0; t<9; t++)
            {
                for(int u=0; u<10; u++)
                {
                    if(matriz[t][u]='P')
                    {
                        if(t>3 && u<6)// hacia esquina superior derecha
                            {
                                letra[t*10+u]=matriz[t][u];
                                letra[P]=letra[t*10+u];
                                if(letra[P-9]='I' || letra[P-9]='i' && letra[P-18]='L' && letra[P-27]='O' && letra[P-36]='N' || letra[P-36]='n')
                                    {
                                        for(int m=P; m<P-45; m=m-9)
                                        {
                                            if(letra[m]>=65 && letra[m]<=90)
                                            letra[m]=letra[m]+32;
                                            else letra[m]=letra[m];
                                        }
                                    }       
                            }
                        else
                            if (u<6)// buscar hacia la derecha
                            {
                                letra[t*10+u]=matriz[t][u];
                                letra[P]=letra[t*10+u];
                                if(letra[P+1]='I' && letra[P+2]='L' && letra[P+3]='O' && letra[P+4]='N')
                                    {
lespego la continuacion del codigo
  #2 (permalink)  
Antiguo 23/11/2014, 02:55
 
Fecha de Ingreso: noviembre-2014
Mensajes: 5
Antigüedad: 9 años, 5 meses
Puntos: 0
Respuesta: Reimprimir Matriz bidimensional modificada

continuacion del codigo
Código:
for(int m=P; m<P+5; m++)
                                        {
                                            if(letra[m]>=65 && letra[m]<=90)
                                            letra[m]=letra[m]+32;
                                            else letra[m]=letra[m];
                                        }
                                    }
                            }
                    else
                        if(t<5 && u<6)// hacia esuuina inferior derecha
                            {
                                letra[t*10+u]=matriz[t][u];
                                letra[P]=letra[t*10+u];
                                if(letra[P+11]='I' && letra[P+22]='L' && letra[P+33]='O' && letra[P+44]='N')
                                    {
                                        for(int m=P; m<P+55; m=m+11)
                                        {
                                            if(letra[m]>=65 && letra[m]<=90)
                                            letra[m]=letra[m]+32;
                                            else letra[m]=letra[m];
                                        }
                                    }       
                            }
                    else
                        if(t<5)// hacia abajo
                            {
                                letra[t*10+u]=matriz[t][u];
                                letra[P]=letra[t*10+u];
                                if(letra[P+10]='I' && letra[P+20]='L' && letra[P+30]='O' && letra[P+40]='N')
                                    {
                                        for(int m=P; m<P+50; m=m+10)
                                        {
                                            if(letra[m]>=65 && letra[m]<=90)
                                            letra[m]=letra[m]+32;
                                            else letra[m]=letra[m];
                                        }
                                    }       
                            }
                        }
                    
                    }
                }

          for(int x=0; x<9; x++)
            {
                for(int y=0; y<10; y++)
                {
                    if(matriz[x][y]='H')
                    {
                         if (y<6)// buscar hacia la derecha
                            {
                                letra[x*10+y]=matriz[x][y];
                                letra[H]=letra[x*10+y];
                                if(letra[H+1]='I' || letra[H+1]='i' && letra[H+2]='L' && letra[H+3]='A' && letra[H+4]='R')
                                    {
                                        for(int n=P; n<P+5; n++)
                                        {
                                            if(letra[n]>=65 && letra[n]<=90)
                                            letra[n]=letra[n]+32;
                                            else letra[n]=letra[n];
                                        }
                                    }
                            }
                    }
                }
            }
             for(int v=0; v<9; v++)
            {
                for(int w=0; w<10; w++)
                {
                    if(matriz[v][w]='Z')
                    {
                        if (v<4)//hacia abajo
                        {
                            letra[v*10+w]=matriz[v][w];
                            letra[Z]=letra[v*10+w];
                            if(letra[Z+10]='A' || letra[Z+10]='a' && letra[Z+20]='P' || letra[Z+20]='p' && letra[Z+30]='A' || letra[Z+30]='a' && letra[Z+40]='T' && letra[Z+50]='O')
                            {
                                for(int b=Z; b<Z+60; b=b+10)
                                        {
                                            if(letra[b]>=65 && letra[b]<=90)
                                            letra[b]=letra[b]+32;
                                            else letra[b]=letra[b];
                                        }
                            }
                        }
                    }
                }
            }
            for(int g=0; g<9; g++)
            {
                for(int h=0; h<10; h++)
                {
                    if(matriz[g][h]='A' || matriz[g][h]='a' )
                    {
                        if (h>5)//hacia izquierda
                        {
                         letra[g*10+h]=matriz[g][h];
                         letra[A]=letra[g*10+h];
                            if(letra[A-1]='N' || letra[A-1]='n' && letra[A-2]='C' && letra[A-3]='I' && letra[A-4]='A' && letra[A-5]='N' || letra[A-5]='n' && letra[A-6]='O')
                            {
                                for(int c=A; c<R-7; c--)
                                {
                                    if(letra[c]>=65 && letra[c]<=90)
                                    letra[c]=letra[c]+32;
                                    else letra[c]=letra[c];
                                }
                            }
                        }
                    }
                }
            }
             for(int e=0; e<9; e++)
            {
                for(int d=0; d<10; d++)
                {
                    if(matriz[e][d]='T' || matriz[e][d]='t')
                    {
                         if (d<5)// buscar hacia la derecha
                            {
                                letra[e*10+d]=matriz[e][d];
                                letra[T]=letra[e*10+d];
                                if(letra[T+1]='U' && letra[T+2]='E' && letra[T+3]='R' && letra[T+4]='C' && letra[T+5]='A' || letra[T+5]='a')
                                    {
                                        for(int s=T; s<T+6; s++)
                                        {
                                            if(letra[s]>=65 && letra[s]<=90)
                                            letra[s]=letra[s]+32;
                                            else letra[s]=letra[s];
                                        }
                                    }
                            }
                    }
                }
            }
             for(int a=0; a<9; a++)
            {
                for(int f=0; f<10; f++)
                {
                    if(matriz[a][f]='C')
                    {
                        if (f>3)//hacia izquierda
                        {
                         letra[a*10+f]=matriz[a][f];
                         letra[C]=letra[a*10+f];
                            if(letra[C-1]='A' && letra[C-2]='M' && letra[C-3]='P' || letra[C-3]='p' && letra[C-4]='O')
                            {
                                for(int blank=C; blank<C-7; blank--)
                                {
                                    if(letra[blank]>=65 && letra[blank]<=90)
                                    letra[blank]=letra[blank]+32;
                                    else letra[blank]=letra[blank];
                                }
                            }
                        }
                    }
                }
            }
                    
return 0;              
}
  #3 (permalink)  
Antiguo 24/11/2014, 02:52
 
Fecha de Ingreso: octubre-2014
Ubicación: Madrid
Mensajes: 1.212
Antigüedad: 9 años, 6 meses
Puntos: 204
Respuesta: Reimprimir Matriz bidimensional modificada

Varios detalles sobre tu código:

1. Intenta dividir el código en funciones

- Esto hace que el código sea más legible, más fácil de mantener y hasta te permite reutilizar el código. Una forma de saber cuándo hace falta una función es pensar en responsabilidades. Si una función (incluido el main) se tiene que encargar de más de una tarea, entonces hace falta dividir esa función en funciones más sencillas.

Por ejemplo, podrías tener una función que se llamase "buscarPalabra", esta función podría llamar a "buscarPalabraHorizontal", "buscarPalabraVertical", "buscarPalabraDiagonalDerecha" y "buscarPalabraDiagonalIzquierda" para intentar localizar la palabra buscada y, de encontrarla, podría llamar a "convertirAMinusculas" para convertir la palabra a minúsculas. Es una de las múltiples formas de resolver el problema... pero repetir sistemáticamente el código para cada palabra ya te adelanto que no es una alternativa viable.

2. Simplifica los if anidados

Código C++:
Ver original
  1. if (q<4)// buscar hacia la derecha
  2. {
  3.   // ...
  4. }
  5. else if(p<3 && q<4)//esquina inferior derecha

La comprobación "q<4" del else no se va a dar nunca, ya que si se cumple, el código entrará en el primer if y, en consecuencia, se saltará automáticamente el else.

De la misma forma tampoco sería necesario comprobar lo contario:

Código C++:
Ver original
  1. if (q <4)
  2. {
  3.   // ...
  4. }
  5. else if( q>=4)

Ya que queda claro, que si "q" no es menor que 4, entonces tendrá que ser, necesariamente, mayor o igual a 4.

3. Si programas en C++ no uses cabeceras de C

Los includes tipo <stdlib.h> son includes propios de C (acaban en .h), es preferible usar la versión C++ de los mismos. Esto se consigue quitando el ".h" y poniendo el prefico "c" a la librería: #include <stdlib.h> -> #include <cstdlib>

Y, bueno, ya puestos, si estás usando C++ quizás prefieras usar "std::cout" antes que "printf":

Código C++:
Ver original
  1. printf(" %c\t", matriz[i][j]);
  2. printf("\n");
  3.  
  4. // opción 1
  5. std::cout << " " << matrix[i][j] << "\t\n";
  6.  
  7. // opción 2
  8. std::cout << " " << matrix[i][j] << "\t" << std::endl;

Si no vas a usar std::cout, puedes quitar la cabecera "iostream", ya que no la estás usando.

5. Asegúrate de que tu código compila y funciona

Si alguien lee tu mensaje la idea que se hace es que no sabes como realizar una tarea concreta... lo que no se espera es que tu código directamente no funcione porque no ha sido probado... hay que ser un poco más respetuoso con quien te intenta ayudar:

Código C++:
Ver original
  1. if(letra[R+1]='A' && letra[R+2]='T' && letra[R+3]='O' && letra[R+4]='N' && letra[R+5]='E' && letra[R+6]='S')

El operador de comparación es '==' y el de asignación es '='. En cada "if" de este tipo estas ASIGNANDO en vez de comparar. Esto demuestra que no te has molestado en probar tu programa antes de postear...

6. Intenta no realizar operaciones "absurdas"

Código C++:
Ver original
  1. if(letra[k]>=65 && letra[k]<=90)
  2.   letra[k]=letra[k]+32;
  3. else
  4.   letra[k]=letra[k];

letra[k]=letra[k]??? por qué??? es código que te puedes ahorrar y, créeme, cuanto menos código tengas en un programa, mejor. Supone menos puntos de fallo, menos código a corregir, menos tiempo de mantenimiento... todo son beneficios. Este tipo de comprobaciones es mejor dejarlas así:

Código C++:
Ver original
  1. if(letra[k]>=65 && letra[k]<=90)
  2.   letra[k]=letra[k]+32;

Y, bueno, ya puestos, si quieres mejorar la legibilidad del código, sustituye los números por el carácter en cuestión. Es fácil acordarse del significado de esos números ahora que estás desarrollando la aplicación, pero si te pones a revisar este mismo código dentro de un tiempo te darás cuenta que poner números ahí te obliga a mirar la tabla ASCII para saber a qué se corresponden:

Código C++:
Ver original
  1. if(letra[k]>='A' && letra[k]<='Z')
  2.   letra[k] += 'a' - 'A';

Así seguro que no vas a tener que consultar la tabla ASCII en la vida para entender la conversión que hace este código.

7. Cuidado con las variables globales

Código C++:
Ver original
  1. char matriz[9][10];
  2.  
  3. int main( )
  4. {
  5.   char letra[12];
  6.   int k,R;
  7.   char matriz[9][10]=

Fíjate que has declarado dos veces la variable "matriz" eso puede darte problemas, ya que "main" utilizará su variable global, mientras que otras funciones pueden acabar accediendo a la variable global, que es diferente y tiene sus propios datos. Esto puede dar lugar a comportamientos inesperados y erróneos y el origen del problema no suele ser fácil de encontrar.

Intenta no usar variables globales, no son necesarias y te ahorrarás problemas.

Cita:
Iniciado por Estdar123455 Ver Mensaje
Lo que pasa es que ya no se como mandar a reimprimir la matriz ya cambiada
Para reimprimir la matriz, puedes probar 2 opciones:
  • Copiar el código que usas al principio del programa para imprimir al matriz
  • Sacar ese código a una función y llamar a dicha función cada vez que quieras sacar la matriz por pantalla (recomendado)

Etiquetas: arreglo, bidimensionales, matriz
Atención: Estás leyendo un tema que no tiene actividad desde hace más de 6 MESES, te recomendamos abrir un Nuevo tema en lugar de responder al actual.
Respuesta




La zona horaria es GMT -6. Ahora son las 05:41.