VisualG Converter números hexadecimais, octais e binários para a base 10

Irwing Seiji Ato · 12 de abril de 2019

Consegui fazer de octal para base 10 e de binário para a base 10 porém de hexadecimal para a base está é o problema

Segue o código abaixo. Como deveria fazer para converter de hexadecimal para base 10?

Var
   // Seção de Declarações das variáveis
   sequencia:vetor[1..8] de inteiro
   i,base,base10 : inteiro
Inicio
   // Seção de Comandos, procedimento, funções, operadores, etc...
   escreval("Qual a base")
   leia(base)
   para i de 8 ate 1 passo -1 faca
      escreval("Digite número",i)
      leia(sequencia[i])
   fimpara
   para i de 1 ate 8 faca
      base10 <- base10+ sequencia[i] * exp(base,i-1)
   fimpara
   escreval("Número base 10 :", base10)
Fimalgoritmo

Simon Viegas · 13 de abril de 2019

A fórmula de qualquer base para decimal é igual...

A diferença para as base acima de 10, é que, para cada "casa", existirá mais de 10 representações, daí é precisa "traduzir" antes de calcular. Vejamos:

Converter o número octal 764 para o sistema decimal:

764 (8) = 7 x 8² + 6 x 8¹ + 4 x 8° = 448 + 48 + 4 = 500 (10)

Normal né? Perceba que na base 8, são 8 representações possíveis (de 0 a 7). Na base 2 existem 2 (de 0 a 1). Numa base 6 teria 6 (de 0 a 5)... por ai vai. Quantas representações existem na base 16? é a mesma coisa: são 16 (de 0 a F, ou seja: os 10 "convencionais", mais de 'A' a 'F'). No caso, existem mais de 10 possibilidades, por isso que se usam letras para representar as 6 que faltam...

Daí, ANTES de calcular, terá que "converter" da letra para seu valor correspondente. Ex.:

Converter o número hexadecimal F2A7 para o sistema decimal:

F2A (16) = 15 x 16² + 2 x 16¹ + 10 x 16° = 3882 (10)

RESUMINDO:

Na hora de calcular acima da base 10, converta antes o valor da "letra" para o seu valor. Onde tem 'A', use 10; para B use 11 etc.

Irwing Seiji Ato · 13 de abril de 2019

tentei fazer isso mas não deu certo

Var
   // Seção de Declarações das variáveis
   sequencia:vetor[1..8] de inteiro
   i,base : inteiro
   base10 : real
Inicio
   // Seção de Comandos, procedimento, funções, operadores, etc...
   escreval("Qual a base")
   leia(base)
   para i de 8 ate 1 passo -1 faca
      escreval("Digite número",i)
      leia(sequencia[i])
      se(sequencia[i] = "A") entao
         sequencia[i] <- 10
      fimse
      se (sequencia[i] = "B") entao
         sequencia[i] <- 11
      fimse
      se (sequencia[i] = "C") entao
         sequencia[i] <- 12
      fimse
      se (sequencia[i] = "D") entao
         sequencia[i] <- 13
      fimse
      se (sequencia[i] = "E") entao
         sequencia[i] <- 14
      fimse
      se (sequencia[i] = "F") entao
         sequencia[i] <- 15
      fimse
   fimpara
   para i de 1 ate 8 faca
      base10 <- base10+ sequencia[i] * exp(base, i-1)
   fimpara
   escreval("Número base 10 :", base10)
Fimalgoritmo

O vetor só recebe valores inteiros, mas ele precisa receber também valores de caracteres como faço isso?

adicionado 32 minutos depois

Esse é o problema do código o vetor não pode receber dois valores do tipo caractere e inteiro e quando converto com se não consigo esse é o problema

adicionado 46 minutos depois

Dei uma modificada no código porém mostra um número diferente do que deveria ser segue o código

Var
   // Seção de Declarações das variáveis
   sequencia:vetor[1..8] de inteiro
   i,base : inteiro
   base10 : real
Inicio
   // Seção de Comandos, procedimento, funções, operadores, etc...
   escreval("Qual a base")
   leia(base)
   para i de 8 ate 1 passo -1 faca
      escreval("Digite número",i)
      leia(sequencia[i])
      se (carac(sequencia[i])) = "A" entao
         sequencia[i] <- 10
      fimse
      se (carac(sequencia[i])) = "B" entao
         sequencia[i] <- 11
      fimse
      se (carac(sequencia[i])) = "C" entao
         sequencia[i] <- 12
      fimse
      se (carac(sequencia[i])) = "D" entao
         sequencia[i] <- 13
      fimse
      se (carac(sequencia[i])) = "E" entao
         sequencia[i] <- 14
      fimse
      se (carac(sequencia[i])) = "F" entao
         sequencia[i] <- 15
      fimse
   fimpara
   para i de 1 ate 8 faca
      base10 <- base10 + sequencia[i] * exp (base, i-1)
   fimpara
   escreval("Número base 10 :", base10)
Fimalgoritmo

adicionado 54 minutos depois

O problema está na conversão como faria essa conversão?

Simon Viegas · 13 de abril de 2019

1 hora atrás, Irwing Seiji Ato disse:
sequencia:vetor[1..8] de inteiro

Se sequencia foi definida do tipo inteiro, ela não pode receber uma letra (caractere)...

Tente fazer o seguinte: o vetor ficará como do tipo caractere. Daí, use uma variável auxiliar para receber o valor traduzido. Ex.:

var
   numBaseOrigem   :vetor[1..8] de caracter //número na base original
   digitoTraduzido :inteiro //valor do dígito na base original traduzido em decimal
   base            :inteiro //base de origem
   base10          :real    //número convertido em decimal
   i               :inteiro //auxiliar para controlar laços de repetições

Você atribuiria o valor traduzido em digitoTraduzido e usaria essa variável na hora de calcular... no caso, a leitura do valor na base original é normal. A conversão só faz na hora de calcular (no segundo para).

Irwing Seiji Ato · 13 de abril de 2019

Queria traduzir também as bases octais e binários se fizer essa modificação acho que não seria possível converter para essas bases para base 10

Simon Viegas · 13 de abril de 2019

2 minutos atrás, Irwing Seiji Ato disse:

Queria traduzir também as bases octais e binários se fizer essa modificação acho que não seria possível converter para essas bases para base 10

Por que não iria? reanalise e justifique.

Irwing Seiji Ato · 13 de abril de 2019

Porque o vetor só aceitaria letras acho que números não

Simon Viegas · 13 de abril de 2019

1 minuto atrás, Irwing Seiji Ato disse:

Porque o vetor só aceitaria letras acho que números não

Tá, mas porque um número Hexadecimal pode ser representado por letras e um octal ou binário não poderia?

Irwing Seiji Ato · 13 de abril de 2019

Porque binário é somente 0 e 1 e a base octal vai de 0 a 7

adicionado 2 minutos depois

Não tem como converter letras para número direto tipo usando

se (int)sequencia[i] = "A"
sequencia[i] <- 10
fimse
se (int)sequencia[i] = "B"
sequencia[i] <- 11
fimse

assim não pode?

adicionado 9 minutos depois

se int (sequencia[i]) = "A" entao
         sequencia[i] <- 10
      fimse
      se int (sequencia[i]) = "B" entao
         sequencia[i] <- 11
      fimse
      se  int (sequencia [i]) = "C" entao
         sequencia[i] <- 12
      fimse
      se int (sequencia [i]) = "D" entao
         sequencia[i] <- 13
      fimse
      se int (sequencia [i]) = "E" entao
         sequencia[i] <- 14
      fimse
      se int (sequencia [i]) = "F"  entao
         sequencia[i] <- 15
      fimse
   fimpara
      fimse
      se int (sequencia [i]) = "F"  entao
         sequencia[i] <- 15
      fimse
   fimpara

Deixa quieto não deu certo funciona porém não mostra os valores corretos

Simon Viegas · 13 de abril de 2019

Vamos lá:

1#

No primeiro caso:

18 minutos atrás, Irwing Seiji Ato disse:
se int (sequencia[i]) = "A" entao sequencia[i] <- 10

O que a função int() faz? segue:

Citação

Int( expressão) - Retorna a parte inteira do valor representado por expressão.

No caso, ele recebe um número real, e retorna a parte inteira desse número. Exemplo:

algoritmo "FCdH"
var
   numReal    :real
   numInteiro :inteiro
inicio
numReal <- PI
escreval(numReal) //vai escrever 3.14159265358979
numInteiro <- int(numReal)
escreval(numInteiro) //vai escrever 3
fimAlgoritmo

No seu código, você está passando um inteiro no parâmtro, pegando a parte inteira (desse número inteiro) e após comparando (se essa parte inteira) é igual a "A". Não era nem para "compilar", pois são tipo incompatíveis.

2#

Nesse outro caso:

27 minutos atrás, Irwing Seiji Ato disse:


      se sequencia[i] = "A" entao
         sequencia[i] <- 10
      fimse

O vetor (supostamente) é do tipo inteiro, logo, não tem como ter uma letra nele. Entende?

Eu comentei sobre isso:

10 horas atrás, Simon Viegas disse:

Se sequencia foi definida do tipo inteiro, ela não pode receber uma letra (caractere)...

Na mesma postagem dou uma sugestão:

10 horas atrás, Simon Viegas disse:
Tente fazer o seguinte: o vetor ficará como do tipo caractere. Daí, use uma variável auxiliar para receber o valor traduzido. Ex.:
var
   numBaseOrigem   :vetor[1..8] de caracter //número na base original
   digitoTraduzido :inteiro //valor do dígito na base original traduzido em decimal
   base            :inteiro //base de origem
   base10          :real    //número convertido em decimal
   i               :inteiro //auxiliar para controlar laços de repetições
Você atribuiria o valor traduzido em digitoTraduzido e usaria essa variável na hora de calcular... no caso, a leitura do valor na base original é normal. A conversão só faz na hora de calcular (no segundo para).

No aguardo.

Irwing Seiji Ato · 13 de abril de 2019

Sim mas o vetor seria caractere e dai não receberia números dai não funcionaria

Simon Viegas · 13 de abril de 2019

A dúvida atual que estamos verificando seria essa:

57 minutos atrás, Irwing Seiji Ato disse:

Queria traduzir também as bases octais e binários se fizer essa modificação acho que não seria possível converter para essas bases para base 10

Ou seja: deu a entender que "IRIA FUNCIONAR COM 16, MAS NÃO IRIA FUNCIONAR COM 8". Daí queria entender porque você achou que iria funcionar com 16, mas não iria funcionar com 8... no caso, eu fiz uma pergunta retórica... Pois suponho que:

13 horas atrás, Simon Viegas disse:

A fórmula de qualquer base para decimal é igual...

Se funcionar com 16, vai funcionar com qualquer base entre 2 a 16 .

Entremos agora em outro ponto:

2 minutos atrás, Irwing Seiji Ato disse:

Sim mas o vetor seria caractere e dai não receberia números dai não funcionaria

Por que não funcionaria? Vou citar a minha citação:

9 minutos atrás, Simon Viegas disse:
Na mesma postagem dou uma sugestão:
10 horas atrás, Simon Viegas disse:
Tente fazer o seguinte: o vetor ficará como do tipo caractere. Daí, use uma variável auxiliar para receber o valor traduzido. Ex.:
var
   numBaseOrigem   :vetor[1..8] de caracter //número na base original
   digitoTraduzido :inteiro //valor do dígito na base original traduzido em decimal
   base            :inteiro //base de origem
   base10          :real    //número convertido em decimal
   i               :inteiro //auxiliar para controlar laços de repetições
Você atribuiria o valor traduzido em digitoTraduzido e usaria essa variável na hora de calcular... no caso, a leitura do valor na base original é normal. A conversão só faz na hora de calcular (no segundo para).

Nesse trecho acima estou "sugerindo" que "vai funcionar" e também "como pode fazer".

Aí temos:

- você entendeu o que estou sugerido, e está contra-argumentando que não vai funcionar?

- ou você não entendeu o que estou sugerindo?

Um outro ponto que pode ter ajudar a entender... veja esse exemplo:

algoritmo "FCdH"
var
   numEmFormatoInteiro   :inteiro
   numEmFormatoCaractere :caractere
inicio
numEmFormatoInteiro   <- 754
numEmFormatoCaractere <- "754"

escreval(numEmFormatoInteiro:1, " <-- Isso é um núemro")
escreval(numEmFormatoCaractere, " <-- Isso NÃO é um número. É uma 'cadeia de caracteres'")
escreval("")
escreval("Vou somar uma variável com ela mesma, veja o que acontece")
escreval("")
escreval("Número    + Número   = Adição      :", numEmFormatoInteiro   + numEmFormatoInteiro  )
escreval("Caractere + Caracere = Concatenação: ", numEmFormatoCaractere + numEmFormatoCaractere)
fimAlgoritmo

Entende? a estrutura "754" é um TEXTO. Assim como poderia ter "Bora Bahêa". Esses "7", "5" e "4" são caracteres!

Irwing Seiji Ato · 13 de abril de 2019

Como ficaria o código então o meu está dando um monte de erros olhe o código como está

Var
   // Seção de Declarações das variáveis
   sequencia:vetor [1..8] de inteiro
   i, base, digitotraduzido:inteiro
   base10: real

Inicio
   // Seção de Comandos, procedimento, funções, operadores, etc...
   escreval("Digite qual a base")
   leia(base)
   para i de 8 ate 1 passo -1 faca
      escreval("Digite o número",i)
      leia(sequencia[i])
   fimpara
   para i de 1 ate 8 faca
   se sequencia[i] = "A" entao
   digitotraduzido <- 10
   fimse
   se sequencia[i] = "B" entao
   digitotraduzido <- 11
   fimse
   se sequencia[i] = "C" entao
   digitotraduzido <- 12
   fimse
   se sequencia[i] = "D" entao
   digitotraduzido <- 13
   fimse
   se sequencia[i] = "E" entao
   digitotraduzido <- 14
   fimse
   se sequencia[i] = "F"  entao
   digitotraduzido <- 15
   fimse
   se sequencia[i] = "0" entao
      base10 <- base10 + sequencia[i] * exp(base, i-1)
   fimse
   se sequencia[i] = "1" entao
      base10 <- base10 + sequencia[i] * exp(base, i-1)
   fimse
   se sequencia[i] = "2" entao
      base10 <- base10 + sequencia[i] * exp(base, i-1)
   fimse
   se sequencia[i] = "3" entao
      base10 <- base10 + sequencia[i] * exp(base, i-1)
   fimse
   se sequencia[i] = "4" entao
      base10 <- base10 + sequencia[i] * exp(base, i-1)
   fimse
   se sequencia[i] = "5" entao
      base10 <- base10 + sequencia[i] * exp(base, i-1)
   fimse
   se sequencia[i] = "6" entao
      base10 <- base10 + sequencia[i] * exp(base, i-1)
   fimse
   se sequencia[i] = "7" entao
      base10 <- base10 + sequencia[i] * exp(base, i-1)
   fimse
   se sequencia[i] = "8" entao
      base10 <- base10 + sequencia[i] * exp(base, i-1)
   fimse
   se sequencia[i] = "9" entao
      base10 <- base10 + sequencia[i] * exp(base, i-1)
   fimse
   fimpara
   escreval("Número na base 10",base10)

Simon Viegas · 13 de abril de 2019

Qual o foco da dúvida atual?

1 hora atrás, Simon Viegas disse:

Entremos agora em outro ponto:

1 hora atrás, Irwing Seiji Ato disse:

Sim mas o vetor seria caractere e dai não receberia números dai não funcionaria

Ou seja: estou sugerindo utilizar um vetor de caractere. Você diz que NÃO iria funcionar. Eu continuo dizendo que vai funcionar com um vetor de caractere e sugiro que faça assim. Daí você continuou utilizando inteiro.

O vetor é de caractere.

Irwing Seiji Ato · 13 de abril de 2019

Acho que consegui segue o código

Var
   // Seção de Declarações das variáveis
   sequencia:vetor [1..8] de caractere
   i, base, digitotraduzido:inteiro
   base10: real

Inicio
   // Seção de Comandos, procedimento, funções, operadores, etc...
   escreval("Digite qual a base")
   leia(base)
   para i de 8 ate 1 passo -1 faca
      escreval("Digite o número",i)
      leia(sequencia[i])
   fimpara
   para i de 1 ate 8 faca
      se sequencia[i] = "A" entao
         digitotraduzido <- 10
         base10 <- base10 + digitotraduzido * exp(base, i-1)
      fimse
      se sequencia[i] = "B" entao
         digitotraduzido <- 11
         base10 <- base10 + digitotraduzido * exp(base, i-1)
      fimse
      se sequencia[i] = "C" entao
         digitotraduzido <- 12
         base10 <- base10 + digitotraduzido * exp(base, i-1)
      fimse
      se sequencia[i] = "D" entao
         digitotraduzido <- 13
         base10 <- base10 + digitotraduzido * exp(base, i-1)
      fimse
      se sequencia[i] = "E" entao
         digitotraduzido <- 14
         base10 <- base10 + digitotraduzido * exp(base, i-1)
      fimse
      se sequencia[i] = "F"  entao
         digitotraduzido <- 15
         base10 <- base10 + digitotraduzido * exp(base, i-1)
      fimse
      se sequencia[i] = "0" entao
         base10 <- base10 + 0 * exp(base, i-1)
      fimse
      se sequencia[i] = "1" entao
         base10 <- base10 + 1 * exp(base, i-1)
      fimse
      se sequencia[i] = "2" entao
         base10 <- base10 + 2 * exp(base, i-1)
      fimse
      se sequencia[i] = "3" entao
         base10 <- base10 + 3 * exp(base, i-1)
      fimse
      se sequencia[i] = "4" entao
         base10 <- base10 + 4 * exp(base, i-1)
      fimse
      se sequencia[i] = "5" entao
         base10 <- base10 + 5 * exp(base, i-1)
      fimse
      se sequencia[i] = "6" entao
         base10 <- base10 + 6 * exp(base, i-1)
      fimse
      se sequencia[i] = "7" entao
         base10 <- base10 + 8 * exp(base, i-1)
      fimse
      se sequencia[i] = "8" entao
         base10 <- base10 + 8 * exp(base, i-1)
      fimse
      se sequencia[i] = "9" entao
         base10 <- base10 + 9 * exp(base, i-1)
      fimse
   fimpara
   escreval("Número na base 10",base10)

Simon Viegas · 13 de abril de 2019

1#

Colando uma expressão em cada se/entao, não precisaria da variável auxiliar. Ex.:

algoritmo "FCdH"
var
   sequencia : vetor [1..8] de caractere
   i, base   : inteiro
   base10    : real

inicio
   escreval("Digite qual a base")
   leia(base)
   para i de 8 ate 1 passo -1 faca
      escreval("Digite o digito",i)
      leia(sequencia[i])
   fimpara
   para i de 1 ate 8 faca
      se sequencia[i] = "0" entao
         base10 <- base10 + 0 * Exp(base, i-1)
      fimse
      se sequencia[i] = "1" entao
         base10 <- base10 + 1 * Exp(base, i-1)
      fimse
      se sequencia[i] = "2" entao
         base10 <- base10 + 2 * Exp(base, i-1)
      fimse
      se sequencia[i] = "3" entao
         base10 <- base10 + 3 * Exp(base, i-1)
      fimse
      se sequencia[i] = "4" entao
         base10 <- base10 + 4 * Exp(base, i-1)
      fimse
      se sequencia[i] = "5" entao
         base10 <- base10 + 5 * Exp(base, i-1)
      fimse
      se sequencia[i] = "6" entao
         base10 <- base10 + 6 * Exp(base, i-1)
      fimse
      se sequencia[i] = "7" entao
         base10 <- base10 + 8 * Exp(base, i-1)
      fimse
      se sequencia[i] = "8" entao
         base10 <- base10 + 8 * Exp(base, i-1)
      fimse
      se sequencia[i] = "9" entao
         base10 <- base10 + 9 * Exp(base, i-1)
      fimse
      se sequencia[i] = "A" entao
         base10 <- base10 + 10 * Exp(base, i-1)
      fimse
      se sequencia[i] = "B" entao
         base10 <- base10 + 11 * Exp(base, i-1)
      fimse
      se sequencia[i] = "C" entao
         base10 <- base10 + 12 * Exp(base, i-1)
      fimse
      se sequencia[i] = "D" entao
         base10 <- base10 + 13 * Exp(base, i-1)
      fimse
      se sequencia[i] = "E" entao
         base10 <- base10 + 14 * Exp(base, i-1)
      fimse
      se sequencia[i] = "F"  entao
         base10 <- base10 + 15 * Exp(base, i-1)
      fimse
   fimpara
   escreva ("Número ")
   para i de 8 ate 1 passo -1 faca
      escreva (sequencia[i])
   fimPara
   escreval(" na base", base, " equivale a",base10, " na base 10")
fimAlgoritmo

2#

Alguns pontos que (sugiro que) precisam ser verificadas:

o número em decimal é inteiro (e não real com). Verás que vai dar erro. Dica: Ctrl+U, e substitua Exp(base, i-1) por Int(Exp(base, i-1)).
as verificações na hora de "traduzir" são mutuamente excludentes, logo poderia utilizar se/senão OU utilizar escolha/caso em vez de vários se/então simples. Deixar como está pode ser considerado um erro de lógica.
está sendo solicitado digito* por dígito, mas não é uma forma muito interessante. Sugiro que leia o número de uma vez só e daí faz o programa separar cada dígito do número.

Veja, são 3 coisas DISTINTAS. Se for implementar, pode fazer uma coisa de cada vez. NÃO PRECISA FAZER AO MESMO TEMPO. A ordem não importa, mas faça um de cada vez. Se tiver dúvidas sobre qualquer uma das partes é só perguntar também.

No aguardo.

Irwing Seiji Ato · 13 de abril de 2019

Atualizei o código e ficou assim o se e o senão, porém se colocar no código int(exp(base,i-1) retorna um valor negativo tem que ser exp(base,i-1) somente isso se for int(exp(base,i-1) aparece negativo

Var
   // Seção de Declarações das variáveis
   sequencia:vetor [1..8] de caractere
   i, base:inteiro
   base10 : real

Inicio
   // Seção de Comandos, procedimento, funções, operadores, etc...
   escreval("Digite qual a base")
   leia(base)
   para i de 8 ate 1 passo -1 faca
      escreval("Digite o número",i)
      leia(sequencia[i])
   fimpara
   para i de 1 ate 8 faca
      se sequencia[i] = "A" entao
         base10 <- base10 + 10 * Exp(base, i-1)
      senao
         se sequencia[i] = "B" entao
            base10 <- base10 + 11 * Exp(base, i-1)
         senao
            se sequencia[i] = "C" entao
               base10 <- base10 + 12 * Exp(base, i-1)
            senao
               se sequencia[i] = "D" entao
                  base10 <- base10 + 13 * Exp(base, i-1)
               senao
                  se sequencia[i] = "E" entao
                     base10 <- base10 + 14 * Exp(base, i-1)
                  senao
                     se sequencia[i] = "F"  entao
                        base10 <- base10 + 15 * Exp(base, i-1)
                     senao
                        se sequencia[i] = "0" entao
                           base10 <- base10 + 0 * Exp(base, i-1)
                        senao
                           se sequencia[i] = "1" entao
                              base10 <- base10 + 1 * Exp(base, i-1)
                           senao
                              se sequencia[i] = "2" entao
                                 base10 <- base10 + 2 * Exp(base, i-1)
                              senao
                                 se sequencia[i] = "3" entao
                                    base10 <- base10 + 3 * Exp(base, i-1)
                                 senao
                                    se sequencia[i] = "4" entao
                                       base10 <- base10 + 4 * Exp(base, i-1)
                                    senao
                                       se sequencia[i] = "5" entao
                                          base10 <- base10 + 5 * Exp(base, i-1)
                                       senao
                                          se sequencia[i] = "6" entao
                                             base10 <- base10 + 6 * Exp(base, i-1)
                                          senao
                                             se sequencia[i] = "7" entao
                                                base10 <- base10 + 8 * Exp(base, i-1)
                                             senao
                                                se sequencia[i] = "8" entao
                                                   base10 <- base10 + 8 * Exp(base, i-1)
                                                senao
                                                   se sequencia[i] = "9" entao
                                                      base10 <- base10 + 9 * Exp(base, i-1)
                                                   fimse
                                                fimse
                                             fimse
                                          fimse
                                       fimse
                                    fimse
                                 fimse
                              fimse
                           fimse
                        fimse
                     fimse
                  fimse
               fimse
            fimse
         fimse
      fimse
   fimpara
   escreval("Número na base 10",base10)

O de ler de uma só vez não acho interessante vou deixar assim mesmo lendo 1 por 1

Simon Viegas · 13 de abril de 2019

29 minutos atrás, Irwing Seiji Ato disse:

[...] porém se colocar no código int(exp(base,i-1) retorna um valor negativo tem que ser real mesmo a base10

Como assim retorna um valor negativo, tem como demonstrar?

Como chegou a conclusão que ter retornado negativo é a justificativa para usar real?

Irwing Seiji Ato · 13 de abril de 2019

adicionado 5 minutos depois

Não sei porque dá negativo quando colocar int(exp(base,i-1)) mas o base10 tem que ser real porque senão não aceita dá um erro

http://www.apoioinformatica.inf.br/produtos/item/30-as-funcoes-do-visualg-versao-2-0

Exp( base, expoente) - Retorna o valor de base elevado a expoente, sendo ambos expressões do tipo real.

Simon Viegas · 13 de abril de 2019

Hum! Entendi. Na hora de pegar a parte inteira, com Int(), já pode dar problema. Provavelmente devido ao tamanho do número!

Se quiser utilizar escolha/caso.

   para i de 1 ate 8 faca
      escolha sequencia[i]
      caso "0"
         base10 <- base10 + 0 * Exp(base, i-1)
      caso "1"
         base10 <- base10 + 1 * Exp(base, i-1)
      caso "2"
         base10 <- base10 + 2 * Exp(base, i-1)
      caso "3"
         base10 <- base10 + 3 * Exp(base, i-1)
      caso "4"
         base10 <- base10 + 4 * Exp(base, i-1)
      caso "5"
         base10 <- base10 + 5 * Exp(base, i-1)
      caso "6"
         base10 <- base10 + 6 * Exp(base, i-1)
      caso "7"
         base10 <- base10 + 8 * Exp(base, i-1)
      caso "8"
         base10 <- base10 + 8 * Exp(base, i-1)
      caso "9"
         base10 <- base10 + 9 * Exp(base, i-1)
      caso "A"
         base10 <- base10 + 10 * Exp(base, i-1)
      caso "B"
         base10 <- base10 + 11 * Exp(base, i-1)
      caso "C"
         base10 <- base10 + 12 * Exp(base, i-1)
      caso  "D"
         base10 <- base10 + 13 * Exp(base, i-1)
      caso "E"
         base10 <- base10 + 14 * Exp(base, i-1)
      caso "F"
         base10 <- base10 + 15 * Exp(base, i-1)
      fimEscolha
   fimPara