(1 ponto) Faça um programa que receba um número inteiro n e um divisor d do usuário e escreva os números de 1 a n inclusive que são múltiplos de d, um por linha.
EXEMPLO
Entrada Saída
10 3
3 6
9

Passo 1

O que o problema pede e quais dados ele fornece:
  • Pede: escrever um programa que receba um número inteiro \,n, e um divisor \,d, fornecidos pelo usuário e escreva, um por linha, todos os números entre 1 e \,n (inclusive) que são múltiplos de \,d.
  • Dados de entrada (exemplo do enunciado): primeira linha \,n=10, segunda linha \,d=3.
  • Saída esperada no exemplo: linhas com 3, 6, 9 (cada número em sua própria linha).
Observação clara (importante): o enunciado fala em “divisor \,d do usuário” — vou assumir que \,d\neq 0 e que queremos os múltiplos de \,d que caibam no intervalo de 1 a \,n. Também considero útil aceitar \,d negativo, tratando-o pelo seu valor absoluto, já que ser múltiplo de -3 é a mesma coisa que ser múltiplo de 3 no conjunto dos inteiros dentro de 1..n.

Passo 2

Ideia matemática simples para encontrar os múltiplos:
  • Um número inteiro x é múltiplo de d quando existe inteiro k tal que x = k\cdot d.
  • Entre 1 e n os múltiplos positivos de d têm a forma k\cdot d com k\ge 1 e k\cdot d \le n.
  • Portanto k varia de 1 até \left\lfloor \dfrac{n}{d'}\right\rfloor, onde d'=\lvert d\rvert (valor absoluto de d). Assim os múltiplos a imprimir são
k\cdot d',\qquad k=1,2,\dots,\left\lfloor \dfrac{n}{d'}\right\rfloor.
Esse método gera só os múltiplos (não precisa testar cada inteiro de 1 a n), e é direto de implementar.

Passo 3

Explicação do operador que aparece frequentemente (o resto da divisão — “módulo”):
  • Uma verificação alternativa é: x é múltiplo de d se e somente se x \bmod d = 0.
  • Aqui \bmod significa o resto inteiro da divisão. Exemplo: 9 \bmod 3 = 0, 10 \bmod 3 = 1.
  • A ideia com a conta por k (Passo 2) evita usar o teste para cada x e é geralmente mais eficiente e mais simples quando queremos listar múltiplos numa faixa.

Passo 4

Tratar casos especiais e suposições práticas:
  • Se \,d=0 não faz sentido perguntar por múltiplos de 0 (divisão por zero). O programa pode simplesmente não produzir saída ou terminar. Vou optar por terminar sem imprimir nada nesse caso.
  • Se \,n<1 então o intervalo 1..n está vazio e não há nada a imprimir.
  • Se \,d<0 tomo d'=\lvert d\rvert (o mesmo conjunto de múltiplos positivos).
  • Supondo entradas razoáveis (dois inteiros), o algoritmo do Passo 2 funciona corretamente.

Passo 5

Transformando a ideia em passos computacionais (algoritmo):
  1. Ler todos os valores de entrada e converter para inteiros: obter \,n e \,d.
  2. Calcular \,d' = \lvert d\rvert.
  3. Se \,d' = 0 ou \,n < 1: terminar sem imprimir nada.
  4. Calcular \,m = \left\lfloor \dfrac{n}{d'}\right\rfloor. (Em linguagens de programação com inteiros, isso é simplesmente n // d'.)
  5. Para k variando de 1 até m (inclusive), imprimir k\cdot d' em sua própria linha.
Comentário de clareza: usar a conta por k evita fazer n testes de módulo e gera exatamente os resultados desejados na ordem crescente.

Passo 6

Como implementar isso em código (detalhes passo a passo — vou usar Python pela simplicidade):
  • Ler entrada: muitas vezes os testes fornecem os dois inteiros em linhas separadas; para tornar robusto, ler todo o stdin e separar por espaços/linhas.
  • Converter para inteiro: usar int(…) para cada token.
  • Usar d_abs = abs(d) para lidar com d negativo.
  • Evitar divisão por zero verificando d_abs == 0.
  • Calcular max_k = n // d_abs (divisão inteira).
  • Fazer um laço for k in range(1, max_k + 1): print(k * d_abs).

Passo 7

Exemplo manual com os números do enunciado para checar a ideia:
  • Dados: n=10, d=3.
  • d'=\lvert 3\rvert=3.
  • \left\lfloor \dfrac{10}{3}\right\rfloor = 3. Então k=1,2,3.
  • Múltiplos: 1\cdot 3=3, 2\cdot 3=6, 3\cdot 3=9.
  • Saída (cada um em linha): 3, 6, 9 — confere com o exemplo.

Passo 8

Complexidade e considerações finais para a prova:
  • Complexidade: imprime \left\lfloor \dfrac{n}{d'}\right\rfloor números e executa esse mesmo número de passos no laço. É muito eficiente quando comparado a testar todos os n inteiros se d' for grande.
  • Implementação simples e direta; atenção às entradas (linha única ou múltiplas linhas) — a leitura por tokens resolve ambos os casos.
  • Lembre-se de tratar \,d=0 ou \,n<1 como casos que produzem nenhuma saída.

Resposta

import sys

tokens = sys.stdin.read().strip().split()
if len(tokens) < 2:
    sys.exit(0)

try:
    n = int(tokens[0])
    d = int(tokens[1])
except Exception:
    sys.exit(0)

d = abs(d)
if d == 0 or n < 1:
    sys.exit(0)

max_k = n // d
for k in range(1, max_k + 1):
    print(k * d)