API tools faq
paste
Advertisement
dantepw

Untitled

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