- Há números n que possuem a seguinte propriedade: o resultado da multiplicação de n por um determinado k é equivalente ao deslocamento do dígito das unidades de n para a primeira posição (i.e., o último dígito vira o primeiro). Assim, por exemplo, 128205 multiplicado por 4 é igual a 512820. Encontre todos os pares (
), em que n é um número com no máximo 6 dígitos em notação decimal, e k é um inteiro entre 1 e 9 . A definição de sua função deve ser: def pares():
- Implemente uma solução usando for
- Implemente uma solução usando while
Passo 1
O enunciado pede: encontrar todos os pares
tais que
-
é um número inteiro positivo escrito em base decimal com no máximo 6 dígitos (ou seja, ); -
é um inteiro entre e ; - o produto
é exatamente o número obtido ao deslocar o dígito das unidades de para a primeira posição (o último dígito vira o primeiro).
Informações relevantes dadas no enunciado: - Exemplo:
multiplicado por resulta em , que é a rotação do dígito das unidades (o foi para a frente). - A função pedida deve ter a assinatura
def pares():e precisamos fornecer duas implementações (uma usandofore outra usandowhile).
Passo 2
Modelagem matemática da rotação:
Se tem exatamente
dígitos (
), podemos escrever
Se
onde
é o dígito das unidades e
é a parte composta pelos
dígitos mais significativos (para
,
; para
temos
). A rotação que põe o último dígito na frente produz o número
A condição do enunciado é
ou seja
Passo 3
Manipulando a equação para isolar
:
Portanto
Para que
seja um inteiro válido devemos ter que o numerador
seja divisível por
. Além disso, se
exigimos
, e
para obter um
não trivial (se
então a fórmula dá
e
, que descartamos).
Passo 4
Uma observação útil (condição de divisibilidade reduzida): seja
Queremos que
divida
. Seja
. Escrevendo
e
com
, a condição passa a ser
, ou seja
. Assim uma condição necessária e suficiente para existir um dígito
que satisfaça a divisibilidade é que
divida algum inteiro em
. Em particular é necessário
e que
seja divisor de um
entre
e
. Essa observação reduz muito o trabalho: para cada
e
calculamos
e, se
, testamos os possíveis
que são múltiplos de
.
Passo 5
Trato especial:
.
Se então a equação original vira
. Isso significa que a rotação não altera o número — ocorre exatamente quando todos os dígitos são iguais (por exemplo
,
,
, etc.). Pela fórmula:
Se
o que dá
igual ao dígito
repetido
vezes. Para
e
obtemos todas as chamadas “repdigits” (números com todos os dígitos iguais). Portanto todos esses pares
são soluções válidas.
Passo 6
Aplicando a condição
para procurar soluções não triviais (com
), faremos
e
. Aqui eu resumo o cálculo essencial (os detalhes são aplicação direta da fórmula de
):
- Para
e verifica-se que é sempre maior que (ou não divide nenhum ), logo não há soluções além do caso . - Para
os cálculos mostram duas situações especiais: -
: e . Observa-se que divide ( ), logo e . Como divide qualquer , existem candidatos para . Calculando Para que tenha exatamente dígitos precisamos de , isto é . Assim . Tomando obtemos e então Cada um desses satisfaz rotação de (verificação direta possível multiplicando). -
: e . Calcula-se , portanto . Como e divide somente quando , apenas é candidato. Para , e Verificação direta: , que é exatamente a rotação que põe o na frente.
-
Passo 7
Sumarizando as soluções encontradas:
- Todas as soluções com
: é qualquer número formado por repetições do mesmo dígito , com e . Em fórmula:
- Soluções não-triviais com
e : -
com . -
com .
-
Passo 8
Implementações pedidas (duas maneiras de computar as soluções). A seguir duas funções Python que retornam a lista de pares
encontrados (uma usando laços
for e outra usando while). Ambas imprimem ou retornam a mesma coleção de pares.Implementação usando for:
def pares_for():
resultados = []
for n in range(1, 10**6): # n de 1 até 999999
s = str(n)
rot = int(s[-1] + s[:-1]) # rotação: último dígito para a frente
for k in range(1, 10): # k de 1 a 9
if k * n == rot:
resultados.append((n, k))
return resultados
Implementação usando while:
def pares_while():
resultados = []
n = 1
while n < 10**6:
s = str(n)
rot = int(s[-1] + s[:-1])
k = 1
while k <= 9:
if k * n == rot:
resultados.append((n, k))
k += 1
n += 1
return resultados
Observação prática: as duas versões testam diretamente a definição (rotacionar como string é simples e correto); para eficiência em prova, pode-se usar a fórmula algébrica apresentada e testar valores limitados de
, mas as implementações acima cumprem o pedido de usar
for e while.Passo 9
Verificações rápidas (para garantir que os candidatos realmente funcionam):
- Exemplo dado:
. Calculando . Rotação de : mover para frente dá . OK. - Para
: . Rotação de (colocar na frente) é . OK. - Para um
repdigit, por exemplo , e a rotação deixa o número igual, OK.