VisuAlg Visualg - Transformando os valores decimais: Binários, Octais e Hexadecimais

18 de julho de 2017

Algoritmo "Transformar os valores decimais em Binários, Octais ou Hexadecimais."
Var
Num, Valor: inteiro
Resultado1, Resultado2, Resultado3: Caracter
Inicio
 Escreval ("==============================================")
 Escreval ("Vamos transformar o valor decimal em Binário!!")
 Escreval ("==============================================")
 
 Escreval ("Digite um valor Decimal: ")
  Leia (Num)
   Valor <- (Num)
   enquanto (Num > 0) faca
    Escolha (Num mod 2)
       caso 0
        Resultado1 <- ("0" + Resultado1)
         caso 1
          Resultado1 <- ("1" + Resultado1)
    FimEscolha
     Num <- (Num div 2)
   FimEnquanto
   
     Escreval ("O valor: ", Valor, " em Dicimal será de: ", Resultado1, " em Binários!!")
 Escreval ("==============================================")
 Escreval ("Vamos transformar o valor decimal em Octal!!")
 Escreval ("==============================================")
 Escreval ("Digite um valor Decimal: ")
  Leia (Num)
   Valor <- (Num)
   enquanto (Num > 0) faca
    Escolha (Num mod 8)
       caso 1
        Resultado2 <- ("1" + Resultado2)
         caso 2
          Resultado2 <- ("2" + Resultado2)
           caso 3
            Resultado2 <- ("3" + Resultado2)
             caso 4
              Resultado2 <- ("4" + Resultado2)
               caso 5
                Resultado2 <- ("5" + Resultado2)
                 caso 6
                  Resultado2 <- ("6" + Resultado2)
                   caso 7
                    Resultado2 <- ("7" + Resultado2)
    FimEscolha
     Num <- (Num div 8)
   FimEnquanto
     Escreval ("O valor: ", Valor, " em Dicimal será de: ", Resultado2, " em Octal!!")
 Escreval ("==================================================")
 Escreval ("Vamos transformar o valor decimal em Hexadecimal!!")
 Escreval ("==================================================")
 Escreval ("Digite um valor Decimal: ")
  Leia (Num)
   Valor <- (Num)
   enquanto (Num > 0) faca
    Escolha (Num mod 16)
       caso 1
        Resultado3 <- ("1" + Resultado3)
         caso 2
          Resultado3 <- ("2" + Resultado3)
           caso 3
            Resultado3 <- ("3" + Resultado3)
             caso 4
              Resultado3 <- ("4" + Resultado3)
               caso 5
                Resultado3 <- ("5" + Resultado3)
                 caso 6
                  Resultado3 <- ("6" + Resultado3)
                   caso 7
                    Resultado3 <- ("7" + Resultado3)
                     caso 8
                      Resultado3 <- ("8" + Resultado3)
                       caso 9
                        Resultado3 <- ("9" + Resultado3)
                         caso 10
                          Resultado3 <- ("A" + Resultado3)
                           caso 11
                            Resultado3 <- ("B" + Resultado3)
                             caso 12
                              Resultado3 <- ("C" + Resultado3)
                               caso 13
                                Resultado3 <- ("D" + Resultado3)
                                 caso 14
                                  Resultado3 <- ("E" + Resultado3)
                                   caso 15
                                    Resultado3 <- ("F" + Resultado3)
    FimEscolha
     Num <- (Num div 16)
   FimEnquanto
     Escreval ("O valor: ", Valor, " em Dicimal será de: ", Resultado3, " em Binários!!")
FimAlgoritmo

Simon Viegas · 19 de julho de 2017

Olá @JESSÉ ÁVILA.

Do que se trata esse código? qual a sua dúvida ou proposta?

No aguardo.

20 de julho de 2017

Minha Dúvida?

Nenhuma, apenas compartilhando o que eu mesmo criei... Compartilhando conhecimento, pois sei que poucos lugares divulgam isso, e este teste, tanto em C++ quanto em JAVA, vão funcionar... E em breve divulgarei mais...

Simon Viegas · 20 de julho de 2017

11 horas atrás, JESSÉ ÁVILA disse:

Minha Dúvida?

Nenhuma, apenas compartilhando o que eu mesmo criei... Compartilhando conhecimento, pois sei que poucos lugares divulgam isso, e este teste, tanto em C++ quanto em JAVA, vão funcionar... E em breve divulgarei mais...

Entendi! é que você apenas postou "um código" sem nenhum comentário.

Em relação ao código, ficou muito bom! Parabéns!

Aproveitando a oportunidade... existe algum motivo especial para fazer essa "escadinha" na indentação do código?

Em 18/07/2017 às 19:45, JESSÉ ÁVILA disse:


 Escreval ("Digite um valor Decimal: ")
  Leia (Num)
   Valor <- (Num)
   enquanto (Num > 0) faca
    Escolha (Num mod 16)
       caso 1
        Resultado3 <- ("1" + Resultado3)
         caso 2
          Resultado3 <- ("2" + Resultado3)
           caso 3
            Resultado3 <- ("3" + Resultado3)
             caso 4
              Resultado3 <- ("4" + Resultado3)
               caso 5
                Resultado3 <- ("5" + Resultado3)
                 caso 6
                  Resultado3 <- ("6" + Resultado3)
                   caso 7
                    Resultado3 <- ("7" + Resultado3)
                     caso 8
                      Resultado3 <- ("8" + Resultado3)
                       caso 9
                        Resultado3 <- ("9" + Resultado3)
                         caso 10
                          Resultado3 <- ("A" + Resultado3)
                           caso 11
                            Resultado3 <- ("B" + Resultado3)
                             caso 12
                              Resultado3 <- ("C" + Resultado3)
                               caso 13
                                Resultado3 <- ("D" + Resultado3)
                                 caso 14
                                  Resultado3 <- ("E" + Resultado3)
                                   caso 15
                                    Resultado3 <- ("F" + Resultado3)

Geralmente deixamos alinhando de acordo com o nível da instrução em relação a sua respectiva estrutura.... ex.:

Algoritmo "Transformar os valores decimais em Binários, Octais ou Hexadecimais."
Var
   Num, Valor: inteiro
   Resultado1, Resultado2, Resultado3: Caracter
Inicio
escreval("==============================================")
escreval("Vamos transformar o valor decimal em Binário!!")
escreval("==============================================")
escreval("Digite um valor Decimal: ")
leia(Num)
Valor <- (Num)
enquanto (Num > 0) faca
escolha (Num mod 2)
   caso 0
      Resultado1 <- ("0" + Resultado1)
   caso 1
      Resultado1 <- ("1" + Resultado1)
fimEscolha
Num <- (Num div 2)
fimEnquanto
escreval("O valor: ", Valor, " em Dicimal será de: ", Resultado1, " em Binários!!")
escreval("==============================================")
escreval("Vamos transformar o valor decimal em Octal!!")
escreval("==============================================")
escreval("Digite um valor Decimal: ")
leia(Num)
Valor <- (Num)
enquanto (Num > 0) faca
   escolha (Num mod 8)
      caso 1
         Resultado2 <- ("1" + Resultado2)
      caso 2
         Resultado2 <- ("2" + Resultado2)
      caso 3
         Resultado2 <- ("3" + Resultado2)
      caso 4
         Resultado2 <- ("4" + Resultado2)
      caso 5
         Resultado2 <- ("5" + Resultado2)
      caso 6
         Resultado2 <- ("6" + Resultado2)
      caso 7
         Resultado2 <- ("7" + Resultado2)
   fimEscolha
   Num <- (Num div 8)
