Programe uma função Python que gere uma lista de n
inverte os 2 primeiros dígitos:
inverte os 3 primeiros dígitos:

inverte os 9 dígitos e pára:
A função terá outro argumento inteiro inv que informará o número máximo de dígitos que serão invertidos na geração de \begin{tabular}{r|l}
\hline Cabeçalho da função: & gera_numeros_de_telefone(n,inv) \
\hline Argumento: &
n, int: quantidade de inv, int: quantidade máxima de dígitos a serem invertidos na
geração de
\
\hline Saída: &
([str], bool): tupla com a lista dos n um booleano indicando se foram gerados todos os n telefone
\
\hline
\end{tabular}

Passo 1

Beleza, vamos começar entendendo o que a questão está pedindo. Temos que criar uma função em Python chamada gera_numeros_de_telefone que recebe dois argumentos:
  1. n (inteiro): a quantidade de números de telefone que queremos gerar.
  2. inv (inteiro): o número máximo de dígitos que serão invertidos em cada telefone gerado.
A função deve retornar uma tupla com uma lista de n números de telefone (como strings) e um booleano que indica se todos os n números foram gerados com sucesso. Para fazer isso, vamos precisar usar conceitos de manipulação de strings e controle de fluxo em Python, como loops e condições.

Passo 2

Primeiro, vamos pensar em como gerar um número de telefone. Normalmente, números de telefone têm 9 dígitos no Brasil, então vamos assumir que cada número terá 9 dígitos. Podemos começar gerando números sequenciais ou aleatórios, mas para simplificar, vamos usar números sequenciais começando de um número base, por exemplo, 100000000.

Passo 3

Agora, precisamos inverter os primeiros dígitos de cada número gerado, de acordo com o argumento inv. Por exemplo, se inv for 2, invertiremos os 2 primeiros dígitos; se for 3, os 3 primeiros, e assim por diante, até no máximo 9 dígitos. Para inverter os dígitos, vamos converter o número para uma string, fazer o fatiamento necessário e inverter essa parte.

Passo 4

Vamos implementar a lógica para limitar a quantidade de dígitos invertidos pelo valor de inv. Isso significa que, se inv for menor que 9, não vamos inverter mais dígitos do que o especificado por inv. Também precisamos garantir que não tentaremos inverter mais dígitos do que o comprimento do número (que são 9 dígitos).

Passo 5

Por fim, vamos montar a lista de números de telefone gerados e verificar se conseguimos gerar todos os n números desejados. Se tudo correr bem, o booleano retornado será True; caso contrário, será False.

Resposta

def gera_numeros_de_telefone(n, inv):
    lista_telefones = []
    base = 100000000  # Número inicial de telefone
    sucesso = True

    for i in range(n):
        numero = base + i
        numero_str = str(numero)

        # Determina quantos dígitos vão ser invertidos, sem passar de 9
        digitos_a_inverter = min(inv, 9)

        # Inverte os primeiros 'digitos_a_inverter' dígitos
        primeiros_digitos = numero_str[:digitos_a_inverter]
        restantes = numero_str[digitos_a_inverter:]
        primeiros_digitos_invertidos = primeiros_digitos[::-1]
        numero_invertido = primeiros_digitos_invertidos + restantes

        lista_telefones.append(numero_invertido)

        # Verifica se conseguimos gerar todos os números sem ultrapassar 999999999
        if base + i > 999999999:
            sucesso = False
            break

    return (lista_telefones, sucesso)

Exercícios relacionados