Logica de programação- While.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1 - Faça um programa que peça uma nota, entre zero e dez. Mostre uma mensagem caso o valor seja inválido e continue pedindo até que o usuário informe um valor válido."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valor inválido!\n",
      "Valor inválido!\n",
      "Nota: 10.0\n"
     ]
    }
   ],
   "source": [
    "nota = float(input('Digite uma nota: '))\n",
    "\n",
    "while nota not in range(0,11):\n",
    "    print('Valor inválido!')\n",
    "    nota = float(input('Digite uma nota: '))\n",
    "\n",
    "print(f'Nota: {nota}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2  - Supondo que a população de um país A seja da ordem de 80000 habitantes com uma taxa anual de crescimento de 3% e que a população de B seja 200000 habitantes com uma taxa de crescimento de 1.5%. Faça um programa que calcule e escreva o número de anos necessários para que a população do país A ultrapasse ou iguale a população do país B, mantidas as taxas de crescimento.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O número de anos necessários para que a população do país A ultrapasse ou iguale a população do país B, mantidas as taxas de crescimento é 33 anos\n"
     ]
    }
   ],
   "source": [
    "pop_A = 80000\n",
    "tx_A = 0.03 ## Taxa de crescimento de A\n",
    "pop_B = 200000 \n",
    "tx_B = 0.0015\n",
    "\n",
    "ano = 0\n",
    "\n",
    "while pop_A <= pop_B:\n",
    "    pop_A += pop_A*tx_A\n",
    "    pop_B += pop_B*tx_B\n",
    "    ano+=1\n",
    "\n",
    "print(f'O número de anos necessários para que a população do país A ultrapasse ou iguale a população do país B, mantidas as taxas de crescimento é {ano} anos')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3 - 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 numero ele deseja ver a tabuada. A saída deve ser conforme o exemplo abaixo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tabuada do 5\n",
      "5x1 = 5\n",
      "5x2 = 10\n",
      "5x3 = 15\n",
      "5x4 = 20\n",
      "5x5 = 25\n",
      "5x6 = 30\n",
      "5x7 = 35\n",
      "5x8 = 40\n",
      "5x9 = 45\n",
      "5x10 = 50\n"
     ]
    }
   ],
   "source": [
    "multiplicando = int(input('Insira o multiplicando: '))\n",
    "multiplicador = 1\n",
    "\n",
    "print(f'Tabuada do {multiplicando}:')\n",
    "while multiplicador <= 10:\n",
    "    print(f'{multiplicando}x{multiplicador} = {multiplicador*multiplicando}')\n",
    "    multiplicador+=1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5 - Faça um programa que mostre todos os primos entre 1 e N sendo N um número inteiro fornecido pelo usuário. O programa deverá mostrar também o número de divisões que ele executou para encontrar os números primos. Serão avaliados o funcionamento, o estilo e o número de testes (divisões) executados.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Os números primos contidos no intervalo de 1 a 13 são: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]\n"
     ]
    }
   ],
   "source": [
    "n = int(input('Digite um número: '))\n",
    "primos = []\n",
    "\n",
    "for i in range(1, n+1):\n",
    "    if i%1 == 0 and i%i == 0:\n",
    "        primos.append(i)\n",
    "\n",
    "print(f'Os números primos contidos no intervalo de 1 a {n} são: {primos}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6 - O Sr. Manoel Joaquim possui uma grande loja de artigos de R$ 1,99, com cerca de 10 caixas. Para agilizar o cálculo de quanto cada cliente deve pagar ele desenvolveu um tabela que contém o número de itens que o cliente comprou e ao lado o valor da conta. Desta forma a atendente do caixa precisa apenas contar quantos itens o cliente está levando e olhar na tabela de preços. Você foi contratado para desenvolver o programa que monta esta tabela de preços, que conterá os preços de 1 até 50 produtos, conforme o exemplo abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Lojas Quase Dois - Tabela de preços\n",
    "1 - R$ 1.99\n",
    "2 - R$ 3.98\n",
    "...\n",
    "50 - R$ 99.50'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bem-vindo a loja do Sr. Manoel\n",
      "Tabela de preços: \n",
      "1 - R$ 1.99\n",
      "2 - R$ 3.98\n",
      "3 - R$ 5.97\n",
      "4 - R$ 7.96\n",
      "5 - R$ 9.95\n",
      "6 - R$ 11.94\n",
      "7 - R$ 13.93\n",
      "8 - R$ 15.92\n",
      "9 - R$ 17.91\n",
      "10 - R$ 19.90\n",
      "11 - R$ 21.89\n",
      "12 - R$ 23.88\n",
      "13 - R$ 25.87\n",
      "14 - R$ 27.86\n",
      "15 - R$ 29.85\n",
      "16 - R$ 31.84\n",
      "17 - R$ 33.83\n",
      "18 - R$ 35.82\n",
      "19 - R$ 37.81\n",
      "20 - R$ 39.80\n",
      "21 - R$ 41.79\n",
      "22 - R$ 43.78\n",
      "23 - R$ 45.77\n",
      "24 - R$ 47.76\n",
      "25 - R$ 49.75\n",
      "26 - R$ 51.74\n",
      "27 - R$ 53.73\n",
      "28 - R$ 55.72\n",
      "29 - R$ 57.71\n",
      "30 - R$ 59.70\n",
      "31 - R$ 61.69\n",
      "32 - R$ 63.68\n",
      "33 - R$ 65.67\n",
      "34 - R$ 67.66\n",
      "35 - R$ 69.65\n",
      "36 - R$ 71.64\n",
      "37 - R$ 73.63\n",
      "38 - R$ 75.62\n",
      "39 - R$ 77.61\n",
      "40 - R$ 79.60\n",
      "41 - R$ 81.59\n",
      "42 - R$ 83.58\n",
      "43 - R$ 85.57\n",
      "44 - R$ 87.56\n",
      "45 - R$ 89.55\n",
      "46 - R$ 91.54\n",
      "47 - R$ 93.53\n",
      "48 - R$ 95.52\n",
      "49 - R$ 97.51\n",
      "50 - R$ 99.50\n"
     ]
    }
   ],
   "source": [
    "print('Bem-vindo a loja do Sr. Manoel')\n",
    "print('Tabela de preços: ')\n",
    "\n",
    "item = 1\n",
    "preco = 1.99\n",
    "\n",
    "while item <= 50:\n",
    "    print(f'{item} - R$ {preco*item:.2f}')\n",
    "    item+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6 - O Sr. Manoel Joaquim acaba de adquirir uma panificadora e pretende implantar a metodologia da tabelinha, que já é um sucesso na sua loja de 1,99. Você foi contratado para desenvolver o programa que monta a tabela de preços de pães, de 1 até 50 pães, a partir do preço do pão informado pelo usuário, conforme o exemplo abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Preço do pão: R$ 0.18\n",
    "Panificadora Pão de Ontem - Tabela de preços\n",
    "1 - R$ 0.18\n",
    "2 - R$ 0.36\n",
    "...\n",
    "50 - R$ 9.00'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bem-vindo a padaria do Sr. Manoel\n",
      "1 - R$ 0.18\n",
      "2 - R$ 0.36\n",
      "3 - R$ 0.54\n",
      "4 - R$ 0.72\n",
      "5 - R$ 0.90\n",
      "6 - R$ 1.08\n",
      "7 - R$ 1.26\n",
      "8 - R$ 1.44\n",
      "9 - R$ 1.62\n",
      "10 - R$ 1.80\n",
      "11 - R$ 1.98\n",
      "12 - R$ 2.16\n",
      "13 - R$ 2.34\n",
      "14 - R$ 2.52\n",
      "15 - R$ 2.70\n",
      "16 - R$ 2.88\n",
      "17 - R$ 3.06\n",
      "18 - R$ 3.24\n",
      "19 - R$ 3.42\n",
      "20 - R$ 3.60\n",
      "21 - R$ 3.78\n",
      "22 - R$ 3.96\n",
      "23 - R$ 4.14\n",
      "24 - R$ 4.32\n",
      "25 - R$ 4.50\n",
      "26 - R$ 4.68\n",
      "27 - R$ 4.86\n",
      "28 - R$ 5.04\n",
      "29 - R$ 5.22\n",
      "30 - R$ 5.40\n",
      "31 - R$ 5.58\n",
      "32 - R$ 5.76\n",
      "33 - R$ 5.94\n",
      "34 - R$ 6.12\n",
      "35 - R$ 6.30\n",
      "36 - R$ 6.48\n",
      "37 - R$ 6.66\n",
      "38 - R$ 6.84\n",
      "39 - R$ 7.02\n",
      "40 - R$ 7.20\n",
      "41 - R$ 7.38\n",
      "42 - R$ 7.56\n",
      "43 - R$ 7.74\n",
      "44 - R$ 7.92\n",
      "45 - R$ 8.10\n",
      "46 - R$ 8.28\n",
      "47 - R$ 8.46\n",
      "48 - R$ 8.64\n",
      "49 - R$ 8.82\n",
      "50 - R$ 9.00\n"
     ]
    }
   ],
   "source": [
    "print('Bem-vindo a padaria do Sr. Manoel')\n",
    "preco_pao = float(input('Preço do pão: '))\n",
    "\n",
    "item = 1\n",
    "\n",
    "while item <= 50:\n",
    "    print(f'{item} - R$ {preco_pao*item:.2f}')\n",
    "    item+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7 - O Sr. Manoel Joaquim expandiu seus negócios para além dos negócios de 1,99 e agora possui uma loja de conveniências. Faça um programa que implemente uma caixa registradora rudimentar. O programa deverá receber um número desconhecido de valores referentes aos preços das mercadorias. Um valor zero deve ser informado pelo operador para indicar o final da compra. O programa deve então mostrar o total da compra e perguntar o valor em dinheiro que o cliente forneceu, para então calcular e mostrar o valor do troco. Após esta operação, o programa deverá voltar ao ponto inicial, para registrar a próxima compra. A saída deve ser conforme o exemplo abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Lojas Tabajara \\nProduto 1: R$ 2.20\\nProduto 2: R$ 5.80\\nProduto 3: R$ 0\\nTotal: R$ 9.00\\nDinheiro: R$ 20.00\\nTroco: R$ 11.00\\n...'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''Lojas Tabajara \n",
    "Produto 1: R$ 2.20\n",
    "Produto 2: R$ 5.80\n",
    "Produto 3: R$ 0\n",
    "Total: R$ 9.00\n",
    "Dinheiro: R$ 20.00\n",
    "Troco: R$ 11.00\n",
    "...'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lojas tabajara\n",
      "Produto 1: R$ 2.2\n",
      "Produto 2: R$ 5.8\n",
      "Produto 3: R$ 0.0\n",
      "Total: R$ 8.00\n",
      "Dinheiro: R$ 20.00 \n",
      "Troco: R$ 12.0\n"
     ]
    }
   ],
   "source": [
    "print('Lojas tabajara')\n",
    "\n",
    "preco_produto = 1\n",
    "total = 0\n",
    "troco = 0\n",
    "produto = 1\n",
    "\n",
    "while preco_produto != 0:\n",
    "\n",
    "    preco_produto = float(input(f'Digite o preço do produto {produto} '))\n",
    "    print(f'Produto {produto}: R$ {preco_produto}')\n",
    "    produto +=1\n",
    "    total += preco_produto\n",
    "\n",
    "dinheiro = float(input('Digite o dinheiro inserido pelo cliente: '))\n",
    "\n",
    "print(f'Total: R$ {total:.2f}')\n",
    "print(f'Dinheiro: R$ {dinheiro:.2f} ')\n",
    "print(f'Troco: R$ {dinheiro-total}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8 - Faça um programa que receba o valor de uma dívida e mostre uma tabela com os seguintes dados: valor da dívida, valor dos juros, quantidade de parcelas e valor da parcela."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Os juros e a quantidade de parcelas seguem a tabela abaixo:\n",
    "\n",
    "Quantidade de Parcelas  % de Juros sobre o valor inicial da dívida\n",
    "1       0\n",
    "3       10\n",
    "6       15\n",
    "9       20\n",
    "12      25\n",
    "\n",
    "Exemplo de saída do programa:\n",
    "\n",
    "Valor da Dívida Valor dos Juros Quantidade de Parcelas  Valor da Parcela\n",
    "R$ 1.000,00     0               1                       R$  1.000,00\n",
    "R$ 1.100,00     100             3                       R$    366,00\n",
    "R$ 1.150,00     150             6                       R$    191,67'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valor divida \t Valor dos juros \t Quantidade de Parcelas \t Valor da Parcela\n",
      "R$ 1000.00        \t 0               \t 1                     \t R$  1000.0\n",
      "R$ 1000.00        \t 100.0                \t 3                  \t R$  366.67\n",
      "R$ 1000.00        \t 150.0               \t 6                  \t R$ 191.67\n",
      "R$ 1000.00        \t 200.0               \t 9                  \t R$ 133.33\n",
      "R$ 1000.00        \t 250.0               \t 12                 \t R$  104.17\n"
     ]
    }
   ],
   "source": [
    "valor_divida = float(input('Digite o valor da dívida: '))\n",
    "\n",
    "print('Valor divida \\t Valor dos juros \\t Quantidade de Parcelas \\t Valor da Parcela')\n",
    "print(f'R$ {valor_divida:.2f}        \\t {0}               \\t 1                     \\t R$  {valor_divida}')\n",
    "print(f'R$ {valor_divida:.2f}        \\t {valor_divida*0.1}                \\t 3                  \\t R$  {(valor_divida+valor_divida*0.1)/3:.2f}')\n",
    "print(f'R$ {valor_divida:.2f}        \\t {valor_divida*0.15}               \\t 6                  \\t R$ {(valor_divida+valor_divida*0.15)/6:.2f}')\n",
    "print(f'R$ {valor_divida:.2f}        \\t {valor_divida*0.20}               \\t 9                  \\t R$ {(valor_divida+valor_divida*0.20)/9:.2f}')\n",
    "print(f'R$ {valor_divida:.2f}        \\t {valor_divida*0.25}               \\t 12                 \\t R$  {(valor_divida+valor_divida*0.25)/12:.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9 - O cardápio de uma lanchonete é o seguinte:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''O cardápio de uma lanchonete é o seguinte:\n",
    "Especificação   Código  Preço\n",
    "Cachorro Quente 100     R$ 1,20\n",
    "Bauru Simples   101     R$ 1,30\n",
    "Bauru com ovo   102     R$ 1,50\n",
    "Hambúrguer      103     R$ 1,20\n",
    "Cheeseburguer   104     R$ 1,30\n",
    "Refrigerante    105     R$ 1,00\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Faça um programa que leia o código dos itens pedidos e as quantidades desejadas. Calcule e mostre o valor a ser pago por item (preço * quantidade) e o total geral do pedido. Considere que o cliente deve informar quando o pedido deve ser encerrado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cardápio:\n",
      "Especificação   Código  Preço\n",
      "Cachorro Quente 100     R$ 1,20\n",
      "Bauru Simples   101     R$ 1,30\n",
      "Bauru com ovo   102     R$ 1,50\n",
      "Hambúrguer      103     R$ 1,20\n",
      "Cheeseburguer   104     R$ 1,30\n",
      "Refrigerante    105     R$ 1,00\n",
      "\n",
      "Produto 1 - R$ 2.4 \n",
      "Produto 2 - R$ 3.0 \n",
      "Produto 3 - R$ 3.5999999999999996 \n",
      "Total: R$ 9.0\n"
     ]
    }
   ],
   "source": [
    "cardapio = {100: 1.20,\n",
    "            101: 1.30,\n",
    "            102: 1.50,\n",
    "            103: 1.20,\n",
    "            104: 1.30,\n",
    "            105: 1.00}\n",
    "\n",
    "print('''Cardápio:\n",
    "Especificação   Código  Preço\n",
    "Cachorro Quente 100     R$ 1,20\n",
    "Bauru Simples   101     R$ 1,30\n",
    "Bauru com ovo   102     R$ 1,50\n",
    "Hambúrguer      103     R$ 1,20\n",
    "Cheeseburguer   104     R$ 1,30\n",
    "Refrigerante    105     R$ 1,00\n",
    "''')\n",
    "\n",
    "total_compra = 0\n",
    "produto = 1\n",
    "\n",
    "codigo = 1\n",
    "while codigo != 0:\n",
    "\n",
    "    codigo = int(input('Digite o código do pedido ou 0 para finalizar: '))\n",
    "    if  codigo != 0:\n",
    "        qtd = int(input('Digite a quantidade desejada: '))\n",
    "        valor = cardapio[codigo]*qtd\n",
    "        print(f'Produto {produto} - R$ {valor:2f} ')\n",
    "        total_compra += valor\n",
    "        produto+=1\n",
    "\n",
    "print(f'Total: R$ {total_compra}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10 - Desenvolver um programa para verificar a nota do aluno em uma prova com 10 questões, o programa deve perguntar ao aluno a resposta de cada questão e ao final comparar com o gabarito da prova e assim calcular o total de acertos e a nota (atribuir 1 ponto por resposta certa). Após cada aluno utilizar o sistema deve ser feita uma pergunta se outro aluno vai utilizar o sistema. Após todos os alunos terem respondido informar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Maior e Menor Acerto;\n",
    "Total de Alunos que utilizaram o sistema;\n",
    "A Média das Notas da Turma.\n",
    "\n",
    "Gabarito da Prova:\n",
    "\n",
    "01 - A\n",
    "02 - B\n",
    "03 - C\n",
    "04 - D\n",
    "05 - E\n",
    "06 - E\n",
    "07 - D\n",
    "08 - C\n",
    "09 - B\n",
    "10 - A'''"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.12 ('base')",
   "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.12"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "3a0de9df006df342b5e4296aedaeaf87f8585c794651fec65fd5881a82402807"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}