( 0,6 pontos) Faça um programa que receba números inteiros positivos do usuário enquanto ele não digitar \mathbf{s}, sem aspas. A seguir leia um inteiro (1 ou 2). Para cada número lido antes de \mathbf{s}, aplique a seguinte função presente na biblioteca math (nesse exercício você pode usar apenas essa biblioteca), conforme determinado pelo último número lido, e converta o resultado para inteiro:
  1. factorial
  2. sqrt
Imprima a lista resultante.
EXTRAS:
  • 0,2 ponto extra: se não usar estruturas de repetição na parte de transformar a lista. Dica: use a função map.
  • 0,2 ponto extra: se não usar estruturas condicionais e apenas uma estrutura de repetição. Dica: pesquise sobre lista de funções.
EXEMPLO
Entrada Saída
5 [2,2,3,2]
4
9
7
s
2

Passo 1

O que o enunciado pede e quais dados ele fornece.
  • Pedido principal: escrever um programa que leia números inteiros positivos do usuário até o usuário digitar exatamente \mathbf{s}, e depois leia um inteiro que será 1 ou 2. Para cada número lido antes de \mathbf{s}, aplicar uma função da biblioteca math (conforme o último inteiro lido) e converter o resultado para inteiro. Finalmente imprimir a lista resultante.
  • A escolha das funções é:
    • Se o último inteiro for 1: usar a função \text{factorial}.
    • Se o último inteiro for 2: usar a função \text{sqrt}.
  • Saída esperada: uma lista Python contendo os resultados (cada resultado convertido para inteiro) na mesma ordem dos números lidos.
  • Observações do enunciado: pode usar apenas a biblioteca math para as operações matemáticas; há extras se transformar a lista sem laços (usar \text{map}) e se evitar estruturas condicionais usando uma lista de funções.

Passo 2

Estratégia de leitura dos dados (etapa que usa repetição para ler até \mathbf{s}).
  • Como os valores vão sendo digitados um por linha até aparecer \mathbf{s}, a forma natural é usar um laço que repete leitura de linha até encontrar a string \text{'s'}.
  • Em cada iteração, vamos:
    1. Ler uma linha e aplicar \text{strip()} para tirar espaços em branco nas pontas.
    2. Comparar com \text{'s'}. Se for igual, interromper o laço.
    3. Caso contrário, converter a string lida para inteiro com \text{int(...)} e adicionar a uma lista chamada, por exemplo, \text{nums}.
  • Ao final desse laço teremos a lista \text{nums} com todos os inteiros positivos lidos, na ordem.

Passo 3

Explicando as funções da biblioteca math que serão usadas (a parte de “ensinar a matéria”).
  • math.factorial:
    • Em Python, \text{math.factorial(n)} calcula o fatorial de \,n, definido por n! = n\cdot(n-1)\cdots2\cdot1 para inteiros \,n\ge 0.
    • Exemplo: \text{math.factorial(5)} retorna \,120.
    • Observação: \text{math.factorial} já retorna um inteiro quando a entrada é inteiro.
  • math.sqrt:
    • Em Python, \text{math.sqrt(x)} retorna a raiz quadrada de x como um número de ponto flutuante.
    • Exemplo: \text{math.sqrt(9)} retorna \,3.0.
    • Como precisamos converter o resultado para inteiro, usaremos \text{int(...)} sobre o valor retornado por \text{math.sqrt}. Em Python, \text{int(3.9)} produz \,3 (trunca a parte decimal), e \text{int(3.0)} produz \,3.

Passo 4

Como aplicar a função escolhida a cada elemento da lista — opção com \text{map} (extra: sem laços na transformação).
  • A transformação “aplicar uma função a cada elemento da lista e obter outra lista” é exatamente o caso de uso de \text{map}.
  • Sintaxe básica: \text{map(f, nums)} cria um iterador que aplica \,f a cada elemento de \text{nums}.
  • Como queremos assegurar a conversão para inteiro do resultado de \,f, podemos usar uma função anônima (lambda) do tipo \text{lambda x: int(f(x))}.
  • Exemplo genérico:
    • \text{res = list(map(lambda x: int(f(x)), nums))}
    • Isso produz a lista final \text{res} sem usar um laço explícito na etapa de transformação, atendendo ao extra de \text{map}.

Passo 5

Como escolher a função sem usar condicionais (extra: lista de funções).
  • Para não escrever \text{if choice == 1: ... elif choice == 2: ...}, podemos montar uma lista (ou tupla) de funções:
    • \text{funcs = [math.factorial, math.sqrt]}
  • O inteiro lido ( \,1 ou \,2) serve como índice deslocado em \text{funcs}. Como índices em Python começam em 0, usamos \text{f = funcs[choice-1]}.
  • Assim não há necessidade de estruturas condicionais para selecionar a função: basta indexar a lista de funções. Isso atende ao segundo extra se fizermos apenas um laço (o da leitura) e nenhuma outra condição para escolha.

Passo 6

Detalhes importantes de implementação e cuidados (para fazer na prova sem confusão).
  • Tratamento de entrada: ao ler cada linha, compará-la exatamente com \text{'s'}. Não pedir que o usuário escreva algo adicional.
  • Conversão segura: ao converter a linha para inteiro, assumir que o enunciado garante que são inteiros positivos até \mathbf{s}. Se quiser, na prática, poderia validar com \text{isdigit()}, mas isso não é exigido aqui.
  • Conversão final para inteiro:
    • Para \text{factorial}, o resultado já é inteiro; \text{int(math.factorial(n))} é redundante mas seguro.
    • Para \text{sqrt}, \text{int(math.sqrt(n))} trunca a parte decimal (ex.: \sqrt{5}\approx 2{,}236 vira \,2).
  • Impressão: exibir a lista Python no formato padrão, por exemplo \text{[2, 2, 3, 2]}. Usar \text{print(res)}.

Passo 7

Colocando tudo junto — fluxo do programa em palavras:
  1. Criar lista vazia \text{nums = []}.
  2. Repetir:
    • Ler linha, fazer \text{s = input().strip()}.
    • Se \text{s == 's'} então parar o laço.
    • Caso contrário, converter com \text{n = int(s)} e fazer \text{nums.append(n)}.
  3. Ler a escolha com \text{choice = int(input().strip())}.
  4. Montar \text{funcs = [math.factorial, math.sqrt]} e selecionar \text{f = funcs[choice-1]}.
  5. Fazer a transformação sem laços explícitos: \text{res = list(map(lambda x: int(f(x)), nums))}.
  6. Imprimir \text{res}.

Resposta

import math

nums = []
while True:
    s = input().strip()
    if s == 's':
        break
    nums.append(int(s))

choice = int(input().strip())
funcs = [math.factorial, math.sqrt]
f = funcs[choice - 1]
res = list(map(lambda x: int(f(x)), nums))
print(res)

Exercícios relacionados