API tools faq
paste
Cabana_Mario_Ariel_F

Clase Ejercicio7 - TPN°3 - Grupo02

Cabana_Mario_Ariel_F
Apr 27th, 2022 (edited)
474
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 14.67 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  ======================================================================================================================
  3.  * Modelo de Desarrollo de Programas y Programación Concurrente - Facultad de Ingeniería - Universidad Nacional de Jujuy
  4.   ======================================================================================================================
  5.  */
  6.  
  7. /**
  8.  * @Autor: Grupo 02 M.D.P y P.C.
  9. /*      @Integrantes:                  |    @Carrera:             |   @DNI:
  10.                                        |                          |
  11.   ALVAREZ, Cesar Fabian                | Ing. Informática         | 41.275.832
  12.   CABANA, Mario Ariel Fernando         | Ing. Informática         | 42.268.639
  13.   MONTELLANO, Leandro                  | Ing. Informática         | 43.114.035
  14.   RETAMOZO CORTEZ, Candelaria          | Ing. Informática         | 95.790.260
  15.   RUIZ, Erica Vanina                   | Ing. Informática         | 38.471.424
  16.  
  17.  * @Fecha: 28/04/2022.
  18.  */
  19.  
  20.  /*
  21.    Trabajo Práctico N°2 / Introducción a Java Parte 2 / Punto 07
  22.   ---------------------   ---------------------------   --------
  23.   * Objetivo General: Definir una matriz de caracteres de 12 x 12.
  24.                       - Programáticamente disponer las siguientes palabras en distintas posiciones.
  25.                       - Asegúrar de que todas quepan.
  26.                       - Rellene los espacios en blanco con caracteres aleatorios.
  27.                       - Muestre el resultado final.
  28.   * El trabajo se ha realizado utilizando las siguientes IDEs: Eclipse 2020-06(4.16)-(IDE for Java Developers) - Apache Netbeans IDE 12.4 - IntelliJ IDEA 2021.2.3
  29.   * Lenguaje de programación: Java POO.
  30.   * Api a utilizar. Paquete:- Java.util / Clase:- Scanner.
  31.   *                 Paquete:- Java.io / Clase:- BufferedReader, FileReader, IOException, StreamTokenizer.
  32.   * Clase principal: EntregaTPN3.
  33.   * Clases secundarias: Helper, Ejercicio5, Ejercicio7.
  34.   */
  35.  
  36. package ar.edu.unju.aplication;
  37.  
  38. public class Ejercicio7 {
  39.    
  40.     //------------------- Inicio método run() -------------------//
  41.  
  42.     public static void run() {
  43.         char [][] sopa= new char[12][12];
  44.         String [] palabras = {"CAMELLO","ELEFANTE","AGUILA","CAMALEON","AVESTRUZ","COCODRILO","ANTILOPE","SERPIENTE","BUFALO","COMADREJA"};
  45.         rellenarConEspaciosEnBlanco(sopa);
  46.         int bandera,opcion=0;
  47.         // Inserción de palabras.
  48.         for(int i=0;i<= palabras.length-1;i++){
  49.             opcion=(int)((Math.random()*(3))+1);
  50.             switch(opcion){
  51.                 case 1:
  52.                         bandera=insertarHorizontal(sopa,palabras[i]);
  53.                         if (bandera==0){
  54.                             i--;
  55.                         }
  56.                         break;
  57.                 case 2:
  58.                         bandera=insertarVertical(sopa,palabras[i]);
  59.                         if (bandera==0){
  60.                             i--;
  61.                         }
  62.                         break;
  63.                 case 3:
  64.                         bandera=insertarDiagonal(sopa, palabras[i]);
  65.                         if (bandera==0){
  66.                             i--;
  67.                         }
  68.                         break;
  69.             }
  70.         }
  71.         rellenarSopa(sopa);
  72.         mostrar(sopa);
  73.     }// Fin run.
  74.    
  75.   //------------------ Método para la matriz ------------------//
  76.  
  77.     // Metodo para rellenar con espacios en blanco
  78.     public static void rellenarConEspaciosEnBlanco(char [][] caracteres){
  79.         for(int i=0;i<=11;i++){
  80.             for(int j=0;j<=11;j++){
  81.                     caracteres[i][j]=' ';
  82.             }
  83.         }
  84.     }
  85.  
  86.     // Metodo para rellenar los espacios en blanco
  87.     public static void rellenarSopa(char [][] caracteres){
  88.         for(int i=0;i<=11;i++){
  89.             for(int j=0;j<=11;j++){
  90.                 if (caracteres[i][j]==' '){
  91.                     int generado=(int) (Math.random()*(90-65)+65);
  92.                     caracteres[i][j]=(char)generado;
  93.                 }
  94.             }
  95.         }
  96.     }
  97.  
  98.     // Metodo para mostrar la sopa de letras
  99.     public static void mostrar(char [][] caracteres){
  100.         System.out.println("     =============== SOPA DE LETRAS ===============");
  101.         System.out.println("     0   1   2   3   4   5   6   7   8   9   10  11");
  102.         System.out.println("     -----------------------------------------------");
  103.         for(int i=0;i<=11;i++){
  104.             if (i<10)  System.out.print("  "+i+"| ");
  105.             else System.out.print(i+" | ");
  106.             for(int j=0;j<=11;j++){
  107.                 if (Character.isLowerCase(caracteres[i][j])){
  108.                     System.out.print(caracteres[i][j]+ "   ");
  109.                 }else{
  110.                     System.out.print(caracteres[i][j]+ "   ");
  111.  
  112.                 }
  113.             }
  114.             System.out.println("\n");
  115.         }
  116.     }
  117.    
  118.   //-------------- Método para insertar palabras --------------//
  119.    
  120.     public static int insertarHorizontal(char sopa[][],String palabra){
  121.         int opcion, palabraInsertada=0;
  122.         int fila, columna, limiteDeIteraciones=1;
  123.         boolean tabien;
  124.         while(palabraInsertada==0 && limiteDeIteraciones!=0){
  125.             fila=numeroAleatorio(); columna=numeroAleatorio();
  126.             tabien=true;
  127.             opcion=banderaAleatoria();
  128.             switch (opcion){
  129.                 case 1:
  130.                     // Si no hay espacio a la derecha, vuelve a intentar en otra columna y fila
  131.                     if(columna+palabra.length()>12){
  132.                          break;
  133.                     }else{
  134.                         for (int i=0;i<=palabra.length()-1;i++){// Me fijo si entra.
  135.                             if (sopa[fila][columna+i]!=' ' && sopa[fila][columna+i]!=Character.toLowerCase(palabra.charAt(i))){
  136.                                 tabien=false;
  137.                                 limiteDeIteraciones--;
  138.                                 break;
  139.                             }
  140.                         }//Fin de for para ver si entra o no.
  141.                         if(tabien==false){
  142.                             palabraInsertada=0; //No se inserto
  143.                         }else{
  144.                             for (int i=0;i<=palabra.length()-1;i++){
  145.                                 sopa[fila][columna+i]=Character.toLowerCase(palabra.charAt(i));
  146.                             }
  147.                             palabraInsertada=1; //Si se inserto
  148.                         }
  149.                         break;
  150.                     }
  151.                    
  152.                 case 2:
  153.                     // Si no hay espacio a la izquierda, vuelve a intentar en otra columna y fila
  154.                     if(columna-palabra.length()<0){
  155.                         break;
  156.                     }else{
  157.                         int k=palabra.length()-1;
  158.                         for (int i=0;i<=palabra.length()-1;i++){// Me fijo si entra.
  159.                             if (sopa[fila][columna-k]!=' ' && sopa[fila][columna-k]!=Character.toLowerCase(palabra.charAt(i))){
  160.                                 tabien=false;
  161.                                 limiteDeIteraciones--;
  162.                                 break;
  163.                             }
  164.                             k--;
  165.                         }//Fin de for para ver si entra o no.
  166.                         if(tabien==false){
  167.                             palabraInsertada=0; //No se inserto
  168.                         }else{
  169.                             int j=palabra.length()-1;
  170.                             for (int i=0;i<=palabra.length()-1;i++){
  171.                                 sopa[fila][columna-j]=Character.toLowerCase(palabra.charAt(j));
  172.                                 j--;
  173.                             }
  174.                             palabraInsertada=1; //Si se inserto
  175.                         }
  176.                         break;
  177.                        }
  178.                     }//fin Swich
  179.             }// fin While
  180.         if (limiteDeIteraciones==0){
  181.             return 0;
  182.         }else{
  183.             return 1;
  184.         }
  185.  
  186.     }//Fin de Metodo insertar Horizontal.
  187.    
  188.     public static int insertarVertical(char sopa[][],String palabra){
  189.         int opcion, palabraInsertada=0;
  190.         int fila, columna, limiteDeIteraciones=1;
  191.         boolean tabien;
  192.         while(palabraInsertada==0 && limiteDeIteraciones!=0){
  193.             fila=numeroAleatorio(); columna=numeroAleatorio();
  194.             tabien=true;
  195.             opcion=banderaAleatoria();
  196.             switch (opcion){
  197.                 case 1:
  198.                     // Si no hay espacio a la derecha, vuelve a intentar en otra columna y fila
  199.                     if(fila+palabra.length()>12){
  200.                         break;
  201.                     }else{
  202.                         for (int i=0;i<=palabra.length()-1;i++) {// Me fijo si entra.
  203.                             if (sopa[fila+i][columna]!=' '&& sopa[fila+i][columna]!=Character.toLowerCase(palabra.charAt(i))){
  204.                                 tabien=false;
  205.                                 limiteDeIteraciones--;
  206.                                 break;
  207.                             }
  208.                         }//Fin de for para ver si entra o no.
  209.                         if(tabien==false){
  210.                             palabraInsertada=0; //No se inserto
  211.                         }else{
  212.                             for (int i=0;i<=palabra.length()-1;i++){// Recien traspaso la palabra.
  213.                                 sopa[fila+i][columna]=Character.toLowerCase(palabra.charAt(i));
  214.                             }
  215.                             palabraInsertada=1; //Si se inserto
  216.                         }
  217.                         break;
  218.                     }
  219.                        
  220.                 case 2:
  221.                     // Si no hay espacio a la izquierda, vuelve a intentar en otra columna y fila
  222.                     if(fila-palabra.length()<0){
  223.                         break;
  224.                     }else{
  225.                         int k=palabra.length()-1;
  226.                         for (int i=0;i<=palabra.length()-1;i++){// Me fijo si entra.
  227.                             if (sopa[fila-k][columna]!=' '&& sopa[fila-k][columna]!=Character.toLowerCase(palabra.charAt(i))){
  228.                                 tabien=false;
  229.                                 limiteDeIteraciones--;
  230.                                 break;
  231.                             }
  232.                             k--;
  233.                         }//Fin de for para ver si entra o no.
  234.                         if(tabien==false){
  235.                             palabraInsertada=0; //No se inserto
  236.                         }else{
  237.                             int j=palabra.length()-1;
  238.                             for (int i=0;i<=palabra.length()-1;i++){
  239.                                 sopa[fila-j][columna]=Character.toLowerCase(palabra.charAt(j));
  240.                                 j--;
  241.                             }  
  242.                             palabraInsertada=1; //Si se inserto
  243.                         }
  244.                         break;
  245.                     }
  246.               }//Swich
  247.             }//While
  248.         if (limiteDeIteraciones==0){
  249.             return 0;
  250.         }else{
  251.             return 1;
  252.         }
  253.     }//fin metodo insertar vertical
  254.  
  255.     public static int insertarDiagonal(char [][] sopa,String palabra){
  256.         int opcion, palabraInsertada=0;
  257.         int fila, columna, limiteDeIteraciones=1;
  258.         boolean tabien;
  259.         while(palabraInsertada==0 && limiteDeIteraciones!=0){
  260.             fila=numeroAleatorio(); columna=numeroAleatorio();
  261.             tabien=true;
  262.             opcion=banderaAleatoria();
  263.             switch (opcion){
  264.                 case 1:
  265.                     // Si no hay espacio a la derecha, vuelve a intentar en otra columna y fila
  266.                     if((fila+palabra.length()>12)||(columna+palabra.length()>12)){
  267.                         break;
  268.                     }else{
  269.                         for (int i=0;i<=palabra.length()-1;i++){// Me fijo si entra.
  270.                             if (sopa[fila+i][columna+i]!=' '&& sopa[fila+i][columna+i]!=Character.toLowerCase(palabra.charAt(i))){
  271.                                 tabien=false;
  272.                                 limiteDeIteraciones--;
  273.                                 break;
  274.                             }
  275.                         }//Fin de for para ver si entra o no.
  276.                         if(tabien==false){
  277.                             palabraInsertada=0; //No se inserto
  278.                         }else{
  279.                             for (int i=0;i<=palabra.length()-1;i++){
  280.                                 sopa[fila+i][columna+i]=Character.toLowerCase(palabra.charAt(i));
  281.                             }
  282.                             palabraInsertada=1; //Si se inserto
  283.                         }
  284.                         break;
  285.                     }
  286.                 case 2:
  287.                     // Si no hay espacio a la izquierda, vuelve a intentar en otra columna y fila
  288.                     if((fila-palabra.length()<0)||(columna-palabra.length()<0)){
  289.                         break;
  290.                     }else{
  291.                         int k=palabra.length()-1;
  292.                         for (int i=palabra.length()-1;i>=0;i--){// Me fijo si entra.
  293.                             if (sopa[fila-k][columna-k]!=' '&& sopa[fila-k][columna-k]!=Character.toLowerCase(palabra.charAt(i))){
  294.                                 tabien=false;
  295.                                 limiteDeIteraciones--;
  296.                                 break;
  297.                             }
  298.                             k--;
  299.                         }//Fin de for para ver si entra o no.
  300.                         if(tabien==false){
  301.                             palabraInsertada=0; //No se inserto
  302.                         }else{
  303.                             int j=palabra.length()-1;
  304.                             for (int i=palabra.length()-1;i>=0;i--){
  305.                                 sopa[fila-j][columna-j]=Character.toLowerCase(palabra.charAt(j));
  306.                                 j--;
  307.                             }
  308.                             palabraInsertada=1; //Si se inserto
  309.                         }
  310.                         break;
  311.                     }
  312.             }//Fin Swich
  313.         }//Fin While
  314.         if (limiteDeIteraciones==0){
  315.             return 0;
  316.         }else{
  317.             return 1;
  318.         }
  319.     }// Fin Metodo Diagonal
  320.    
  321.   //------------- Método para generar aleatorios -------------//
  322.    
  323.     public static int banderaAleatoria(){
  324.         return (int)((Math.random()*(2))+1);//Devuelve cero o uno
  325.     }
  326.    
  327.     //Este metodo solo se utiliza para devolver un valor de fila o columna
  328.     public static int numeroAleatorio(){
  329.         int numerito = (int)(Math.random()*(12)+0);
  330.         return numerito;
  331.     }
  332.  
  333. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!