Skip to content

Instantly share code, notes, and snippets.

@chamatt

chamatt/lista python 1.ipynb

Created March 16, 2020 21:08
Show Gist options
  • Save chamatt/70ff3d5f2a84b285ec1ea8b5e3d67efc to your computer and use it in GitHub Desktop.
Save chamatt/70ff3d5f2a84b285ec1ea8b5e3d67efc to your computer and use it in GitHub Desktop.
Download ZIP
Lista Python 1
Display the source blob
Display the rendered blob
Raw
lista python 1.ipynb
{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"name": "ListaExerciciosPython.ipynb",
"version": "0.3.2",
"provenance": []
},
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
}
},
"cells": [
{
"metadata": {
"id": "_bdC-H0RxpOU",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"# Lista de exercícios sobre programação em Python"
]
},
{
"metadata": {
"id": "Ewi6c1nTxpOX",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"<br/>**Disciplina**: Introdução a redes neurais profundas 2018/2\n",
"<br/>**Professor**: Jorge Leonid Aching Samatelo"
]
},
{
"metadata": {
"id": "adEtUH9RxpOY",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"**Aluno**: Pedro Farias"
]
},
{
"metadata": {
"id": "OFE_hF7gxpOa",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"## Tabela de conteúdos\n",
"1. [Indicações](#indicacoes)\n",
"1. [Exercícios sobre String](#ExerString)\n",
"1. [Exercícios sobre Listas](#ExerListas)\n",
"1. [Exercícios sobre Tuplas](#ExerTuplas)\n",
"1. [Exercícios sobre Dicionarios](#ExerDicionarios)\n",
"1. [Exercícios sobre Sentenças Condicionais e Repetição](#ExerCondRept)\n",
"1. [Exercícios de Programação](#ExerProgramacao)"
]
},
{
"metadata": {
"id": "xWdSkyMOxpOb",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"## Indicações <a name=\"indicacoes\"></a>\n",
"\n",
"### Considerações\n",
"* Cada aluno enviará por e-mail a solução dos exercícios propostos, tais soluções devem ser inseridas neste mesmo arquivo. \n",
"* Para saber cómo trabalhar com arquivos `*.ipynb` é necessario ler os slides `003_JUPYTER_2x2.pdf`.\n",
"\n",
"### Prazo\n",
"* Envio das soluções: Domingo 21/08/2018 - (11:59 pm) \n",
"\n",
"### Procedimento para o envio das soluções\n",
"* O arquivo `*.ipynb` com as soluções dos exercícios deve ser enviado ao email <[email protected]> com o assunto: `LISTA_EXERCICIO_PYTHON_2018_2`. \n",
"* O nome do arquivo `*.ipynb` deve iniciar com o rotulo `DL_LISTA_PYTHON` seguido pelas iniciais do nome do aluno que soluciono os exercícios (por exemplo, o aluno Pedro Farias enviara o arquivo `DL_LISTA_PYTHON_PF.ipynb`).\n",
"\n",
"### Dicas execução\n",
"* Carregue todos os pacotes que serão necessários no início do arquivo.\n",
"* Para executar comandos da shell dentro do notebook, utilize o prefixo `!` antes do comando de shell. (e.g. para listar os arquivos da pasta atual faça `! ls` para UNIX ou `! dir` para Windows."
]
},
{
"metadata": {
"id": "XbHoOUgmxpOb",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"## Exercícios sobre String <a name=\"ExerString\"></a>"
]
},
{
"metadata": {
"id": "FulGu7ANxpOd",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 1 \n",
"Faça um programa que leia 2 strings e inprima o conteúdo delas seguido do seu comprimento. Informe também se as duas strings possuem o mesmo comprimento e são iguais ou diferentes no conteúdo. \n",
"\n",
"Exemplo:\n",
"```\n",
"Compara duas strings.\n",
"String 1: 'Brasil Hexa 2006'\n",
"String 2: 'Brasil! Hexa 2006!'\n",
"Tamanho de 'Brasil Hexa 2006': 16 caracteres\n",
"Tamanho de 'Brasil! Hexa 2006!': 18 caracteres\n",
"As duas strings são de tamanhos diferentes.\n",
"As duas strings possuem conteúdo diferente.\n",
"```"
]
},
{
"metadata": {
"id": "wJgjI2LaxpOd",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "97s_7Q0_xpOh",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 2\n",
"\n",
"Dado o texto: \n",
"\n",
"> *The Python Software Foundation and the global Python community welcome and encourage participation by everyone. Our community is based on mutual respect, tolerance, and encouragement, and we are working to help each other live up to these principles. We want our community to be more diverse: whoever you are, and whatever your backgrou and, we welcome you.*\n",
"\n",
"Calcule quantas palavras possuem uma das letras “python” e que tenham mais de 4 caracteres. Não esqueça de transformar maiúsculas para minúsculas e de remover antes os caracteres especiais."
]
},
{
"metadata": {
"id": "klTPpPb5xpOh",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "aUwBTLf8xpOk",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 3\n",
"Conta espaços e vogais. Dado uma string com uma frase informada pelo usuário (incluindo espaços em branco), conte:\n",
"1. Quantos espaços em branco existem na frase.\n",
"2. Quantas vezes aparecem as vogais a, e, i, o, u. "
]
},
{
"metadata": {
"id": "TgcZBRGExpOk",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "aRRdRkn8xpOm",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 4\n",
"Faça um programa que receba uma palavra e imprime cada letra dessa palavra separadamente. Para isso utilize a função `len` que informa o comprimento de uma string: len(palavra)"
]
},
{
"metadata": {
"id": "oZLcVvy2xpOo",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "oRTEXv8yxpOs",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 5\n",
"Escreva um programa que determine o valor da soma: a + aa + aaa + aaaa, onde, o valor de a é definido como um caráter. Por exemplo.\n",
"Suponha que a = '9'. Então, a saída do programa deve ser: 11106 ( = 9+99+999+9999)"
]
},
{
"metadata": {
"id": "Zpc0-8OxxpOt",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "LFAWl6CyxpOw",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"## Exercicios sobre Listas <a name=\"ExerListas\"></a>"
]
},
{
"metadata": {
"id": "9kH2OpR9xpOw",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 1\n",
"Escreva uma função que combine duas listas tomando alternadamente seus elementos. Por exemplo: dadas as duas listas `[a, b, c]` e `[1, 2, 3]`, a função deve retornar `[a, 1, b, 2, c, 3]`."
]
},
{
"metadata": {
"id": "LREQfmsNxpOx",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "E_irUDsGxpOz",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 2\n",
"\n",
"Escreva um programa para determinar os elementos não comuns entre duas listas. \n",
"\n",
"Exemplo.\n",
"```python\n",
"lista1 = [\"red\", \"orange\", \"green\", \"blue\", \"white\"]\n",
"lista2 = [\"black\", \"yellow\", \"green\", \"blue\"]\n",
"```\n",
"Saídas esperadas:\n",
"```python\n",
"lista1_lista2: ['white', 'orange', 'red']\n",
"lista2_lista1: ['black', 'yellow']\n",
"```"
]
},
{
"metadata": {
"id": "SPGSgAEkxpO1",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "mc5Jif_vxpO2",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 3\n",
"Escreva um programa Python que permita remover elementos duplicados de uma lista.\n",
"\n",
"Exemplo\n",
"```python\n",
"ListaInput = [10,20,30,20,10,50,60,40,80,50,40] \n",
"ListaOutput = [10,20,30,50,60,40,80]\n",
"```"
]
},
{
"metadata": {
"id": "NIBUXs4ZxpO3",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "83oJ8JT9xpO6",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 4\n",
"Escreva um programa que dada uma lista de entrada, retorne uma nova lista cujo conteúdo é igual ao original, mas invertida. \n",
"\n",
"Exemplo\n",
"```python\n",
"ListaInput = [ 'Di', 'bom', 'dia', 'a', 'papa'] \n",
"ListaOutput = [ 'papa', 'a', 'dia', 'boa', 'Di']\n",
"```"
]
},
{
"metadata": {
"id": "0TSXuphQxpO7",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "ilpvSIUOxpO-",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 5\n",
"Faça uma função que determine a superposição de duas listas, ou seja, que retorne `True` se as listas têm pelo menos um elemento em comum, caso contrario, deve retornar `False`."
]
},
{
"metadata": {
"id": "5dE74EV0xpO-",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "OklzdgM3xpPB",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"## Exercícios sobre Tuplas <a name=\"ExerTuplas\"></a>"
]
},
{
"metadata": {
"id": "_RE8OnU2xpPC",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 1\n",
"Escreva um programa que permita classificar as tuplas (nome, idade, altura) por ordem crescente, onde o nome é string, idade e altura são números. \n",
"As tuplas são inseridas pelo console. \n",
"\n",
"Os critérios de classificação são:\n",
"1. Classificar com base no nome;\n",
"2. Em seguida, classificar com base na idade;\n",
"3. Em seguida, classificar por altura.\n",
"4. A prioridade é que: `nome> idade> altura`.\n",
"\n",
"A entrada é dada como uma string, onde as tuplas são separadas por dois pontos (;) e os elementos de cada tupla são separados por vírgula (,).\n",
"\n",
"Exemplo.\n",
"Se as seguintes tuplas são dadas como entrada para o programa:\n",
"```python\n",
"str_input = 'Tom,19,80;João,20,90;Jony,17,91;Jony,17,93;Json,21,85'\n",
"```\n",
"Em seguida, a saída do programa deve ser:\n",
"```python\n",
"tupla_output = [('Jony', '17', '91'), ('Jony', '17', '93'), ('João', '20', '90'), ('Json', '21', '85'), ('Tom', '19', '80')]\n",
"```"
]
},
{
"metadata": {
"id": "rh3Qq3PPxpPC",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "3c4FhBmTxpPE",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 2\n",
"Escreva um programa que mostre todas fichas de dominó, sem repetir, um por linha. da seguinte forma:\n",
"```\n",
"1:1\n",
"1:2\n",
"...\n",
"6:6\n",
"```"
]
},
{
"metadata": {
"id": "fKAUv7tNxpPE",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "WLEIXl1AxpPH",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 3\n",
"Escreva uma função que retorne `True` se duas fichas de dominó encaixarem ou não. \n",
"As fichas de dominó são representadas como tuplas, por exemplo, `(3,4)` e `(5,4)`."
]
},
{
"metadata": {
"id": "4SwvyIftxpPJ",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "ucmPScpcxpPK",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"## Exercícios sobre Dicionários <a name=\"ExerDicionarios\"></a>"
]
},
{
"metadata": {
"id": "Zq7pCojDxpPL",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 1\n",
"Escreva uma função que permita concatenar dicionários e criar um novo dicionário.\n",
"\n",
"Exemplo.\n",
"Sejam os dicionários de entrada\n",
"```python\n",
"dic1={1:10, 2:20}\n",
"dic2={3:30, 4:40}\n",
"dic3={5:50,6:60}\n",
"```\n",
"o resultado esperado será:\n",
"```python\n",
"{1: 10, 2: 20, 3: 30, 4: 40, 5: 50, 6: 60}\n",
"```"
]
},
{
"metadata": {
"id": "RQ11SEyzxpPN",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "0pHYNF2gxpPO",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 2\n",
"Escreva um programa para calcular a frequência das palavras a partir de uma string de entrada. \n",
"A saída deve ser exibida após a classificação alfanumérica da chave.\n",
"\n",
"Exemplo:\n",
"Suponha que o seguinte string de entrada seja fornecida ao programa:\n",
"```python\n",
"str_input = 'Novo para Python ou escolher entre Python 2 e Python 3? Leia Python 2 ou Python 3'\n",
"```\n",
"Em seguida, a saída do programa deve ser:\n",
"```\n",
"2:2\n",
"3:1\n",
"3?:1\n",
"Leia:1\n",
"Novo:1\n",
"Python:5\n",
"e:1\n",
"entre:1\n",
"escolher:1\n",
"ou:2\n",
"para:1\n",
"```\n",
"Sugestões: use um dicionário para guardar os pares (palavra, frequência) ."
]
},
{
"metadata": {
"id": "RE4G65T3xpPP",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "LZsv9YI7xpPS",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 3\n",
"Existem 36 possíveis combinações de dois dados. \n",
"Usando a soma dos dois dados como a chave, criar um dicionário de todas as combinações de ṕares possíveis para os dois dados. Evidentemente, cada valor no dicionário deve ser uma lista de tuplas, onde, cada tupla tem o valor de dois dados."
]
},
{
"metadata": {
"id": "HlH-7PnMxpPT",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "L4BvELWZxpPW",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 4\n",
"A data do formulário 8-MAR-75 inclui o nome do mês, que deve ser traduzido para um número. \n",
"Crie um dicionário adequado para decodificar nomes de mês para números. \n",
"Crie uma função que aceite uma data no formato \"dd-mm-yy\" e devolva uma tupla de (y, m, d)."
]
},
{
"metadata": {
"id": "k6div5tmxpPX",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "nJ54MFtYxpPZ",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 5\n",
"\n",
"Em criptografia, a Cifra de César, também conhecida como cifra de troca, código de César ou troca de César, é uma das mais simples e conhecidas técnicas de criptografia, na qual cada letra do texto é substituída por outra, que se apresenta no alfabeto abaixo dela um número fixo de vezes.\n",
"Por exemplo, com uma mudança de 3, \n",
"A seria substituído por D, \n",
"B se tornaria E, e assim por diante. \n",
"\n",
"ROT-13 (\"rotação por 13 posições\") é um exemplo amplamente utilizado de uma cifra de César, onde o deslocamento é 13. \n",
"Em Python, a chave para ROT-13 pode ser representada por meio do seguinte dicionário:\n",
"```python\n",
"key = {'a':'n', 'b':'o', 'c':'p', 'd':'q', 'e':'r', 'f':'s', 'g':'t', 'h':'u', \n",
" 'i':'v', 'j':'w', 'k':'x', 'l':'y', 'm':'z', 'n':'a', 'o':'b', 'p':'c', \n",
" 'q':'d', 'r':'e', 's':'f', 't':'g', 'u':'h', 'v':'i', 'w':'j', 'x':'k',\n",
" 'y':'l', 'z':'m', 'A':'N', 'B':'O', 'C':'P', 'D':'Q', 'E':'R', 'F':'S', \n",
" 'G':'T', 'H':'U', 'I':'V', 'J':'W', 'K':'X', 'L':'Y', 'M':'Z', 'N':'A', \n",
" 'O':'B', 'P':'C', 'Q':'D', 'R':'E', 'S':'F', 'T':'G', 'U':'H', 'V':'I', \n",
" 'W':'J', 'X':'K', 'Y':'L', 'Z':'M'}\n",
"```\n",
"Sua tarefa neste exercício é implementar um codificador/decodificador para ROT-13. \n",
"Depois de terminar, você poderá ler o seguinte mensagem secreto:\n",
"\n",
"> _Pnrfne pvcure? V zhpu cersre Pnrfne fnynq\\!_\n",
"\n",
"Note que, uma vez que, foi usado o alfabeto em inglês, seu programa será capaz de codificar e decodificar textos escritos em inglês usando ROT-13."
]
},
{
"metadata": {
"id": "HTmSevCZxpPa",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "EiUxJvcdxpPc",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"## Exercícios sobre sentenças condicionais e de repetição <a name=\"ExerCondRept\"></a>"
]
},
{
"metadata": {
"id": "ZvgB1WPtxpPe",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 1\n",
"Escreva três funções que calculem a soma dos elementos de uma lista, usando a instrução `while`, a instrução `for` e _recursão_."
]
},
{
"metadata": {
"id": "can-iez4xpPg",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "iJT-mOWyxpPi",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 2\n",
"Desenvolva um gerador de tabuada, capaz de gerar a tabuada de qualquer número inteiro entre 1 a 10. O usuário deve informar de qual número ele deseja ver a tabuada. A saída deve ser conforme o exemplo abaixo:\n",
"Tabuada de $5$:\n",
"$$\n",
"\\begin{eqnarray}\n",
"5 \\times 1 &=& 5\\\\\n",
"5 \\times 2 &=& 10\\\\\n",
"...\\\\\n",
"5 \\times 10 &=& 50\n",
"\\end{eqnarray}\n",
"$$"
]
},
{
"metadata": {
"id": "-cUPRYwLxpPj",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "cQlBHCBwxpPl",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 3\n",
"Escreva um programa que determine todos os números que são divisíveis por 7, mas não são um múltiplo de 5, entre 2000 e 3200 (ambos incluídos).\n",
"Os números obtidos devem ser impressos em uma seqüência separada por vírgulas em uma única linha."
]
},
{
"metadata": {
"id": "V2aui15YxpPl",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "P_aW9t69xpPm",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe.4\n",
"Escreva um programa, que determine todos os números entre 1000 e 3000 (ambos incluídos), de tal forma que, cada dígito de número é um número par.\n",
"Os números obtidos devem ser impressos em uma seqüência separada por vírgulas em uma única linha."
]
},
{
"metadata": {
"id": "W-NWYLK6xpPn",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "f6ERRrP-xpPp",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 5\n",
"Faça um programa que mostre os números potência de 2 menores de 10000 da seguinte forma:\n",
"```\n",
"0001\n",
"0002\n",
"0004\n",
"0008\n",
"...\n",
"8192\n",
"```"
]
},
{
"metadata": {
"id": "ecafQsgVxpPq",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "n4zCfrtjxpPt",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"## Exercícios de Programação <a name=\"ExerProgramacao\"></a>"
]
},
{
"metadata": {
"id": "lRsnOJ8NxpPu",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 1\n",
"Faça um programa que leia um número inteiro menor que 1000 e imprima a quantidade de centenas, dezenas e unidades do mesmo. Observando os termos no plural a colocação do “e”, da vírgula entre outros.\n",
"\n",
"Exemplo:\n",
"* 326 = 3 centenas, 2 dezenas e 6 unidades\n",
"* 12 = 1 dezena e 2 unidades\n",
"\n",
"Testar com: 326, 300, 100, 320, 310,305, 301, 101, 311, 111, 25, 20, 10, 21, 11, 1, 7 e 16 \n"
]
},
{
"metadata": {
"id": "ZBs1jjuqxpPu",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "axiCWbetxpPx",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 2\n",
"Faça um programa que mostre os $n$ termos da Série a seguir: \n",
"$$\n",
"S = \\frac{1}{1} + \\frac{2}{3} + \\frac{3}{5} + \\frac{4}{7} + \\frac{5}{9} + ... + \\frac{n}{m}. \n",
"$$\n",
"Imprima no final a soma da série. "
]
},
{
"metadata": {
"id": "cxav2c7gxpPx",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "mdJyzEMxxpP1",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 3\n",
"Escreva uma função que, dada uma lista de inteiros não negativos, organize seus elementos de tal forma que eles formem o maior número possível. Por exemplo, dado [50, 2, 1, 9], o maior número formado é 95021."
]
},
{
"metadata": {
"id": "-IfdXaZExpP2",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "cT_b6WwCxpP3",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 4\n",
"Escreva um programa que imprima todas as possibilidades para colocar + ou - ou nada entre os números 1, 2, ..., 9 (nesta ordem) de forma que o resultado seja sempre 100. Por exemplo: 1 + 2 + 34 - 5 + 67 - 8 + 9 = 100."
]
},
{
"metadata": {
"id": "uFtEMz2IxpP3",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "HLjooK7rxpP5",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 5\n",
"Um site exige que para se registrar os usuários devem inserir o nome de usuário e a senha. \n",
"Escreva um programa para verificar a validade da entrada da senha do usuário, considerando os seguintes critérios:\n",
"1. Pelo menos 1 letra minúscula entre \\[a-z\\]\n",
"1. Pelo menos 1 número entre \\[0-9\\]\n",
"1. Pelo menos uma letra maiúscula entre \\[A-Z\\]\n",
"1. Pelo menos 1 caractere de \\[\\$ \\# \\@\\]\n",
"1. Comprimento mínimo da senha: 6\n",
"1. Comprimento máximo da senha: 12\n",
"\n",
"<br/> Seu programa deve aceitar uma seqüência de senhas separadas por vírgulas e verificá-las de acordo com os critérios acima. As senhas que correspondem aos critérios devem ser impressas, cada uma separada por uma vírgula.\n",
"\n",
"<br/> Exemplo.\n",
"<br/> Se as seguintes senhas são dadas como entrada para o programa:\n",
"<br/> ABd1234 @ 1, um F1 #, 2w3E *, 2We3345\n",
"<br/> Em seguida, a saída do programa deve ser:\n",
"<br/> ABd1234 @ 1"
]
},
{
"metadata": {
"id": "WwwlMFZuxpP6",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
},
{
"metadata": {
"id": "jYM-n1HqxpP8",
"colab_type": "text"
},
"cell_type": "markdown",
"source": [
"### Exe. 6\n",
"Um robô se move num plano partindo do ponto original (0,0). \n",
"O robô pode-se mover nas direções ACIMA, ABAIXO, ESQUERDA e DIREITA, tal que, em cada direção pode-se deslocar um número determinado de passos. \n",
"Por exemplo, podemos descrever o movimento do robô como:\n",
"<br/>UP 5\n",
"<br/>DOWN 3\n",
"<br/>ESQUERDA 3\n",
"<br/>RIGHT 2\n",
"<br/>Onde, os números após a direção são os passos. \n",
"\n",
"Escreva um programa para calcular a distância da posição atual após uma seqüência de movimento a partir do ponto original.\n",
"Se a distância for um float, basta imprimir o número inteiro mais próximo.\n",
"\n",
"<br/> Exemplo:\n",
"<br/> Se as seguintes tuplas são dadas como entrada para o programa:\n",
"<br/> [('UP',5),('DOWN',3),('ESQUERDA',3),('RIGHT',2)]\n",
"<br/> Em seguida, a saída do programa deve ser:\n",
"<br/> 3"
]
},
{
"metadata": {
"id": "MeAF6pk5xpP8",
"colab_type": "code",
"colab": {}
},
"cell_type": "code",
"source": [
"#inserir tua solução aqui"
],
"execution_count": 0,
"outputs": []
}
]
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment