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

O programa principal deve apresentar ao usuário um menu com as possibilidades de execução de cada função acima. Além disso, deve fazer a verificação de entrada de cada valor que o usuário tiver que digitar e deve apresentar os resultados de forma adequada e deve esperar que o usuário decida voltar ao menu principal. O menu deve apresentar também a possibilidade de sair do programa principal e, nesse caso, este deve apresentar uma mensagem de fim de execução do programa.
Faça uma função que receba um inteiro n como argumento e retorno uma lista de Abcde, Bcdef, Cdefg, …, Zabcd,
ABcde, BCdef, CDefg, …, ZAbcd,
ABCde, BCDef, CDEfg, …, ZABcd,
ABCDe, BCDEf, CDEFg, …, ZABCd,
ABCDE, BCDEF, CDEFG, … ,ZABCD,
ZBCDE, ZCDEF, ZDEFG, … ,ZZABC,
ZZBCD, ZZCDE, ZZDEF, … ,ZZZAB,
ZZZBC, ZZZCD, ZZZDE, … ,ZZZZA,
ZZZZB, ZZZZC, ZZZZD, … ,ZZZZZ.
A função deve retornar uma lista com todos os strings gerados de tamanho n:
Cabeçalho da função: gera_nomes ( n )
Argumento: n, int: tamanho dos nomes.
Saída: [str]: lista de strings com os nomes de tamanho n.
Assinale a alternativa que contenha uma memória SRAM
a)Registrador
b)Memória Principal
c)Memória Flash
d)Disco magnético
e)ROM
Qual a diferença entre SDRAM e DRAM?