Advertisement
LightProgrammer000

Calculadora [Diversas Funções]

Dec 6th, 2018
310
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 13.65 KB | None | 0 0
  1. // Bibliotecas
  2. using System;
  3.  
  4. // Programa
  5. namespace EX_17
  6. {
  7.     // Classe
  8.     public class Programa
  9.     {
  10.         // Método Principal
  11.         public static void Main(string[] args)
  12.         {
  13.             // Variável
  14.             string cod = "A";
  15.  
  16.             while (cod != "n" && cod != "N")
  17.             {
  18.                 // Chamada de Método
  19.                 Menu();
  20.  
  21.                 // Retorno de Menu
  22.                 cod = Menu_Loop(cod);
  23.             }
  24.         }
  25.  
  26.         //////////////////////////////// FUNÇÕES ////////////////////////////////
  27.         private static void Menu()
  28.         {
  29.             // Sistema
  30.             Console.Clear();
  31.             Console.ForegroundColor = ConsoleColor.Green;
  32.  
  33.             // Variáveis
  34.             int resp;
  35.  
  36.             // Apresentação + Entrada de Dados
  37.             Console.Write("\n ============================= ");
  38.             Console.Write("\n              MENU             ");
  39.             Console.Write("\n ============================= ");
  40.             Console.Write("\n\n - [1] Fatorial");
  41.             Console.Write("\n - [2] Divisiveis");
  42.             Console.Write("\n - [3] Primo");
  43.             Console.Write("\n - [4] Tabuada");
  44.             Console.Write("\n - [5] Potência");
  45.             Console.Write("\n - [6] Raiz");
  46.             Console.Write("\n - [7] Equação do 2º Grau [Raizes]");
  47.             Console.Write("\n - [8] Soma de uma Progressão Aritmética");
  48.             Console.Write("\n - [9] Soma de uma Progressão Geométrica");
  49.             Console.Write("\n\n - Resp.: ");
  50.             resp = int.Parse(Console.ReadLine());
  51.  
  52.             // Estrutura de Escolha [Funções]
  53.             switch (resp)
  54.             {
  55.                 case 1:
  56.                     Fatorial();
  57.                     break;
  58.  
  59.                 case 2:
  60.                     Divisivel();
  61.                     break;
  62.  
  63.                 case 3:
  64.                     Primo();
  65.                     break;
  66.  
  67.                 case 4:
  68.                     Tabuada();
  69.                     break;
  70.  
  71.                 case 5:
  72.                     Potencia();
  73.                     break;
  74.  
  75.                 case 6:
  76.                     Raiz();
  77.                     break;
  78.  
  79.                 case 7:
  80.                     Eq_Seg_Gr();
  81.                     break;
  82.  
  83.                 case 8:
  84.                     Soma_PA();
  85.                     break;
  86.  
  87.                 case 9:
  88.                     Soma_PG();
  89.                     break;
  90.  
  91.                 default:
  92.                     break;
  93.             }
  94.         }
  95.  
  96.         private static string Menu_Loop(string cod)
  97.         {
  98.             // Sistema
  99.             Console.ForegroundColor = ConsoleColor.Red;
  100.  
  101.             // Variáveis
  102.             string a;
  103.  
  104.             // Entrada de Dados
  105.             Console.Write("\n\n - Retornar ao Menu Principal...");
  106.             Console.Write("\n - [s] Sim ");
  107.             Console.Write("\n - [n] Não ");
  108.             Console.Write("\n\n - Resp.: ");
  109.             a = Console.ReadLine();
  110.  
  111.             // Proteção
  112.             while (!a.Equals("s") && !a.Equals("n"))
  113.             {
  114.                 Console.Clear();
  115.                 Console.Write("\n\n - Retornar ao Menu Principal...");
  116.                 Console.Write("\n - [s] Sim ");
  117.                 Console.Write("\n - [n] Não ");
  118.                 Console.Write("\n\n - Resp.: ");
  119.                 a = Console.ReadLine();
  120.             }
  121.  
  122.             // Estrutura de Decisão
  123.             if (a.Equals("s"))
  124.             {
  125.                 return "s";
  126.             }
  127.  
  128.             else
  129.             {
  130.                 return "n";
  131.             }
  132.         }
  133.  
  134.         // Fatorial
  135.         private static void Fatorial()
  136.         {
  137.             // Sistema
  138.             Console.Clear();
  139.             Console.ForegroundColor = ConsoleColor.White;
  140.  
  141.             // Variáveis
  142.             int fat = 1;
  143.             int num, aux;
  144.  
  145.             // Apresentação + Entrada de Dados
  146.             Console.Write("\n ---------------------------- ");
  147.             Console.Write("\n           FATORIAL           ");
  148.             Console.Write("\n ---------------------------- ");
  149.  
  150.             Console.Write("\n\n - Digite um Número [Limite 12]: ");
  151.             num = int.Parse(Console.ReadLine());
  152.             aux = num;
  153.  
  154.             // Proteção
  155.             while (num < 0 || num > 12)
  156.             {
  157.                 Console.ForegroundColor = ConsoleColor.Red;
  158.                 Console.Write("\n *** Digite um Número entre 1 e 12 ***");
  159.                 Console.Write("\n\n - Digite um Número [Limite 12]: ");
  160.                 num = int.Parse(Console.ReadLine());
  161.                 aux = num;
  162.             }
  163.  
  164.             // Cálculo
  165.             while (num > 1)
  166.             {
  167.                 fat *= num;
  168.  
  169.                 num--;
  170.             }
  171.  
  172.             Console.ForegroundColor = ConsoleColor.White;
  173.             Console.Write("\n - Fatorial [" + aux + "]: " + fat);
  174.         }
  175.  
  176.         // Divisível
  177.         private static void Divisivel()
  178.         {
  179.             // Sistema
  180.             Console.Clear();
  181.             Console.ForegroundColor = ConsoleColor.Yellow;
  182.  
  183.             // Variáveis
  184.             int num;
  185.             int i = 1;
  186.             string lista = "";
  187.  
  188.             // Apresentação + Entrada de Dados
  189.             Console.Write("\n ----------------------------- ");
  190.             Console.Write("\n           DIVISÍVEL           ");
  191.             Console.Write("\n ----------------------------- ");
  192.  
  193.             Console.Write("\n\n - Digite um Número: ");
  194.             num = int.Parse(Console.ReadLine());
  195.  
  196.             // Proteção
  197.             if (num == 0)
  198.             {
  199.                 Console.Write("\n - Número [0]: Não tem Divisores");
  200.             }
  201.  
  202.             else if (num < 0)
  203.             {
  204.                 Console.Write("\n - Número Negativos são Inválidos");
  205.             }
  206.  
  207.             else
  208.             {
  209.                 // Cálculo
  210.                 while (i <= num)
  211.                 {
  212.                     if (num % i == 0)
  213.                     {
  214.                         lista += "\n - " + i;
  215.                     }
  216.  
  217.                     // Incrementador
  218.                     i++;
  219.                 }
  220.  
  221.                 // Conclusão
  222.                 Console.Write("\n - Lista: " + lista);
  223.             }
  224.         }
  225.  
  226.         // Primo
  227.         private static void Primo()
  228.         {
  229.             // Sistema
  230.             Console.Clear();
  231.             Console.ForegroundColor = ConsoleColor.Cyan;
  232.  
  233.             // Variáveis
  234.             int a;
  235.             int i = 1;
  236.             int cont_zero = 0;
  237.             string res = "Número";
  238.  
  239.             // Apresentação + Entrada de Dados
  240.             Console.Write("\n ------------------------- ");
  241.             Console.Write("\n           PRIMO           ");
  242.             Console.Write("\n ------------------------- ");
  243.  
  244.             Console.Write("\n\n - Digite um Número: ");
  245.             a = int.Parse(Console.ReadLine());
  246.  
  247.             while (i <= a)
  248.             {
  249.                 // Divisão Exata
  250.                 if (a % i == 0)
  251.                 {
  252.                     cont_zero++;
  253.                 }
  254.  
  255.                 // Restagem de "0" > 2
  256.                 if (cont_zero > 2)
  257.                 {
  258.                     break;
  259.                 }
  260.  
  261.                 i++;
  262.             }
  263.  
  264.             // Análise Mediante a Contagem de "Zeros"
  265.             if (cont_zero == 2)
  266.             {
  267.                 Console.Write("\n - Situação: Primo");
  268.             }
  269.  
  270.             else if (cont_zero > 2)
  271.             {
  272.                 Console.Write("\n - Situação: Não Primo");
  273.             }
  274.         }
  275.  
  276.         private static void Tabuada()
  277.         {
  278.             // Sistema
  279.             Console.Clear();
  280.             Console.ForegroundColor = ConsoleColor.Blue;
  281.  
  282.             // Variáveis
  283.             int a, i = 1;
  284.  
  285.             Console.Write("\n -------------------------- ");
  286.             Console.Write("\n           Tabuada          ");
  287.             Console.Write("\n -------------------------- ");
  288.  
  289.             Console.Write("\n\n - Digite um Número: ");
  290.             a = int.Parse(Console.ReadLine());
  291.  
  292.             Console.Write("\n ************************************************************ \n");
  293.             while (i <= 10)
  294.             {
  295.                 Console.WriteLine("\n # [" + (a) + "] x [" + (i) + "] = [" + (a * i) + "]");
  296.  
  297.                 // Incrementador
  298.                 i++;
  299.             }
  300.             Console.Write("\n ************************************************************ ");
  301.         }
  302.  
  303.         private static void Potencia()
  304.         {
  305.             // Sistema
  306.             Console.Clear();
  307.             Console.ForegroundColor = ConsoleColor.Magenta;
  308.  
  309.             // Variáveis
  310.             double num, exp;
  311.  
  312.             // Apresentação + Entrada de Dados
  313.             Console.Write("\n ---------------------------- ");
  314.             Console.Write("\n           Potencia           ");
  315.             Console.Write("\n ---------------------------- ");
  316.  
  317.             Console.Write("\n\n - Digite um Número [Base]: ");
  318.             num = int.Parse(Console.ReadLine());
  319.  
  320.             Console.Write("\n - Digite o Expoente: ");
  321.             exp = double.Parse(Console.ReadLine());
  322.  
  323.             // Saída de Dados
  324.             Console.Write("\n - Resultado: " + Math.Pow(num, exp));
  325.         }
  326.  
  327.         private static void Raiz()
  328.         {
  329.             // Sistema
  330.             Console.Clear();
  331.             Console.ForegroundColor = ConsoleColor.Magenta;
  332.  
  333.             // Variáveis
  334.             double num, ind;
  335.  
  336.             // Apresentação + Entrada de Dados
  337.             Console.Write("\n ------------------------ ");
  338.             Console.Write("\n           Raiz           ");
  339.             Console.Write("\n ------------------------ ");
  340.  
  341.             Console.Write("\n\n - Digite um Número [Base]: ");
  342.             num = int.Parse(Console.ReadLine());
  343.  
  344.             Console.Write("\n - Digite o Índice: ");
  345.             ind = double.Parse(Console.ReadLine());
  346.  
  347.             // Saída de Dados
  348.             Console.Write("\n - Resultado: " + Math.Pow(num, 1 / ind));
  349.         }
  350.  
  351.         private static void Eq_Seg_Gr()
  352.         {
  353.             // Sistema
  354.             Console.Clear();
  355.             Console.ForegroundColor = ConsoleColor.Yellow;
  356.  
  357.             // Variáveis
  358.             double a, b, c;
  359.             double raiz1, raiz2;
  360.  
  361.             // Apresentação + Entrada de Dados
  362.             Console.Write("\n ------------------------------------------- ");
  363.             Console.Write("\n           Equação do Segundo Grau           ");
  364.             Console.Write("\n               Ax² +- Bx +- C                ");
  365.             Console.Write("\n ------------------------------------------- ");
  366.  
  367.             Console.Write("\n\n - Digite A: ");
  368.             a = double.Parse(Console.ReadLine());
  369.  
  370.             Console.Write("\n - Digite B: ");
  371.             b = double.Parse(Console.ReadLine());
  372.  
  373.             Console.Write("\n - Digite C: ");
  374.             c = double.Parse(Console.ReadLine());
  375.  
  376.             // Cálculos das Raízes :  [ - b +- Raiz_Quadrada(Delta = (b² - 4ac) ] ) /2a
  377.  
  378.             // (-b + Delta1) / 2a -> Raiz 1
  379.             raiz1 = (-b + Math.Sqrt((Math.Pow(b, 2) - 4 * a * c))) / 2 * a;
  380.  
  381.             // (-b + Delta2) / 2a -> Raiz 2
  382.             raiz2 = (-b - Math.Sqrt((Math.Pow(b, 2) - 4 * a * c))) / 2 * a;
  383.  
  384.             // Conclusão
  385.             Console.Write("\n - Raiz 1: " + raiz1);
  386.             Console.Write("\n - Raiz 2: " + raiz2);
  387.         }
  388.  
  389.         private static void Soma_PA()
  390.         {
  391.             // Sistema
  392.             Console.Clear();
  393.             Console.ForegroundColor = ConsoleColor.Yellow;
  394.  
  395.             // Variáveis
  396.             double a1, an, n, Sn;
  397.  
  398.             // Apresentação + Entrada de Dados
  399.             Console.Write("\n ------------------------------------------------- ");
  400.             Console.Write("\n           Soma de Progressão Matemática           ");
  401.             Console.Write("\n ------------------------------------------------- ");
  402.  
  403.             Console.Write("\n\n - Digite o 1º Elemento [A1]: ");
  404.             a1 = double.Parse(Console.ReadLine());
  405.  
  406.             Console.Write("\n - Digite o Último Elemento [An]: ");
  407.             an = double.Parse(Console.ReadLine());
  408.  
  409.             Console.Write("\n - Digite a Quantidade de Termos [n]: ");
  410.             n = double.Parse(Console.ReadLine());
  411.  
  412.             // Cálculo: Sn= [ (a1 + an) * n ] / 2
  413.             Sn = (a1 + an) * n / 2;
  414.  
  415.             Console.Write("\n - Resultado [Soma] : " + Sn);
  416.         }
  417.  
  418.         private static void Soma_PG()
  419.         {
  420.             // Sistema
  421.             Console.Clear();
  422.             Console.ForegroundColor = ConsoleColor.Yellow;
  423.  
  424.             // Variáveis
  425.             double a1, q, n, Sn;
  426.  
  427.             // Apresentação + Entrada de Dados
  428.             Console.Write("\n ------------------------------------------------- ");
  429.             Console.Write("\n           Soma de Progressão Geométrica           ");
  430.             Console.Write("\n ------------------------------------------------- ");
  431.  
  432.             Console.Write("\n\n - Digite o 1º Elemento [A1]: ");
  433.             a1 = double.Parse(Console.ReadLine());
  434.  
  435.             Console.Write("\n - Digite a Razão [q]: ");
  436.             q = double.Parse(Console.ReadLine());
  437.  
  438.             Console.Write("\n - Digite a Quantidade de Termos [n]: ");
  439.             n = double.Parse(Console.ReadLine());
  440.  
  441.             // Cálculo: Sn = a1 * (q ^ n - 1 ) / q - 1
  442.             Sn = ( a1 * (Math.Pow(q, n) - 1)) / (q - 1);
  443.  
  444.             // Apresentação do Dados
  445.             Console.Write("\n - Resultado [Soma] : " + Sn );
  446.         }
  447.     }
  448. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement