Advertisement
Guest User

ExeConversorNumeraçãoNumérica

a guest
May 24th, 2015
197
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 9.48 KB | None | 0 0
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6.  
  7.  
  8. namespace ExeConversorNumeraçãoRomana
  9. {
  10.     class Program
  11.     {
  12.         static void Main(string[] args)
  13.         {
  14.             //O programa com os comentários funciona, mas a versão simplificada/finalizada e com exceções está no final
  15.  
  16.             /*Antes de mais começamos por perceber qual a lógica de como números romanos são convertidos.
  17.              As regras:
  18.  
  19.              * Um número maior à frente de um número menor significa subtração.
  20.              * A adição é caracterizada por um número menor à frente de um número maior.
  21.              Por exemplo, IV significa 4, VI significa 6.
  22.              * Não se utiliza mais de um número menor antes de um número maior para subtrair.
  23.              Por exemplo, IIV não corresponde a 3.
  24.              * Devem separar-se, dezenas, centenas, e milhares como numerais separados.
  25.              Isso significa que a 99 corresponde XCIX (90 + 9), nunca deve ser escrito como IC.
  26.  
  27. I   Corresponde ao numeral 1. II são dois, III são três, IV são 4 (ocasionalmente pode ver-se IIII como 4)
  28. V   Corresponde ao numeral 5. IV são 4, VI são 6, VII são 7, VIII são 8.
  29. X   Corresponde ao numeral 10. IX são 9, XI é 11, etc..
  30. L   Corresponde ao numeral 50. XL é o 40.
  31. C   Corresponde ao numeral 100.*/
  32.  
  33.             //Método converter numeros com 1 digito
  34.             //Frase onde vamos guardar o resultado da nossa numeração romana
  35.             string resultado = " ";
  36.             //Pergunta ao utilizador para introduzir o número
  37.             Console.WriteLine("Introduza um número singular (Só funciona 1 digito nesta parte do código): ");
  38.             //Introdução, limpeza de espaços adjacentes e conversão para inteiro
  39.             int recebe = int.Parse(Console.ReadLine().Trim());
  40.             /*Dividimos o numero introduzido com 10 para usarmos o seu resto para gerar os números romanos,
  41.             neste caso particular com 1 digito não era necessário pois o resto de qualquer numero com um digito dividido por 10
  42.             é sempre o próprio número de acordo com a aritmética modular*/
  43.             recebe = recebe % 10; /* 3 mod 10 é o mesmo que dizer que o resto da divisão 3 por 10 = 3 */
  44.             /*Agora temos de definir o que é guardado na nossa variável de texto "resultado", em cima declarada, conforme
  45.             a introdução que o utilizador faça*/
  46.             if (recebe == 9)
  47.             {
  48.                 /*Não podemos fazer a subtração de carateres de acordo com as regras acima descritas
  49.                 pois o número nove é muito especifico pois é quando está prestes a ocorrer a mudança
  50.                 para o X(numero 10) então definimos individualmente sendo uma das exceções*/
  51.                 resultado = "IX";
  52.             }
  53.             else if (recebe > 4)
  54.             {
  55.                 /*Nesta exceção, se o valor recebido for superior a 4,
  56.                 a função "Substring" vai cortar a frase "VIII" conforme o número indicado pelo utilizador
  57.                 Vou indicar o procedimento para alguns dos casos..
  58.                 Se recebe = 5 -> Substring(0, 5-4) -> Substring(0, 1) Ou seja vai desde a posição 0 até à 1,
  59.                 ou seja vai cortar "III" ficando apenas "V"
  60.                 Se recebe = 6 -> Substring(0, 6-4) -> Substring(0, 2) Ou seja vai desde a posição 0 até à 2,
  61.                 ou seja vai cortar "II" ficando apenas "VI"
  62.                  * Trivial.
  63.                 */
  64.                 resultado = "VIII".Substring(0, recebe - 4);
  65.             }
  66.             else if (recebe == 4)
  67.             {
  68.                 /*Exceção caso seja 4 pela mesma razão do 9 acima descrita*/
  69.                 resultado = "IV";
  70.             }
  71.             else /*Aqui podia ser acrescentado if(recebe == 1 || recebe == 2 || recebe == 3)
  72.                  Se o valor recebido fosse 1 ou 2 ou 3 o programa vem para esta parte do código,
  73.                  mas como já é subentendido pelo sistema não é necessário*/
  74.             {
  75.                 /*Todos os outros casos que vão sobrar que são apenas 3, 1-2-3. Seguem a mesma lógica dos maior que 4
  76.                 mas não precisamos de subtrair 4 pois o valor que recebe é o valor que vai ser lido da frase "III" */
  77.                 resultado = "III".Substring(0, recebe);
  78.             }
  79.             //Divulgar então o que foi guardado na variavel texto "resultado"
  80.             Console.WriteLine(resultado + "\n");
  81.  
  82.             /*A 2º Parte da explicação tem variáveis que podem não ser usadas,
  83.             mas para explicação é mais visivel o procedimento desta forma. A versão final está simplificada.*/
  84.             Console.WriteLine("2º Parte da explicação");
  85.             //Método converter números com 2 digitos
  86.             Console.WriteLine("Introduza um número com 2 digitos (Apenas funciona 1 ou 2 digitos): ");
  87.             int recebe2 = int.Parse(Console.ReadLine().Trim());
  88.             string resultado2 = " "; //Variável texto para guardar informação do primeiro Digito
  89.             string resultado3 = " "; //Variável texto para guardar informação do segundo Digito
  90.            
  91.             int segundo_digito = recebe2 % 10; /*A ordem da declaração e inicialização das variáveis interessa pois 'recebe2'
  92.             vai ser alterada na linha seguinte e precisamos desse valor para o cálculo do primeiro digito
  93.             embora a númeração romana seja guardada em variáveis de texto diferentes*/
  94.  
  95.             /*Com a mesma lógica anterior mas como o número recebido tem 2 digitos a conta é feita da seguinte forma
  96.             Imaginemos que o utilizador introduz 99, recebe2 = 99;
  97.             recebe2 % 100 é o resto da divisão 99 por 100, que é 99.
  98.             Esse valor calculado é dividido por 10, ou seja, 9,9.
  99.             Como só nos interessa a parte inteira do número, usamos (int) antes do cálculo para obter o número '9' do primeiro
  100.             digito.*/
  101.             recebe2 = (int)((recebe2 % 100) / 10);
  102.  
  103.             if (recebe2 == 9) /*Como podem ver, introduzindo 99 e depois do cálculo feito sai a parte do primeiro digito '9'
  104.                               que é precisamente a exceção para a condição*/
  105.             {
  106.                 resultado2 = "XC"; //90 em numeração romana
  107.             }
  108.             else if (recebe2 > 4)
  109.             {
  110.                 resultado2 = "LXXX".Substring(0, recebe2 - 4);
  111.             }
  112.             else if (recebe2 == 4)
  113.             {
  114.                 resultado2 = "XL";
  115.             }
  116.             else
  117.             {
  118.                 resultado2 = "XXX".Substring(0, recebe2);
  119.             }
  120.  
  121.             if (segundo_digito != 0) /* As condições para o segundo digito
  122.                                      são iguais à primeira parte com a diferença desta linha que vai apenas entrar neste ciclo
  123.                                      se o segundo digito for diferente de 0 */
  124.             {
  125.                 if (segundo_digito == 9)
  126.                 {
  127.                     resultado3 = "IX";
  128.                 }
  129.                 else if (segundo_digito > 4)
  130.                 {
  131.                     resultado3 = "VIII".Substring(0, segundo_digito - 4);
  132.                 }
  133.                 else if (segundo_digito == 4)
  134.                 {
  135.                     resultado3 = "IV";
  136.                 }
  137.                 else
  138.                 {
  139.                     resultado3 = "III".Substring(0, segundo_digito);
  140.                 }
  141.             }
  142.             //Esta linha imprime o texto criado com a númeração romana do primeiro e depois do segundo digito
  143.             Console.WriteLine(resultado2 + resultado3);
  144.             Console.ReadKey();
  145.  
  146.             /******EM BAIXO SEGUE O PROGRAMA COM AS MARIQUICES TODAS, SIMPLIFICADO E ORGANIZADO******/
  147.             /*COPIAR, TIRAR OS COMENTÁRIOS DAS PONTAS E CORRER*/
  148.  
  149.             /*
  150.             int recebe;
  151.             do
  152.             {
  153.                 Console.Clear();
  154.                 Console.WriteLine("Introduza um valor entre 1 e 99: ");
  155.                 recebe = int.Parse(Console.ReadLine().Trim());
  156.             } while (recebe.ToString().Length > 2 || recebe.ToString() == "0");
  157.             string resultado = " ";
  158.             int segundo_digito = recebe % 10;
  159.             recebe = (int)((recebe % 100) / 10);
  160.  
  161.             if (recebe == 9)
  162.             {
  163.                 resultado = "XC";
  164.             }
  165.             else if (recebe > 4)
  166.             {
  167.                 resultado = "LXXX".Substring(0, recebe - 4);
  168.             }
  169.             else if (recebe == 4)
  170.             {
  171.                 resultado = "XL";
  172.             }
  173.             else
  174.             {
  175.                 resultado = "XXX".Substring(0, recebe);
  176.             }
  177.             if (segundo_digito != 0)
  178.             {
  179.                 if (segundo_digito == 9)
  180.                 {
  181.                     resultado += "IX";
  182.                 }
  183.                 else if (segundo_digito > 4)
  184.                 {
  185.                     resultado += "VIII".Substring(0, segundo_digito - 4);
  186.                 }
  187.                 else if (segundo_digito == 4)
  188.                 {
  189.                     resultado += "IV";
  190.                 }
  191.                 else
  192.                 {
  193.                     resultado += "III".Substring(0, segundo_digito);
  194.                 }
  195.             }
  196.             Console.Write("Número em Romano: " + resultado);
  197.             Console.ReadKey();
  198.             */
  199.  
  200.         }
  201.     }
  202. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement