Need a unique gift idea?
A Pastebin account makes a great Christmas gift
SHARE
TWEET

ProjetoDeLogica

ramomjcs Nov 14th, 2018 86 Never
Upgrade to PRO!
ENDING IN00days00hours00mins00secs
 
  1. package logic;
  2.  
  3. import java.io.File;
  4. import java.io.PrintWriter;
  5. import java.util.HashMap;
  6. import java.util.Map;
  7. import java.util.Scanner;
  8.  
  9. public class main {
  10. //..........................................................................................................................................//
  11.     // RESUMO -> Pego o string de numeros e transformo em um array de numeros inteiros
  12.     static int[] PegarNumeros(int tamanho, String numeros) {
  13.         int var[] = new int[tamanho];
  14.         for (int j = 0; j < tamanho; j++) {
  15.             var[j] = Character.getNumericValue(numeros.charAt(j));
  16.         }
  17.         return var; // Retorna um array de inteiros
  18.     }
  19.    
  20. //..........................................................................................................................................//
  21.         //RESUMO -> Retorna se a expressao e legitma ou nao
  22.         static boolean isLegit(String exp) {
  23.            
  24.             if(exp.length() == 1 && exp.charAt(0) >= 'A' && exp.charAt(0) <= 'Z')
  25.                 return true;
  26.            
  27.             int s = 0;
  28.             int f = exp.length() - 1;
  29.            
  30.             if(exp.charAt(s) == '(' && exp.charAt(f) == ')' && exp.charAt(s + 1) == '~' && s + 2 < f)
  31.                 return isLegit(exp.substring(s + 2, f));
  32.            
  33.             else if(exp.charAt(s) == '(' && exp.charAt(f) == ')') {
  34.                 int operatorIndex = findOperator(exp);
  35.                 if(operatorIndex != -1 &&  s + 1 < operatorIndex - 1 && operatorIndex + 2 < f)
  36.                     return isLegit(exp.substring(s + 1, operatorIndex - 1)) &&
  37.                             isLegit(exp.substring(operatorIndex + 2, f));
  38.             }  
  39.            
  40.             return false;
  41.            
  42.         }
  43.        
  44. //..........................................................................................................................................//
  45.         // RESUMO -> Retorna se a expressao e satisfativel ou nao
  46.         static boolean satisfies(Map<Character, Boolean> valoresverdade, String exp) {
  47.            
  48.             if(exp.length() == 1)
  49.                 return valoresverdade.get(exp.charAt(0));
  50.            
  51.             int s = 0;
  52.             int f = exp.length() - 1;
  53.             int operatorIndex = findOperator(exp);
  54.             switch(exp.charAt(operatorIndex)) {
  55.            
  56.             case '~': return !satisfies(valoresverdade, exp.substring(operatorIndex + 1, f));
  57.             case '&': return
  58.                         satisfies(valoresverdade, exp.substring(s + 1, operatorIndex - 1))
  59.                         && satisfies(valoresverdade, exp.substring(operatorIndex + 2, f));
  60.             case 'v': return
  61.                     satisfies(valoresverdade, exp.substring(s + 1, operatorIndex - 1))
  62.                     || satisfies(valoresverdade, exp.substring(operatorIndex + 2, f));
  63.             case '>': return
  64.                     !satisfies(valoresverdade, exp.substring(s + 1, operatorIndex - 1))
  65.                     || satisfies(valoresverdade, exp.substring(operatorIndex + 2, f));
  66.             default:
  67.                     return true;
  68.             }
  69.         }
  70. //.........................................................................................................................................//
  71.         //RESUMO -> Encontra o operador central da expressao
  72.         static int findOperator(String exp) {
  73.            
  74.             int numParenthesis = 0;
  75.             for(int i = 0; i < exp.length(); i++) {
  76.                
  77.                 if(exp.charAt(i) == '(')
  78.                     numParenthesis++;
  79.                 else if(exp.charAt(i) == ')')
  80.                     numParenthesis--;
  81.                
  82.                 if((exp.charAt(i) == '>' || exp.charAt(i) == '&' || exp.charAt(i) == 'v' ||
  83.                         exp.charAt(i) == '~') && numParenthesis == 1)
  84.                     return i;
  85.             }
  86.            
  87.             return -1;    
  88.         }
  89.      
  90. //........................Troca o nome do arquivo .in para SAIDA.out ..........................................//
  91.         public static String getPath(String path) {
  92.             String path1 = path.replaceAll(".in", "SAIDA.out");
  93.             return path1;
  94.         }
  95.  
  96. //...........................................................................................................................................//
  97.         //RESUMO -> Metodo main
  98.         public static void main(String[] args) {
  99.             String path = "C:\\Users\\Ramom José\\Desktop\\Arquivos\\Entrada3.in"; //colocar o diretório de entrada e saida
  100.             String path1 = getPath(path);
  101.        
  102.         try {
  103.  
  104.             PrintWriter writer = new PrintWriter(path1, "UTF-8");
  105.             File file = new File(path);
  106.             Scanner tec = new Scanner(file);
  107.    
  108.             int n = tec.nextInt(); //quantidade de expressoes
  109.             tec.nextLine();
  110.            
  111.              for(int i = 0; i < n; i++) {
  112.                 String exp = tec.nextLine();
  113.                 Map<Character, Boolean> valoresverdade = new HashMap<>(); //HashMap - relaciona A com 1, exemplo
  114.                  
  115.             //.....................Separa a expressao da valoracao.................................//
  116.  
  117.                 String letras = exp; // inicialmente com numeros. Depois a expressao fica sem numeros
  118.                 String numeros = ""; // string de numeros
  119.                 int tam = letras.length();
  120.                
  121.                 for(int k = 0; k < tam; k++) {
  122.                     if(letras.charAt(k) == '0' || letras.charAt(k) == '1') {
  123.                         numeros = letras.substring(k); // tira as letras mas continua String
  124.                         letras = letras.substring(0, k-1); // tira os numeros
  125.                         k = tam; //stop
  126.                     }
  127.                 }
  128.  
  129.             //.......................................................................................//      
  130.                 numeros = numeros.replaceAll("\\s","");  // junta todos os numeros - sem espaco
  131.                 tam = numeros.length();
  132.                
  133.                 int arrayNumerosValores[] = PegarNumeros(tam, numeros);
  134.                
  135.                 boolean valores[] = new boolean[tam]; //array da valoração
  136.                
  137.                 for (int k = 0; k < tam; k++) { // coloco os valores verdades no array(valores) de acordo com os numeros(1-True, 0-False)
  138.                     if (arrayNumerosValores[k] == 0)
  139.                         valores[k] = false;
  140.                     else if (arrayNumerosValores[k] == 1) {
  141.                         valores[k] = true;
  142.                     }
  143.                 }
  144.                
  145.                 int k1 = 0; //index do array de valores que sera usado posteriormente
  146.                 String novaLetras = letras; //string de expressao sem numeros
  147.                 tam = letras.length();
  148.  
  149.                 //...............................Colocando a valoracao em cada letra....................................//
  150.                 for(int k = 0; k < tam; k++) {
  151.                        
  152.                     if((int)letras.charAt(k) >= 'A' && (int)letras.charAt(k) <= 'Z') { //So pega as letras de A a Z para valora-las
  153.                        
  154.                         valoresverdade.put(letras.charAt(k), valores[k1]); //coloca o valor verdade em cada letra no mapa hash(valoresverdade)
  155.                         k1++;
  156.                         letras = letras.replace(letras.charAt(k), '-');
  157.                     }
  158.                 }
  159.                 //.....................................................................................................//
  160.  
  161.                 letras = novaLetras; //volta ao normal a variavel letras
  162.                
  163.                 //etapa 4
  164.                 if(letras.charAt(0) != '{' ) {// se não for um conjunto de expressoes
  165.                         if(isLegit(letras)) {
  166.                             if(satisfies(valoresverdade,letras)) {
  167.                                 writer.println("Problema #" + (i+1));
  168.                                 writer.println("A valoracao-verdade satisfaz a proposicao.");
  169.                                 if(i != n-1)
  170.                                 writer.println("");
  171.                             }else {
  172.                                 writer.println("Problema #" + (i+1));
  173.                                 writer.println("A valoracao-verdade nao satisfaz a proposicao.");
  174.                                 if(i != n-1)
  175.                                 writer.println("");
  176.                             }
  177.                         }else {
  178.                             writer.println("Problema #" + (i+1));
  179.                             writer.println("A palavra nao e legitima.");
  180.                             if(i != n-1)
  181.                             writer.println("");
  182.                         }
  183.                 }
  184.                
  185.                 else{ //se for um conjunto de expressoes
  186.  
  187.                     String[] vetorSentencas = letras.split(","); // armazena cada sentença em um index
  188.                     vetorSentencas[0] = vetorSentencas[0].substring(1); // tira a { chave do inicio
  189.                    
  190.                     // tira a ultima chave } e ja armazena na sentenca
  191.                     vetorSentencas[vetorSentencas.length - 1] = vetorSentencas[vetorSentencas.length - 1].substring(0, vetorSentencas[vetorSentencas.length - 1].length()- 1);
  192.                    
  193.                     // garanto que o resto fique no seu index certo já que o [inicial] e o [ultimo] estao certos pelo de cima          
  194.                     for(int k = 1; k < vetorSentencas.length;k++) {
  195.                         vetorSentencas[k] = vetorSentencas[k].substring(1);
  196.                     }
  197.                    
  198.                     int status = 0;
  199.                     int alltrue = 0;
  200.                     int aux = 0;
  201.                    
  202.                     //.....Testa todas as sentencas do vetorSentencas e encontra a satisfativel....//
  203.                     while(aux < vetorSentencas.length && status == 0) {
  204.                         if(!isLegit(vetorSentencas[aux])) {
  205.                              writer.println("Problema #" + (i+1));
  206.                              writer.println("Ha uma palavra nao legitima no conjunto.");
  207.                              if(i != n-1)
  208.                              writer.println("");
  209.                              aux = -1;
  210.                              status = 1;
  211.                         }
  212.                         aux++;
  213.                     }
  214.                     aux = 0;
  215.                     //............................................................................//
  216.  
  217.                     //...Testa todas as sentencas do vetorSentencas e encontra a nao satisfativel....//
  218.                     while(aux < vetorSentencas.length && status != 1) {
  219.                         if(!satisfies(valoresverdade, vetorSentencas[aux])) {
  220.                              writer.println("Problema #" + (i+1));
  221.                              writer.println("A valoracao-verdade nao satisfaz o conjunto.");
  222.                              if(i != n-1)
  223.                              writer.println("");
  224.                              status = 1;
  225.                              aux = -1;
  226.                         }
  227.                         aux++;
  228.                         if(aux >= vetorSentencas.length)
  229.                             alltrue = 1;
  230.                     }
  231.                     //...........................................................................//
  232.  
  233.                     //..................Se todas as sentencas forem satisfativeis................//
  234.                     if(alltrue == 1) {
  235.                         writer.println("Problema #" + (i+1));
  236.                         writer.println("A valoracao-verdade satisfaz o conjunto.");
  237.                         if(i != n-1)
  238.                         writer.println("");
  239.                     }
  240.                     //..........................................................................//
  241.  
  242.                 }
  243.             }
  244.            writer.close();
  245.         } catch (Exception ex) {
  246.             ex.printStackTrace();
  247.         }
  248.     }
  249. }
RAW Paste Data
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
 
Top