fimEnquanto
escreval("O valor: ", Valor, " em Dicimal será de: ", Resultado2, " em Octal!!")
escreval("==================================================")
escreval("Vamos transformar o valor decimal em Hexadecimal!!")
escreval("==================================================")
escreval("Digite um valor Decimal: ")
leia(Num)
Valor <- (Num)
enquanto (Num > 0) faca
   escolha (Num mod 16)
      caso 1
         Resultado3 <- ("1" + Resultado3)
      caso 2
         Resultado3 <- ("2" + Resultado3)
      caso 3
         Resultado3 <- ("3" + Resultado3)
      caso 4
         Resultado3 <- ("4" + Resultado3)
      caso 5
         Resultado3 <- ("5" + Resultado3)
      caso 6
         Resultado3 <- ("6" + Resultado3)
      caso 7
         Resultado3 <- ("7" + Resultado3)
      caso 8
         Resultado3 <- ("8" + Resultado3)
      caso 9
         Resultado3 <- ("9" + Resultado3)
      caso 10
         Resultado3 <- ("A" + Resultado3)
      caso 11
         Resultado3 <- ("B" + Resultado3)
      caso 12
         Resultado3 <- ("C" + Resultado3)
      caso 13
         Resultado3 <- ("D" + Resultado3)
      caso 14
         Resultado3 <- ("E" + Resultado3)
      caso 15
         Resultado3 <- ("F" + Resultado3)
   fimEscolha
   Num <- (Num div 16)
fimEnquanto
escreval("O valor: ", Valor, " em Dicimal será de: ", Resultado3, " em Binários!!")
fimAlgoritmo

Sei que talvez a proposta não seja entregar um produto final ou perfeito.. mas, aproveitando, existem alguns pontos que poderiam ser verificados, ex.:

- Só precisaria de uma variável para o resultado, ou seja, basta reutilizar o resultado. Assim como é feito com Valor e Num. (pela lógica teria que ter valor1, valor2 e valor3... e o mesmo para os Num).

- Lá na leitura dos "valores" a serem convertidos, eu faria o contrário:

Em 18/07/2017 às 19:45, JESSÉ ÁVILA disse:
escreval("Digite um valor Decimal: ")
leia(Num)
Valor <- (Num)

Ou seja, leria Valor... e num seria igual a este. E continuaria usando o num nas operações. O resultado seria o mesmo, é apenas uma questão de interpretação.

- Experimente informar 0 em qualquer uma das operações (zero também é um número decimal).

- Idem acima para números negativos...;

- Analisando aqui, essa sua técnica é universal, ou seja, teoricamente funcionaria de decimal para qualquer base... logo, bastaria solicitar os números e a também a "base final", daí, faria algo do tipo:

enquanto (Num > 0) faca
   escolha (Num mod BASE)
      caso 1
         Resultado3 <- ("1" + Resultado3)
      caso 2
         Resultado3 <- ("2" + Resultado3)
      caso 3
         Resultado3 <- ("3" + Resultado3)
      caso 4
         Resultado3 <- ("4" + Resultado3)
      caso 5
         Resultado3 <- ("5" + Resultado3)
      caso 6
         Resultado3 <- ("6" + Resultado3)
      caso 7
         Resultado3 <- ("7" + Resultado3)
      caso 8
         Resultado3 <- ("8" + Resultado3)
      caso 9
         Resultado3 <- ("9" + Resultado3)
      caso 10
         Resultado3 <- ("A" + Resultado3)
      caso 11
         Resultado3 <- ("B" + Resultado3)
      caso 12
         Resultado3 <- ("C" + Resultado3)
      caso 13
         Resultado3 <- ("D" + Resultado3)
      caso 14
         Resultado3 <- ("E" + Resultado3)
      caso 15
         Resultado3 <- ("F" + Resultado3)
   fimEscolha
   Num <- (Num div BASE)

Obs.: teoricamente funcionaria até a base 16, ou seja, de base decimal para base 2 a 16.

Por ai vai..

Att

24 de julho de 2017

Sim, Sim perfeito, acatei a sua dica e pratiquei,muito bom mesmo, alias excelente.... Muito obrigado por isto, pode crer...

O fato de colocar escadinha é apenas a facilidade na identificação da indentação é, sabendo apenas pelo portugol onde estaria o fim de cada comando atribuído...