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 1 e 999 para algarismos romanos.
  • É obrigatório usar os três dicionários fornecidos: UNIDADES, DEZENAS e CENTENAS (cada chave 0 a 9 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 n, usa-se divisão inteira por 100: c = n // 100.
  • Para obter o resto após retirar as centenas, usa-se o operador módulo: r = n \% 100.
  • A partir desse resto, a quantidade de dezenas é d = r // 10.
  • E as unidades são u = r \% 10.
    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.: 347 // 100 = 3.
  • Resto % dá o que sobra depois da divisão inteira. Ex.: 347 \% 100 = 47.
  • Assim, para 347 obtemos c=3, r=47, então d=4, u=7.

Passo 3

Os dicionários que você deve usar (explicando cada um):
  • UNIDADES mapeia o dígito das unidades 0 a 9 para sua forma romana: 0 \mapsto "", 1 \mapsto "I", 4 \mapsto "IV", 9 \mapsto "IX", etc.
  • DEZENAS faz o mesmo para as dezenas: 1 \mapsto "X", 4 \mapsto "XL", 9 \mapsto "XC".
  • CENTENAS faz o mesmo para as centenas: 1 \mapsto "C", 4 \mapsto "CD", 9 \mapsto "CM".
    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 1 \le n \le 999. 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 n=44 retornar "XLIV").

Passo 5

Exemplos manuais passo-a-passo (para fixar a ideia):
  • Exemplo n = 1:
    • c = 1 // 100 = 0, r = 1 \% 100 = 1, d = 1 // 10 = 0, u = 1 \% 10 = 1.
    • Resultado = CENTENAS[0] + DEZENAS[0] + UNIDADES[1] = "" + "" + "I" = "I".
  • Exemplo n = 44:
    • c = 44 // 100 = 0, r = 44 \% 100 = 44, d = 44 // 10 = 4, u = 44 \% 10 = 4.
    • Resultado = CENTENAS[0] + DEZENAS[4] + UNIDADES[4] = "" + "XL" + "IV" = "XLIV".
  • Exemplo n = 399:
    • c = 399 // 100 = 3, r = 399 \% 100 = 99, d = 99 // 10 = 9, u = 99 \% 10 = 9.
    • 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 c, d, u.
  • Teste alguns casos-limite: 1, 4, 9, 40, 90, 400, 900 e 999.
  • 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”,
}
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]

Exercícios relacionados