API tools faq
paste
Advertisement
dantepw

Untitled

dantepw
Mar 19th, 2014
86
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 40.07 KB | None | 0 0
raw download clone embed print report
  1. package eqsegundograu;
  2.  
  3.  
  4. import java.util.ArrayList;
  5. import java.util.List;
  6. import javax.swing.JOptionPane;
  7.  
  8. public class Eq1grauNOVO {
  9.    
  10.     static List <Double> numeros; //array para armazenar todos os números inteiros
  11.     static List <Double> numerosX; //array para armazenar todos os números X
  12.     static List <Integer> ParentesesXouINT; //verifica se o número dentro do parenteses é um Inteiro ou uma incógnita.
  13.     static List <Double> Parenteses; //array para armazenar todos os números inteiros dentro de parenteses
  14.     static List <Double> MultiplicadorParenteses; //para armazenar todos os multiplicadores de parenteses
  15.     static List <Integer> MultiplicadorParentesesXouINT; //verifico se o número dentro do parenteses é um X ou INT
  16.     static List <Integer> InverterSinalParentesesInt;
  17.     static List <Integer> InverterSinalParentesesX;
  18.    
  19.     static boolean NaoInverterSinal = false; //no caso de um cálculo como 2x(2 + 5x) = 14, com o multiplicador sendo X, o sinal do
  20.                                                                           //int não pode ser invertido. Essa variável previne que isso aconteça!
  21.    
  22.     static int PosicaoVetorParentesesInt = 0;
  23.     static int PosicaoVetorParentesesX = 0;
  24.    
  25.    
  26.    
  27.  
  28.     //exemplo: 2 (3x + 4);
  29.     //2 = multiplicador ~ 3x = ParentesesX ~ 4 = ParentesesInt
  30.  
  31.    
  32.     public static void main (String[] args){
  33.        
  34.         /*
  35.        
  36.         CÁLCULOS JÁ TESTADOS (e que funcionam):
  37.         a) 18x - 43 = 65 ~~~~ Resultado: X = 6
  38.         b) 23x - 16 = 14 - 17x ~~~~ Resultado: X = 3/4 = 0,75
  39.         c) 10X - 5 (1 + 1x) = 3 (2x - 2) - 20 ~~~~ Resultado: X = -21
  40.         d) 5x (1 + 1x) = 3x (2x - 2) + 12 + 55 (6x - 7) ~~~~ x = 1.165625
  41.         e) 2x(2 + 5x) = 14 ~~~~ Resultado: X = 1
  42.         f) 8x - (x + 3) = 11 ~~~~ Resultado: X = 2
  43.        
  44.        
  45.         IDEIAS:
  46.         1. Quando abrir parenteses ver se o X ou INT foi adicionado primeiro para exibir depois no passo-a-passo
  47.        
  48.        
  49.        
  50.         BUGS:
  51.         1. Não reconhece o X sozinho valendo como 1. Para fazer um cálculo como: X +2 = 3, você deve digitar 1x + 2 = 3
  52.        
  53.        
  54.        
  55.        
  56.         UPDATES PRETENDIDOS:
  57.         1. Trabalhar com frações. Exemplo: (1x - 5)/10 + (1 - 2x)/5 = (3-1x)/4
  58.        
  59.         2. Trabalhar com potências. Exemplo: 1x(1x + 4) + 1x(1x + 2) = 2x² + 12
  60.        
  61.         3.
  62.        
  63.        
  64.        
  65.         CÁLCULOS QUE DEVERÁ RESOLVER:
  66.        
  67.          a)18x - 43 = 65 --------- X = 6
  68.         b) 23x - 16 = 14 - 17x --------------- X = 3/4 = 0,75
  69.         c) 10X - 5 (1 + 1x) = 3 (2x - 2) - 20 ----------------- X = -21
  70.         d) 1x(1x + 4) + 1x(1x + 2) = 2x² + 12
  71.         e) (1x - 5)/10 + (1 - 2x)/5 = (3-1x)/4
  72.         f) 4x (1x + 6) - 1x² = 5x²
  73.        
  74.         -- outros --
  75.         vários exercícios:
  76.          http://rachacuca.com.br/quiz/2717/equacao-de-1-grau/
  77.        
  78.         exercícios de eq1grau resolvidos passo - a - passo:
  79.         http://www.nilsong.com.br/index.php?option=com_content&view=article&id=110:exercicios-resolvidos-de-equacoes-do-1o-grau&catid=61:resumo-da-6o-serie&Itemid=93
  80.        
  81.         como fazer + exemplos de eq1grau com 2 variáveis, X & Y:
  82.         http://www.somatematica.com.br/fundam/equacoes2v.php
  83.        
  84.         Exercícios resolvidos passo a -passo:
  85.         http://sabermatematica.com.br/equacoesprimeirograuer.html
  86.         http://jmpmat7.blogspot.com.br/
  87.         */
  88.        
  89.         int InverterSinalNaHoraDosCalculosInt = 0;
  90.         int InverterSinalNaHoraDosCalculosX = 0; //quando multiplica-se o número dentro do parenteses não pode inverter
  91.                                                                                         //o sinal dele (antes/depois do =).    
  92.     boolean ExibeCalculosComParenteses = false;
  93.     String aux1 = JOptionPane.showInputDialog(null, "digite: ", "4 (3x + 8) + 5x (1 + 1x) = 3x (2x - 2) + 12 + 55 (6x - 7) "); //recebe equação do usuário
  94.     String s = aux1.toLowerCase(); //converte string inteira para letras minúsculas
  95.     s = s.replaceAll("\\s", "");   //remove todos os espaços da String;
  96.  
  97.  
  98.    
  99.     int AuxCalculos;
  100.     char [] AuxiliarS; //usado como auxiliar para quando encontrar um sentença como 2+(3x+4) = 2, por exemplo. o parenteses
  101.                                     //nesse caso tem que desaparecer e os sinais devem ser somados!
  102.     AuxiliarS = s.toCharArray();
  103.    
  104.      for(int i=0; i < s.length() - 1; i++){  //procura na string por sinais de '(' & X sozinhos, como "x + 2 = 4"
  105.  
  106.          
  107.          if(s.charAt(i) == 'x'){ //se encontrar,
  108.              if (!Character.isDigit(s.charAt(i-1))){ //verifica se é uma multiplicação
  109.              System.out.println("X SOZINHO");            
  110.              
  111.              }
  112.          }
  113.              
  114.          
  115.          if(s.charAt(i) == '('){ //se encontrar,
  116.              if (Character.isDigit(s.charAt(i-1)) || s.charAt(i-1) == 'x'){ //verifica se é uma multiplicação
  117.              System.out.println("MULTIPLICADOR");
  118.              ExibeCalculosComParenteses = true;
  119.  
  120.              }
  121.              
  122.              else if (s.charAt(i-1) == '-'){ //se não for uma multiplicação, for algo como 8x - (1x + 3) = 11
  123.                  System.out.println("TRAP");
  124.                  AuxCalculos = i; //atribuo o valor da posição para uma variável e faço outro teste para inverter sinais!
  125.                  //System.out.print("VALOR DO I: " + i);
  126.                  int b = 0;
  127.                       for (int a = AuxCalculos; a >= 0; a++){
  128.                          
  129.                           if(s.charAt(a) == '-'){ //se encontrar sinal de - substituo por +
  130.                               System.out.print("ENCONTREI UM - : ");
  131.                               AuxiliarS[a] = '+';
  132.                           }
  133.                                                    
  134.                           if(s.charAt(a) == '+'){ //se encontrar sinal de + substituo por -
  135.                               System.out.print("ENCONTREI UM + : ");
  136.                               AuxiliarS[a] = '-';
  137.                           }
  138.                          
  139.                           if(s.charAt(a) == ')'){ //quando encontrar o final do parenteses
  140.                              
  141.                               AuxiliarS[i] = ' '; //elimina o parenteses '('
  142.                               AuxiliarS[a] = ' '; //elimina o parenteses ')'
  143.                               break;
  144.                           }  
  145.                      }
  146.                 }
  147.             }
  148.         } //fim do for
  149.      
  150.      s = new String(AuxiliarS); //converte o char para string novamente depois de realizar as alterações
  151.      s = s.replaceAll("\\s", "");   //remove todos os espaços da String novamente
  152.      s = " " + s; //adicionando uma gambiarra para quando o número iniciar com inteiro, como por exemplo 2 +2x = 4
  153.     System.out.println(s); //simplesmente exibe a equação para analise
  154.    
  155.         Eq1grauNOVO.AnalisaNumeros(s, InverterSinalNaHoraDosCalculosInt,InverterSinalNaHoraDosCalculosX); //analisa se o número é X ou int e faz todas as conversões
  156.        
  157.         if(ExibeCalculosComParenteses == true){
  158.             Eq1grauNOVO.ExibeCalculosParenteses(InverterSinalNaHoraDosCalculosInt, InverterSinalNaHoraDosCalculosX, aux1);
  159.         }
  160.        
  161.         else{
  162.         Eq1grauNOVO.ExibeCalculos(aux1); //mostra os cálculos realizados passo-a-passo
  163.         }
  164.      
  165.     } //fim Main
  166.    
  167.     public static void AnalisaNumeros(String s, int InverterSinalNaHoraDosCalculosInt, int InverterSinalNaHoraDosCalculosX ){
  168.         int i; //usado como contador do For
  169.         int j = 0, sinalDeIgual = 0;
  170.         int b = 0; //usado com contadores para encontrar sinais de =, atribuir valores positivos/negativos, entre outros!
  171.         int encontrado; //simplesmente recebe valor de I + J. é usado com laço For para ver se variável está antes ou depois do
  172.                                       //sinal de = para inverter o sinal se preciso. Por exemplo: 10x + 2 = 2 ~> 10x = 2 - 2 (inverteu sinal)
  173.        
  174.         int ParentesesEncontrado = 0; //quando encontrar um parenteses começa a adicionar em outro arraylist!
  175.                                                                     //com o valor 0, o programa utiliza os métodos AdicionaNumeroVetorX & AdicionaNumeroVetor
  176.                                                                     //com o valor 1, é utilizado AdicionaNumeroVetorParentesesInt & AdicionaNumeroVetorParentesesX
  177.        
  178.         int NumeroMultiplicador = 0; //se o número anteceder um parenteses ele é um número multiplicador. São responsáveis
  179.                                                                   //por multiplicar os números dentro do parenteses, e são armazenados num Array diferente
  180.                                                                   //0 = Número NÃO é multiplicador ~ 1 = Número é Multiplicador. ~ 2 Número é um Multiplicador X.
  181.                                                                   //Exemplos:
  182.                                                                   //Valor 0 -> 2 + (5x + 4)
  183.                                                                   //Valor 1 -> 2(5x + 4)
  184.                                                                   //Valor 2 -> 2x(5x + 4)
  185.        
  186.  
  187.        
  188.     int limite = s.length() -1; //limite da equação do usuário
  189.     numeros = new ArrayList<>(); //array contendo todos os números da string já convertidos para double
  190.     numerosX = new ArrayList<>(); //array contendo todos os números COM X da string já convertidos para double
  191.     Parenteses = new ArrayList<>();
  192.     MultiplicadorParenteses = new ArrayList<>(); //armazena o número que multiplica valores dentro do parenteses
  193.     MultiplicadorParentesesXouINT= new ArrayList<>();
  194.      InverterSinalParentesesInt = new ArrayList<>();
  195.     InverterSinalParentesesX = new ArrayList<>();
  196.     ParentesesXouINT = new ArrayList<>();
  197.    
  198.    
  199.     //ParentesesXouINT = tem a função de ver se o número dentro do parenteses é uma incógnita ou um inteiro.
  200.     //valor 0 = Inteiro &
  201.     //valor 1 = Incógnita ~
  202.     //valor 2 = se for um inteiro e estiver ANTES do sinal de =
  203.     //valor 3 = se for uma incógnita & estiver depois do sinal de =
  204.    
  205.    
  206.     //MultiplicadorParentesesXouINT = Quando receber o valor de 0, é um Inteiro, ou seja, não mostra o X na tela. Quando receber
  207.                                                                             //o valor de 1, é uma incógnita, e exibe o X na tela.
  208.    
  209.    
  210.     for(i=0; i < limite; i++){
  211.  
  212.        
  213.         try{
  214.        String Auxiliar = ""; //Se encontrar na string um número com 2+ dígitos, quando convertido o programa ainda
  215.                                             //subentende como "1 & 8", e não "18", por exemplo. Para isso, eu uso uma string auxiliar para concatenar tudo e
  216.                                             //depois simplesmente converter para double!
  217.  
  218.  
  219.        
  220.         //ENCONTRA UM NÚMERO (ou conjunto de números) NA EQUAÇÃO
  221.        while(Character.isDigit(s.charAt(i + j))){ //se encontrar um número, verifica se o próximo é um número também. enquanto o
  222.                                                                                  //próximo for um número, permanece no while
  223.            s += " "; //adiciona espaço vazio no final da equação para não estourar o Catch
  224.            Auxiliar += s.charAt(i + j); //concatena número para um String
  225.  
  226.            
  227.            if(s.charAt(i + j + 1) == '(' ){
  228.  
  229.                NumeroMultiplicador = 1;
  230.            }
  231.            
  232.            else if(s.charAt(i + j + 1) == 'x'){
  233.                if(s.charAt(i+j+2) == '('){
  234.                      //System.out.print("~~~~~~~~NÚMERO MULTIPLICADOR X~~~~~~");
  235.                      NumeroMultiplicador = 2;
  236.                      ParentesesEncontrado = 1;
  237.                      }
  238.            }
  239.            
  240.            j += 1; //incrementa o J para poder ver o próximo caractere
  241.         } //fim da procura de números
  242.        
  243.  
  244.        
  245.            encontrado = i+j; //simplesmente recebe valor do i + j
  246.            boolean Negativando = false; //usado como auxiliar para encontrar sinais de =. Serve para "não ativar um if".
  247.            boolean SinaldeIgual = false;
  248.            
  249.            
  250.            double Numero = Double.parseDouble(String.valueOf(Auxiliar)); //converte string auxiliar concatenada para Double
  251.                  
  252.            //analisa se o número é X ou Inteiro
  253.                   Eq1grauNOVO.VerificaX(InverterSinalNaHoraDosCalculosX, NumeroMultiplicador, ParentesesEncontrado, s, encontrado, b, SinaldeIgual, Negativando, Numero); //verifica se o número é X
  254.                   Eq1grauNOVO.VerificaInteiro(InverterSinalNaHoraDosCalculosInt, NumeroMultiplicador,ParentesesEncontrado, s, encontrado, b, SinaldeIgual, Negativando, Numero); //verifica se o número é Int
  255.  
  256.                  
  257.           if(s.charAt(i + j) == '('){ //quando encontrar um sinal de ( começa a armazenar em arraylist de parenteses!
  258.               //System.out.println("ABRINDO Parenteses! próximo char: " + s.charAt(i+j + 1));
  259.               ParentesesEncontrado = 1;
  260.           }
  261.          
  262.           else if (s.charAt(i + j) == ')' || s.charAt(i + j + 1) == ')'){ //quando encontrar o sinal de ')' volta a armazenar nos outros arraylists
  263.               //System.out.println("FECHANDO Parenteses! Próximo: " + s.charAt(i+j-1) );
  264.               ParentesesEncontrado = 0;
  265.           }
  266.               NumeroMultiplicador = 0; //depois de ativar a variável e fazer os testes necessários "reseta" ela.
  267.                  
  268.    } //fim do Try
  269.    
  270.    //capturando erros
  271.             catch(StringIndexOutOfBoundsException | NumberFormatException | NullPointerException e){  
  272.             System.out.print("");
  273.         }
  274.     } //final do for    
  275. } //final do método AnalisaNumero
  276.    
  277.    
  278.     public static void VerificaInteiro(int InverterSinalNaHoraDosCalculosInt, int NumeroMultiplicador, int ParentesesEncontrado, String s, int encontrado, int b, boolean SinaldeIgual, boolean Negativando, double Numero){
  279.                   //ANALISA SE É NÚMERO INTEIRO (não é incógnita)
  280.           if (s.charAt(encontrado) != 'y' && s.charAt(encontrado) != 'x'){ //caso não seja incógnita
  281.  
  282.               //VERIFICA SE NÚMERO ESTÁ DEPOIS DO SINAL DE =
  283.               for(b = encontrado; b >= 0; b--){ //pesquisa reversamente a string iniciando do número que encontrou.
  284.  
  285.               if(s.charAt(b) == '=' && SinaldeIgual == false){ //se encontrar um sinal de =, mantém sinal, por que ele tem que ficar do lado direito!
  286.               Negativando = true;
  287.               SinaldeIgual = true;
  288.               }
  289.               } //fim do for
  290.              
  291.               for(b = encontrado; b >= 0; b--){
  292.  
  293.               //System.out.print(s.charAt(b-1)); //mostrando os caracteres              
  294.               if(s.charAt(b) == '='){ //apenas previne bugs em relação ao sinal de =, para inverter o sinal quando necessário!
  295.                   Negativando = false;
  296.               }
  297.              
  298.              
  299.               if(s.charAt(b-1) == '-'){ //se encontrar um sinal de -, dá o valor negativo para o nº e encerra o laço o programa
  300.                
  301.               Numero *= -1;
  302.               System.out.print(Numero + " [NEGATIVO]");
  303.               break;
  304.                  
  305.               } //fim da análise de números negativos
  306.              
  307.               //considerar colocar um ELSE ao invés de condições.
  308.              
  309.               if(s.charAt(b-1) == '+' || s.charAt(b-1) == '*' || s.charAt(b-1) == '/' || s.charAt(b-1) == '=' || s.charAt(b-1) == '(' || s.charAt(b-1) == ' ') { //se encontrar um sinal de positivo, deixa o número positivo mesmo :)
  310.              
  311.               System.out.print(Numero +" [POSITIVO]");
  312.               break;
  313.               }
  314.               } //final do for
  315.              
  316.               //ADICIONANDO PARA O ARRAYLIST
  317.              
  318.               Eq1grauNOVO.AnalisandoIgualInt(NumeroMultiplicador, Numero, Negativando, ParentesesEncontrado, SinaldeIgual);
  319.              
  320.               }//final da análise de Inteiros
  321.                
  322.     }
  323.    
  324.     public static void VerificaX(int InverterSinalNaHoraDosCalculosX, int NumeroMultiplicador, int ParentesesEncontrado, String s, int encontrado, int b, boolean SinaldeIgual, boolean Negativando, double Numero){
  325.                  //ANALISA SE É INCÓGNITA X
  326.           if (s.charAt(encontrado) == 'x'){ //se possuir a letra X após o número (se for uma incógnita)
  327.  
  328.                             //VERIFICA SE NÚMERO ESTÁ DEPOIS DO SINAL DE =
  329.               for(b = encontrado; b >= 0; b--){ //pesquisa reversamente a string iniciando do número que encontrou.
  330.                                                                            
  331.                   if(s.charAt(b) == '=' && SinaldeIgual == false){ //se encontrar um sinal de =, mantém sinal, por que ele tem que ficar do lado direito!
  332.                   Negativando = true;
  333.                   SinaldeIgual = true;
  334.                  
  335.                   }
  336.               } //fim do for
  337.              
  338.  
  339.              
  340.               for(b = encontrado; b >= 0; b--){ //pesquisa a string reversamente
  341.                  
  342.                   //System.out.print(s.charAt(b) ); //mostrando os caracteres
  343.                  
  344.                   if(s.charAt(b) == '-'){ //se encontrar um sinal de -, dá o valor negativo para o nº e encerra o laço o programa
  345.                       Numero *= -1;
  346.                       System.out.print(Numero + "x [NEGATIVO]");
  347.                       break;
  348.                   }
  349.                  
  350.                   if(s.charAt(b) == '+' || s.charAt(b) == '*' || s.charAt(b) == '/' || s.charAt(b) == '=' || s.charAt(b) == '(' ) { //se encontrar um sinal de positivo, deixa o número positivo mesmo :)
  351.                        //o s.charAt(b) == '=' é caso a equação esteja assim: 2x + 10 = 18x
  352.                       //nesse caso o 18x seria negativado
  353.                      
  354.                       System.out.print(Numero + "x [POSITIVO]");
  355.                       break;
  356.                   }          
  357.               } //final do for de procura de sinais
  358.    
  359.  
  360.  
  361.              
  362.                             if(NumeroMultiplicador == 2){
  363.               AdicionaNumeroMultiplicador(Numero);
  364.               NumeroMultiplicadorXouINT(1);
  365.               System.out.print(Numero + "x Adicionado em: AdicionaNumeroMultiplicador");
  366.               ParentesesEncontrado = 3;
  367.               NaoInverterSinal = true;
  368.              
  369.               }
  370.                            
  371.                            
  372.                 //VERIFICA SE NÚMERO ESTÁ ANTES DO SINAL DE =, SE SIM, MANTÉM SINAL
  373.              
  374.                 Eq1grauNOVO.AnalisandoIgualX(NumeroMultiplicador, Numero, Negativando, ParentesesEncontrado, SinaldeIgual);
  375.  
  376.                   } //final da análise de incógnitas
  377.     }
  378.    
  379.    
  380.    
  381.    
  382.    
  383.    
  384.    
  385.    
  386.    
  387.         public static void AnalisandoIgualX(int NumeroMultiplicador, double Numero, boolean Negativando, int ParentesesEncontrado, boolean SinaldeIgual){
  388.                       if (Negativando == false && NumeroMultiplicador == 0){
  389.                  
  390.                   if(ParentesesEncontrado == 0){
  391.                       AdicionaNumeroVetorX(Numero);
  392.                       System.out.print(Numero + "x [número ANTES DO IGUAL] adicionado em: AdicionaNumeroVetorX"); //exibe na tela para teste
  393.                   }
  394.                  
  395.                   else if (ParentesesEncontrado == 1){
  396.                       AdicionaNumeroVetorParenteses(Numero);
  397.                       ParentesesXouInt(1); //atribui o valor 1 por que é uma incógnita
  398.                       System.out.print(Numero + "x ~ adicionado em: AdicionaNumeroVetorParenteses [INCÓGNITA X]");
  399.                   }
  400.               }
  401.                            
  402.                
  403.               //VERIFICA SE NÚMERO ESTÁ DEPOIS DO SINAL DE =, SE SIM, INVERTE SINAL
  404.               if (Negativando == true && SinaldeIgual == true){
  405.                  
  406.                   if(ParentesesEncontrado == 0){
  407.                                           AdicionaNumeroVetorX(Numero * -1); //adiciona no arraylist
  408.                     System.out.print(Numero * -1 + " [número DEPOIS DO IGUAL] adicionado em: AdicionaNumeroVetorX"); //exibe na tela para teste
  409.                   }
  410.                  else if(ParentesesEncontrado == 1){
  411.                             //AdicionaNumeroVetorParentesesX(Numero);
  412.                       AdicionaNumeroVetorParenteses(Numero);
  413.                       ParentesesXouInt(3); //se for uma incógnita & estiver depois do sinal de =, recebe o valor 3
  414.                       InverterSinaldoParentesesX(PosicaoVetorParentesesX);
  415.                       System.out.println(Numero + "x ~ [SINAL MANTIDO] adicionado em: AdicionaNumeroVetorParentesesX. Posição: "+ PosicaoVetorParentesesX);
  416.                      PosicaoVetorParentesesX++;
  417.                  }  
  418.               }
  419.                  
  420.                   System.out.print("\n");
  421.     }
  422.    
  423.    
  424.    
  425.    
  426.     public static void AnalisandoIgualInt(int NumeroMultiplicador, double Numero, boolean Negativando, int ParentesesEncontrado, boolean SinaldeIgual){
  427.                      
  428.        
  429.         if(NumeroMultiplicador == 1){
  430.                   AdicionaNumeroMultiplicador(Numero);
  431.                   NumeroMultiplicadorXouINT(0);
  432.                   System.out.print("~~~~~~NÚMERO MULTIPLICADOR~~~~~~~~~~");
  433.               }
  434.              
  435.               if (Negativando == false && NumeroMultiplicador == 0){ //SE ESTIVER ANTES DO =, INVERTE O SINAL
  436.                  
  437.                   if (ParentesesEncontrado == 0){ //se não encontrar nenhum parenteses
  438.                      
  439.  
  440.                      
  441.                       AdicionaNumeroVetor(Numero * -1);
  442.                       System.out.print(Numero*-1 + " [número ANTES DO IGUAL] adicionado em: AdicionaNumeroVetor ");//exibe na tela para teste
  443.                   }
  444.                  
  445.                   else if(ParentesesEncontrado == 1){//se encontrar parenteses  
  446.      
  447.                       AdicionaNumeroVetorParenteses(Numero);
  448.                       ParentesesXouInt(2); //recebe o valor 2 pq está dentro do parenteses e é INT & tem q inverter o sinal depois
  449.                       InverterSinaldoParentesesInt(PosicaoVetorParentesesInt);
  450.                       System.out.println(Numero+ "[SINAL MANTIDO] adicionado em: AdicionaNumeroVetorParenteses [INTEIRO]");
  451.                       PosicaoVetorParentesesInt++;
  452.                      
  453.               }
  454.               }
  455.              
  456.               //SE ESTIVER DEPOIS DO =, MANTÉM O SINAL
  457.               if(Negativando == true && SinaldeIgual == true && NumeroMultiplicador == 0){
  458.                  
  459.                   if (ParentesesEncontrado == 0 ){
  460.                       AdicionaNumeroVetor(Numero);
  461.                       System.out.print(Numero + " [número DEPOIS DO IGUAL] adicionado em: AdicionaNumeroVetor"); //exibe na tela para teste
  462.                   }
  463.                  
  464.                   else if (ParentesesEncontrado == 1){
  465.                       AdicionaNumeroVetorParenteses(Numero);
  466.                       ParentesesXouInt(0); //recebe o valor 0 pq está depois do =, dentro do parenteses e é INT
  467.                       System.out.print(Numero + " adicionado em: AdicionaNumeroVetorParenteses [INTEIRO]");  
  468.                   }
  469.               }
  470.              
  471.               System.out.print("\n");
  472.     }
  473.    
  474.    
  475.    
  476.     public static void ExibeCalculos(String aux1){
  477.     System.out.print("\n\n1º Passo: " + aux1 +" [String digitada pelo usuário]") ;
  478.  
  479.     System.out.print("\n2º Passo: ");
  480.    
  481.                                              for (int k = 0; k < numerosX.size(); k++){//for para exibir tudo q está dentro do arraylist
  482.                                              if (numerosX.get(k) < 0){ //analisando se  número é negativo para adicionar parenteses
  483.                                                    
  484.                                             if(k == numerosX.size() - 1){
  485.                                             if (numerosX.get(k) < 0)
  486.                                                     System.out.print("(" + Math.round(numerosX.get(k)) + "x)");
  487.                                             }
  488.                                            
  489.                                             else
  490.                                             System.out.print("(" +Math.round(numerosX.get(k)) + "x) + ");
  491.                                             } //fim da análise de negativos
  492.                                                
  493.                                             else if (numerosX.get(k) > 0){
  494.                                             if(k == numerosX.size() - 1){ //se for o último número não exibe o "+" no final
  495.                                             System.out.print(Math.round(numerosX.get(k)) + "x"); //mostra todos os números
  496.                                              }
  497.                                                    
  498.                                             else
  499.                                             System.out.print(Math.round(numerosX.get(k)) + "x + "); //mostra todos os números
  500.                                             }
  501.                                             }
  502.                                
  503.                         System.out.print(" = ");
  504.            
  505.                                              for (int k = 0; k < numeros.size(); k++){//for para exibir tudo q está dentro do arraylist
  506.                                              if (numeros.get(k) < 0){ //analisando se  número é negativo para adicionar parenteses
  507.                                                    
  508.                                             if(k == numeros.size() - 1){
  509.                                             if (numeros.get(k) < 0)
  510.                                                     System.out.print("(" + Math.round(numeros.get(k)) + ")");
  511.                                             }
  512.                                            
  513.                                             else
  514.                                             System.out.print("(" +Math.round(numeros.get(k)) + ") + ");
  515.                                             } //fim da análise de negativos
  516.                                                
  517.                                             else if (numeros.get(k) > 0){
  518.                                             if(k == numeros.size() - 1){ //se for o último número não exibe o "+" no final
  519.                                             System.out.print(Math.round(numeros.get(k))); //mostra todos os números
  520.                                              }
  521.                                                    
  522.                                             else
  523.                                             System.out.print(Math.round(numeros.get(k)) + " + "); //mostra todos os números
  524.                                             }
  525.                                             }
  526.    
  527.     System.out.print(" [Números convertidos para Double, incógnitas para esquerda & números para direita]");
  528.      
  529.    
  530.     double soma = 0;
  531.     double somaX = 0;
  532.    
  533.     for(int somando=0; somando<numerosX.size(); somando++){
  534.     somaX+=(double) Math.round(numerosX.get(somando));
  535.     }
  536.    
  537.     for(int somando=0; somando<numeros.size(); somando++){
  538.     soma+=(double) Math.round(numeros.get(somando));
  539.     }
  540.    
  541.     System.out.print("\n3º Passo: " + Math.round(somaX) +"x = " + Math.round(soma));
  542.     System.out.print("\n4º Passo: x = " + Math.round(soma) + " / "  + Math.round(somaX));
  543.     System.out.print("\n5º Passo: x = " + (soma / somaX) + "\n");
  544.    
  545.     //System.out.print(somaX + " = " + soma);
  546.    
  547.    
  548.    
  549.    
  550.    
  551.    
  552.    
  553.    
  554.    
  555.    
  556.    
  557.    
  558.    
  559.    
  560.    
  561.    
  562.    
  563.    
  564.    
  565.    
  566.     } //final do método de exibição de cálculos
  567.    
  568.     public static void ExibeCalculosParenteses(int InverterSinalNaHoraDosCalculosX, int InverterSinalNaHoraDosCalculosInt,String aux1){
  569.        
  570.             System.out.print("Valores dentro do InverterSinalParentesesX: " + InverterSinalParentesesX + "\nValores dentro do InverterSinalParentesesInt: " + InverterSinalParentesesInt);
  571.                         System.out.print("Conteúdo do parenteses: ");
  572.             for(int k = 0; k < Parenteses.size(); k++){
  573.                 System.out.print("\nValor: " + ParentesesXouINT.get(k)+ " - Número: " +Parenteses.get(k) + " ~ ");
  574.             }
  575.             System.out.print("\n\n1º Passo: " + aux1 +" [String digitada pelo usuário]") ;
  576.             System.out.println("\n\n2º Passo: [Multiplicando o valor dos parenteses com o sinal já invertido]\n");
  577.            
  578.            
  579.             int numeroDoParenteses = 1;
  580.             int cont = 0;
  581.            
  582.            
  583.             for (int k = 0; k < MultiplicadorParenteses.size(); k++){ //pego todos números que são multiplicadores
  584.                
  585.                
  586.                 System.out.print((numeroDoParenteses) + "º Parenteses: "); //mostrando os parenteses sendo resolvidos
  587.                
  588.                
  589.                 if(MultiplicadorParentesesXouINT.get(k) == 0){ //exibe números com Multiplicadores INT
  590.                     for(int CompletandoParenteses = 0; CompletandoParenteses <2; CompletandoParenteses++){
  591.                     System.out.print("(" +Math.round(MultiplicadorParenteses.get(k)) + " * "); //exibindo o multiplicador INT
  592.                    
  593.                     if(ParentesesXouINT.get(cont) == 0 || ParentesesXouINT.get(cont) == 2){ //verificando se o número dentro do parenteses é um INT
  594.                         System.out.print(Math.round(Parenteses.get(cont)));
  595.                        
  596.                         if(ParentesesXouINT.get(cont) == 2){
  597.                             System.out.print("[INVERTE SINAL]");
  598.                             AdicionaNumeroVetor(MultiplicadorParenteses.get(k) * (Parenteses.get(cont) * -1));
  599.                         }
  600.                         else{
  601.                             AdicionaNumeroVetor(MultiplicadorParenteses.get(k) * Parenteses.get(cont));
  602.                         }
  603.                        
  604.                         cont++;
  605.                     }
  606.                    
  607.                     else if(ParentesesXouINT.get(cont) == 1 || ParentesesXouINT.get(cont) == 3){ //verificando se o número dentro do parenteses é X
  608.                          System.out.print(Math.round(Parenteses.get(cont)) + "x");
  609.                          
  610.                          if(ParentesesXouINT.get(cont) == 3){
  611.                             System.out.print("[VIRA X & INVERTE SINAL]");
  612.                             AdicionaNumeroVetorX(MultiplicadorParenteses.get(k) * (Parenteses.get(cont) * -1));
  613.                         }
  614.                          else{
  615.                              AdicionaNumeroVetorX(MultiplicadorParenteses.get(k) * Parenteses.get(cont));
  616.                          }
  617.                          
  618.                          cont++;
  619.                      }
  620.                    
  621.                     if(CompletandoParenteses == 1){ //apenas exibindo os parenteses que fecham
  622.                         System.out.print(")");
  623.                     }
  624.                     else{
  625.                         System.out.print(") + ");
  626.                     }    
  627.                     }
  628.                     cont--;    
  629.                 }
  630.                
  631.                
  632.                
  633.                
  634.                
  635.                
  636.                 else if (MultiplicadorParentesesXouINT.get(k) == 1){ //exibe números com Multiplicadores X
  637.                    
  638.                     for(int CompletandoParenteses = 0; CompletandoParenteses <2; CompletandoParenteses++){
  639.                     System.out.print("("+Math.round(MultiplicadorParenteses.get(k)) + "x * "); //exibindo o multiplicador X
  640.  
  641.                     if(ParentesesXouINT.get(cont) == 0 || ParentesesXouINT.get(cont) == 2){ //verificando se o número dentro do parenteses é um Int
  642.                         System.out.print(Math.round(Parenteses.get(cont)));
  643.                        
  644.                         if(ParentesesXouINT.get(cont) == 0){
  645.                             System.out.print("[VIRA X & INVERTE SINAL]");
  646.                             AdicionaNumeroVetorX(MultiplicadorParenteses.get(k) * (Parenteses.get(cont) * -1));
  647.                         }
  648.                         else{
  649.                             System.out.print("[VIRA X]");
  650.                             AdicionaNumeroVetorX(MultiplicadorParenteses.get(k) * Parenteses.get(cont));
  651.                         }
  652.                        
  653.                        
  654.                         cont++;
  655.                     }
  656.                    
  657.                     else if(ParentesesXouINT.get(cont) == 1 || ParentesesXouINT.get(cont) == 3){ //verificando se o número dentro do parenteses é X
  658.                          System.out.print(Math.round(Parenteses.get(cont)) + "x");
  659.                          
  660.                          if(ParentesesXouINT.get(cont) == 3){
  661.                             System.out.print("[INVERTE SINAL]");
  662.                             AdicionaNumeroVetorX(MultiplicadorParenteses.get(k) * (Parenteses.get(cont) * -1));
  663.                         }
  664.                          else{
  665.                              AdicionaNumeroVetorX(MultiplicadorParenteses.get(k) * Parenteses.get(cont));
  666.                          }
  667.                          
  668.                          cont++;
  669.                      }
  670.                    
  671.                    
  672.                     if(CompletandoParenteses == 1){
  673.                         System.out.print(")");
  674.                     }
  675.                     else{
  676.                         System.out.print(") + ");
  677.                     }
  678.                    
  679.                     }//fim do for
  680.                     cont--;
  681.                 }
  682.  
  683.                 System.out.println(); numeroDoParenteses++;
  684.                 //MultiplicadorParentesesX.remove(k);
  685.                 cont++;
  686.  
  687.             } //final do for
  688.            
  689.  
  690.            
  691.            
  692.            
  693.            
  694.            
  695.            
  696.          
  697.           System.out.print("\n\n3º Passo: ");
  698.          
  699.          
  700.           for (int k = 0; k < numerosX.size(); k++){//for para exibir tudo q está dentro do arraylist
  701.  
  702.                                              if (numerosX.get(k) < 0){ //analisando se  número é negativo para adicionar parenteses
  703.                                                    
  704.                                             if(k == numerosX.size() - 1){
  705.                                             if (numerosX.get(k) < 0)
  706.                                                     System.out.print("(" + Math.round(numerosX.get(k)) + "x)");
  707.                                             }
  708.                                            
  709.                                             else
  710.                                             System.out.print("(" +Math.round(numerosX.get(k)) + "x) + ");
  711.                                             } //fim da análise de negativos
  712.                                                
  713.                                             else if (numerosX.get(k) > 0){
  714.                                             if(k == numerosX.size() - 1){ //se for o último número não exibe o "+" no final
  715.                                             System.out.print(Math.round(numerosX.get(k)) + "x"); //mostra todos os números
  716.                                              }
  717.                                                    
  718.                                             else
  719.                                             System.out.print(Math.round(numerosX.get(k)) + "x + "); //mostra todos os números
  720.                                             }
  721.                                             }
  722.                                
  723.                         System.out.print(" = ");
  724.            
  725.                                              for (int k = 0; k < numeros.size(); k++){//for para exibir tudo q está dentro do arraylist
  726.                                              if (numeros.get(k) < 0){ //analisando se  número é negativo para adicionar parenteses
  727.                                                    
  728.                                             if(k == numeros.size() - 1){
  729.                                             if (numeros.get(k) < 0)
  730.                                                     System.out.print("(" +Math.round(numeros.get(k)) + ")");
  731.                                             }
  732.                                            
  733.                                             else
  734.                                             System.out.print("(" +Math.round(numeros.get(k)) + ") + ");
  735.                                             } //fim da análise de negativos
  736.                                                
  737.                                             else if (numeros.get(k) > 0){
  738.                                             if(k == numeros.size() - 1){ //se for o último número não exibe o "+" no final
  739.                                             System.out.print(Math.round(numeros.get(k))); //mostra todos os números
  740.                                              }
  741.                                                    
  742.                                             else
  743.                                             System.out.print(Math.round(numeros.get(k)) + " + "); //mostra todos os números
  744.                                             }
  745.                                             }
  746.    
  747.     System.out.print(" [Números convertidos para Double, incógnitas para esquerda & números para direita]");
  748.    
  749.         double soma = 0;
  750.     double somaX = 0;
  751.    
  752.     for(int somando=0; somando<numerosX.size(); somando++){
  753.     somaX+=(double) Math.round(numerosX.get(somando));
  754.     }
  755.    
  756.     for(int somando=0; somando<numeros.size(); somando++){
  757.     soma+=(double) Math.round(numeros.get(somando));
  758.     }
  759.    
  760.     System.out.print("\n4º Passo: " + Math.round(somaX) +"x = " + Math.round(soma));
  761.     System.out.print("\n5º Passo: x = " + Math.round(soma) + " / "  + Math.round(somaX));
  762.     System.out.print("\n6º Passo: x = " + (soma / somaX) + "\n");
  763.     }
  764.    
  765.    
  766.    
  767.    
  768.  
  769.    
  770.    
  771.     public static void AdicionaNumeroVetor(double AdicionarNumero){ //método para adicionar números
  772.         numeros.add(AdicionarNumero);
  773.     }
  774.    
  775.         public static void AdicionaNumeroVetorX(double AdicionarNumero){ //método para adicionar números
  776.         numerosX.add(AdicionarNumero);
  777.     }
  778.        
  779.         public static void AdicionaNumeroVetorParenteses(double AdicionarNumero){ //método para adicionar números
  780.         Parenteses.add(AdicionarNumero);
  781.     }
  782.        
  783.         /*                public static void AdicionaNumeroVetorParentesesX(double AdicionarNumero){ //método para adicionar números
  784.         ParentesesX.add(AdicionarNumero);
  785.         }*/
  786.  
  787.                                 public static void AdicionaNumeroMultiplicador(double AdicionarNumero){ //método para adicionar números
  788.         MultiplicadorParenteses.add(AdicionarNumero);
  789.     }
  790.                                
  791.                                                           public static void ParentesesXouInt(int AdicionarNumero){ //método para adicionar números
  792.                                 ParentesesXouINT.add(AdicionarNumero);
  793.                                 }
  794.                                
  795.                                 public static void InverterSinaldoParentesesInt(int AdicionarNumero){ //método para adicionar números
  796.         InverterSinalParentesesInt.add(AdicionarNumero);
  797.     }
  798.                                
  799.                                 public static void InverterSinaldoParentesesX(int AdicionarNumero){ //método para adicionar números
  800.         InverterSinalParentesesX.add(AdicionarNumero);
  801.     }
  802.                                 public static void NumeroMultiplicadorXouINT(int AdicionarNumero){ //método para adicionar números
  803.         MultiplicadorParentesesXouINT.add(AdicionarNumero);
  804.     }
  805.                                
  806.                                
  807.                                
  808.                
  809.        
  810. } //fim classe
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!