{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "ULxWGdhVqcRt" }, "source": [ "# Capítulo 4: Controle de Fluxo e Números Aleatórios" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![ch4](ch4.jpeg)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Estruturas de Decisão Aninhadas\n", "\n", "**🎙️ Ouça a explicação sobre condicionais (if-elif-else):** \n", "\n", "\n", "\n", "\n", "\n", "As estruturas condicionais permitem que o programador controle o fluxo do programa, executando diferentes blocos de código de acordo com condições específicas. Vamos revisar as estruturas mais utilizadas:\n", "\n", "- **`if`:** Avalia uma condição e executa um bloco de código se a condição for verdadeira.\n", "- **`elif`:** Avalia uma condição e executa um bloco de código se a condição for verdadeira, **mas somente se a condição anterior for falsa**.\n", "- **`else`:** Executa um bloco de código se **todas as condições anteriores forem falsas**.\n", "\n", "**Cadeias de Comparação:**\n", "\n", "Python permite cadeias de comparação, que são uma maneira concisa de expressar múltiplas comparações. Por exemplo, `if a < b < c:` é equivalente a `if a < b and b < c:`.\n", "\n", "**Aninhamento de Estruturas Condicionais:**\n", "\n", "O poder real das estruturas condicionais reside na capacidade de **aninhá-las**, criando lógica complexa para lidar com diferentes cenários.\n", "\n", "**Exemplo: Verificação de Maioridade e Sexo**\n", "\n", "```python\n", "idade = 25\n", "sexo = \"Feminino\"\n", "\n", "if idade >= 18:\n", " print(\"Você é maior de idade.\")\n", " if sexo == \"Feminino\":\n", " print(\"E também do sexo feminino.\")\n", "else:\n", " print(\"Você é menor de idade.\")\n", "```\n", "\n", "Saída do Código:\n", "\n", "```python\n", "Você é maior de idade.\n", "E também do sexo feminino.\n", "```\n", "\n", "Neste exemplo, verificamos a idade e o sexo da pessoa. Se a pessoa for maior de idade, verificamos o sexo e imprimimos uma mensagem adicional se for feminino.\n", "\n", "**Exemplo: Classificação de Notas com Cadeias de Comparação**\n", "\n", "```python\n", "nota = 75\n", "\n", "if 90 <= nota < 100:\n", " print(\"Parabéns! Você obteve uma nota A.\")\n", "elif 80 <= nota < 90:\n", " print(\"Ótimo! Sua nota é B.\")\n", "elif 70 <= nota < 80:\n", " print(\"Bom trabalho! Sua nota é C.\")\n", "else:\n", " print(\"Infelizmente, você não atingiu a nota mínima. Sua nota é D.\")\n", "```\n", "\n", "Saída do Código:\n", "\n", "```python\n", "Bom trabalho! Sua nota é C.\n", "```\n", "\n", "Neste exemplo, a nota do aluno é comparada em intervalos usando cadeias de comparação. O código verifica a qual faixa de notas a nota pertence e imprime uma mensagem correspondente. Como a nota é 75, a condição `70 <= nota < 80` é satisfeita, e o programa imprime que o aluno obteve uma nota C.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Estrutura de Repetição `for`\n", "\n", "O loop `for` é amplamente utilizado em Python para realizar iterações sobre coleções de dados como listas, tuplas, dicionários e até strings. \n", "\n", "
\n", "\n", "![for](for_loop.svg)\n", "\n", "
\n", "\n", "\n", "Mas antes de explorarmos a estrutura do `for`, é importante entender dois conceitos fundamentais: a função `range()` e o operador `in`.\n", "\n", "#### A Função `range()`\n", "\n", "A função `range()` é utilizada para gerar sequências numéricas. Ela pode ser configurada para definir o início, o fim e o intervalo entre os números da sequência, utilizando a seguinte sintaxe:\n", "\n", "- `range(início, fim, passo)`, onde:\n", " - **`início`**: O primeiro número da sequência (inclusivo). O valor padrão é 0.\n", " - **`fim`**: O último número da sequência (exclusivo).\n", " - **`passo`**: A diferença entre os números consecutivos. O valor padrão é 1.\n", "\n", "Por exemplo:\n", "\n", "```python\n", "# Gera uma lista com os números de 0 a 4\n", "lista_numeros = list(range(5))\n", "print(lista_numeros)\n", "```\n", "\n", "**Saída do Código:**\n", "```python\n", "[0, 1, 2, 3, 4]\n", "```\n", "\n", "Neste exemplo, a função `range(5)` gera uma sequência de números de 0 a 4, e usamos `list()` para transformar essa sequência em uma lista visível.\n", "\n", "Outro exemplo com incremento de 2:\n", "\n", "```python\n", "# Gera uma lista com números pares de 0 a 10\n", "pares = list(range(0, 11, 2))\n", "print(pares)\n", "```\n", "\n", "**Saída do Código:**\n", "```python\n", "[0, 2, 4, 6, 8, 10]\n", "```\n", "\n", "Aqui, `range(0, 11, 2)` gera uma sequência de números pares de 0 a 10 com incrementos de 2.\n", "\n", "#### O Operador `in`\n", "\n", "O operador `in` é usado para verificar se um valor está presente em uma sequência, e no contexto do loop `for`, ele indica que o loop deve iterar sobre cada elemento dessa sequência.\n", "\n", "Por exemplo:\n", "\n", "```python\n", "if 3 in [1, 2, 3, 4, 5]:\n", " print(\"3 está presente na lista\")\n", "```\n", "\n", "**Saída do Código:**\n", "```python\n", "3 está presente na lista\n", "```\n", "\n", "Aqui, o operador `in` verifica se o número 3 está dentro da lista. Ele retorna `True` se o valor estiver presente e `False` caso contrário.\n", "\n", "#### O Loop `for`\n", "\n", "Agora que entendemos `range()` e o operador `in`, podemos introduzir o loop `for`. Ele permite iterar sobre cada elemento de uma sequência (lista, string, tupla, etc.) e executar um bloco de código para cada elemento:\n", "\n", "```python\n", "for variavel in sequencia:\n", " # Bloco de código a ser repetido\n", "```\n", "\n", "A variável assume, em cada iteração, o valor de um elemento da sequência, e o bloco de código é executado para cada um desses valores.\n", "\n", "#### Exemplo Prático: Iterando Sobre uma Sequência Numérica\n", "\n", "Com base no que aprendemos sobre `range()`, podemos agora utilizar um loop `for` para iterar sobre a sequência de números:\n", "\n", "```python\n", "for i in range(5):\n", " print(i)\n", "```\n", "\n", "**Saída do Código:**\n", "```python\n", "0\n", "1\n", "2\n", "3\n", "4\n", "```\n", "\n", "Aqui, o loop `for` itera sobre a sequência gerada por `range(5)`, imprimindo os números de 0 a 4.\n", "\n", "#### Iterando Sobre uma String\n", "\n", "Podemos usar o loop `for` para iterar sobre os caracteres de uma string:\n", "\n", "```python\n", "palavra = \"Python\"\n", "for letra in palavra:\n", " print(letra)\n", "```\n", "\n", "**Saída do Código:**\n", "```python\n", "P\n", "y\n", "t\n", "h\n", "o\n", "n\n", "```\n", "\n", "Nesse caso, o loop `for` percorre cada letra da string `\"Python\"` e as imprime individualmente.\n", "\n", "#### Iterando Sobre uma Lista de Números\n", "\n", "Podemos também usar o loop `for` para percorrer uma lista de números e realizar cálculos:\n", "\n", "```python\n", "numeros = [10, 20, 30, 40, 50]\n", "for num in numeros:\n", " print(f\"O dobro de {num} é {2 * num}.\")\n", "```\n", "\n", "**Saída do Código:**\n", "```python\n", "O dobro de 10 é 20.\n", "O dobro de 20 é 40.\n", "O dobro de 30 é 60.\n", "O dobro de 40 é 80.\n", "O dobro de 50 é 100.\n", "```\n", "\n", "Nesse exemplo, iteramos sobre cada número na lista `numeros` e imprimimos o seu dobro.\n", "\n", "#### Executando um Número Específico de Vezes\n", "\n", "Se quisermos executar um bloco de código um número fixo de vezes, podemos usar o `for` com `range()`:\n", "\n", "```python\n", "for _ in range(3):\n", " print(\"Olá, mundo!\")\n", "```\n", "\n", "**Saída do Código:**\n", "```python\n", "Olá, mundo!\n", "Olá, mundo!\n", "Olá, mundo!\n", "```\n", "\n", "O uso de `_` como variável (também chamado de placeholder) indica que não estamos interessados no valor da variável durante a iteração, apenas no número de vezes que o loop será executado.\n", "\n", "#### Iterando Sobre um Dicionário\n", "\n", "Podemos usar o loop `for` para percorrer as chaves e valores de um dicionário:\n", "\n", "```python\n", "aluno_notas = {\"João\": 8.5, \"Maria\": 9.0, \"Pedro\": 7.8}\n", "for nome, nota in aluno_notas.items():\n", " print(f\"{nome} obteve nota {nota}.\")\n", "```\n", "\n", "**Saída do Código:**\n", "```python\n", "João obteve nota 8.5.\n", "Maria obteve nota 9.0.\n", "Pedro obteve nota 7.8.\n", "```\n", "\n", "Aqui, o método `.items()` permite iterar tanto pelas chaves quanto pelos valores do dicionário, imprimindo o nome do aluno e sua respectiva nota.\n", "\n", "#### Entendendo o `for` Aninhado\n", "\n", "Em alguns casos, pode ser necessário usar loops aninhados, ou seja, um loop `for` dentro de outro. Um exemplo prático seria iterar sobre uma matriz (ou tabela) de números:\n", "\n", "```python\n", "matriz = [\n", " [1, 2, 3], # Primeira linha\n", " [4, 5, 6], # Segunda linha\n", " [7, 8, 9] # Terceira linha\n", "]\n", "\n", "for linha in matriz:\n", " for numero in linha:\n", " print(numero, end=' ') # Mantém os números da mesma linha juntos\n", " print() # Pula para a próxima linha\n", "```\n", "\n", "**Saída do Código:**\n", "```python\n", "1 2 3 \n", "4 5 6 \n", "7 8 9 \n", "```\n", "\n", "Aqui, usamos um loop externo para percorrer cada linha da matriz, e um loop interno para percorrer cada número dentro da linha. A combinação de loops permite navegar em estruturas mais complexas como essa.\n", "\n", "#### Outro Exemplo de `for` Aninhado\n", "\n", "Vamos usar um `for` aninhado para gerar todas as combinações possíveis entre dois grupos de elementos. Imagine que você tem duas listas, uma de cores e outra de tamanhos, e quer combinar cada cor com cada tamanho.\n", "\n", "```python\n", "cores = [\"vermelho\", \"azul\", \"verde\"]\n", "tamanhos = [\"P\", \"M\", \"G\"]\n", "\n", "for cor in cores:\n", " for tamanho in tamanhos:\n", " print(f\"{cor} - {tamanho}\")\n", "```\n", "\n", "**Saída do Código:**\n", "```python\n", "vermelho - P\n", "vermelho - M\n", "vermelho - G\n", "azul - P\n", "azul - M\n", "azul - G\n", "verde - P\n", "verde - M\n", "verde - G\n", "```\n", "\n", "Nesse exemplo, o loop externo itera sobre cada cor e o loop interno itera sobre cada tamanho, gerando todas as combinações possíveis de cor e tamanho. Este é um exemplo clássico de como o `for` aninhado pode ser útil para resolver problemas envolvendo múltiplos conjuntos de dados.\n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Estrutura de Repetição `while`\n", "\n", "O loop `while` é Utilizado para repetir um bloco de código enquanto uma condição especificada for verdadeira, proporcionando controle preciso sobre o fluxo de execução.\n", "\n", "
\n", "\n", "![for](while_loop.svg)\n", "\n", "
\n", "\n", "A estrutura do loop `while` é composta por duas partes. Sua sintaxe básica é:\n", "\n", "```python\n", "while condicao:\n", " # Bloco de código a ser repetido\n", "```\n", "\n", "* **Condição:** Uma expressão booleana que determina se o loop deve continuar ou parar.\n", "* **Bloco de Código:** As instruções que serão executadas enquanto a condição for verdadeira.\n", "\n", "Exemplo de um contador simples para contar até 5 usando o loop `while`:\n", "\n", "```python\n", "contador = 1\n", "while contador <= 5:\n", " print(contador)\n", " contador += 1\n", "```\n", "\n", "**Saída do Código:**\n", "```\n", "1\n", "2\n", "3\n", "4\n", "5\n", "```\n", "\n", "Explicando o código:\n", "\n", "* `contador` é inicializado com 1.\n", "* A condição `contador <= 5` é avaliada. Se for `True`, o bloco de código é executado.\n", "* `print(contador)` imprime o valor atual de `contador`.\n", "* `contador += 1` incrementa `contador` em 1.\n", "* O loop repete enquanto a condição for `True`, até que `contador` seja maior que 5.\n", "\n", "**Imprimindo os Números Pares de 1 a 10:**\n", "\n", "```python\n", "numero = 1\n", "while numero <= 10:\n", " if numero % 2 == 0:\n", " print(numero)\n", " numero += 1\n", "```\n", "\n", "**Saída do Código:**\n", "```\n", "2\n", "4\n", "6\n", "8\n", "10\n", "```\n", "\n", "* O loop itera de 1 a 10.\n", "* A condição `numero % 2 == 0` verifica se `numero` é par.\n", "* Se for par, `print(numero)` imprime o número.\n", "* `numero += 1` incrementa `numero` em 1.\n", "\n", "#### Usando o while not\n", "Durante o `while not`, o loop continua enquanto a condição, por exemplo, da variável `flag` for `False`.\n", "\n", "```python\n", "flag = False\n", "while not flag:\n", " resposta = input(\"Você deseja sair? (sim/não): \")\n", " if resposta.lower() == 'sim':\n", " flag = True\n", "print(\"Você saiu do loop.\")\n", "```\n", "\n", "Explicando o código:\n", "\n", "* `flag` é inicializada como `False`.\n", "* O loop `while not` continua enquanto `flag` for `False`.\n", "* O usuário é solicitado a responder se deseja sair.\n", "* Se o usuário digitar \"sim\", `flag` se torna `True`.\n", "* Quando `flag` é `True`, o loop termina e imprime \"Você saiu do loop.\"\n", "\n", "**While dentro de outro while**: Exemplo de aninhamento de loops `while`.\n", "\n", "```python\n", "x = 0\n", "while x < 3:\n", " y = 0\n", " while y < 2:\n", " print(f\"Valor de x: {x}, Valor de y: {y}\")\n", " y += 1\n", " x += 1\n", "```\n", "\n", "**Saída do Código:**\n", "```python\n", "Valor de x: 0, Valor de y: 0\n", "Valor de x: 0, Valor de y: 1\n", "Valor de x: 1, Valor de y: 0\n", "Valor de x: 1, Valor de y: 1\n", "Valor de x: 2, Valor de y: 0\n", "Valor de x: 2, Valor de y: 1\n", "```\n", "\n", "Aqui, `x` varia de 0 a 2 e `y` de 0 a 1. Para tornar o exemplo mais interessante, podemos adicionar uma condição para destacar quando `x` e `y` são iguais:\n", "\n", "```python\n", "x = 0\n", "while x < 3:\n", " y = 0\n", " while y < 2:\n", " if x == y:\n", " print(f\"X e Y são iguais e valem: {x}!\")\n", " else:\n", " print(f\"Valor de x: {x}, Valor de y: {y}\")\n", " y += 1\n", " x += 1\n", "```\n", "\n", "**Saída do Código:**\n", "```python\n", "X e Y são iguais e valem: 0!\n", "Valor de x: 0, Valor de y: 1\n", "Valor de x: 1, Valor de y: 0\n", "X e Y são iguais e valem: 1!\n", "Valor de x: 2, Valor de y: 0\n", "Valor de x: 2, Valor de y: 1\n", "```\n", "\n", "#### For dentro de um while\n", "Também é possível aninhar estruturas diferentes, como um loop `for` dentro de um loop `while`.\n", "\n", "```python\n", "x = 0\n", "while x < 3:\n", " for i in range(3):\n", " print(f\"Valor de x: {x}, Valor de i: {i}\")\n", " x += 1\n", "```\n", "\n", "**Saída do Código:**\n", "```python\n", "Valor de x: 0, Valor de i: 0\n", "Valor de x: 0, Valor de i: 1\n", "Valor de x: 0, Valor de i: 2\n", "Valor de x: 1, Valor de i: 0\n", "Valor de x: 1, Valor de i: 1\n", "Valor de x: 1, Valor de i: 2\n", "Valor de x: 2, Valor de i: 0\n", "Valor de x: 2, Valor de i: 1\n", "Valor de x: 2, Valor de i: 2\n", "```\n", "\n", "No último exemplo, `x` é incrementado após cada ciclo do loop `for`, até que atinja o valor 3 e o loop `while` seja interrompido." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Compreensões de Listas (List Comprehensions)\n", "\n", "Uma das características mais poderosas do Python é a capacidade de simplificar operações complexas em poucas linhas de código, e as **compreensões de listas** são um exemplo perfeito disso.\n", "\n", "As compreensões de listas fornecem uma maneira concisa de criar listas. Aplicações comuns incluem gerar novas listas em que cada elemento é o resultado de alguma operação aplicada a cada membro de outra sequência ou iterável, ou criar uma subsequência de elementos que atendem a uma determinada condição.\n", "\n", "### Sintaxe Básica\n", "\n", "A sintaxe básica de uma compreensão de lista é:\n", "\n", "```python\n", "[expressão for item in iterável if condição]\n", "```\n", "\n", "- **expressão**: A operação que será realizada em cada item, como uma operação matemática ou chamada de função.\n", "- **item**: Representa cada elemento da sequência ou coleção que está sendo percorrida.\n", "- **iterável**: Uma sequência (lista, tupla, etc.) ou coleção (conjunto, dicionário, etc.) sobre a qual você deseja iterar.\n", "- **condição** (opcional): Um filtro que inclui apenas os elementos onde a condição for verdadeira.\n", "\n", "### Exemplo: Elevando Números ao Quadrado\n", "\n", "Suponha que você queira elevar ao quadrado cada número em uma lista. Veja como isso pode ser feito usando uma compreensão de lista:\n", "\n", "```python\n", "numeros = [1, 2, 3, 4, 5]\n", "quadrados = [x ** 2 for x in numeros]\n", "print(quadrados) \n", "```\n", "\n", "**Saída do Código:**\n", "```python\n", "[1, 4, 9, 16, 25]\n", "```\n", "\n", "### Exemplo: Filtrando e Elevando ao Quadrado Apenas Números Pares\n", "\n", "Agora, suponha que você queira elevar ao quadrado apenas os números **pares** de uma lista. Para isso, você pode adicionar uma condição `if` na compreensão de lista. Veja o exemplo:\n", "\n", "```python\n", "numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "quadrados_pares = [x ** 2 for x in numeros if x % 2 == 0]\n", "print(quadrados_pares)\n", "```\n", "\n", "**Saída do Código:**\n", "```python\n", "[4, 16, 36, 64, 100]\n", "```\n", "\n", "Nesse exemplo, a lista resultante contém apenas os quadrados dos números pares, pois o `if x % 2 == 0` filtra os elementos da lista original, garantindo que apenas os pares sejam elevados ao quadrado.\n", "\n", "### Compreensão de Lista vs. Estrutura Convencional\n", "\n", "Para ver o quanto as compreensões de listas podem simplificar o código, compare a filtragem de números pares e a elevação ao quadrado com e sem o uso de compreensão de listas.\n", "\n", "**Sem Compreensão de Lista (Modo Convencional)**\n", "\n", "```python\n", "numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "quadrados_pares = []\n", "\n", "for x in numeros:\n", " if x % 2 == 0:\n", " quadrados_pares.append(x ** 2)\n", "\n", "print(quadrados_pares)\n", "```\n", "\n", "Nesse caso, o código exige várias linhas para definir a lista resultante, iterar sobre a lista original, aplicar a condição e adicionar os resultados.\n", "\n", "**Com Compreensão de Lista**\n", "\n", "```python\n", "numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "quadrados_pares = [x ** 2 for x in numeros if x % 2 == 0]\n", "print(quadrados_pares)\n", "```\n", "\n", "Aqui, a compreensão de lista condensa a lógica em uma única linha, mantendo o código mais direto e legível. \n", "\n", "Ao usar compreensões de listas, você pode reduzir significativamente o número de linhas de código, facilitando a leitura e a manutenção. Isso torna o código mais \"Pythonic\" e é especialmente útil para operações que envolvem filtragem e mapeamento de dados, como no exemplo acima, onde o código foi reduzido de cinco linhas para apenas uma." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Controle de Fluxo com `exit()` e `break`\n", "\n", "Python oferece várias formas de controlar o fluxo de execução em seu código. Duas dessas possibilidades são `exit()` e `break`, utilizadas para interromper a execução do programa ou de loops.\n", "\n", "A função `exit()` é usada para encerrar a execução do programa completamente. Se chamada dentro de um loop, `exit()` interrompe o loop e encerra o programa, e nenhum código subsequente é executado.\n", "\n", "### Exemplo de uso do `exit()` em um loop `for`\n", "\n", "```python\n", "frutas = [\"maçã\", \"uva\", \"morango\", \"banana\", \"abacaxi\"]\n", "for fruta in frutas:\n", " if fruta == \"banana\":\n", " print(\"Encontrei uma banana! Saindo do programa.\")\n", " exit()\n", " print(f\"Estou processando a fruta {fruta}.\")\n", "print(\"Estou fora do Loop.\") # Esta linha não será executada.\n", "```\n", "\n", "**Saída do Código:**\n", "```python\n", "Estou processando a fruta maçã.\n", "Estou processando a fruta uva.\n", "Estou processando a fruta morango.\n", "Encontrei uma banana! Saindo do programa.\n", "```\n", "\n", "Quando \"banana\" é encontrada, `exit()` é chamado e o programa é encerrado imediatamente, sem executar o restante do código, incluindo a linha após o loop `for`.\n", "\n", "### Exemplo de uso do `exit()` em um loop `while`\n", "\n", "```python\n", "contador = 1\n", "while True:\n", " print(f\"Contagem: {contador}\")\n", " if contador == 10:\n", " print(\"Contagem chegou a 10. Saindo do programa.\")\n", " exit()\n", " contador += 1\n", "```\n", "\n", "Neste exemplo, o loop `while` repete indefinidamente até que `contador` chegue a 10. Nesse ponto, `exit()` é chamado, encerrando o programa.\n", "\n", "### `break` para Sair do Loop Atual\n", "\n", "A função `break`, por outro lado, é usada para interromper apenas o loop atual, permitindo que o restante do código seja executado após o loop.\n", "\n", "### Exemplo de uso do `break` em um loop `for`\n", "\n", "```python\n", "frutas = [\"maçã\", \"uva\", \"morango\", \"banana\", \"abacaxi\"]\n", "for fruta in frutas:\n", " if fruta == \"banana\":\n", " print(\"Encontrei uma banana! Saindo do loop.\")\n", " break\n", " print(f\"Estou processando a fruta {fruta}.\")\n", "print(\"Estou fora do Loop.\")\n", "```\n", "\n", "**Saída do Código:**\n", "```python\n", "Estou processando a fruta maçã.\n", "Estou processando a fruta uva.\n", "Estou processando a fruta morango.\n", "Encontrei uma banana! Saindo do loop.\n", "Estou fora do Loop.\n", "```\n", "\n", "Neste caso, o `break` interrompe apenas o loop `for`, e o programa continua executando o código subsequente, incluindo a linha `print(\"Estou fora do Loop.\")`.\n", "\n", "### Exemplo de uso do `break` em um loop `while`\n", "\n", "```python\n", "while True:\n", " opcao = input(\"Digite uma opção (a/b/c/sair): \")\n", " if opcao == \"sair\":\n", " print(\"Saindo do programa.\")\n", " break\n", " elif opcao == \"a\":\n", " print(\"Executando ação relacionada à opção 'a'\")\n", " elif opcao == \"b\":\n", " print(\"Executando ação relacionada à opção 'b'\")\n", " else:\n", " print(\"Opção inválida. Tente novamente.\")\n", "```\n", "\n", "Neste exemplo, o loop `while` repete indefinidamente até que a opção \"sair\" seja escolhida, momento em que `break` é chamado para encerrar o loop, permitindo a continuidade do programa. \n", "\n", "### Resumo das Diferenças\n", "\n", "- **`exit()`**: Interrompe todo o programa, parando a execução imediatamente, mesmo que chamado dentro de um loop.\n", "- **`break`**: Encerra apenas o loop atual, permitindo que o código fora do loop continue a ser executado.\n", "\n", "Esses exemplos mostram como `exit()` e `break` podem ser aplicados para controlar o fluxo de execução de maneira efetiva e precisa, de acordo com a necessidade." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Números Aleatórios\n", "\n", "O módulo `random` em Python facilita a geração de números aleatórios, fornecendo uma interface simples e direta. Este módulo implementa geradores de números **pseudoaleatórios**, que produzem sequências de números que **aproximam a aleatoriedade verdadeira** para uma variedade de distribuições estatísticas.\n", "\n", "> Para comparação, números **verdadeiramente aleatórios** podem ser gerados a partir de fenômenos físicos, como os disponíveis no site [random.org](https://www.random.org), que utiliza ruído atmosférico para isso.\n", "\n", "\n", "### Módulos em Python\n", "\n", "Módulos em Python são arquivos contendo definições e instruções Python que podem ser reutilizados em outros programas. Para utilizá-los, você precisa importá-los no seu código. Isso é feito usando a instrução `import`, seguida pelo nome do módulo.\n", "\n", "Por exemplo, para importar o módulo `random`, que é responsável pela geração de números aleatórios, você pode usar:\n", "\n", "```python\n", "import random\n", "```\n", "\n", "Depois de importar o módulo, você pode acessar suas funções e classes usando a notação de ponto, como `random.random()`, `random.randint()` e `random.sample()`.\n", "\n", "### Métodos Comuns do Módulo `random`\n", "\n", "| Método | Descrição | Exemplo |\n", "|-------------------------|--------------------------------------------------------------|------------------------------------------------------|\n", "| `random.random()` | Retorna um número flutuante aleatório entre 0 e 1 | `random.random()` ➞ `0.45` |\n", "| `random.randint(a, b)` | Retorna um número inteiro aleatório entre `a` e `b` (inclusive) | `random.randint(1, 10)` ➞ `7` |\n", "| `random.choice(seq)` | Retorna um elemento aleatório de uma sequência | `random.choice(['maçã', 'banana', 'cereja'])` ➞ `'banana'` |\n", "| `random.sample(seq, k)` | Retorna uma amostra de `k` elementos aleatórios de uma sequência | `random.sample([1, 2, 3, 4, 5], 3)` ➞ `[4, 1, 5]` |\n", "| `random.shuffle(seq)` | Embaralha a sequência original | ``` lista = [1, 2, 3]; random.shuffle(lista); lista ➞ `[3, 1, 2]` ``` |\n", "\n", "### Exemplos de Uso\n", "\n", "Aqui estão alguns exemplos de como você pode gerar números aleatórios utilizando o módulo `random`:\n", "\n", "```python\n", "import random\n", "\n", "# Gerar um número flutuante aleatório entre 0 e 1\n", "random_float = random.random()\n", "print(f\"Número flutuante aleatório entre 0 e 1: {random_float}\")\n", "\n", "# Gerar um número inteiro aleatório entre 1 e 10\n", "random_integer = random.randint(1, 10)\n", "print(f\"Número inteiro aleatório entre 1 e 10: {random_integer}\")\n", "\n", "# Escolher aleatoriamente de uma lista\n", "lista = ['maçã', 'banana', 'cereja']\n", "escolha_aleatoria = random.choice(lista)\n", "print(f\"Escolha aleatória de uma lista: {escolha_aleatoria}\")\n", "\n", "# Amostra aleatória de elementos de uma lista\n", "amostra_aleatoria = random.sample(lista, 2)\n", "print(f\"Amostra aleatória de 2 elementos da lista: {amostra_aleatoria}\")\n", "```\n", "\n", "**Saída do Código (exemplo):**\n", "```python\n", "Número flutuante aleatório entre 0 e 1: 0.08329587492346713\n", "Número inteiro aleatório entre 1 e 10: 8\n", "Escolha aleatória de uma lista: maçã\n", "Amostra aleatória de 2 elementos da lista: ['banana', 'cereja']\n", "```\n", "\n", "### Definindo uma Semente\n", "\n", "Definir uma semente antes de gerar números aleatórios pode ser útil quando você precisa reproduzir resultados específicos em diferentes execuções do seu programa. Ao definir uma semente, a sequência de números gerada será sempre a mesma, garantindo a reprodução dos resultados.\n", "\n", "Aqui está um exemplo com a geração de números aleatórios após a inicialização de uma semente fixa:\n", "\n", "```python\n", "import random\n", "\n", "# Define uma semente para reproduzibilidade\n", "random.seed(123)\n", "\n", "# Agora, a sequência de números aleatórios será sempre a mesma\n", "for i in range(3):\n", " print(f\"Número aleatório {i+1}: {random.randint(1, 100)}\")\n", "```\n", "\n", "**Saída do Código (exemplo):**\n", "```python\n", "Número aleatório 1: 7\n", "Número aleatório 2: 34\n", "Número aleatório 3: 27\n", "```\n", "\n", "### Inicialização da Semente com o Tempo Atual\n", "\n", "Para garantir que a sequência de números aleatórios seja diferente a cada execução, você pode inicializar a semente usando o tempo atual, utilizando o módulo `time`:\n", "\n", "```python\n", "import random\n", "import time\n", "\n", "# Define a semente com o tempo atual\n", "random.seed(time.time())\n", "\n", "# Exemplo de geração de números aleatórios\n", "for i in range(3):\n", " print(f\"Número aleatório {i+1}: {random.randint(1, 100)}\")\n", "```\n", "\n", "A função `time.time()` retorna o tempo atual em segundos (com frações) desde 1º de janeiro de 1970. Como esse valor muda constantemente, ele permite gerar sementes diferentes a cada execução, garantindo variedade na sequência de números aleatórios.\n", "\n", "**Saída do Código (exemplo):**\n", "```python\n", "Número aleatório 1: 43\n", "Número aleatório 2: 77\n", "Número aleatório 3: 23\n", "```\n", "\n", "### Exemplo de Jogo com Dados\n", "\n", "Vamos criar um exemplo simples de um jogo onde dois jogadores jogam um dado, e o primeiro a obter um 6 ganha o jogo.\n", "\n", "```python\n", "import random\n", "\n", "# Simulação do jogo\n", "jogador1_vitorias = 0\n", "jogador2_vitorias = 0\n", "\n", "for i in range(1, 11): # Simular 10 rodadas\n", " jogador1_resultado = random.randint(1, 6)\n", " jogador2_resultado = random.randint(1, 6)\n", "\n", " print(f\"Rodada {i}: Jogador 1 tirou {jogador1_resultado}, Jogador 2 tirou {jogador2_resultado}\")\n", "\n", " if jogador1_resultado == 6 and jogador2_resultado == 6:\n", " print(\"Empate nesta rodada!\")\n", " elif jogador1_resultado == 6:\n", " jogador1_vitorias += 1\n", " print(\"Jogador 1 ganhou esta rodada!\")\n", " elif jogador2_resultado == 6:\n", " jogador2_vitorias += 1\n", " print(\"Jogador 2 ganhou esta rodada!\")\n", " else:\n", " print(\"Nenhum jogador ganhou esta rodada.\")\n", " print()\n", "\n", "if jogador1_vitorias > jogador2_vitorias:\n", " print(\"Jogador 1 Venceu!\")\n", " print(f\"Jogador 1 venceu {jogador1_vitorias} rodadas.\")\n", " print(f\"Jogador 2 venceu {jogador2_vitorias} rodadas.\")\n", "elif jogador2_vitorias > jogador1_vitorias:\n", " print(\"Jogador 2 venceu!\")\n", " print(f\"Jogador 1 venceu {jogador1_vitorias} rodadas.\")\n", " print(f\"Jogador 2 venceu {jogador2_vitorias} rodadas.\")\n", "else:\n", " print(\"Empate no total de rodadas!\")\n", " print(f\"Jogador 1 venceu {jogador1_vitorias} rodadas.\")\n", " print(f\"Jogador 2 venceu {jogador2_vitorias} rodadas.\")\n", "```\n", "\n", "**Exemplo de Saída do Código:**\n", "```python\n", "Rodada 1: Jogador 1 tirou 4, Jogador 2 tirou 2\n", "Nenhum jogador ganhou esta rodada.\n", "\n", "Rodada 2: Jogador 1 tirou 6, Jogador 2 tirou 3\n", "Jogador 1 ganhou esta rodada!\n", "\n", "Rodada 3: Jogador 1 tirou 2, Jogador 2 tirou 6\n", "Jogador 2 ganhou esta rodada!\n", "\n", "Rodada 4: Jogador 1 tirou 1, Jogador 2 tirou 5\n", "Nenhum jogador ganhou esta rodada.\n", "\n", "...\n", "\n", "Empate no total de rodadas!\n", "Jogador 1 venceu 1 rodadas.\n", "Jogador 2 venceu 1 rodadas.\n", "```\n", "\n", "Neste exemplo, dois jogadores lançam um dado, e o primeiro a tirar um 6 ganha a rodada. O programa simula 10 rodadas e conta quantas cada jogador ganhou. Defina uma semente caso queira garantir que os resultados sejam reproduzíveis." ] }, { "cell_type": "markdown", "metadata": { "id": "JJEbJLtWttKH" }, "source": [ "## Exercícios\n", "\n", "Antes de começar os exercícios, vamos aprender mais um pouco sobre a leitura dos dados de entrada. Desta vez sobre a função `map()`, que é usada para aplicar uma função específica a todos os elementos de uma sequência (como listas ou tuplas), retornando um iterador com os resultados. Ela recebe dois argumentos: a função a ser aplicada e a sequência de entrada.\n", "\n", "Por exemplo, quando queremos converter a entrada do usuário em números de ponto flutuante, usamos `map()` juntamente com a função `float()`:\n", "\n", "```python\n", "nota1, nota2, nota3 = map(float, input().split())\n", "```\n", "\n", "
\n", " \n", "
\n", "\n", "\n", "\n", "Neste código, o `input()` recebe três notas separadas por espaços. O método `.split()` divide a entrada em uma lista de strings. Em seguida, `map(float, ...)` aplica a função `float()` a cada elemento da lista, convertendo as strings em números de ponto flutuante. Finalmente, os valores convertidos são atribuídos às variáveis `nota1`, `nota2` e `nota3`.\n", "\n", "Outro exemplo é quando queremos converter a entrada do usuário em uma lista de números de ponto flutuante. Podemos fazer isso da seguinte maneira:\n", "\n", "```python\n", "notas = list(map(float, input().split()))\n", "```\n", "\n", "Neste caso, o `input()` recebe várias notas separadas por espaços. O método `.split()` divide a entrada em uma lista de strings. Em seguida, `map(float, ...)` aplica a função `float()` a cada elemento da lista, convertendo as strings em números de ponto flutuante. Finalmente, a função `list()` transforma o objeto map em uma lista de números de ponto flutuante, que é atribuída à variável `notas`.\n", "Agora sim, vamos aos **Exercícios**.\n", "\n", "1. **Classificação Etária**:\n", "Desenvolva um programa que recebe várias idades de usuários na entrada, todas separadas por espaços. Para cada idade, o programa deve imprimir a categoria correspondente de acordo com a seguinte escala:\n", "\n", "| Categoria | Faixa Etária |\n", "|-----------------|----------------|\n", "| Menor de idade | Menos de 13 anos |\n", "| Adolescente | De 13 a 17 anos |\n", "| Maior de idade | De 18 a 59 anos |\n", "| Idoso | 60 anos ou mais |\n", "\n", "\n", "```python\n", "# Teste\n", "Entrada: 12 15 20 16 21 60 22 14 23 65\n", "Saída: \n", "Menor de idade\n", "Adolescente\n", "Maior de idade\n", "Adolescente\n", "Maior de idade\n", "Idoso\n", "Maior de idade\n", "Adolescente\n", "Maior de idade\n", "Idoso\n", "```\n", "2. **Verificação de Palíndromo**:\n", "Faça um programa que receba uma lista de palavras e verifique se cada palavra é um palíndromo. Um palíndromo é uma palavra que permanece a mesma quando lida de trás para frente. O programa deve imprimir “Sim” para palíndromos e “Não” para não palíndromos. Utilize `end=' '` no comando print para que os resultados sejam exibidos na mesma linha, separados por espaços.\n", "\n", "```python\n", "# Teste\n", "Entrada: arara python reviver código osso casa radar programa mussum piloto\n", "Saída: Sim Não Sim Não Sim Não Sim Não Sim Não\n", "```\n", "\n", "3. **Contagem Regressiva**: Escreva uma contagem regressiva de 10 a 1, com um intervalo de 1 segundo entre cada número. Para isso, pesquise e utilize o módulo `time` para pausar a execução do programa por 1 segundo antes de imprimir cada número.\n", "\n", "Lembre-se de importar o módulo time e usar a função `time.sleep(1)` para criar o atraso desejado. Você pode encontrar mais informações sobre o módulo `time` na [documentação oficial do Python](https://docs.python.org/3/library/time.html).\n", "\n", "```python\n", "# Teste\n", "Entrada: Sem entrada\n", "Saída: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1\n", "```\n", "\n", "4. **Análise de Desempenho de uma Turma com até 100 Alunos**:\n", "Analise o desempenho de uma turma com até 100 alunos em uma disciplina de linguagem de programação. Seu programa deve receber como entrada uma lista de até 100 números entre 0 e 10, representando as notas finais de cada aluno.\n", "\n", "Para cada nota na lista, o programa deve:\n", "\n", "- Adicionar a nota à uma soma total (para posterior cálculo da média da turma).\n", "- Verificar se a nota é maior ou igual a 5. Se for, incrementar o contador de alunos aprovados.\n", "- Se a nota for menor que 5, incrementar o contador de alunos reprovados.\n", "\n", "Após processar todas as notas, o programa deve calcular e imprimir as seguintes informações: **Número de Alunos Aprovados, Número de Alunos Reprovados e Média da Turma.**\n", "\n", "Obs: Considere utilizar essa sintaxe para o armazenamento das notas em uma lista: `list(map(float, input().split(',')))`\n", "\n", "```python\n", "# Teste 1\n", "Entrada: 1.3, 2.8, 8.1, 5.6, 8.1, 6.9, 9.7, 0.7, 0.7, 1.1, 10.0, 1.7, 8.5, 3.3, 2.4, 6.9, 2.5, 0.3, 8.8, 3.1, 8.1, 9.2, 1.4, 4.6, 4.6, 0.6, 10.0, 1.4, 4.3, 7.9, 3.9, 2.4, 5.4, 5.6, 4.4, 3.5, 0.5, 7.4, 2.7, 2.1, 3.5, 6.3, 3.6, 0.0, 7.7, 0.8, 7.7, 9.7, 1.6, 0.3, 6.5, 4.2, 1.2, 4.3, 4.5, 8.9, 5.8, 7.5, 9.7, 8.2, 1.5, 9.2, 6.1, 9.7, 6.7, 0.5, 7.1, 3.4, 7.8, 8.1, 4.5, 4.1, 5.8, 3.4, 0.3, 10.0, 7.7, 0.2, 9.9, 2.3, 7.8, 5.6, 3.6, 1.3, 9.5, 1.2, 6.4, 3.2, 9.1, 8.6, 6.2, 7.9, 4.9, 7.3, 1.2, 5.1, 9.2, 7.6, 0.3, 7.4\n", "Saída:\n", "Número de Alunos Aprovados: 50\n", "Número de Alunos Reprovados: 50\n", "Média da Turma: 5.06\n", "\n", "# Teste 2\n", "Entrada: 7.0, 8.5, 9.0, 4.5, 6.0, 3.0, 2.5, 8.0, 9.5, 5.0\n", "Saída:\n", "Número de Alunos Aprovados: 7\n", "Número de Alunos Reprovados: 3\n", "Média da Turma: 6.30\n", "\n", "# Teste 3\n", "Entrada: 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0\n", "Saída:\n", "Número de Alunos Aprovados: 10\n", "Número de Alunos Reprovados: 0\n", "Média da Turma: 10.00\n", "\n", "# Teste 4\n", "Entrada: 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0\n", "Saída:\n", "Número de Alunos Aprovados: 0\n", "Número de Alunos Reprovados: 10\n", "Média da Turma: 0.00\n", "```\n", "\n", "5. **Cálculo do Fatorial**:\n", "Escreva um programa que receba uma lista de números inteiros, e obedecendo alguns critérios, calcule e imprima o fatorial de cada um deles. O fatorial de um número é o produto de todos os números inteiros de 1 até o próprio número.\n", "\n", "Aqui estão as etapas e critérios para implementar seu programa:\n", "\n", "- Receba e armazene uma lista de números inteiros.\n", "- Verifique se cada número é válido (ou seja, maior ou igual a zero e menor do que 15).\n", "- Calcule o fatorial de cada número usando um loop `for` ou `while`.\n", "- Exiba o resultado do fatorial para cada um dos números. Se não for possível calcular o fatorial (por exemplo, para números não válidos), escreva um `X`.\n", "- Mostre a quantidade de números para os quais não foi possível calcular o fatorial.\n", "\n", "```python\n", "# Teste 1\n", "Entrada: 7, 6, -1, 14, 1, 12, 0, 18, 15, 12, 5, 9, 10, 0, 12, 17, 2, 15, 12, 2, 16, 19, 5, 4, 10\n", "Saída: 5040, 720, X, 87178291200, 1, 479001600, 1, X, X, 479001600, 120, 362880, 3628800, 1, 479001600, X, 2, X, 479001600, 2, X, X, 120, 24, 3628800\n", "Quantidade de números inválidos: 7\n", "\n", "# Teste 2\n", "Entrada: 3, 9, 12, 15, 12, 0, 8, 15, 12, 5, 9, 10, 0, 12, 17, 2, 15, 12, 2, 16, 19, 5, 4, 10, 3, 13\n", "Saída: 6 362880 479001600 X 479001600 1 40320 X 479001600 120 362880 3628800 1 479001600 X 2 X 479001600 2 X X 120 24 3628800 X 6227020800 \n", "Quantidade de números inválidos: 6\n", "```\n", "\n", "Lembre-se de tratar casos especiais. Zero possui fatorial 1 e um número negativo não possui fatorial.\n", "\n", "**6. Jogo da Adivinhação (Jogador vs Computador):**\n", "O objetivo é desenvolver um jogo interativo de adivinhação de números no qual o jogador compete contra o computador. O jogo deve seguir as seguintes regras:\n", "\n", "- No início do jogo, o programa deve gerar um número aleatório secreto entre 1 e 100. Este será o número que o jogador e o computador tentarão adivinhar.\n", "\n", "- Tanto o jogador quanto o computador têm um número limitado de tentativas para adivinhar o número. Por exemplo, pode-se limitar a 20 tentativas.\n", "\n", "- Em cada rodada, o jogador e o computador fazem um palpite. O programa deve então fornecer uma dica para ambos, indicando se o número secreto é maior ou menor que os palpites.\n", "\n", "- Se o jogador ou o computador adivinhar o número corretamente, o programa deve parabenizá-lo e informar o número de tentativas que foram necessárias para adivinhar o número. Se ambos adivinharem o número na mesma rodada, o jogo termina em empate.\n", "\n", "- Se o jogador e o computador esgotarem todas as suas tentativas sem adivinhar o número, o programa deve informar que o jogo terminou e revelar o número secreto.\n", "\n", "**7. Exercício de Padrão de Asteriscos:**\n", "Escreva um programa em Python que imprima um triângulo de asteriscos. O programa deve receber na entrada o número de linhas do triângulo e o tipo de triângulo a ser impresso (tipo1 ou tipo2). Em seguida, o programa deve imprimir o triângulo de asteriscos com o número de linhas especificado e no formato escolhido.\n", "\n", "- **Tipo 1:** Cada linha começa com um asterisco e aumenta o número de asteriscos à medida que descemos.\n", "- **Tipo 2:** O número máximo de asteriscos aparece na primeira linha e à medida que avançamos para a direita, este número vai diminuindo.\n", "\n", "```python\n", "# Teste 1\n", "Entrada: tipo1, 3\n", "Saída:\n", "*\n", "**\n", "***\n", "\n", "# Teste 2\n", "Entrada: tipo1, 5\n", "Saída:\n", "*\n", "**\n", "***\n", "****\n", "*****\n", "\n", "# Teste 3\n", "Entrada: tipo2, 4\n", "Saída:\n", "****\n", "***\n", "**\n", "*\n", "```\n", "\n", "**8. Identificação de Números Primos em uma Lista:**\n", "Desenvolva um programa que identifique todos os números primos presentes em uma lista fornecida na entrada. Um número primo é um número maior que 1 que não possui divisores positivos além de 1 e si próprio. Siga as Instruções a seguir:\n", "\n", "- Leia uma lista de números inteiros.\n", "- Para cada número na lista, verifique se ele é um número primo.\n", "- Se o número for primo, adicione-o a uma nova lista.\n", "- Após verificar todos os números na lista original, exiba a nova lista contendo apenas os números primos.\n", "\n", "```python\n", "# Teste 1\n", "Entrada: -23, 15, -7, 49, -35, 21, -2, 30, -14, 8, -50, 44, -29, 17, -3, 34, -9, 25, -40, 12, 5, -28, 37, -16, 10, -4, 42, -33, 18, -6, 27, -13, 39, -22, 11, -1, 31, -19, 20, -36, 14, -8, 26, -45, 9, -24, 32, -10, 23, -5\n", "Saída: 17, 5, 37, 11, 31, 23\n", "\n", "# Teste 2\n", "Entrada: -18, 33, -12, 27, -6, 42, -30, 21, -3, 39, -24, 15, -9, 36, -15, 12, -1, 45, -27, 18, -7, 30, -21, 9, -33, 24, -13, 6, -42, 36, -19, 3, -39, 30, -10, 0, 48, -25, 16, -4, 41, -28, 22, -5, 38\n", "Saída: 3, 41\n", "```\n", "\n", "**9. Loteria de 5 números:**\n", "Desenvolva um programa que simule uma loteria onde são sorteados 5 números distintos entre 1 e 50. O programa deve gerar aleatoriamente jogos de 5 números até que um jogo corresponda exatamente à combinação sorteada. O objetivo é determinar quantos jogos são necessários até que haja um ganhador. Siga as instruções a seguir:\n", "\n", "- Receba na entrada um inteiro correspondente à semente para geração pseudoaleatória de números.\n", "- Gere uma combinação vencedora de 5 números únicos entre 1 e 50 usando `random.sample`.\n", "- Converta a combinação vencedora em um conjunto (set) para facilitar a comparação.\n", "- Crie um loop que simule jogos de 5 números únicos entre 1 e 50, também usando `random.sample`.\n", "- Após cada jogo, converta a combinação de números gerada em um conjunto (set) e verifique se ela corresponde à combinação vencedora.\n", "- Conte o número de jogos realizados até que um jogo corresponda exatamente à combinação vencedora.\n", "- Exiba o número total de jogos necessários para encontrar um ganhador.\n", "\n", "```python\n", "# Teste 1\n", "Entrada: 1\n", "Saída: Número de jogos necessários: 24836\n", "\n", "# Teste 2\n", "Entrada: 2\n", "Saída: Número de jogos necessários: 622164\n", "\n", "# Teste 3\n", "Entrada: 11\n", "Saída: Número de jogos necessários: 807045\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**10. O \"Velho\" Fibonacci:**\n", "A **sequência de Fibonacci** é uma série infinita de números inteiros em que cada número é a soma dos dois anteriores. Ela começa com os números 1 e 1:\n", "\n", "1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...\n", "\n", "Para calcular o próximo número na sequência, somamos os dois números anteriores. Por exemplo:\n", "\n", "- O terceiro número é 1 + 1 = 2.\n", "- O quarto número é 1 + 2 = 3.\n", "- O quinto número é 2 + 3 = 5.\n", "\n", "E assim por diante. \n", "\n", "Veja a imagem ilustrativa a seguir:\n", "\n", "\"fib\"\n", "\n", "Agora, vamos criar um programa que gere a sequência de Fibonacci até o **n-ésimo termo**. O usuário fornecerá o valor de **n**.\n", "\n", "- Inicializamos as variáveis `ultimo` e `penultimo` com os valores 1, pois os dois primeiros termos da sequência são 1.\n", "- Usamos um laço de repetição (como um `for` ou `while`) para calcular os próximos termos. Salvando os valores em uma lista.\n", "- A cada iteração, somamos `ultimo` e `penultimo` para obter o próximo termo.\n", "- Atualizamos as variáveis `ultimo` e `penultimo` para os valores corretos.\n", "- Repetimos o processo até chegarmos ao **n-ésimo termo**.\n", "- Por fim, todos os números da sequência, armazenados em uma lista, devem ser impressos.\n", "\n", "```python\n", "# Teste 1\n", "Entrada: 10\n", "Saída: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55\n", "\n", "# Teste 2\n", "Entrada: 19\n", "Saída: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181\n", "\n", "# Teste 3\n", "Entrada: 23\n", "Saída: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657 \n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**11. Gerador de Senhas Aleatórias**\n", "\n", "Você foi contratado para desenvolver um sistema simples que gere senhas seguras para usuários. Cada senha deve conter letras maiúsculas, letras minúsculas e números. Para facilitar a criação de várias senhas, o sistema deve gerar um conjunto de senhas automaticamente.\n", "\n", "> **Importante:** a semente deve ser definida com `random.seed(42)` **antes** de qualquer chamada a funções como `random.choices()` ou `random.shuffle()`. Isso garante que todos os alunos gerem exatamente as mesmas senhas.\n", "\n", "**Requisitos:**\n", "\n", "* Cada senha deve conter:\n", "\n", " * 3 letras **maiúsculas**\n", " * 3 letras **minúsculas**\n", " * 3 **dígitos**\n", "* A senha deve ter **9 caracteres** no total, dispostos em **ordem aleatória**.\n", "* Utilize um laço de repetição para gerar a quantidade (`qtd`) de senhas desejada.\n", "* Use o módulo `random` e defina a semente com `random.seed(42)` antes de gerar qualquer senha.\n", "\n", "\n", "**Dicas:**\n", "\n", "* `import string` pode ser útil \n", "* Use `string.ascii_uppercase`, `string.ascii_lowercase` e `string.digits` para acessar letras e números.\n", "* Use `random.choices(..., k=3)` para sortear 3 caracteres de uma lista.\n", "* Por fim, use `random.shuffle(lista)` para embaralhar a ordem dos caracteres da senha.\n", "\n", "```python\n", "# Teste 1\n", "Entrada: 3\n", "Saída: rfH4t80AQ wl74S1SKh Gl0I9J2bd\n", "\n", "# Teste 2\n", "Entrada: 5\n", "Saída: rfH4t80AQ wl74S1SKh Gl0I9J2bd W6l37evJW ft8R8YHi0\n", "\n", "# Teste 3\n", "Entrada: 8\n", "Saída: rfH4t80AQ wl74S1SKh Gl0I9J2bd W6l37evJW ft8R8YHi0 5LKgg8Xo2 pDrE45kW2 19gC5LLyw\n", "```\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**12. Batalha de Números Primos**\n", "\n", "Dois jogadores entraram em uma batalha matemática! Cada um receberá **15 números aleatórios entre 1 e 1000**. O objetivo é simples: **quem tiver mais números primos vence a partida**.\n", "\n", "Para garantir que os testes possam ser reproduzidos de forma idêntica, o programa deve receber **duas sementes** de números aleatórios — uma para cada jogador.\n", "\n", " **Requisitos**\n", "\n", "* Receba dois números inteiros como entrada: eles serão usados como sementes (`random.seed()`) — uma para cada jogador.\n", "* Após definir a semente, sorteie **15 números entre 1 e 1000** para cada jogador.\n", "* Verifique quais desses números são primos.\n", "* Mostre:\n", "\n", " * Os **15 números** sorteados para cada jogador\n", " * Quantos números primos cada jogador recebeu\n", "* Declare o vencedor com base em quem teve mais primos. Em caso de empate, informe: **\"Empate!\"**\n", "\n", "```python\n", "# Teste 1\n", "Entrada: 123 456\n", "Saída:\n", "JOGADOR 1\n", "[54, 275, 90, 788, 418, 273, 111, 859, 923, 896, 40, 389, 550, 576, 341]\n", "Número de Primos: 2\n", "\n", "JOGADOR 2\n", "[767, 461, 990, 478, 446, 400, 814, 911, 664, 42, 633, 749, 843, 921, 809]\n", "Número de Primos: 3\n", "\n", "Vencedor: Jogador 2\n", "\n", "# Teste 2\n", "Entrada: 111 222\n", "Saída esperada:\n", "JOGADOR 1\n", "[848, 972, 218, 944, 966, 324, 506, 199, 408, 427, 632, 832, 174, 645, 199]\n", "Número de Primos: 2\n", "\n", "JOGADOR 2\n", "[798, 111, 241, 291, 314, 33, 30, 494, 229, 456, 758, 738, 452, 464, 77]\n", "Número de Primos: 2\n", "\n", "Vencedor: Empate\n", "\n", "# Teste 3\n", "Entrada: 42 99\n", "Saída:\n", "JOGADOR 1\n", "[655, 115, 26, 760, 282, 251, 229, 143, 755, 105, 693, 759, 914, 559, 90]\n", "Número de Primos: 2\n", "\n", "JOGADOR 2\n", "[414, 390, 205, 614, 184, 236, 255, 137, 779, 89, 258, 747, 393, 544, 701]\n", "Número de Primos: 3\n", "\n", "Vencedor: Jogador 2\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n" ] } ], "metadata": { "colab": { "provenance": [], "toc_visible": true }, "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.20" } }, "nbformat": 4, "nbformat_minor": 4 }