Advertisement
LightProgrammer000

Gênio da Lâmpada

Jul 7th, 2024
190
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 10.88 KB | None | 0 0
  1. // Pacote
  2. package Tarefas_1;
  3.  
  4. // Bibliotecas
  5. import java.util.Scanner;
  6.  
  7. public class EX11
  8. {
  9.     // Instanciacao
  10.     static Scanner ent = new Scanner(System.in);
  11.  
  12.     public static void main(String[] args)
  13.     {
  14.         System.out.println("# Programa EX11");
  15.  
  16.         try
  17.         {
  18.             // Apresentacao
  19.             System.out.println("\n----- Genio da lampada -----\n");
  20.             System.out.println("+ Vou adivinhar o animal que o senhor(a) escolheu dentre os abaixo\n");
  21.  
  22.             // Programa
  23.             exec_program();
  24.         }
  25.  
  26.         catch(Exception e)
  27.         {
  28.             System.err.println(e.getMessage());
  29.         }
  30.        
  31.         finally
  32.         {
  33.             ent.close();
  34.         }
  35.     }
  36.  
  37.     // Metodo: Execucao do programa principal
  38.     private static void exec_program()
  39.     {
  40.         // Variavel
  41.         String animal;
  42.         String lista[] = {"leao", "cavalo", "homem", "macaco", "morcego",
  43.                           "baleia", "avestruz", "pinguim", "pato", "aguia",
  44.                           "tartaruga", "crocodilo", "cobra"};
  45.  
  46.         // Aprensentacao das opcoes
  47.         System.out.println("# Animais possiveis: ");
  48.         for (int i = 0; i < lista.length; i++)
  49.         {
  50.             System.out.printf("[%d]. %s\n",(i + 1), lista[i]);          
  51.         }
  52.  
  53.         while(true)
  54.         {
  55.             // Chamada de funcao
  56.             animal = questionario();
  57.  
  58.             // Estrutura de decisao
  59.             if (!animal.equals("nenhum"))
  60.             {
  61.                 System.out.println("\n---------------- Resultado ----------------");
  62.                 System.out.println("\n# Entao o animal escolhido foi o " + animal);
  63.                 System.out.println("\n-------------------------------------------");
  64.                 return;
  65.             }
  66.  
  67.             else
  68.             {
  69.                 System.out.println("\n---------------- Resultado ----------------");
  70.                 System.out.println("\n# Nao consegui adivinhar");
  71.                 System.out.println("\n-------------------------------------------");
  72.             }
  73.         }
  74.     }
  75.  
  76.     // Funcao: Escolha dentre os tipos de animais
  77.     private static String questionario()
  78.     {
  79.         // Variavel
  80.         String opc = null;
  81.  
  82.         // Estrutura em escolha
  83.         switch (animais())
  84.         {
  85.             case "mamiferos":
  86.  
  87.                 // Mamifero
  88.                 opc = mamiferos();
  89.                 break;
  90.  
  91.             case "aves":
  92.  
  93.                 // Aves
  94.                 opc = aves();
  95.                 break;
  96.  
  97.             case "repteis":
  98.  
  99.                 // Repteis
  100.                 opc = repteis();
  101.                 break;
  102.  
  103.             case "nenhum":
  104.                 opc = "nenhum";
  105.  
  106.             default:
  107.                 break;
  108.         }
  109.  
  110.         return opc;
  111.     }
  112.  
  113.     // Funcao: Analise de animais
  114.     private static String animais()
  115.     {
  116.         // Variavel
  117.         String opc;
  118.  
  119.         // Entrada de dados
  120.         System.out.print("\n* Mamifero \n[s] Sim \n[n] Nao \nOpc: ");
  121.         opc = ent.next().toLowerCase();
  122.  
  123.         // Estrutura de decisao: Mamiferos
  124.         if (opc.equals("s"))
  125.         {
  126.             opc = "mamiferos";
  127.         }
  128.  
  129.         else
  130.         {
  131.             System.out.print("\n* Aves \n[s] Sim \n[n] Nao \nOpc: ");
  132.             opc = ent.next().toLowerCase();
  133.  
  134.             // Estrutura de decisao: Aves
  135.             if (opc.equals("s"))
  136.             {
  137.                 opc = "aves";                
  138.             }
  139.  
  140.             else
  141.             {
  142.                 System.out.print("\n* Repteis \n[s] Sim \n[n] Nao \nOpc: ");
  143.                 opc = ent.next().toLowerCase();
  144.  
  145.                 // Estrutura de decisao: Repteis
  146.                 if (opc.equals("s"))
  147.                 {
  148.                     opc = "repteis";                
  149.                 }
  150.  
  151.                 else
  152.                 {
  153.                     opc = "nenhum";
  154.                 }
  155.             }
  156.         }
  157.  
  158.         return opc;
  159.     }
  160.  
  161.     // Funcao: Analise dos mamiferos
  162.     private static String mamiferos()
  163.     {
  164.         // Variavel
  165.         String opc;
  166.  
  167.         // Entrada de dados
  168.         System.out.print("\n* Quadrupede \n[s] Sim \n[n] Nao \nOpc: ");
  169.         opc = ent.next().toLowerCase();
  170.  
  171.         // Estrutura de decisao: Quadrupede
  172.         if(opc.equals("s"))
  173.         {
  174.             System.out.print("\n* Carnivoro \n[s] Sim \n[n] Nao \nOpc: ");
  175.             opc = ent.next().toLowerCase();
  176.  
  177.             // Estrutura em escolha
  178.             switch (opc)
  179.             {
  180.                 // Escolha: Resultado -> leao
  181.                 case "s":
  182.                     opc = "leao";
  183.                     break;
  184.  
  185.                 // Escolha: Herbivoro
  186.                 case "n":
  187.                     System.out.print("\n* Herbivoro \n[s] Sim \n[n] Nao \nOpc: ");
  188.                     opc = ent.next().toLowerCase();
  189.  
  190.                     // Estrutura de decisao: Resultado -> cavalo
  191.                     if (opc.equals("s"))
  192.                     {
  193.                         opc = "cavalo";
  194.                     }
  195.  
  196.                     else
  197.                     {
  198.                         opc = "nenhum";
  199.                     }
  200.  
  201.                     break;
  202.  
  203.                 default:
  204.                     break;
  205.             }
  206.         }
  207.  
  208.         else
  209.         {
  210.             System.out.print("\n* Bipedes \n[s] Sim \n[n] Nao \nOpc: ");
  211.             opc = ent.next().toLowerCase();
  212.  
  213.             // Estrutura de decisao: Bipedes
  214.             if (opc.equals("s"))
  215.             {
  216.                 System.out.print("\n* Onivoros \n[s] Sim \n[n] Nao \nOpc: ");
  217.                 opc = ent.next().toLowerCase();
  218.  
  219.                 // Estrutura em escolha
  220.                 switch (opc)
  221.                 {
  222.                     // Escolha: Resultado -> homem
  223.                     case "s":
  224.                         opc = "homem";
  225.                         break;
  226.  
  227.                     // Escolha: Frutivoros
  228.                     case "n":
  229.                         System.out.print("\n* Frutivoros \n[s] Sim \n[n] Nao \nOpc: ");
  230.                         opc = ent.next().toLowerCase();
  231.  
  232.                         // Estrutura de decisao: Resultado -> Macaco
  233.                         if (opc.equals("s"))
  234.                         {
  235.                             opc = "Macaco";
  236.                         }
  237.  
  238.                         else
  239.                         {
  240.                             opc = "nenhum";
  241.                         }
  242.  
  243.                         break;
  244.  
  245.                     default:
  246.                         break;
  247.                 }
  248.             }
  249.  
  250.             // Estrutura de decisao: Voadores
  251.             else
  252.             {
  253.                 System.out.print("\n* Voadores \n[s] Sim \n[n] Nao \nOpc: ");
  254.                 opc = ent.next().toLowerCase();
  255.  
  256.                 // Estrutura em escolha
  257.                 switch (opc)
  258.                 {
  259.                     // Escolha: Resultado -> Morcego
  260.                     case "s":
  261.                         opc = "morcego";
  262.                         break;
  263.  
  264.                     // Escolha: Aquaticos
  265.                     case "n":
  266.                         System.out.print("\n* Aquaticos \n[s] Sim \n[n] Nao \nOpc: ");
  267.                         opc = ent.next().toLowerCase();
  268.  
  269.                         if (opc.equals("s"))
  270.                         {
  271.                             opc = "baleia";
  272.                         }
  273.  
  274.                         else
  275.                         {
  276.                             opc = "nenhum";
  277.                         }
  278.  
  279.                         break;
  280.  
  281.                     default:
  282.                         break;
  283.                 }
  284.             }
  285.         }
  286.  
  287.         return opc;
  288.     }
  289.    
  290.     private static String aves()
  291.     {
  292.         // Variavel
  293.         String opc;
  294.  
  295.         // Entrada de dados
  296.         System.out.print("\n* Nao-voadoras \n[s] Sim \n[n] Nao \nOpc: ");
  297.         opc = ent.next().toLowerCase();
  298.        
  299.         // Estrutura de decisao: Nao-voadoras
  300.         if(opc.equals("s"))
  301.         {
  302.             System.out.print("\n* Tropicais \n[s] Sim \n[n] Nao \nOpc: ");
  303.             opc = ent.next().toLowerCase();
  304.  
  305.             // Estrutura em escolha
  306.             switch (opc)
  307.             {
  308.                 // Escolha: Resultado -> Avestruz
  309.                 case "s":
  310.  
  311.                     opc = "avestruz";
  312.                     break;
  313.  
  314.                 // Escolha: Polares
  315.                 case "n":
  316.  
  317.                     System.out.print("\n* Polares \n[s] Sim \n[n] Nao \nOpc: ");
  318.                     opc = ent.next().toLowerCase();
  319.  
  320.                     // Estrutura de decisao: Polares
  321.                     if (opc.equals("s"))
  322.                     {
  323.                         opc = "pinguim";
  324.                     }
  325.  
  326.                     else
  327.                     {
  328.                         opc = "nenhum";
  329.                     }
  330.  
  331.                     break;
  332.  
  333.                 default:
  334.                     break;
  335.             }
  336.         }
  337.  
  338.         else
  339.         {
  340.             System.out.print("\n* Nadadoras \n[s] Sim \n[n] Nao \nOpc: ");
  341.             opc = ent.next().toLowerCase();
  342.  
  343.             // Estrutura de decisao: Nadadoras
  344.             if (opc.equals("s"))
  345.             {
  346.                 opc = "pato";  
  347.             }
  348.  
  349.             else
  350.             {
  351.                 System.out.print("\n* De rapina \n[s] Sim \n[n] Nao \nOpc: ");
  352.                 opc = ent.next().toLowerCase();
  353.  
  354.                 // Estrutura de decisao: De rapina
  355.                 if (opc.equals("s"))
  356.                 {
  357.                     opc = "aguia";                    
  358.                 }
  359.  
  360.                 else
  361.                 {
  362.                     opc = "nenhum";
  363.                 }
  364.             }
  365.         }
  366.  
  367.         return opc;
  368.     }
  369.    
  370.     private static String repteis()
  371.     {
  372.         // Variavel
  373.         String opc;
  374.  
  375.         // Entrada de dados
  376.         System.out.print("\n* Com casco \n[s] Sim \n[n] Nao \nOpc: ");
  377.         opc = ent.next().toLowerCase();
  378.  
  379.         // Estrutura de decisao: Com casco
  380.         if(opc.equals("s"))
  381.         {
  382.             opc = "tartaruga";
  383.         }
  384.  
  385.         else
  386.         {
  387.             System.out.print("\n* Carnivoros \n[s] Sim \n[n] Nao \nOpc: ");
  388.             opc = ent.next().toLowerCase();
  389.            
  390.             // Estrutura de decisao: Carnivoros
  391.             if (opc.equals("s"))
  392.             {
  393.                 opc = "crocodilo";  
  394.             }
  395.  
  396.             else
  397.             {
  398.                 System.out.print("\n* Sem patas \n[s] Sim \n[n] Nao \nOpc: ");
  399.                 opc = ent.next().toLowerCase();
  400.  
  401.                 // Estrutura de decisao: Sem patas
  402.                 if (opc.equals("s"))
  403.                 {
  404.                     opc = "cobra";                    
  405.                 }
  406.  
  407.                 else
  408.                 {
  409.                     opc = "nenhum";
  410.                 }
  411.             }
  412.         }
  413.  
  414.         return opc;
  415.     }
  416. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement