Escreva uma função que converte números inteiros entre 1 e 999 para algarismos romanos. Não converta o número para uma string. Use os três dicionários abaixo:
- UNIDADES = { 0: ", 1: ‘I’, 2: ‘II’, 3: ‘III’, 4: ‘IV’, 5: ‘V’, 6: ‘VI’, 7: ‘VII’, 8: ‘VIII’, 9: ‘IX’ }
- DEZENAS = { 0: ", 1: ‘X’, 2: ‘XX’, 3: ‘XXX’, 4: ‘XL’, 5: ‘L’, 6: ‘LX’, 7: ‘LXX’, 8: ‘LXXX’, 9:‘XC’ }
- CENTENAS = { 0: ", 1: ‘C’, 2: ‘CC’, 3: ‘CCC’, 4: ‘CD’, 5: ‘D’, 6: ‘DC’, 7: ‘DCC’, 8:‘DCCC’, 9:‘CM’ }
Passo 1
O que o problema pede e quais informações temos:
- Pedem uma função que converte um número inteiro entre
e para algarismos romanos. - É obrigatório usar os três dicionários fornecidos: UNIDADES, DEZENAS e CENTENAS (cada chave
a mapeando para a representação romana daquela casa). - É proibido “converter o número para uma string” para extrair dígitos (ou seja, não usar algo como
str(n)e indexar a string). Deve-se extrair as centenas, dezenas e unidades por operações aritméticas inteiras. - A função deve receber um inteiro e retornar a representação em algarismos romanos (uma string com os símbolos romanos correspondentes).
Passo 2
Ideia geral do método (sem código ainda): extrair as casas por divisão inteira e resto.
- Para obter a quantidade de centenas de um número
, usa-se divisão inteira por : . - Para obter o resto após retirar as centenas, usa-se o operador módulo:
. - A partir desse resto, a quantidade de dezenas é
. - E as unidades são
.
Essas operações usam apenas aritmética inteira, nenhuma conversão para string. Depois, pega-se o texto romano correspondente a cada casa nos dicionários e concatena-se: resultado = CENTENAS[c] + DEZENAS[d] + UNIDADES[u].
Pequena explicação das operações (como se eu estivesse do seu lado ensinando):
- Divisão inteira
//dá quantas vezes o divisor cabe no número, descartando fração. Ex.:. - Resto
%dá o que sobra depois da divisão inteira. Ex.:. - Assim, para
obtemos , , então , .
Passo 3
Os dicionários que você deve usar (explicando cada um):
UNIDADESmapeia o dígito das unidadesa para sua forma romana: , , , , etc. DEZENASfaz o mesmo para as dezenas:, , . CENTENASfaz o mesmo para as centenas:, , .
Esses dicionários permitem transformar cada dígito independentemente em sua parte romana e depois juntar as três partes.
Passo 4
Validações e detalhes de implementação que você vai querer na prova:
- Verificar que o argumento é inteiro e que está no intervalo válido
. Se não, levantar uma exceção (por exemplo ValueError) ou devolver um erro claro. - Não usar
str(n)em nenhuma etapa para separar dígitos — usar apenas//e%. - A concatenação de strings em Python é simples:
"CC" + "XL" + "IX" = "CCXLIX". - A função final deve retornar a string com os símbolos romanos (ex.: para
retornar "XLIV").
Passo 5
Exemplos manuais passo-a-passo (para fixar a ideia):
- Exemplo
: -
, , , . - Resultado = CENTENAS[0] + DEZENAS[0] + UNIDADES[1] =
"" + "" + "I"="I".
-
- Exemplo
: -
, , , . - Resultado = CENTENAS[0] + DEZENAS[4] + UNIDADES[4] =
"" + "XL" + "IV"="XLIV".
-
- Exemplo
: -
, , , . - Resultado = CENTENAS[3] + DEZENAS[9] + UNIDADES[9] =
"CCC" + "XC" + "IX"="CCCXCIX".
-
Passo 6
Observações finais, dicas para a hora da prova:
- Escreva primeiro os dicionários (são fixos) e depois a sequência de operações para extrair
, , . - Teste alguns casos-limite:
, , , , , , e . - Se quiser, inclua checagem de tipo/intervalo para mensagens de erro mais claras; em concursos acadêmicos, normalmente basta assumir que a entrada está no intervalo pedido, mas em programação defensiva é bom validar.
Resposta
def int_para_romano(n):
UNIDADES = {
0: “”,
1: “I”,
2: “II”,
3: “III”,
4: “IV”,
5: “V”,
6: “VI”,
7: “VII”,
8: “VIII”,
9: “IX”,
}
DEZENAS = {
0: “”,
1: “X”,
2: “XX”,
3: “XXX”,
4: “XL”,
5: “L”,
6: “LX”,
7: “LXX”,
8: “LXXX”,
9: “XC”,
}
CENTENAS = {
0: “”,
1: “C”,
2: “CC”,
3: “CCC”,
4: “CD”,
5: “D”,
6: “DC”,
7: “DCC”,
8: “DCCC”,
9: “CM”,
}
UNIDADES = {
0: “”,
1: “I”,
2: “II”,
3: “III”,
4: “IV”,
5: “V”,
6: “VI”,
7: “VII”,
8: “VIII”,
9: “IX”,
}
DEZENAS = {
0: “”,
1: “X”,
2: “XX”,
3: “XXX”,
4: “XL”,
5: “L”,
6: “LX”,
7: “LXX”,
8: “LXXX”,
9: “XC”,
}
CENTENAS = {
0: “”,
1: “C”,
2: “CC”,
3: “CCC”,
4: “CD”,
5: “D”,
6: “DC”,
7: “DCC”,
8: “DCCC”,
9: “CM”,
}
if not isinstance(n, int):
raise TypeError("O valor deve ser um inteiro.")
if not (1 <= n <= 999):
raise ValueError("O número deve estar entre 1 e 999 inclusive.")
c = n // 100
r = n % 100
d = r // 10
u = r % 10
return CENTENAS[c] + DEZENAS[d] + UNIDADES[u]