├── 01.ipynb
├── 02.ipynb
├── 03.ipynb
├── 04.ipynb
├── 05.ipynb
├── README.md
└── imgs
├── UOJ_1041.png
└── UOJ_1049_b.png
/01.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Primeiros passos\n",
8 | "\n",
9 | "O interpretador Python é um cara legal que gosta de conversar, mas ele é um pouco repetitivo..\n",
10 | "\n",
11 | "Os notebooks Jupyter se comunicam com o interpretador, mandando suas mensagens e mostrando as resposta que ele dá. \n",
12 | "\n",
13 | "Clique no botão de Play para executar a célula abaixo (ou selecione a célula e aperte Shift+Enter)."
14 | ]
15 | },
16 | {
17 | "cell_type": "code",
18 | "execution_count": null,
19 | "metadata": {},
20 | "outputs": [],
21 | "source": [
22 | "\"Oi Python!\""
23 | ]
24 | },
25 | {
26 | "cell_type": "markdown",
27 | "metadata": {},
28 | "source": [
29 | "## Melhorando a conversa com o interpretador\n",
30 | "\n",
31 | ">Se o interpretador apenas repete o que eu falo, pra que ele serve? 🤔\n",
32 | ">*, perguntou um aluno apressado.*\n",
33 | "\n",
34 | "O interpretador é mais sagaz do que parece. Teste as células abaixo:"
35 | ]
36 | },
37 | {
38 | "cell_type": "code",
39 | "execution_count": null,
40 | "metadata": {},
41 | "outputs": [],
42 | "source": [
43 | "\"Oi Python!\".upper()"
44 | ]
45 | },
46 | {
47 | "cell_type": "code",
48 | "execution_count": null,
49 | "metadata": {
50 | "scrolled": true
51 | },
52 | "outputs": [],
53 | "source": [
54 | "\"Oi Python!\".lower()"
55 | ]
56 | },
57 | {
58 | "cell_type": "code",
59 | "execution_count": null,
60 | "metadata": {},
61 | "outputs": [],
62 | "source": [
63 | "\"Oi Python!\" + \" Tudo bom?\""
64 | ]
65 | },
66 | {
67 | "cell_type": "code",
68 | "execution_count": null,
69 | "metadata": {},
70 | "outputs": [],
71 | "source": [
72 | "\"Oi Python!\".split()"
73 | ]
74 | },
75 | {
76 | "cell_type": "markdown",
77 | "metadata": {},
78 | "source": [
79 | "### Exercícios de fixação"
80 | ]
81 | },
82 | {
83 | "cell_type": "markdown",
84 | "metadata": {},
85 | "source": [
86 | "EF1 - Peça pra o interpretador dizer **\"Bom dia\"** com letras minúsculas. "
87 | ]
88 | },
89 | {
90 | "cell_type": "code",
91 | "execution_count": null,
92 | "metadata": {},
93 | "outputs": [],
94 | "source": []
95 | },
96 | {
97 | "cell_type": "markdown",
98 | "metadata": {},
99 | "source": [
100 | "EF2 - Peça pra o interpretador dizer **\"Boa tarde\"** com letras maiúsculas. "
101 | ]
102 | },
103 | {
104 | "cell_type": "code",
105 | "execution_count": null,
106 | "metadata": {},
107 | "outputs": [],
108 | "source": []
109 | },
110 | {
111 | "cell_type": "markdown",
112 | "metadata": {},
113 | "source": [
114 | "EF3 - Peça pra o interpretador dizer **\"Bom dia ou Boa tarde?\"**, sendo o **\"Bom dia\"** com letras maiúsculas e o **\"boa tarde\"** com letras minúsculas. "
115 | ]
116 | },
117 | {
118 | "cell_type": "code",
119 | "execution_count": null,
120 | "metadata": {},
121 | "outputs": [],
122 | "source": []
123 | },
124 | {
125 | "cell_type": "markdown",
126 | "metadata": {},
127 | "source": [
128 | "### Exercícios complementares"
129 | ]
130 | },
131 | {
132 | "cell_type": "markdown",
133 | "metadata": {},
134 | "source": [
135 | "EC1 - O que você acha que a opção `split()` significa para o interpretador? Dica -- pesquise no Google Translate."
136 | ]
137 | },
138 | {
139 | "cell_type": "markdown",
140 | "metadata": {},
141 | "source": [
142 | "*Escreva sua resposta aqui*"
143 | ]
144 | },
145 | {
146 | "cell_type": "markdown",
147 | "metadata": {},
148 | "source": [
149 | "A gente vai estudar o `split` com mais calma depois, mas por enquanto vamos ver um pouco sobre números."
150 | ]
151 | },
152 | {
153 | "cell_type": "markdown",
154 | "metadata": {},
155 | "source": [
156 | "## Trabalhando com números\n",
157 | "\n",
158 | "O interpretador Python também consegue lidar com números e operadores aritméticos, que podem ser usados para construir **expressões aritméticas**. \n",
159 | "\n",
160 | "As regras básicas sobre expressões aritméticas em Python são:\n",
161 | "\n",
162 | "* Em geral, a precedência dos operadores em Python segue a precedência que conhecemos da matemática. \n",
163 | "* Assim como na matemática, é possível usar parênteses para mudar a ordem de avaliação de uma expressão.\n",
164 | "* Caso reste apenas operações de mesma precedência, a expressão passa a ser avaliada da esquerda para a direita.\n",
165 | "\n",
166 | "Alguns dos operadores aritméticos disponíveis em Python estão listados abaixo. "
167 | ]
168 | },
169 | {
170 | "cell_type": "markdown",
171 | "metadata": {},
172 | "source": [
173 | "| Símbolo | Operação |\n",
174 | "|:----:|---|\n",
175 | "| + | Adição |\n",
176 | "| - | Subtração |\n",
177 | "| / | Divisão |\n",
178 | "| // | Divisão inteira |\n",
179 | "| % | Resto |\n",
180 | "| * | Multiplicação |\n",
181 | "| ** | Exponenciação |"
182 | ]
183 | },
184 | {
185 | "cell_type": "markdown",
186 | "metadata": {},
187 | "source": [
188 | "Teste as células abaixo:"
189 | ]
190 | },
191 | {
192 | "cell_type": "code",
193 | "execution_count": null,
194 | "metadata": {},
195 | "outputs": [],
196 | "source": [
197 | "1+2+5"
198 | ]
199 | },
200 | {
201 | "cell_type": "code",
202 | "execution_count": null,
203 | "metadata": {},
204 | "outputs": [],
205 | "source": [
206 | "2-1"
207 | ]
208 | },
209 | {
210 | "cell_type": "code",
211 | "execution_count": null,
212 | "metadata": {},
213 | "outputs": [],
214 | "source": [
215 | "1*2"
216 | ]
217 | },
218 | {
219 | "cell_type": "code",
220 | "execution_count": null,
221 | "metadata": {
222 | "scrolled": true
223 | },
224 | "outputs": [],
225 | "source": [
226 | "3/4"
227 | ]
228 | },
229 | {
230 | "cell_type": "code",
231 | "execution_count": null,
232 | "metadata": {},
233 | "outputs": [],
234 | "source": [
235 | "2 ** 3"
236 | ]
237 | },
238 | {
239 | "cell_type": "markdown",
240 | "metadata": {},
241 | "source": [
242 | "No entanto, você não deve misturar textos e números:"
243 | ]
244 | },
245 | {
246 | "cell_type": "code",
247 | "execution_count": null,
248 | "metadata": {
249 | "scrolled": true
250 | },
251 | "outputs": [],
252 | "source": [
253 | "\"Este é um texto\" + 3"
254 | ]
255 | },
256 | {
257 | "cell_type": "markdown",
258 | "metadata": {},
259 | "source": [
260 | "### Exercícios de fixação"
261 | ]
262 | },
263 | {
264 | "cell_type": "markdown",
265 | "metadata": {},
266 | "source": [
267 | "EF4 - Calcule o produto dos números 11 e 12."
268 | ]
269 | },
270 | {
271 | "cell_type": "code",
272 | "execution_count": null,
273 | "metadata": {},
274 | "outputs": [],
275 | "source": []
276 | },
277 | {
278 | "cell_type": "markdown",
279 | "metadata": {},
280 | "source": [
281 | "EF5 - Calcule o quadrado do número 16."
282 | ]
283 | },
284 | {
285 | "cell_type": "code",
286 | "execution_count": null,
287 | "metadata": {},
288 | "outputs": [],
289 | "source": []
290 | },
291 | {
292 | "cell_type": "markdown",
293 | "metadata": {},
294 | "source": [
295 | "EF6 - Calcule a raiz quadrada de 1024."
296 | ]
297 | },
298 | {
299 | "cell_type": "code",
300 | "execution_count": null,
301 | "metadata": {},
302 | "outputs": [],
303 | "source": []
304 | },
305 | {
306 | "cell_type": "markdown",
307 | "metadata": {},
308 | "source": [
309 | "### Exercícios complementares\n",
310 | "\n",
311 | "Os operadores // e % trabalham com divisão inteira. Por exemplo, dividir 15 por 10 considerando apenas número inteiros é igual a 1. O resto da divisão é igual a 15 - (10*1), ou seja, 5."
312 | ]
313 | },
314 | {
315 | "cell_type": "code",
316 | "execution_count": null,
317 | "metadata": {
318 | "scrolled": true
319 | },
320 | "outputs": [],
321 | "source": [
322 | "15//10"
323 | ]
324 | },
325 | {
326 | "cell_type": "code",
327 | "execution_count": null,
328 | "metadata": {
329 | "scrolled": true
330 | },
331 | "outputs": [],
332 | "source": [
333 | "15%10"
334 | ]
335 | },
336 | {
337 | "cell_type": "markdown",
338 | "metadata": {},
339 | "source": [
340 | "EC2 - Calcule o resto da divisão de 227 por 20."
341 | ]
342 | },
343 | {
344 | "cell_type": "code",
345 | "execution_count": null,
346 | "metadata": {},
347 | "outputs": [],
348 | "source": []
349 | },
350 | {
351 | "cell_type": "markdown",
352 | "metadata": {},
353 | "source": [
354 | "# Valores, nomes e variáveis"
355 | ]
356 | },
357 | {
358 | "cell_type": "markdown",
359 | "metadata": {},
360 | "source": [
361 | "Em Python, tanto textos como números são chamados de *valores*. \n",
362 | "\n",
363 | "Podemos nos referir a valores usando *nomes*. \n",
364 | "\n",
365 | ">Em outras linguagens, usa-se o termo **variável** em vez de nome. Vamos adotar este termo aqui por ele ser mais universal.\n",
366 | "\n",
367 | "Teste as células abaixo:"
368 | ]
369 | },
370 | {
371 | "cell_type": "code",
372 | "execution_count": null,
373 | "metadata": {
374 | "scrolled": true
375 | },
376 | "outputs": [],
377 | "source": [
378 | "x = 2 # qualquer coisa após o # é um comentário\n",
379 | "y = 5\n",
380 | "x + y"
381 | ]
382 | },
383 | {
384 | "cell_type": "markdown",
385 | "metadata": {},
386 | "source": [
387 | "Múltiplas variáveis podem estar associadas ao mesmo valor."
388 | ]
389 | },
390 | {
391 | "cell_type": "code",
392 | "execution_count": null,
393 | "metadata": {},
394 | "outputs": [],
395 | "source": [
396 | "x = y = 1\n",
397 | "y"
398 | ]
399 | },
400 | {
401 | "cell_type": "code",
402 | "execution_count": null,
403 | "metadata": {},
404 | "outputs": [],
405 | "source": [
406 | "texto = 'Este é um texto.' # textos podem ser escritos entre aspas simples\n",
407 | "texto"
408 | ]
409 | },
410 | {
411 | "cell_type": "code",
412 | "execution_count": null,
413 | "metadata": {},
414 | "outputs": [],
415 | "source": [
416 | "outro_texto = \"Este é outro texto.\" # textos podem ser escritos entre aspas duplas\n",
417 | "outro_texto"
418 | ]
419 | },
420 | {
421 | "cell_type": "markdown",
422 | "metadata": {},
423 | "source": [
424 | "### Exercícios de fixação\n",
425 | "\n",
426 | "Para verificar que seu código está correto, lembre-se de acrescentar uma linha contendo apenas o nome da variável para visualizar o valor associado a ela."
427 | ]
428 | },
429 | {
430 | "cell_type": "markdown",
431 | "metadata": {},
432 | "source": [
433 | "EF7 - Associe uma variável `numero` ao número `10`."
434 | ]
435 | },
436 | {
437 | "cell_type": "code",
438 | "execution_count": null,
439 | "metadata": {},
440 | "outputs": [],
441 | "source": []
442 | },
443 | {
444 | "cell_type": "markdown",
445 | "metadata": {},
446 | "source": [
447 | "EF8 - Associe uma variável `nome` ao texto `Python`."
448 | ]
449 | },
450 | {
451 | "cell_type": "code",
452 | "execution_count": null,
453 | "metadata": {},
454 | "outputs": [],
455 | "source": []
456 | },
457 | {
458 | "cell_type": "markdown",
459 | "metadata": {},
460 | "source": [
461 | "EF9 - Associe uma variável `resto` ao resultado do operação de resto entre `234` e `10`."
462 | ]
463 | },
464 | {
465 | "cell_type": "code",
466 | "execution_count": null,
467 | "metadata": {},
468 | "outputs": [],
469 | "source": []
470 | },
471 | {
472 | "cell_type": "markdown",
473 | "metadata": {},
474 | "source": [
475 | "EF10 - Associe uma variável `k` ao valor `8`. Associe uma variável `quadrado_k` ao quadrado do valor associado à variável `k`."
476 | ]
477 | },
478 | {
479 | "cell_type": "code",
480 | "execution_count": null,
481 | "metadata": {},
482 | "outputs": [],
483 | "source": []
484 | },
485 | {
486 | "cell_type": "markdown",
487 | "metadata": {},
488 | "source": [
489 | "EF11 - Associe uma váriavel `z` ao valor `256`. Associe uma variável `divisao_zk` ao resultado da divisão entre os valores associados às variáveis `z` e `k`."
490 | ]
491 | },
492 | {
493 | "cell_type": "code",
494 | "execution_count": null,
495 | "metadata": {},
496 | "outputs": [],
497 | "source": []
498 | },
499 | {
500 | "cell_type": "markdown",
501 | "metadata": {},
502 | "source": [
503 | "## Dados informados pelo usuário"
504 | ]
505 | },
506 | {
507 | "cell_type": "markdown",
508 | "metadata": {},
509 | "source": [
510 | "O procedimento `input()` solicita ao usuário dados que podem ser associados a variáveis. É possível personalizar a mensagem de solicitação, como mostrado abaixo."
511 | ]
512 | },
513 | {
514 | "cell_type": "code",
515 | "execution_count": null,
516 | "metadata": {},
517 | "outputs": [],
518 | "source": [
519 | "texto_usuario = input(\"Diga um valor: \")\n",
520 | "texto_usuario"
521 | ]
522 | },
523 | {
524 | "cell_type": "markdown",
525 | "metadata": {},
526 | "source": [
527 | "Por padrão, qualquer dado passada pelo usuário será tratado como texto. Para tratá-lo como um valor numérico, você deve usar os procedimentos `int()` ou `float()`, dependendo de serem números inteiros ou reais."
528 | ]
529 | },
530 | {
531 | "cell_type": "code",
532 | "execution_count": null,
533 | "metadata": {},
534 | "outputs": [],
535 | "source": [
536 | "inteiro = int(input(\"Diga um valor inteiro: \"))\n",
537 | "inteiro + 1"
538 | ]
539 | },
540 | {
541 | "cell_type": "code",
542 | "execution_count": null,
543 | "metadata": {},
544 | "outputs": [],
545 | "source": [
546 | "real = float(input(\"Diga um valor real: \"))\n",
547 | "real + 1"
548 | ]
549 | },
550 | {
551 | "cell_type": "markdown",
552 | "metadata": {},
553 | "source": [
554 | "### Exercícios de fixação"
555 | ]
556 | },
557 | {
558 | "cell_type": "markdown",
559 | "metadata": {},
560 | "source": [
561 | "EF12 - Solicite ao usuário *seu nome* e o associe a uma variavél chamada `nome`."
562 | ]
563 | },
564 | {
565 | "cell_type": "code",
566 | "execution_count": null,
567 | "metadata": {},
568 | "outputs": [],
569 | "source": []
570 | },
571 | {
572 | "cell_type": "markdown",
573 | "metadata": {},
574 | "source": [
575 | "EF13 - Solicite ao usuário *sua idade* e a associe a uma variável chamada `idade`."
576 | ]
577 | },
578 | {
579 | "cell_type": "code",
580 | "execution_count": null,
581 | "metadata": {},
582 | "outputs": [],
583 | "source": []
584 | },
585 | {
586 | "cell_type": "markdown",
587 | "metadata": {},
588 | "source": [
589 | "EF14 - Solicite ao usuário *sua altura* e a associe a uma variável chamada `altura`."
590 | ]
591 | },
592 | {
593 | "cell_type": "code",
594 | "execution_count": null,
595 | "metadata": {},
596 | "outputs": [],
597 | "source": []
598 | },
599 | {
600 | "cell_type": "markdown",
601 | "metadata": {},
602 | "source": [
603 | "## Informando dados ao usuário"
604 | ]
605 | },
606 | {
607 | "cell_type": "markdown",
608 | "metadata": {},
609 | "source": [
610 | "Assim como é possível receber dados do usuário, também é possível informar dados ao usuário.\n",
611 | "\n",
612 | "Para isto, usamos o procedimento `print()`."
613 | ]
614 | },
615 | {
616 | "cell_type": "code",
617 | "execution_count": null,
618 | "metadata": {},
619 | "outputs": [],
620 | "source": [
621 | "print(texto)"
622 | ]
623 | },
624 | {
625 | "cell_type": "markdown",
626 | "metadata": {},
627 | "source": [
628 | "É possível informar os valores associados a múltiplas variáveis com uma única chamada ao procedimento `print()`. "
629 | ]
630 | },
631 | {
632 | "cell_type": "code",
633 | "execution_count": null,
634 | "metadata": {},
635 | "outputs": [],
636 | "source": [
637 | "print(texto, x)"
638 | ]
639 | },
640 | {
641 | "cell_type": "markdown",
642 | "metadata": {},
643 | "source": [
644 | "Também é possível informar textos, valores e o resultado de expressões:"
645 | ]
646 | },
647 | {
648 | "cell_type": "code",
649 | "execution_count": null,
650 | "metadata": {},
651 | "outputs": [],
652 | "source": [
653 | "print(\"Testando\", 3, x + y)"
654 | ]
655 | },
656 | {
657 | "cell_type": "markdown",
658 | "metadata": {},
659 | "source": [
660 | "### Exercícios de fixação"
661 | ]
662 | },
663 | {
664 | "cell_type": "markdown",
665 | "metadata": {},
666 | "source": [
667 | "EF15 - Informe ao usuário **seu nome**."
668 | ]
669 | },
670 | {
671 | "cell_type": "code",
672 | "execution_count": null,
673 | "metadata": {},
674 | "outputs": [],
675 | "source": []
676 | },
677 | {
678 | "cell_type": "markdown",
679 | "metadata": {},
680 | "source": [
681 | "EF16 - Informe ao usuário **sua idade**."
682 | ]
683 | },
684 | {
685 | "cell_type": "code",
686 | "execution_count": null,
687 | "metadata": {},
688 | "outputs": [],
689 | "source": []
690 | },
691 | {
692 | "cell_type": "markdown",
693 | "metadata": {},
694 | "source": [
695 | "EF17 - Informe ao usuário **seu índice de massa corporal (IMC)**. Para isso, solicite ao usuário seu peso."
696 | ]
697 | },
698 | {
699 | "cell_type": "code",
700 | "execution_count": null,
701 | "metadata": {},
702 | "outputs": [],
703 | "source": []
704 | },
705 | {
706 | "cell_type": "markdown",
707 | "metadata": {},
708 | "source": [
709 | "## Exercícios do URI"
710 | ]
711 | },
712 | {
713 | "cell_type": "markdown",
714 | "metadata": {},
715 | "source": [
716 | "O URI é um juiz online utilizado em treinamentos para competições de programação.\n",
717 | "\n",
718 | "Nesta disciplina, utilizaremos exercícios inspirados na seção **Iniciante**, adaptados para o nosso contexto.\n",
719 | "\n",
720 | "Para ver a descrição do exercício em sua versão original do URI, clique no seu número."
721 | ]
722 | },
723 | {
724 | "cell_type": "markdown",
725 | "metadata": {},
726 | "source": [
727 | "[1008](https://www.urionlinejudge.com.br/judge/pt/problems/view/1008) - Um sistema do setor de recursos humanos de uma empresa deve calcular o salário a ser pago para cada funcionário da empresa em função de quantas horas o funcionário trabalhou no mês e de quanto ele recebe por hora trabalhada.\n",
728 | "\n",
729 | "Escreva um código Python que leia o nome de um funcionário, seu número de horas trabalhadas, o valor que recebe por hora e calcula seu salário. Em seguida, mostre o nome e o salário do funcionário."
730 | ]
731 | },
732 | {
733 | "cell_type": "markdown",
734 | "metadata": {},
735 | "source": [
736 | "|.| Entrada | Saída |\n",
737 | "|-|----|---|\n",
738 | "| *Exemplo 1* | João 100 5.50 | João 550.00 | \n",
739 | "| *Exemplo 2* | Maria 200 20.50 | Maria 4100.00 |\n",
740 | "| *Exemplo 3* | Facebookson 145 15.55 | Facebookson 2254.75 |"
741 | ]
742 | },
743 | {
744 | "cell_type": "code",
745 | "execution_count": null,
746 | "metadata": {},
747 | "outputs": [],
748 | "source": []
749 | },
750 | {
751 | "cell_type": "markdown",
752 | "metadata": {},
753 | "source": [
754 | "[1009](https://www.urionlinejudge.com.br/judge/pt/problems/view/1009) - No caso de empresas do setor de comércio, a remuneração mensal de cada vendedor é composta por um salário fixo mais uma bonificação proporcional às vendas efetuadas pelo vendedor naquele mês.\n",
755 | "\n",
756 | "Escreva um código Python que leia o nome de um vendedor, o seu salário fixo e o total de vendas efetuadas por ele no mês (em dinheiro). Sabendo que este vendedor ganha 15% de comissão sobre suas vendas efetuadas, informe o total que ele deverá receber no final do mês."
757 | ]
758 | },
759 | {
760 | "cell_type": "markdown",
761 | "metadata": {},
762 | "source": [
763 | "|.| Entrada | Saída |\n",
764 | "|-|----|---|\n",
765 | "| *Exemplo 1* | João 500 1230.30 | João 684.54 | \n",
766 | "| *Exemplo 2* | Pedro 700 0.00 | Pedro 700.00 |\n",
767 | "| *Exemplo 3* | Mangojata 1700 1230.50 | Mangojata 1884.58 |"
768 | ]
769 | },
770 | {
771 | "cell_type": "code",
772 | "execution_count": null,
773 | "metadata": {},
774 | "outputs": [],
775 | "source": []
776 | },
777 | {
778 | "cell_type": "markdown",
779 | "metadata": {},
780 | "source": [
781 | "[1010](https://www.urionlinejudge.com.br/judge/pt/problems/view/1010) - Outro tipo de sistema utilizado no setor de comércio é o sistema de frente de loja, que calcula o total de uma venda baseado nos itens adquiridos, suas quantidades e seus valores unitários.\n",
782 | "\n",
783 | "Escreva um código Python que leia as informações de dois produtos adquiridos em uma compra e informe o valor a ser pago. Para cada produto, leia seu código, sua quantidade e seu valor unitário."
784 | ]
785 | },
786 | {
787 | "cell_type": "markdown",
788 | "metadata": {},
789 | "source": [
790 | "|.| Entrada | Saída |\n",
791 | "|-|----|---|\n",
792 | "| *Exemplo 1* | 12 1 5.30
16 2 5.10 | VALOR A PAGAR: 15.50 |\n",
793 | "| *Exemplo 2* | 13 2 15.30
161 4 5.20 | VALOR A PAGAR: 51.40 |\n",
794 | "| *Exemplo 3* | 1 1 15.10
2 1 15.10 | VALOR A PAGAR: 30.20 |"
795 | ]
796 | },
797 | {
798 | "cell_type": "code",
799 | "execution_count": null,
800 | "metadata": {},
801 | "outputs": [],
802 | "source": []
803 | },
804 | {
805 | "cell_type": "markdown",
806 | "metadata": {},
807 | "source": [
808 | "[1018](https://www.urionlinejudge.com.br/judge/pt/problems/view/1018) - Sistemas de frente de loja também devem auxiliar vendedores a dar trocos. Por simplicidade, vamos considerar primeiro apenas trocos inteiros, que podem ser dados usando apenas cédulas.\n",
809 | "\n",
810 | "Escreva um código Python que leia um valor de troco e informe quantas cédulas de cada valor devem ser entregues pelo vendedor ao cliente.\n",
811 | "\n",
812 | "**Obs.:** Considere que ainda existem notas de R$ 1,00."
813 | ]
814 | },
815 | {
816 | "cell_type": "markdown",
817 | "metadata": {},
818 | "source": [
819 | "|.| Entrada | Saída |\n",
820 | "|-|----|---|\n",
821 | "| *Exemplo 1* | 576 | 5 nota(s) de 100,00
1 nota(s) de 50,00
1 nota(s) de 20,00
0 nota(s) de 10,00
1 nota(s) de 5,00
0 nota(s) de 2,00
1 nota(s) de 1,00 |\n",
822 | "| *Exemplo 2* | 11257 | 112 nota(s) de 100,00
1 nota(s) de 50,00
0 nota(s) de 20,00
0 nota(s) de 10,00
1 nota(s) de 5,00
1 nota(s) de 2,00
0 nota(s) de 1,00 |\n",
823 | "| *Exemplo 3* | 503 | 5 nota(s) de 100,00
0 nota(s) de 50,00
0 nota(s) de 20,00
0 nota(s) de 10,00
0 nota(s) de 5,00
1 nota(s) de 2,00
1 nota(s) de 1,00 |"
824 | ]
825 | },
826 | {
827 | "cell_type": "code",
828 | "execution_count": null,
829 | "metadata": {
830 | "scrolled": true
831 | },
832 | "outputs": [],
833 | "source": []
834 | },
835 | {
836 | "cell_type": "markdown",
837 | "metadata": {},
838 | "source": [
839 | "[1021](https://www.urionlinejudge.com.br/judge/pt/problems/view/1021) - Agora vamos voltar ao mundo real, onde trocos podem precisar utilizar cédulas e moedas.\n",
840 | "\n",
841 | "Escreva um código Python que leia um valor de troco e informe quantas cédulas e moedas de cada valor devem ser entregues pelo vendedor ao cliente.\n",
842 | "\n",
843 | "**Obs.:** Considere que ainda existem moedas de R$ 0,01."
844 | ]
845 | },
846 | {
847 | "cell_type": "markdown",
848 | "metadata": {},
849 | "source": [
850 | "|.| Entrada | Saída |\n",
851 | "|-|----|---|\n",
852 | "| *Exemplo 1* | 576.73 | NOTAS:
5 nota(s) de 100,00
1 nota(s) de 50,00
1 nota(s) de 20,00
0 nota(s) de 10,00
1 nota(s) de 5,00
0 nota(s) de 2,00
MOEDAS:
1 moeda(s) de 1,00
1 moeda(s) de 0,50
0 moeda(s) de 0,25
2 moeda(s) de 0,10
0 moeda(s) de 0,05
3 moeda(s) de 0,01 |\n",
853 | "| *Exemplo 2* | 4.00 | NOTAS:
0 nota(s) de 100,00
0 nota(s) de 50,00
0 nota(s) de 20,00
0 nota(s) de 10,00
0 nota(s) de 5,00
2 nota(s) de 2,00
MOEDAS:
0 moeda(s) de 1,00
0 moeda(s) de 0,50
0 moeda(s) de 0,25
0 moeda(s) de 0,10
0 moeda(s) de 0,05
0 moeda(s) de 0,01 |\n",
854 | "| *Exemplo 3* | 91.01 | NOTAS:
0 nota(s) de 100,00
1 nota(s) de 50,00
2 nota(s) de 20,00
0 nota(s) de 10,00
0 nota(s) de 5,00
0 nota(s) de 2,00
MOEDAS:
1 moeda(s) de 1,00
0 moeda(s) de 0,50
0 moeda(s) de 0,25
0 moeda(s) de 0,10
0 moeda(s) de 0,05
1 moeda(s) de 0,01 |"
855 | ]
856 | },
857 | {
858 | "cell_type": "code",
859 | "execution_count": null,
860 | "metadata": {},
861 | "outputs": [],
862 | "source": []
863 | },
864 | {
865 | "cell_type": "markdown",
866 | "metadata": {},
867 | "source": [
868 | "[1019](https://www.urionlinejudge.com.br/judge/pt/problems/view/1019) - Sistemas de frente de loja também precisam registrar a data e o horário das vendas. \n",
869 | "\n",
870 | "Computadores normalmente armazenam datas utilizando uma única unidade de tempo, convertendo para o formato de apresentação desejado quando necessário. Por simplicidade, considere neste exercício que o dado informado representa apenas o horário da venda.\n",
871 | "\n",
872 | "Escreva um código Python que leia um valor em segundos e o converta para o formato *horas:minutos:segundos*.\n",
873 | "\n",
874 | "**Dica 1 --** a opção sep do procedimento print() permite configurar o caracter de separação entre as diferentes partes de uma impressão, como no exemplo abaixo."
875 | ]
876 | },
877 | {
878 | "cell_type": "code",
879 | "execution_count": null,
880 | "metadata": {
881 | "scrolled": true
882 | },
883 | "outputs": [],
884 | "source": [
885 | "print(10,33,51,sep=\":\")"
886 | ]
887 | },
888 | {
889 | "cell_type": "markdown",
890 | "metadata": {},
891 | "source": [
892 | "**Dica 2 --** é possível utilizar o procedimento print para impressão formatada. Pesquise o funcionamento da máscara de formatação abaixo:"
893 | ]
894 | },
895 | {
896 | "cell_type": "code",
897 | "execution_count": null,
898 | "metadata": {},
899 | "outputs": [],
900 | "source": [
901 | "print(\"%02d:%02d:%02d\" % (9,33,51))"
902 | ]
903 | },
904 | {
905 | "cell_type": "markdown",
906 | "metadata": {},
907 | "source": [
908 | "|.| Entrada | Saída |\n",
909 | "|-|----|---|\n",
910 | "| *Exemplo 1* | 556 | 00:09:16 | \n",
911 | "| *Exemplo 2* | 1 | 00:00:01 |\n",
912 | "| *Exemplo 3* | 86153 | 23:55:53 |"
913 | ]
914 | }
915 | ],
916 | "metadata": {
917 | "kernelspec": {
918 | "display_name": "Python 3",
919 | "language": "python",
920 | "name": "python3"
921 | },
922 | "language_info": {
923 | "codemirror_mode": {
924 | "name": "ipython",
925 | "version": 3
926 | },
927 | "file_extension": ".py",
928 | "mimetype": "text/x-python",
929 | "name": "python",
930 | "nbconvert_exporter": "python",
931 | "pygments_lexer": "ipython3",
932 | "version": "3.6.7"
933 | }
934 | },
935 | "nbformat": 4,
936 | "nbformat_minor": 1
937 | }
938 |
--------------------------------------------------------------------------------
/02.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "\n",
8 | "Este notebook foi baseado nos notebooks disponíveis em [https://gitlab.erc.monash.edu.au/andrease/Python4Maths.git]\n",
9 | ""
10 | ]
11 | },
12 | {
13 | "cell_type": "markdown",
14 | "metadata": {},
15 | "source": [
16 | "# Comparando e decidindo\n",
17 | "\n",
18 | "Python permite comparar os valores associados a diferentes variáveis usando **operadores de comparação**. \n",
19 | "\n",
20 | "Expressões que contêm operadores de comparação são chamadas **expressões lógicas** e podem ser usadas em **estruturas de decisão** para decidir o que o seu código deve fazer. \n",
21 | "\n",
22 | "Neste roteiro, você aprenderá a utilizar estes conceitos da linguagem Python.\n",
23 | "\n",
24 | "## Operadores de comparação\n",
25 | "\n",
26 | "Operadores de comparação são utilizados para construir **expressões lógicas**. \n",
27 | "\n",
28 | "As regras básicas sobre expressões lógicas em Python são:\n",
29 | "\n",
30 | "* Expressões lógicas são avaliadas como verdadeiras (**True**) ou falsas (**False**).\n",
31 | "* Todos os operadores de comparação em Python têm precedência igual. \n",
32 | "* Assim como em expressões aritméticas, é possível usar parênteses para mudar a ordem de avaliação de uma expressão.\n",
33 | "* Caso haja empate de precedência, a expressão é avaliada da esquerda para a direita.\n",
34 | "\n",
35 | "Alguns dos operadores de comparação disponíveis em Python estão listados abaixo. "
36 | ]
37 | },
38 | {
39 | "cell_type": "markdown",
40 | "metadata": {},
41 | "source": [
42 | "| Símbolo | Significado |\n",
43 | "|:----:|---|\n",
44 | "| == | Igualdade |\n",
45 | "| != | Diferença |\n",
46 | "| < | Menor |\n",
47 | "| > | Maior |\n",
48 | "| <= | Menor ou igual |\n",
49 | "| >= | Maior ou igual |\n",
50 | "\n",
51 | "Note que é diferente usar `==` (comparação de igualdade) e `=` (associação de variável a valor)."
52 | ]
53 | },
54 | {
55 | "cell_type": "code",
56 | "execution_count": null,
57 | "metadata": {},
58 | "outputs": [],
59 | "source": [
60 | "z = 2\n",
61 | "z == 2"
62 | ]
63 | },
64 | {
65 | "cell_type": "code",
66 | "execution_count": null,
67 | "metadata": {},
68 | "outputs": [],
69 | "source": [
70 | "z > 2"
71 | ]
72 | },
73 | {
74 | "cell_type": "code",
75 | "execution_count": null,
76 | "metadata": {},
77 | "outputs": [],
78 | "source": [
79 | "z <= 2"
80 | ]
81 | },
82 | {
83 | "cell_type": "code",
84 | "execution_count": null,
85 | "metadata": {
86 | "scrolled": true
87 | },
88 | "outputs": [],
89 | "source": [
90 | "z != 2"
91 | ]
92 | },
93 | {
94 | "cell_type": "markdown",
95 | "metadata": {},
96 | "source": [
97 | "### Exercícios de fixação"
98 | ]
99 | },
100 | {
101 | "cell_type": "markdown",
102 | "metadata": {},
103 | "source": [
104 | "1 - Leia dois números inteiros e teste se o primeiro é menor do que o segundo."
105 | ]
106 | },
107 | {
108 | "cell_type": "code",
109 | "execution_count": null,
110 | "metadata": {
111 | "collapsed": true
112 | },
113 | "outputs": [],
114 | "source": []
115 | },
116 | {
117 | "cell_type": "markdown",
118 | "metadata": {},
119 | "source": [
120 | "2 - Sorteie dois números e teste se ambos são iguais.\n",
121 | "\n",
122 | "**Dica --** O procedimento **randint**(*menor*, *maior*) sorteia inteiros no intervalo entre menor e maior. Este procedimento não é um procedimento nativo do Python, por isso precisamos importá-lo do módulo **random**, que o fornece."
123 | ]
124 | },
125 | {
126 | "cell_type": "code",
127 | "execution_count": null,
128 | "metadata": {
129 | "scrolled": true
130 | },
131 | "outputs": [],
132 | "source": [
133 | "from random import randint\n",
134 | "randint(0,100)"
135 | ]
136 | },
137 | {
138 | "cell_type": "markdown",
139 | "metadata": {},
140 | "source": [
141 | "### Comparando textos"
142 | ]
143 | },
144 | {
145 | "cell_type": "markdown",
146 | "metadata": {},
147 | "source": [
148 | "Também é possível utilizar operadores de comparação para comparar textos:\n",
149 | "* A igualdade (==) e a diferença (!=) funcionam de forma trivial, assim como no caso dos valores numéricos.\n",
150 | "* As demais operações consideram a ordem alfabética.\n"
151 | ]
152 | },
153 | {
154 | "cell_type": "code",
155 | "execution_count": null,
156 | "metadata": {},
157 | "outputs": [],
158 | "source": [
159 | "nome = \"Stevejobsson\"\n",
160 | "nome == \"Stevejobsson\""
161 | ]
162 | },
163 | {
164 | "cell_type": "code",
165 | "execution_count": null,
166 | "metadata": {},
167 | "outputs": [],
168 | "source": [
169 | "nome != \"Facebookson\""
170 | ]
171 | },
172 | {
173 | "cell_type": "code",
174 | "execution_count": null,
175 | "metadata": {},
176 | "outputs": [],
177 | "source": [
178 | "'abc' < 'bbc'"
179 | ]
180 | },
181 | {
182 | "cell_type": "code",
183 | "execution_count": null,
184 | "metadata": {},
185 | "outputs": [],
186 | "source": [
187 | "'bbc' <= 'bbc'"
188 | ]
189 | },
190 | {
191 | "cell_type": "code",
192 | "execution_count": null,
193 | "metadata": {},
194 | "outputs": [],
195 | "source": [
196 | "'bbc' <= 'bac'"
197 | ]
198 | },
199 | {
200 | "cell_type": "markdown",
201 | "metadata": {},
202 | "source": [
203 | "### Exercícios de fixação"
204 | ]
205 | },
206 | {
207 | "cell_type": "markdown",
208 | "metadata": {},
209 | "source": [
210 | "3 - Leia dois nomes e teste se o primeiro é anterior ao segundo considerando a ordem alfabética."
211 | ]
212 | },
213 | {
214 | "cell_type": "code",
215 | "execution_count": null,
216 | "metadata": {
217 | "collapsed": true
218 | },
219 | "outputs": [],
220 | "source": []
221 | },
222 | {
223 | "cell_type": "markdown",
224 | "metadata": {},
225 | "source": [
226 | "4 - Teste se os textos \"Python\" e \"python\" são considerados idênticos."
227 | ]
228 | },
229 | {
230 | "cell_type": "code",
231 | "execution_count": null,
232 | "metadata": {},
233 | "outputs": [],
234 | "source": []
235 | },
236 | {
237 | "cell_type": "markdown",
238 | "metadata": {},
239 | "source": [
240 | "## Operadores lógicos"
241 | ]
242 | },
243 | {
244 | "cell_type": "markdown",
245 | "metadata": {},
246 | "source": [
247 | "É possível criar expressões lógicas mais complexas utilizando **operadores lógicos**.\n",
248 | "\n",
249 | "Os operadores lógicos mais simples do Python são os operadores E (**and**) e OU (**or**).\n",
250 | "\n",
251 | "As regras básicas sobre expressões que contenham operadores lógicos em Python são:\n",
252 | "\n",
253 | "* Operadores de comparação têm maior precedência que operadores lógicos.\n",
254 | "* O operador lógico **and** tem maior precedência que o operador **or**. \n",
255 | "* É possível usar parênteses para mudar a ordem de avaliação de uma expressão.\n",
256 | "* Caso reste apenas operações de mesma precedência, a expressão passa a ser avaliada da esquerda para a direita."
257 | ]
258 | },
259 | {
260 | "cell_type": "markdown",
261 | "metadata": {},
262 | "source": [
263 | "| Símbolo | Significado |\n",
264 | "|:----:|---|\n",
265 | "| **and** | **True**, desde que ambos os lados da expressão sejam verdadeiros |\n",
266 | "| **or** | **True**, desde que pelo menos um lado da expressão seja verdadeiro |"
267 | ]
268 | },
269 | {
270 | "cell_type": "code",
271 | "execution_count": null,
272 | "metadata": {},
273 | "outputs": [],
274 | "source": [
275 | "\"a\" < \"b\" and 5 >= 5"
276 | ]
277 | },
278 | {
279 | "cell_type": "code",
280 | "execution_count": null,
281 | "metadata": {},
282 | "outputs": [],
283 | "source": [
284 | "\"a\" <= \"b\" and 5 > 5"
285 | ]
286 | },
287 | {
288 | "cell_type": "code",
289 | "execution_count": null,
290 | "metadata": {},
291 | "outputs": [],
292 | "source": [
293 | "\"a\" <= \"b\" or 5 > 5"
294 | ]
295 | },
296 | {
297 | "cell_type": "markdown",
298 | "metadata": {},
299 | "source": [
300 | "### Exercícios de fixação"
301 | ]
302 | },
303 | {
304 | "cell_type": "markdown",
305 | "metadata": {},
306 | "source": [
307 | "5 - Leia um gênero e uma idade. Teste se esta combinação representa alguém em situação de obrigatoriedade militar.\n",
308 | "\n",
309 | "**Dica --** Em tempos de \"paz\", o serviço militar só é obrigatório para homens maiores de idade."
310 | ]
311 | },
312 | {
313 | "cell_type": "code",
314 | "execution_count": null,
315 | "metadata": {
316 | "collapsed": true
317 | },
318 | "outputs": [],
319 | "source": []
320 | },
321 | {
322 | "cell_type": "markdown",
323 | "metadata": {},
324 | "source": [
325 | "6 - Leia uma idade e teste se esta pessoa está obrigada a votar.\n",
326 | "\n",
327 | "**Dica --** Estão obrigados a votar pessoas entre 18 e 70 anos de idade."
328 | ]
329 | },
330 | {
331 | "cell_type": "code",
332 | "execution_count": null,
333 | "metadata": {
334 | "collapsed": true
335 | },
336 | "outputs": [],
337 | "source": []
338 | },
339 | {
340 | "cell_type": "markdown",
341 | "metadata": {},
342 | "source": [
343 | "7 - Leia uma idade e teste se para esta pessoa o voto é facultativo.\n",
344 | "\n",
345 | "**Dica --** O voto é facultativo para pessoas entre 16 e 18 anos ou acima dos 70 anos."
346 | ]
347 | },
348 | {
349 | "cell_type": "code",
350 | "execution_count": null,
351 | "metadata": {
352 | "collapsed": true
353 | },
354 | "outputs": [],
355 | "source": []
356 | },
357 | {
358 | "cell_type": "markdown",
359 | "metadata": {},
360 | "source": [
361 | "8 - Leia três inteiros e teste se o primeiro pertence ao intervalo delimitado pelos dois últimos.\n",
362 | "\n",
363 | "**Observação --** Por simplicidade, suponha que os dois últimos números estão ordenados de forma crescente."
364 | ]
365 | },
366 | {
367 | "cell_type": "code",
368 | "execution_count": null,
369 | "metadata": {
370 | "collapsed": true
371 | },
372 | "outputs": [],
373 | "source": []
374 | },
375 | {
376 | "cell_type": "markdown",
377 | "metadata": {},
378 | "source": [
379 | "### Estruturas de decisão"
380 | ]
381 | },
382 | {
383 | "cell_type": "markdown",
384 | "metadata": {},
385 | "source": [
386 | "A principal estrutura utilizada em Python para definir se um trecho de um código será executado é a estrutura **if**, ilustrada a seguir:\n",
387 | "\n",
388 | "```python\n",
389 | "if condicao:\n",
390 | " expressao\n",
391 | " expressao\n",
392 | " ...```"
393 | ]
394 | },
395 | {
396 | "cell_type": "markdown",
397 | "metadata": {},
398 | "source": [
399 | "As regras básicas para o uso da estrutura **if** em Python são:\n",
400 | "\n",
401 | "* O trecho de código delimitado por uma estrutura **if** é chamado bloco.\n",
402 | "* Um bloco é caracterizado pela *identação* de suas linhas. Assim, a quantidade de espaços no começo de cada linha é bastante importante no Python.\n",
403 | "* O bloco de uma estrutura **if** só é executado se sua condição for satisfeita. A condição é avaliada como uma expressão lógica."
404 | ]
405 | },
406 | {
407 | "cell_type": "code",
408 | "execution_count": null,
409 | "metadata": {},
410 | "outputs": [],
411 | "source": [
412 | "numero = int(input())\n",
413 | "if numero % 2 == 0:\n",
414 | " print(\"O número\", numero, \"é par.\")"
415 | ]
416 | },
417 | {
418 | "cell_type": "markdown",
419 | "metadata": {},
420 | "source": [
421 | "### Exercícios de fixação"
422 | ]
423 | },
424 | {
425 | "cell_type": "markdown",
426 | "metadata": {},
427 | "source": [
428 | "9 - Leia um inteiro e o imprima se ele for múltiplo de 3."
429 | ]
430 | },
431 | {
432 | "cell_type": "code",
433 | "execution_count": null,
434 | "metadata": {
435 | "collapsed": true
436 | },
437 | "outputs": [],
438 | "source": []
439 | },
440 | {
441 | "cell_type": "markdown",
442 | "metadata": {},
443 | "source": [
444 | "10 - Informe entradas para o código abaixo que façam a mensagem ser impressa."
445 | ]
446 | },
447 | {
448 | "cell_type": "code",
449 | "execution_count": null,
450 | "metadata": {},
451 | "outputs": [],
452 | "source": [
453 | "texto = input()\n",
454 | "numero = int(input())\n",
455 | "if texto < \"hello\" and numero ** 0.5 == 8:\n",
456 | " print(\"Mensagem impressa ;)\")"
457 | ]
458 | },
459 | {
460 | "cell_type": "markdown",
461 | "metadata": {},
462 | "source": [
463 | "### A estrutura ```if-else```"
464 | ]
465 | },
466 | {
467 | "cell_type": "markdown",
468 | "metadata": {},
469 | "source": [
470 | "Uma expansão da estrutura **if** é a estrutura **if-else**, que define trechos de código mutuamente exclusivos.\n",
471 | "\n",
472 | "```python\n",
473 | "if condicao:\n",
474 | " # bloco se a condição for satisfeita\n",
475 | " expressao\n",
476 | " ...\n",
477 | "else:\n",
478 | " # bloco se a condição não for satisfeita\n",
479 | " expressao\n",
480 | " ...\n",
481 | "```\n",
482 | "Ambos os blocos de uma estrutura **if-else** devem estar *identados*, de preferência pela mesma quantidade de espaços."
483 | ]
484 | },
485 | {
486 | "cell_type": "code",
487 | "execution_count": null,
488 | "metadata": {},
489 | "outputs": [],
490 | "source": [
491 | "numero = int(input())\n",
492 | "if numero % 2 == 0:\n",
493 | " print(\"O número\", numero, \"é par.\")\n",
494 | "else:\n",
495 | " print(\"O número\", numero, \"é ímpar.\")"
496 | ]
497 | },
498 | {
499 | "cell_type": "markdown",
500 | "metadata": {},
501 | "source": [
502 | "### Exercícios de fixação"
503 | ]
504 | },
505 | {
506 | "cell_type": "markdown",
507 | "metadata": {
508 | "collapsed": true
509 | },
510 | "source": [
511 | "11 - Leia um inteiro e informe se ele é ou não múltiplo de 6."
512 | ]
513 | },
514 | {
515 | "cell_type": "code",
516 | "execution_count": null,
517 | "metadata": {
518 | "collapsed": true
519 | },
520 | "outputs": [],
521 | "source": []
522 | },
523 | {
524 | "cell_type": "markdown",
525 | "metadata": {},
526 | "source": [
527 | "12 - Leia dois nomes de pessoas e os imprima em ordem alfabética."
528 | ]
529 | },
530 | {
531 | "cell_type": "code",
532 | "execution_count": null,
533 | "metadata": {
534 | "collapsed": true
535 | },
536 | "outputs": [],
537 | "source": []
538 | },
539 | {
540 | "cell_type": "markdown",
541 | "metadata": {},
542 | "source": [
543 | "### A estrutura ```if-elif-else```"
544 | ]
545 | },
546 | {
547 | "cell_type": "markdown",
548 | "metadata": {},
549 | "source": [
550 | "É possível utilizar a estrutura **if-elif-else** para especificar múltiplos fluxos de execução do algoritmo, em função de uma condição principal e de condições alternativas:\n",
551 | "\n",
552 | "```python\n",
553 | "if condicao_principal:\n",
554 | " # bloco se a condição principal for satisfeita\n",
555 | " expressao\n",
556 | " ...\n",
557 | "elif condicao_alternativa_1:\n",
558 | " # bloco se a condição principal não for satisfeita mas a condição alternativa 1 for\n",
559 | " expressao\n",
560 | " ...\n",
561 | "elif condicao_alternativa_2:\n",
562 | " # bloco se nem a condição principal nem a condição alternativa 1 forem satisfeitas, mas a condição alternativa 2 for\n",
563 | " expressao\n",
564 | " ...\n",
565 | "...\n",
566 | "else:\n",
567 | " # bloco se nem a condição principal nem as condições alternativas forem satisfeitas\n",
568 | " expressao\n",
569 | " ...\n",
570 | "\n",
571 | "```"
572 | ]
573 | },
574 | {
575 | "cell_type": "markdown",
576 | "metadata": {},
577 | "source": [
578 | "As regras básicas para o uso da estrutura **if-elif-else** em Python são:\n",
579 | "\n",
580 | "* O bloco **if** é executado se a condição principal for satisfeita.\n",
581 | "* Um bloco **elif** é executado se sua condição for satisfeita e as condições acima dele não forem. \n",
582 | "* O bloco **else** é executado se nenhuma condição for satisfeita.\n"
583 | ]
584 | },
585 | {
586 | "cell_type": "code",
587 | "execution_count": null,
588 | "metadata": {},
589 | "outputs": [],
590 | "source": [
591 | "from random import randint\n",
592 | "\n",
593 | "numero = randint(0,100)\n",
594 | "chute = int(input(\"Chute um número entre 0 e 100: \"))\n",
595 | "if chute == numero:\n",
596 | " print(\"Parabéns, você acertou!\")\n",
597 | "elif chute < numero:\n",
598 | " print(\"Seu chute foi menor que o número sorteado!\")\n",
599 | "else:\n",
600 | " print(\"Seu chute foi maior que o número sorteado!\")"
601 | ]
602 | },
603 | {
604 | "cell_type": "markdown",
605 | "metadata": {},
606 | "source": [
607 | "### Exercícios de fixação"
608 | ]
609 | },
610 | {
611 | "cell_type": "markdown",
612 | "metadata": {},
613 | "source": [
614 | "13 - Leia um número e teste se ele é positivo, negativo ou nulo."
615 | ]
616 | },
617 | {
618 | "cell_type": "code",
619 | "execution_count": null,
620 | "metadata": {
621 | "collapsed": true
622 | },
623 | "outputs": [],
624 | "source": []
625 | },
626 | {
627 | "cell_type": "markdown",
628 | "metadata": {},
629 | "source": [
630 | "### Combinando múltiplas estruturas de decisão"
631 | ]
632 | },
633 | {
634 | "cell_type": "markdown",
635 | "metadata": {},
636 | "source": [
637 | "Também é possível combinar estruturas de decisão em múltiplos níveis, o que é conhecido como **aninhar estruturas**.\n",
638 | "\n",
639 | "As regras básicas para aninhar estruturas de decisão em Python são:\n",
640 | "* Não há limite com relação a quantas estruturas e em quantos níveis.\n",
641 | "* Blocos de níveis mais profundos devem apresentar maior grau de identação. "
642 | ]
643 | },
644 | {
645 | "cell_type": "code",
646 | "execution_count": null,
647 | "metadata": {},
648 | "outputs": [],
649 | "source": [
650 | "from random import randint\n",
651 | "\n",
652 | "numero = randint(0,100)\n",
653 | "if numero % 6 == 0:\n",
654 | " print(\"O número\", numero, \"é múltiplo de 6!\")\n",
655 | "else:\n",
656 | " if numero % 2 == 0:\n",
657 | " print(\"O número\", numero, \"é múltiplo de 2, mas não de 3!\")\n",
658 | " elif numero % 3 == 0:\n",
659 | " print(\"O número\", numero, \"é múltiplo de 3, mas não de 2!\")\n",
660 | " else:\n",
661 | " print(\"O número\", numero, \"não é multiplo de 2 nem de 3, muito menos de 6!\")"
662 | ]
663 | },
664 | {
665 | "cell_type": "markdown",
666 | "metadata": {
667 | "collapsed": true
668 | },
669 | "source": [
670 | "## Exercícios do URI"
671 | ]
672 | },
673 | {
674 | "cell_type": "markdown",
675 | "metadata": {
676 | "collapsed": true
677 | },
678 | "source": [
679 | "[1037](https://www.urionlinejudge.com.br/judge/pt/problems/view/1037) - Um histograma é um tipo de gráfico estatístico que particiona os dados disponíveis em subgrupos e informa quantos elementos existem em cada subgrupo.\n",
680 | "\n",
681 | "Escreva um código Python que possa ser usado para construir um histograma de um conjunto de números inteiros sorteados no intervalo [0,100), isto é, valores maiores ou iguais a 0 e menores que 100. \n",
682 | "\n",
683 | "Por simplicidade, considere que apenas um número será sorteado. Você deve identificar a qual dos intervalos a seguir este número pertence: [0,25), [25,50), [50,75), [75,100). "
684 | ]
685 | },
686 | {
687 | "cell_type": "markdown",
688 | "metadata": {},
689 | "source": [
690 | "|.| Entrada | Saída |\n",
691 | "|-|:----:|---|\n",
692 | "| *Exemplo 1* | 5 | [0,25) | \n",
693 | "| *Exemplo 2* | 50 | [50,75) |\n",
694 | "| *Exemplo 3* | 74 | [50,75) |"
695 | ]
696 | },
697 | {
698 | "cell_type": "code",
699 | "execution_count": null,
700 | "metadata": {
701 | "collapsed": true
702 | },
703 | "outputs": [],
704 | "source": []
705 | },
706 | {
707 | "cell_type": "markdown",
708 | "metadata": {},
709 | "source": [
710 | "[1049](https://www.urionlinejudge.com.br/judge/pt/problems/view/1049) - Uma árvore de classificação é uma ferramenta usada em diferentes áreas da ciência para ajudar a identificar objetos por suas características.\n",
711 | "\n",
712 | "Considerando a árvore de classificação abaixo, escreva um código Python que identifique um animal por suas características. Mais precisamente, seu código deve receber três textos como entrada e informar ao usuário de qual animal se trata.\n",
713 | "\n",
714 | "![](\"imgs/UOJ_1049_b.png\")
"
715 | ]
716 | },
717 | {
718 | "cell_type": "markdown",
719 | "metadata": {},
720 | "source": [
721 | "|.| Entrada | Saída |\n",
722 | "|-|----|---|\n",
723 | "| *Exemplo 1* | vertebrado
mamifero
onivoro | homem | \n",
724 | "| *Exemplo 2* | vertebrado
ave
carnivoro | aguia |\n",
725 | "| *Exemplo 3* | invertebrado
anelideo
onivoro | minhoca |"
726 | ]
727 | },
728 | {
729 | "cell_type": "code",
730 | "execution_count": null,
731 | "metadata": {
732 | "collapsed": true
733 | },
734 | "outputs": [],
735 | "source": []
736 | },
737 | {
738 | "cell_type": "markdown",
739 | "metadata": {},
740 | "source": [
741 | "[1041](https://www.urionlinejudge.com.br/judge/pt/problems/view/1041) - Em sistemas de computação gráfica, compreender diferentes sistemas de coordenadas é fundamental.\n",
742 | "\n",
743 | "Considere o sistema de coordenadas cartesiano apresentado na figura abaixo. Ele serve para representar pontos que apresentam duas dimensões, normalmente representados com a notação (x, y), onde x representa a coordenada horizontal e y a vertical.\n",
744 | "\n",
745 | "![](\"imgs/UOJ_1041.png\")
\n",
746 | "\n",
747 | "O ponto (0,0) representa a origem dos eixos e é a intersecção entre as quatro subregiões ilustradas na figura abaixo (Q1, Q2, Q3 e Q4, onde Q significa *quadrante*, isto é, uma subregião). Cada quadrante da figura representa pontos com as seguintes características:\n",
748 | "\n",
749 | "| Quadrante | Horizontal | Vertical |\n",
750 | "|:-:|:-:|:-:|\n",
751 | "| Q1 | x > 0 | y > 0 |\n",
752 | "| Q2 | x < 0 | y > 0 |\n",
753 | "| Q3 | x < 0 | y < 0 |\n",
754 | "| Q4 | x > 0 | y < 0 |\n",
755 | "\n",
756 | "Também é possível que um ponto esteja sobre um dos eixos:\n",
757 | "* Um ponto estará sobre o eixo x se y = 0;\n",
758 | "* Um ponto estará sobre o eixo y se x = 0.\n",
759 | "\n",
760 | "Considerando este contexto, escreva um código Python que leia um ponto (duas coordenadas reais) e informe a primeira condição abaixo que se mostrar verdadeira:\n",
761 | "* Se o ponto está na \"Origem\";\n",
762 | "* Se o ponto está sobre o \"Eixo X\";\n",
763 | "* Se o ponto está sobre o \"Eixo Y\";\n",
764 | "* Em qual quadrante o ponto está."
765 | ]
766 | },
767 | {
768 | "cell_type": "markdown",
769 | "metadata": {},
770 | "source": [
771 | "|.| Entrada | Saída |\n",
772 | "|-|:-:|:-:|\n",
773 | "| *Exemplo 1* | 4.5
-2.2 | Q4 | \n",
774 | "| *Exemplo 2* | 0.1
0.0 | Eixo X |\n",
775 | "| *Exemplo 3* | 0.0
0.0 | Origem |"
776 | ]
777 | },
778 | {
779 | "cell_type": "code",
780 | "execution_count": null,
781 | "metadata": {
782 | "collapsed": true
783 | },
784 | "outputs": [],
785 | "source": []
786 | },
787 | {
788 | "cell_type": "markdown",
789 | "metadata": {},
790 | "source": [
791 | "[1051](https://www.urionlinejudge.com.br/judge/pt/problems/view/1051) - Sistemas contábeis e de recursos humanos precisam conhecer bem a legislação tributária do país para calcular os impostos a serem recolhidos mensalmente sobre o salário dos funcionários. \n",
792 | "\n",
793 | "Trabalhadores também precisam entender quanto ganham e porque existem descontos em seus contra-cheques.\n",
794 | "\n",
795 | "Neste exercício, você vai ajudar empresas e trabalhadores a entender os descontos da previdência social (INSS).\n",
796 | "\n",
797 | "A tabela usada para calcular esses descontos é apresentada a seguir."
798 | ]
799 | },
800 | {
801 | "cell_type": "markdown",
802 | "metadata": {},
803 | "source": [
804 | "| Salário de contribuição | Alíquota |\n",
805 | "|:-:|:-:|\n",
806 | "| Até 1.693,72 | 8% | \n",
807 | "| De 1.693,73 a 2.822,90 | 9% |\n",
808 | "| De 2.822,91 até 5.645,80 | 11% |"
809 | ]
810 | },
811 | {
812 | "cell_type": "markdown",
813 | "metadata": {},
814 | "source": [
815 | "Como você pode ver, o desconto sobre o salário depende da faixa salarial na qual um trabalhador se enquadre.\n",
816 | "\n",
817 | "Além disso, existe um teto na tabela que determina que pessoas que ganhem a partir de 5.645,81 devem contribuir com 621,04 (11% de 5.645,80).\n",
818 | "\n",
819 | "Escreva um código Python que receba um salário bruto (antes do desconto) e informe o valor da contribuição para o INSS e o salário líquido (após o desconto)."
820 | ]
821 | },
822 | {
823 | "cell_type": "markdown",
824 | "metadata": {},
825 | "source": [
826 | "|.| Entrada | Saída |\n",
827 | "|-|:-:|-|\n",
828 | "| *Exemplo 1* | 7456.57 | 621.04 6835.53 | \n",
829 | "| *Exemplo 2* | 2822.90 | 254.06 2568.84 |\n",
830 | "| *Exemplo 3* | 1693.73 | 152.44 1541.29 |"
831 | ]
832 | },
833 | {
834 | "cell_type": "code",
835 | "execution_count": null,
836 | "metadata": {
837 | "collapsed": true
838 | },
839 | "outputs": [],
840 | "source": []
841 | },
842 | {
843 | "cell_type": "markdown",
844 | "metadata": {},
845 | "source": [
846 | "Um segundo tipo de dedução mensal que incide sobre os ganhos dos trabalhadores é o *imposto de renda sobre pessoa física* (IRPF).\n",
847 | "\n",
848 | "Para o cálculo do IRPF, utiliza-se como base de cálculo o salário bruto descontado da contribuição do INSS. \n",
849 | "\n",
850 | "As principais diferenças em relação ao cálculo do INSS são:\n",
851 | "* Quem possui salário-base até 1.903,98 é isento do pagamento do IRPF.\n",
852 | "* Não há teto para a contribuição do IRPF.\n",
853 | "* O valor do IRPF cobrado a uma pessoa é abatido de um valor que varia em função da alíquota correspondente.\n",
854 | "\n",
855 | "A tabela usada para o cálculo do IRPF é mostrada abaixo."
856 | ]
857 | },
858 | {
859 | "cell_type": "markdown",
860 | "metadata": {},
861 | "source": [
862 | "| Base de cálculo (R\\$) | Alíquota | Parcela a deduzir |\n",
863 | "|:-:|:-:|:-:|\n",
864 | "| Até 1.903,98 | - | - |\n",
865 | "| De 1.903,99 até 2.826,65 | 7,5% | 142,80 |\n",
866 | "| De 2.826,66 até 3.751,05 | 15% | 354,80 |\n",
867 | "| De 3.751,06 até 4.664,68 | 22,5% | 636,13 |\n",
868 | "| Acima de 4.664,68 | 27,5% | 869,36 |"
869 | ]
870 | },
871 | {
872 | "cell_type": "markdown",
873 | "metadata": {},
874 | "source": [
875 | "Para entender melhor o cálculo do IRPF, vamos tomar como exemplo uma pessoa que, descontada a contribuição do INSS, ganha 2.000,00.\n",
876 | "\n",
877 | "A alíquota para esta remuneração é de 7,5% e o abatimento de 142,80. Assim, a contribuição do IRPF será de 2.000,00 * 7,5% - 142,80 = 7,20.\n",
878 | "\n",
879 | "Escreva um código Python que receba um salário-base (já descontado do INSS) e informe o valor da contribuição do IRPF e o salário líquido (após o desconto do IRPF)."
880 | ]
881 | },
882 | {
883 | "cell_type": "markdown",
884 | "metadata": {},
885 | "source": [
886 | "|.| Entrada | Saída |\n",
887 | "|-|:-:|-|\n",
888 | "| *Exemplo 1* | 6835.53 | 1010.41 5825.12 | \n",
889 | "| *Exemplo 2* | 2568.84 | 49.86 2518.98 |\n",
890 | "| *Exemplo 3* | 1541.29 | 0.00 1541.29 |"
891 | ]
892 | },
893 | {
894 | "cell_type": "code",
895 | "execution_count": null,
896 | "metadata": {
897 | "collapsed": true
898 | },
899 | "outputs": [],
900 | "source": []
901 | }
902 | ],
903 | "metadata": {
904 | "kernelspec": {
905 | "display_name": "Python 3",
906 | "language": "python",
907 | "name": "python3"
908 | },
909 | "language_info": {
910 | "codemirror_mode": {
911 | "name": "ipython",
912 | "version": 3
913 | },
914 | "file_extension": ".py",
915 | "mimetype": "text/x-python",
916 | "name": "python",
917 | "nbconvert_exporter": "python",
918 | "pygments_lexer": "ipython3",
919 | "version": "3.6.7"
920 | }
921 | },
922 | "nbformat": 4,
923 | "nbformat_minor": 1
924 | }
925 |
--------------------------------------------------------------------------------
/03.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "\n",
8 | "Este notebook foi baseado nos notebooks disponíveis em [https://gitlab.erc.monash.edu.au/andrease/Python4Maths.git]\n",
9 | ""
10 | ]
11 | },
12 | {
13 | "cell_type": "markdown",
14 | "metadata": {},
15 | "source": [
16 | "# Repetindo sem perder o controle!\n",
17 | "\n",
18 | "Python permite que um trecho de código seja executado múltiplas vezes **estruturas de repetição**. \n",
19 | "\n",
20 | "Pra não perder o controle do seu código e cair em um loop infinito, estruturas de repetição se baseiam em **condições de parada**.\n",
21 | "\n",
22 | "Neste roteiro, você aprenderá a utilizar estes conceitos da linguagem Python.\n",
23 | "\n",
24 | "## Estruturas de repetição\n",
25 | "\n",
26 | "Muitas vezes, é necessário executar um mesmo trecho de código várias vezes:\n",
27 | "* Quando um sistema pede uma senha ao usuário, mas ele tem uma certa quantidade de tentativas possívels.\n",
28 | "* Quando queremos cadastrar múltiplos contatos em uma agenda.\n",
29 | "* Quando estamos calculando a média de várias avaliações de uma disciplina.\n",
30 | "\n",
31 | "Em todas essas situações, precisamos repetir um trecho de código **sem cair em um loop infinito**. Há três situações comuns:\n",
32 | "* Sabemos quantas vezes queremos executar um código.\n",
33 | "* Queremos executar um código enquanto uma condição for verdadeira.\n",
34 | "* Queremos executar um código até que determinada situação aconteça.\n",
35 | "\n",
36 | "Python oferece duas estruturas de repetição, que podem ser usadas nas situações descritas acima:"
37 | ]
38 | },
39 | {
40 | "cell_type": "markdown",
41 | "metadata": {},
42 | "source": [
43 | "| Estrutura | Significado |\n",
44 | "|:----:|:--|\n",
45 | "| ```for``` | Sabemos quantas vezes queremos executar um código.
Queremos iterar sobre os elementos de uma coleção.|\n",
46 | "| ```while``` | Queremos executar um código até que determinada situação aconteça.
Queremos executar um código enquanto uma condição for verdadeira. |"
47 | ]
48 | },
49 | {
50 | "cell_type": "markdown",
51 | "metadata": {},
52 | "source": [
53 | "## A estrutura ```for```"
54 | ]
55 | },
56 | {
57 | "cell_type": "markdown",
58 | "metadata": {},
59 | "source": [
60 | "Quando sabemos quantas vezes queremos executar um código, a estrutura de repetição ```for``` deve ser nossa escolha:\n",
61 | "\n",
62 | "```python\n",
63 | "for iterador in intervalo:\n",
64 | " expressao\n",
65 | " expressao\n",
66 | " ...\n",
67 | "```\n",
68 | "\n",
69 | "As regras básicas para o uso da estrutura **for** em Python são:\n",
70 | "\n",
71 | "* O trecho de código delimitado por uma estrutura **for** é chamado bloco e deve ser identado.\n",
72 | "* O procedimento **range(inicio, fim)** permite definir um intervalo de valores que a variavel **iterador** pode assumir durante a execução do ```for```. \n",
73 | "\n",
74 | "O exemplo abaixo mostra como esta estrutura pode ser usada para que um código seja repetido por 5 vezes:"
75 | ]
76 | },
77 | {
78 | "cell_type": "code",
79 | "execution_count": null,
80 | "metadata": {
81 | "collapsed": true,
82 | "scrolled": true
83 | },
84 | "outputs": [],
85 | "source": [
86 | "for i in range(0,5):\n",
87 | " print(\"Execução\", i+1)"
88 | ]
89 | },
90 | {
91 | "cell_type": "markdown",
92 | "metadata": {},
93 | "source": [
94 | "Note que a função range define intervalos do tipo **[início, fim)**, isto é, valores maiores ou iguais a **início** e menores que **fim**.\n",
95 | "\n",
96 | "Também é possível definir intervalos mais elaborados, criando séries com diferentes crescimentos ou até mesmo decréscimos:"
97 | ]
98 | },
99 | {
100 | "cell_type": "code",
101 | "execution_count": null,
102 | "metadata": {
103 | "collapsed": true,
104 | "scrolled": true
105 | },
106 | "outputs": [],
107 | "source": [
108 | "# Série crescedo de 2 em 2\n",
109 | "for i in range(0,5,2):\n",
110 | " print(\"Valor de i:\", i)"
111 | ]
112 | },
113 | {
114 | "cell_type": "code",
115 | "execution_count": null,
116 | "metadata": {
117 | "collapsed": true,
118 | "scrolled": true
119 | },
120 | "outputs": [],
121 | "source": [
122 | "# Série decrescendo de 5 em 5\n",
123 | "for i in range(15,-20,-5):\n",
124 | " print(\"Valor de i:\", i)"
125 | ]
126 | },
127 | {
128 | "cell_type": "markdown",
129 | "metadata": {},
130 | "source": [
131 | "### Exercícios de fixação"
132 | ]
133 | },
134 | {
135 | "cell_type": "markdown",
136 | "metadata": {},
137 | "source": [
138 | "1 - Peça ao usuário suas notas das 3 unidades de uma disciplina e calcule sua média."
139 | ]
140 | },
141 | {
142 | "cell_type": "code",
143 | "execution_count": null,
144 | "metadata": {
145 | "collapsed": true
146 | },
147 | "outputs": [],
148 | "source": []
149 | },
150 | {
151 | "cell_type": "markdown",
152 | "metadata": {},
153 | "source": [
154 | "2 - Solicite ao usuário um inteiro positivo *n* e imprima a soma dos números pares entre 0 e *n*."
155 | ]
156 | },
157 | {
158 | "cell_type": "code",
159 | "execution_count": null,
160 | "metadata": {
161 | "collapsed": true
162 | },
163 | "outputs": [],
164 | "source": []
165 | },
166 | {
167 | "cell_type": "markdown",
168 | "metadata": {},
169 | "source": [
170 | "3 - Analise os números entre -25 e 50. Se o número for múltiplo de 2, imprima BUS. Se for múltiplo de 3, imprima FEES. Caso seja múltiplo de 2 e de 3 ao mesmo tempo, imprima BUS e FEES."
171 | ]
172 | },
173 | {
174 | "cell_type": "code",
175 | "execution_count": null,
176 | "metadata": {
177 | "collapsed": true
178 | },
179 | "outputs": [],
180 | "source": []
181 | },
182 | {
183 | "cell_type": "markdown",
184 | "metadata": {},
185 | "source": [
186 | "4 - Solicite ao usuário um inteiro positivo *n* e calcule o fatorial de *n*."
187 | ]
188 | },
189 | {
190 | "cell_type": "code",
191 | "execution_count": null,
192 | "metadata": {
193 | "collapsed": true
194 | },
195 | "outputs": [],
196 | "source": []
197 | },
198 | {
199 | "cell_type": "markdown",
200 | "metadata": {},
201 | "source": [
202 | "## A estrutura ```while```"
203 | ]
204 | },
205 | {
206 | "cell_type": "markdown",
207 | "metadata": {},
208 | "source": [
209 | "Quando queremos executar um código enquanto uma condição for verdadeira, a estrutura de repetição ```while``` deve ser nossa escolha:\n",
210 | "\n",
211 | "```python\n",
212 | "while condicao:\n",
213 | " expressao\n",
214 | " expressao\n",
215 | " ...\n",
216 | "```\n",
217 | "\n",
218 | "As regras básicas para o uso da estrutura **while** em Python são:\n",
219 | "\n",
220 | "* O trecho de código delimitado por uma estrutura **while** é chamado bloco e deve ser identado.\n",
221 | "* O bloco delimitado por uma estrutura **while** será executado enquanto a expressão lógica (```condicao```) for verdadeira (```True```).\n",
222 | "\n",
223 | "Um exemplo de uso desta estrutura é o caso em que não se sabe quantas vezes será necessário executar um trecho de código:"
224 | ]
225 | },
226 | {
227 | "cell_type": "code",
228 | "execution_count": null,
229 | "metadata": {
230 | "collapsed": true,
231 | "scrolled": true
232 | },
233 | "outputs": [],
234 | "source": [
235 | "from random import randint\n",
236 | "\n",
237 | "n_multiplos = 0\n",
238 | "while n_multiplos < 3:\n",
239 | " numero = randint(0,30)\n",
240 | " if numero % 3 == 0:\n",
241 | " n_multiplos += 1\n",
242 | " print(\"Múltiplo #\", n_multiplos, \"-\", numero)"
243 | ]
244 | },
245 | {
246 | "cell_type": "markdown",
247 | "metadata": {},
248 | "source": [
249 | "Também é possível utilizar a estrutura de repetição ```while``` quando queremos executar um código até que uma determinada situação ocorra:\n",
250 | "\n",
251 | "```python\n",
252 | "while True:\n",
253 | " expressao\n",
254 | " expressao\n",
255 | " ...\n",
256 | " if condicao:\n",
257 | " break\n",
258 | "```\n",
259 | "\n",
260 | "As regras básicas para o uso da estrutura **while** neste contexto são:\n",
261 | "\n",
262 | "* O bloco será executado uma ou mais vezes, até que a condição se torne verdadeira.\n",
263 | "* O comando **```break```** provoca a interrupção da repetição.\n",
264 | "\n",
265 | "O exemplo abaixo mostra como esta estrutura pode ser usada para solicitar uma senha ao usuário até que ele acerte a senha:"
266 | ]
267 | },
268 | {
269 | "cell_type": "code",
270 | "execution_count": null,
271 | "metadata": {
272 | "collapsed": true,
273 | "scrolled": false
274 | },
275 | "outputs": [],
276 | "source": [
277 | "senha_correta = \"swordfish\"\n",
278 | "while True:\n",
279 | " senha = input(\"Informe sua senha: \")\n",
280 | " if senha == senha_correta:\n",
281 | " break\n",
282 | " else:\n",
283 | " print(\"Senha incorreta!\")"
284 | ]
285 | },
286 | {
287 | "cell_type": "markdown",
288 | "metadata": {},
289 | "source": [
290 | "### Exercícios de fixação"
291 | ]
292 | },
293 | {
294 | "cell_type": "markdown",
295 | "metadata": {},
296 | "source": [
297 | "1 - Sorteie um número entre 0 e 10 e peça ao usuário para tentar adivinhá-lo. Quando o usuário acertar o número, informe quantas tentativas foram necessárias."
298 | ]
299 | },
300 | {
301 | "cell_type": "code",
302 | "execution_count": null,
303 | "metadata": {
304 | "collapsed": true
305 | },
306 | "outputs": [],
307 | "source": []
308 | },
309 | {
310 | "cell_type": "markdown",
311 | "metadata": {},
312 | "source": [
313 | "### Pulando parte do código\n",
314 | "\n",
315 | "É possível evitar que parte do código seja executada durante uma repetição utilizando o comando ```continue```.\n"
316 | ]
317 | },
318 | {
319 | "cell_type": "code",
320 | "execution_count": null,
321 | "metadata": {
322 | "scrolled": true
323 | },
324 | "outputs": [],
325 | "source": [
326 | "soma = 0\n",
327 | "for i in range(10):\n",
328 | " if i == 3:\n",
329 | " continue\n",
330 | " print(i)"
331 | ]
332 | },
333 | {
334 | "cell_type": "markdown",
335 | "metadata": {},
336 | "source": [
337 | "### Exercícios de fixação"
338 | ]
339 | },
340 | {
341 | "cell_type": "markdown",
342 | "metadata": {},
343 | "source": [
344 | "1 - Imprima os números partes entre 0 e 50, pulando os números múltiplos de 4. Use o comando ```continue```."
345 | ]
346 | },
347 | {
348 | "cell_type": "code",
349 | "execution_count": null,
350 | "metadata": {
351 | "collapsed": true
352 | },
353 | "outputs": [],
354 | "source": []
355 | },
356 | {
357 | "cell_type": "markdown",
358 | "metadata": {},
359 | "source": [
360 | "## Combinando múltiplas estruturas de repetição"
361 | ]
362 | },
363 | {
364 | "cell_type": "markdown",
365 | "metadata": {},
366 | "source": [
367 | "Assim como vimos para estruturas de decisão, também podemos combinar estruturas de repetição em múltiplos níveis. \n",
368 | "\n",
369 | "As regras básicas para **aninhar estruturas de repetição** em Python são:\n",
370 | "* Não há limite com relação a quantas estruturas e em quantos níveis.\n",
371 | "* Blocos de níveis mais profundos devem apresentar maior grau de identação.\n",
372 | "* Os efeitos dos comandos ```break``` e ```continue``` se limitam ao nível atual.\n",
373 | "\n",
374 | "O exemplo abaixo mostra como imprimir uma matriz identidade. Note que a função ```print``` pode ser usada para imprimir várias vezes em uma mesma linha, utilizando pra isso a opção ```end```."
375 | ]
376 | },
377 | {
378 | "cell_type": "code",
379 | "execution_count": null,
380 | "metadata": {
381 | "collapsed": true
382 | },
383 | "outputs": [],
384 | "source": [
385 | "for i in range(3):\n",
386 | " for j in range(3):\n",
387 | " if i == j:\n",
388 | " print(\" 1 \", end='')\n",
389 | " else:\n",
390 | " print(\" 0 \", end='')\n",
391 | " print()"
392 | ]
393 | },
394 | {
395 | "cell_type": "markdown",
396 | "metadata": {
397 | "collapsed": true
398 | },
399 | "source": [
400 | "## Exercícios do URI"
401 | ]
402 | },
403 | {
404 | "cell_type": "markdown",
405 | "metadata": {
406 | "collapsed": true
407 | },
408 | "source": [
409 | "[1080](https://www.urionlinejudge.com.br/judge/pt/problems/view/1080) - Calcular estatísticas é uma importante tarefa dos sistema de computação que trabalham com análise de dados. Em um roteiro anterior, você implementou uma função para uso em histogramas, que informava a qual intervalo um elemento pertencia.\n",
410 | "\n",
411 | "Neste exercício, você vai voltar pro mundo real e de fato preparar um histograma dos dados (colher de chá: não precisa gerar o gráfico no final).\n",
412 | "\n",
413 | "Escreva um código Python que receba um inteiro informando quantos números no intervalo \\[0,100\\) serão informados a seguir. Considerando 5 subintervalos de igual tamanho, seu programa deverá calcular a frequência de elementos presentes em cada subintervalo.\n",
414 | "\n",
415 | "Por fim, seu programa deverá informar os elementos máximo e mínimo encontrados nos dados, e suas posições na sequência dos dados de entrada."
416 | ]
417 | },
418 | {
419 | "cell_type": "markdown",
420 | "metadata": {},
421 | "source": [
422 | "|.| Entrada | Saída |\n",
423 | "|-|:----:|---|\n",
424 | "| *Exemplo 1* | 5
100
40
32
87
90 | \\[0,20\\) - 1
\\[20,40\\) - 1
\\[40,60\\) - 1
\\[60,80\\) - 0
\\[80,100\\) - 3
Máximo: 100 (0)
Mínimo: 32 (2) | \n",
425 | "| *Exemplo 2* | 3
12
29
45 | \\[0,20\\) - 1
\\[20,40\\) - 1
\\[40,60\\) - 1
\\[60,80\\) - 0
\\[80,100\\) - 0
Máximo: 45 (2)
Mínimo: 12 (0) | \n",
426 | "| *Exemplo 3* | 7
13
88
45
63
94
27
5 | \\[0,20\\) - 1
\\[20,40\\) - 1
\\[40,60\\) - 1
\\[60,80\\) - 1
\\[80,100\\) - 2
Máximo: 94 (4)
Mínimo: 5 (6) | \n"
427 | ]
428 | },
429 | {
430 | "cell_type": "markdown",
431 | "metadata": {
432 | "collapsed": true
433 | },
434 | "source": [
435 | "[1164](https://www.urionlinejudge.com.br/judge/pt/problems/view/1164) - Um número **perfeito** é um número igual à soma dos seus divisores (exceto ele mesmo).\n",
436 | "\n",
437 | "O número 28 é um exemplo de número perfeito: 28 = 1 + 2 + 4 + 7 + 14.\n",
438 | "\n",
439 | "[1165](https://www.urionlinejudge.com.br/judge/pt/problems/view/1165) - Um número **primo** é um número que só pode ser dividido por 1 e por ele mesmo. \n",
440 | "\n",
441 | "O número 17, por exemplo, só pode ser dividido por 1 e por 17.\n",
442 | "\n",
443 | "Escreva um código Python que receba um inteiro N e imprima os números do intervalo [1,N] que são primos ou perfeitos."
444 | ]
445 | },
446 | {
447 | "cell_type": "markdown",
448 | "metadata": {
449 | "collapsed": true
450 | },
451 | "source": [
452 | "|.| Entrada | Saída |\n",
453 | "|-|:-:|:-|\n",
454 | "| *Exemplo 1* | 10 | 1 2 3 5 6 7 10 | \n",
455 | "| *Exemplo 2* | 15 | 1 2 3 5 6 7 10 11 13 |\n",
456 | "| *Exemplo 3* | 20 | 1 2 3 5 6 7 10 11 13 17 19 |"
457 | ]
458 | },
459 | {
460 | "cell_type": "code",
461 | "execution_count": null,
462 | "metadata": {
463 | "collapsed": true
464 | },
465 | "outputs": [],
466 | "source": []
467 | },
468 | {
469 | "cell_type": "markdown",
470 | "metadata": {
471 | "collapsed": true
472 | },
473 | "source": [
474 | "[1789](https://www.urionlinejudge.com.br/judge/pt/problems/view/1789) - Jogos de corrida utilizam simulações baseadas nas regras da física para trazer realismo à experiência do usuário.\n",
475 | "\n",
476 | "Neste exercício, você deve simular uma das regras mais simples da mecânica clássica, que mostra que a distância percorrida por um objeto é proporcional à sua velocidade.\n",
477 | "\n",
478 | "Neste jogo serão 3 corredores, cada um com uma velocidade dada por um número real sorteado no intervalo [0,100) m/s.\n",
479 | "\n",
480 | "Considere que todos os competidores partem do mesmo lugar e apresente a posição de cada corredor atualizada segundo a segundo.\n",
481 | "\n",
482 | "Considere ainda que a linha de chegada está a 482m de distância do ponto de partida e encerre a corrida quando o vencedor cruzar a linha, identificando o vencedor.\n",
483 | "\n",
484 | "** Dica --** Para gerar um número real aleatório no intervalo [0,100), utilize a função ```uniform(0,100)```."
485 | ]
486 | },
487 | {
488 | "cell_type": "markdown",
489 | "metadata": {
490 | "collapsed": true
491 | },
492 | "source": [
493 | "|.| Velocidades | Saída |\n",
494 | "|-|:-:|:-|\n",
495 | "| *Exemplo 1* | 15.38
55.49
48.65 | 15.38 55.49 48.65
30.76 110.98 97.30
46.14 166.47 145.95
61.52 221.96 194.60
76.90 277.45 243.25
92.28 332.94 291.90
107.66 388.43 340.55
123.04 443.92 389.20
138.42 499.41 437.85
P2 | \n",
496 | "| *Exemplo 2* | 42.27
95.26
72.25 | 42.27 95.26 72.25
84.54 190.52 144.50
126.81 285.78 216.75
169.08 381.04 289.00
211.35 476.30 361.25
253.62 571.56 433.50
P2 |\n",
497 | "| *Exemplo 3* | 98.76
93.21
96.65 | 98.76 93.21 96.65
197.52 186.42 193.30
296.28 279.63 289.95
395.04 372.84 386.60
493.80 466.05 483.25
P1 |"
498 | ]
499 | },
500 | {
501 | "cell_type": "code",
502 | "execution_count": null,
503 | "metadata": {
504 | "collapsed": true
505 | },
506 | "outputs": [],
507 | "source": [
508 | "from random import uniform"
509 | ]
510 | },
511 | {
512 | "cell_type": "markdown",
513 | "metadata": {
514 | "collapsed": true
515 | },
516 | "source": [
517 | "[1828](https://www.urionlinejudge.com.br/judge/pt/problems/view/1828) - Pedra, paper e tesoura, ou じゃんけんぽん (jankenpon), é um jogo simples que envolve apenas quatro regras:\n",
518 | "\n",
519 | "- Dois jogadores disputam entre si, podendo escolher entre 3 opções de ação: pedra, papel ou tesoura.\n",
520 | "- A pedra quebra a tesoura.\n",
521 | "- A tesoura corta o papel.\n",
522 | "- O papel embrulha a pedra.\n",
523 | "\n",
524 | "Também é possível que não haja um vencedor, quando os dois jogadores escolhem a mesma ação.\n",
525 | "\n",
526 | "Escreva um código Python que receba um inteiro informando número de rodadas de uma partida e simule dois jogadores competindo entre si. Você deve imprimir as ações e o vencedor de cada rodada, bem como o vencedor da partida."
527 | ]
528 | },
529 | {
530 | "cell_type": "markdown",
531 | "metadata": {},
532 | "source": [
533 | "|.| Entrada | Saída |\n",
534 | "|-|:-:|:-|\n",
535 | "| *Exemplo 1* | 3 | Jogador 2
Empate
Jogador 2
Placar final: 0 x 2
Partida vencida pelo Jogador 2! | \n",
536 | "| *Exemplo 2* | 5 | Jogador 1
Jogador 1
Empate
Empate
Jogador 1
Placar final: 3 x 0
Partida vencida pelo Jogador 1! |\n",
537 | "| *Exemplo 3* | 4 | Empate
Jogador 2
Empate
Empate
Placar final: 0 x 1
Partida vencida pelo Jogador 2! |"
538 | ]
539 | },
540 | {
541 | "cell_type": "code",
542 | "execution_count": null,
543 | "metadata": {
544 | "collapsed": true
545 | },
546 | "outputs": [],
547 | "source": []
548 | },
549 | {
550 | "cell_type": "markdown",
551 | "metadata": {},
552 | "source": [
553 | "Agora que você já sabe até como criar um jogo de jonkenpon, implemente uma versão em que você pode jogar contra o computador e mostre que você pode derrotá-lo :D"
554 | ]
555 | },
556 | {
557 | "cell_type": "code",
558 | "execution_count": null,
559 | "metadata": {
560 | "collapsed": true
561 | },
562 | "outputs": [],
563 | "source": []
564 | },
565 | {
566 | "cell_type": "markdown",
567 | "metadata": {},
568 | "source": [
569 | "[Blackjack](https://pt.wikipedia.org/wiki/Blackjack) - Vinte-e-um (21) é um dos mais icônicos jogos de cartas, onde um jogador real compete contra um jogador imaginário (a banca) para ver quem consegue o jogo de maior valor sem estourar o limite de 21 pontos.\n",
570 | "\n",
571 | "Por simplicidade, considere apenas as seguintes regras:\n",
572 | "- Cada jogador pode pedir uma carta por rodada ou dizer que quer parar de pedir.\n",
573 | "- O jogador que acumular mais de 21 pontos perde a partida.\n",
574 | "- Se o jogador e a banca atingirem o mesmo número de pontos, a partida termina empatada.\n",
575 | "- As cartas numéricas valem o número de pontos que elas indicam (ex: 2 vale 2, 10 vale 10).\n",
576 | "- As cartas de figuras (rei, valete e dama) valem 10 pontos.\n",
577 | "- O Ás vale 11 pontos.\n",
578 | "\n",
579 | "Escreva um código Python que te permite jogar blackjack contra o computador, escrevendo a cada rodada o valor do jogo de cada jogador e, ao final, o vencedor da partida."
580 | ]
581 | },
582 | {
583 | "cell_type": "code",
584 | "execution_count": null,
585 | "metadata": {
586 | "collapsed": true
587 | },
588 | "outputs": [],
589 | "source": []
590 | }
591 | ],
592 | "metadata": {
593 | "kernelspec": {
594 | "display_name": "Python 3",
595 | "language": "python",
596 | "name": "python3"
597 | },
598 | "language_info": {
599 | "codemirror_mode": {
600 | "name": "ipython",
601 | "version": 3
602 | },
603 | "file_extension": ".py",
604 | "mimetype": "text/x-python",
605 | "name": "python",
606 | "nbconvert_exporter": "python",
607 | "pygments_lexer": "ipython3",
608 | "version": "3.6.8"
609 | }
610 | },
611 | "nbformat": 4,
612 | "nbformat_minor": 1
613 | }
614 |
--------------------------------------------------------------------------------
/04.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "\n",
8 | "Este notebook foi baseado nos notebooks disponíveis em [https://gitlab.erc.monash.edu.au/andrease/Python4Maths.git]\n",
9 | ""
10 | ]
11 | },
12 | {
13 | "cell_type": "markdown",
14 | "metadata": {},
15 | "source": [
16 | "# Reaproveitando código\n",
17 | "\n",
18 | "Uma outra maneira de utilizar um código múltiplas vezes é através de **procedimentos**.\n",
19 | "\n",
20 | "Um procedimento é um conjunto de instruções agrupados em um bloco que recebem um nome e podem ser chamados quantas vezes for necessário.\n",
21 | "\n",
22 | "Nos roteiros anteriores, você já vem usando procedimentos como ```input()```, ```print()``` e ```randint()```.\n",
23 | "\n",
24 | "Você também pode criar seus próprios procedimentos usando o seguinte padrão:\n",
25 | "\n",
26 | "```python\n",
27 | "def nome():\n",
28 | " instrucao\n",
29 | " instrucao\n",
30 | " ...\n",
31 | "```\n",
32 | "\n",
33 | "O padrão acima pode ser lido como ```definir``` um procedimento chamado ```nome```, que executará o seguinte bloco de instruções.\n",
34 | "\n",
35 | "As regras básicas para a **definição e uso de procedimentos** em Python são:\n",
36 | "\n",
37 | "* O trecho de código delimitado por um procedimento é chamado bloco e deve ser identado.\n",
38 | "* Um procedimento é chamado utilizando a notação ```nome()```."
39 | ]
40 | },
41 | {
42 | "cell_type": "code",
43 | "execution_count": null,
44 | "metadata": {},
45 | "outputs": [],
46 | "source": [
47 | "def bom_dia():\n",
48 | " print(\"Bom dia!\")\n",
49 | "\n",
50 | "bom_dia()"
51 | ]
52 | },
53 | {
54 | "cell_type": "markdown",
55 | "metadata": {},
56 | "source": [
57 | "### Exercícios de fixação"
58 | ]
59 | },
60 | {
61 | "cell_type": "markdown",
62 | "metadata": {},
63 | "source": [
64 | "1 - Crie um procedimento ```aleatorio()``` que imprima um inteiro aleatorio pertencente ao intervalo [1,60]."
65 | ]
66 | },
67 | {
68 | "cell_type": "code",
69 | "execution_count": null,
70 | "metadata": {
71 | "collapsed": true
72 | },
73 | "outputs": [],
74 | "source": []
75 | },
76 | {
77 | "cell_type": "markdown",
78 | "metadata": {},
79 | "source": [
80 | "2 - Crie um procedimento mega_sena() que use o procedimento aleatorio() e imprima um jogo da mega sena."
81 | ]
82 | },
83 | {
84 | "cell_type": "code",
85 | "execution_count": null,
86 | "metadata": {
87 | "collapsed": true
88 | },
89 | "outputs": [],
90 | "source": []
91 | },
92 | {
93 | "cell_type": "markdown",
94 | "metadata": {},
95 | "source": [
96 | "## Customizando a execução de um procedimento"
97 | ]
98 | },
99 | {
100 | "cell_type": "markdown",
101 | "metadata": {},
102 | "source": [
103 | "Você pode configurar o comportamento de um procedimento utilizando **parâmetros de chamada** (também conhecidos como *argumentos*).\n",
104 | "\n",
105 | "Não existe um limite para a quantidade de argumentos de um procedimento, mas você deve nomeá-los ao definir seu procedimento para poder utilizá-los como variáveis:\n",
106 | "\n",
107 | "```python\n",
108 | "def nome(arg1, arg2, ..., argN):\n",
109 | " instrucao\n",
110 | " instrucao\n",
111 | " ...\n",
112 | "```\n"
113 | ]
114 | },
115 | {
116 | "cell_type": "code",
117 | "execution_count": null,
118 | "metadata": {
119 | "scrolled": true
120 | },
121 | "outputs": [],
122 | "source": [
123 | "def info_pessoa(nome, idade, email):\n",
124 | " print(\"Nome:\", nome)\n",
125 | " print(\"Idade:\", idade)\n",
126 | " print(\"Email:\", email)\n",
127 | "\n",
128 | "info_pessoa(\"Leonardo Bezerra\", \"31\", \"leobezerra@imd.ufrn.br\")"
129 | ]
130 | },
131 | {
132 | "cell_type": "markdown",
133 | "metadata": {},
134 | "source": [
135 | "### Exercícios de fixação"
136 | ]
137 | },
138 | {
139 | "cell_type": "markdown",
140 | "metadata": {},
141 | "source": [
142 | "1 - Crie um procedimento ```media()``` que receba notas de 3 unidades de uma disciplina e calcule sua média."
143 | ]
144 | },
145 | {
146 | "cell_type": "code",
147 | "execution_count": null,
148 | "metadata": {
149 | "collapsed": true
150 | },
151 | "outputs": [],
152 | "source": []
153 | },
154 | {
155 | "cell_type": "markdown",
156 | "metadata": {},
157 | "source": [
158 | "2 - Crie um procedimento ```fatorial()``` que receba um inteiro N e imprima seu fatorial."
159 | ]
160 | },
161 | {
162 | "cell_type": "code",
163 | "execution_count": null,
164 | "metadata": {
165 | "collapsed": true
166 | },
167 | "outputs": [],
168 | "source": []
169 | },
170 | {
171 | "cell_type": "markdown",
172 | "metadata": {},
173 | "source": [
174 | "## Interrompendo a execução de um procedimento"
175 | ]
176 | },
177 | {
178 | "cell_type": "markdown",
179 | "metadata": {},
180 | "source": [
181 | "Assim como é possível interromper uma repetição usando o comando ```break```, é possível interromper a execução de um procedimento usando o comando ```return```."
182 | ]
183 | },
184 | {
185 | "cell_type": "code",
186 | "execution_count": null,
187 | "metadata": {
188 | "scrolled": true
189 | },
190 | "outputs": [],
191 | "source": [
192 | "def raiz_quadrada(n):\n",
193 | " if n < 0:\n",
194 | " return\n",
195 | " print(\"Raiz:\", n ** 0.5)\n",
196 | "\n",
197 | "raiz_quadrada(4)\n",
198 | "raiz_quadrada(16)\n",
199 | "raiz_quadrada(-1)"
200 | ]
201 | },
202 | {
203 | "cell_type": "markdown",
204 | "metadata": {},
205 | "source": [
206 | "### Exercícios de fixação"
207 | ]
208 | },
209 | {
210 | "cell_type": "markdown",
211 | "metadata": {},
212 | "source": [
213 | "1 - Crie um procedimento ```divisao_inteira()``` que imprima o resultado e o resto da divisão inteira de dois parâmetros inteiros. Se não houver resto, seu procedimento deverá imprimir apenas o resultado da divisão."
214 | ]
215 | },
216 | {
217 | "cell_type": "code",
218 | "execution_count": null,
219 | "metadata": {
220 | "collapsed": true
221 | },
222 | "outputs": [],
223 | "source": []
224 | },
225 | {
226 | "cell_type": "markdown",
227 | "metadata": {},
228 | "source": [
229 | "## Produzindo um valor a partir de um procedimento"
230 | ]
231 | },
232 | {
233 | "cell_type": "markdown",
234 | "metadata": {},
235 | "source": [
236 | "Outro uso do comando ```return``` é permitir que um procedimento produza um resultado (retorne um valor).\n",
237 | "\n",
238 | "Tanto é possível retornar valores diretamente, como usando as varíaveis associadas a esses valores."
239 | ]
240 | },
241 | {
242 | "cell_type": "code",
243 | "execution_count": null,
244 | "metadata": {
245 | "scrolled": true
246 | },
247 | "outputs": [],
248 | "source": [
249 | "def soma_n_primeiros(n):\n",
250 | " soma = 0\n",
251 | " for i in range(n):\n",
252 | " soma += i\n",
253 | " return soma\n",
254 | "\n",
255 | "print(soma_n_primeiros(3))\n",
256 | "print(soma_n_primeiros(5))\n",
257 | "print(soma_n_primeiros(10))"
258 | ]
259 | },
260 | {
261 | "cell_type": "markdown",
262 | "metadata": {},
263 | "source": [
264 | "### Exercícios de fixação"
265 | ]
266 | },
267 | {
268 | "cell_type": "markdown",
269 | "metadata": {},
270 | "source": [
271 | "1 - Crie um procedimento ```valor_absoluto()``` que retorne o valor absoluto de um parâmetro."
272 | ]
273 | },
274 | {
275 | "cell_type": "code",
276 | "execution_count": null,
277 | "metadata": {
278 | "collapsed": true
279 | },
280 | "outputs": [],
281 | "source": []
282 | },
283 | {
284 | "cell_type": "markdown",
285 | "metadata": {},
286 | "source": [
287 | "## Usando procedimentos definidos por outros"
288 | ]
289 | },
290 | {
291 | "cell_type": "markdown",
292 | "metadata": {},
293 | "source": [
294 | "Um dos principais usos de procedimentos é a construção de **bibliotecas**, que são códigos criados por outras pessoas que você pode utilizar dentro do seu código.\n",
295 | "\n",
296 | "Nesta disciplina, você poderá **importar** procedimentos de bibliotecas de duas formas:\n",
297 | "- Importando procedimento(s) específico(s) de uma biblioteca\n",
298 | "```python\n",
299 | "from biblioteca import procedimento1, procedimento2, ..., procedimentoN\n",
300 | "```\n",
301 | "- Importando todos os procedimentos de uma biblioteca\n",
302 | "```python\n",
303 | "from biblioteca import *\n",
304 | "```"
305 | ]
306 | },
307 | {
308 | "cell_type": "markdown",
309 | "metadata": {},
310 | "source": [
311 | "### Exercícios de fixação"
312 | ]
313 | },
314 | {
315 | "cell_type": "markdown",
316 | "metadata": {},
317 | "source": [
318 | "1 - Em roteiros anteriores, você usou a função ```randint()```. Qual biblioteca fornece esse procedimento?"
319 | ]
320 | },
321 | {
322 | "cell_type": "markdown",
323 | "metadata": {},
324 | "source": [
325 | "Resposta: "
326 | ]
327 | },
328 | {
329 | "cell_type": "markdown",
330 | "metadata": {},
331 | "source": [
332 | "2 - Use os procedimentos ```sin()``` e ```floor()``` da biblioteca ```math``` para calcular o seno de um número e transformá-lo em um inteiro arredondando-o para baixo."
333 | ]
334 | },
335 | {
336 | "cell_type": "code",
337 | "execution_count": null,
338 | "metadata": {},
339 | "outputs": [],
340 | "source": []
341 | },
342 | {
343 | "cell_type": "markdown",
344 | "metadata": {
345 | "collapsed": true
346 | },
347 | "source": [
348 | "## Exercícios do URI"
349 | ]
350 | },
351 | {
352 | "cell_type": "markdown",
353 | "metadata": {
354 | "collapsed": true
355 | },
356 | "source": [
357 | "[2630](https://www.urionlinejudge.com.br/judge/pt/problems/view/2630) - Sistemas de computação gráfica representam imagens como um conjunto de pontos (pixels) formados por três componentes: vermelho, verde e azul.\n",
358 | "\n",
359 | "Alguns algoritmos de processamento de imagem exigem um pré-processamento no qual é necessário transformar uma imagem colorida em uma imagem em tons de cinza. Esta conversão pode ser realizada de diversas maneiras, dependendo do resultado que se pretende obter.\n",
360 | "\n",
361 | "Para preservar a percepção das cores básicas pelo olho humano, uma conversão apropriada seria tomar 30% da componente vermelha (R), 59% da componente verde (G) e 11% da componente azul (B). Em termos matemáticos,\n",
362 | "\n",
363 | "P = 0,30R + 0,59G + 0,11B\n",
364 | "\n",
365 | "Outras abordagens possíveis seriam determinar o valor de P através da média aritmética das três componentes ou atribuir a P os valores da maior ou da menor entre as três componentes.\n",
366 | "\n",
367 | "Escreva um código Python que, dadas as componentes RGB de um pixel da imagem colorida, determine o valor do pixel P da imagem em tons de cinza correspondente, determinada a conversão a ser utilizada. Despreze a parte decimal do resultado, caso exista.\n",
368 | "\n",
369 | "A entrada consiste em T (1 ≤ T ≤ 100) casos de teste, onde o valor de T é dado na primeira linha da entrada. Cada caso de teste é composto por quatro linhas: a primeira linha contém a conversão a ser utilizada: eye para a primeira abordagem descrita, mean para a média aritmética, max para o valor da maior componente e min para o valor da menor componente. As demais linhas contêm os valores R, G, B (0 ≤ R, G, B ≤ 255) do pixel da imagem colorida.\n",
370 | "\n",
371 | "Para cada caso de testes dever ser impresso P, onde P é o nível de cinza do pixel da imagem em tons de cinza após a conversão do pixel da imagem colorida."
372 | ]
373 | },
374 | {
375 | "cell_type": "markdown",
376 | "metadata": {},
377 | "source": [
378 | "|.| Entrada | Saída |\n",
379 | "|-|:----:|:-:|\n",
380 | "| *Exemplo 1* | 3
min
35
70
35
mean
10
74
181
eye
23
78
197 | 35
88
74 | \n",
381 | "| *Exemplo 2* | 4
min
41
27
32
min
10
21
6
max
15
41
72
max
40
21
63 | 27
6
72
41 | \n",
382 | "| *Exemplo 3* | 2
eye
7
62
200
mean
15
49
227 | 60
97 | "
383 | ]
384 | },
385 | {
386 | "cell_type": "code",
387 | "execution_count": null,
388 | "metadata": {
389 | "collapsed": true
390 | },
391 | "outputs": [],
392 | "source": []
393 | },
394 | {
395 | "cell_type": "markdown",
396 | "metadata": {},
397 | "source": [
398 | "[2165](https://www.urionlinejudge.com.br/judge/pt/problems/view/2165) - O microblog Twitter é conhecido por limitar as postagens em 140 caracteres. Mais recentemente, alguns usuários como a @HBO_Brasil tiveram seus limites de caracteres dobrados para 280.\n",
399 | "\n",
400 | "Escreva um código que confira se um texto vai caber em um tuíte. Cada caso de teste é iniciado com um inteiro informando a qual limite o usuário tem direito. Caso o tamanho do caracter exceda esse limite, seu código deverá imprimir a mensagem NO. Caso contrário, seu código deverá imprimir a mensagem OK.\n"
401 | ]
402 | },
403 | {
404 | "cell_type": "markdown",
405 | "metadata": {},
406 | "source": [
407 | "|.| Entrada | Saída |\n",
408 | "|-|----|:-:|\n",
409 | "| *Exemplo 1* | 280
Agora dá: Daenerys Targaryen, Filha da Tormenta, Não Queimada, Mãe de Dragões, Rainha de Mereen,
Rainha dos Ândalos e dos Primeiros Homens, Quebradora de Correntes, Senhora dos Sete Reinos,
Khaleesi dos Dothraki, a Primeira de Seu Nome. Descendente da Casa Targaryen. | OK | \n",
410 | "| *Exemplo 2* | 140
Jon Snow. Ele é Rei do Norte. | OK | \n",
411 | "| *Exemplo 3* | 140
Fish fingers last night! Looking forward to meeting with
Prime Minister @Netanyahu shortly. (Was thinking of making a joke on
his name – Netanya-WHO!? but @IvankaTrump said best not.)
Peace in the Middle East would be a truly great legacy for ALL people! | NO | \n",
412 | "\n",
413 | "\n"
414 | ]
415 | },
416 | {
417 | "cell_type": "code",
418 | "execution_count": null,
419 | "metadata": {
420 | "collapsed": true
421 | },
422 | "outputs": [],
423 | "source": []
424 | },
425 | {
426 | "cell_type": "markdown",
427 | "metadata": {},
428 | "source": [
429 | "3 - Em exercícios de notebooks anteriores, você implementou códigos para calcular a contribuição mensal de um trabalhador para o INSS e seu IRPF (imposto de renda pessoa física).\n",
430 | "\n",
431 | "Reuse seus códigos de forma modularizada para criar um código que leia o salário bruto de um trabalhador e imprima se salário líquido (descontados INSS e IRPF)."
432 | ]
433 | },
434 | {
435 | "cell_type": "markdown",
436 | "metadata": {},
437 | "source": [
438 | "|.| Entrada | Saída |\n",
439 | "|-|:-:|-|\n",
440 | "| *Exemplo 1* | 1200.00 | 1104.00 | \n",
441 | "| *Exemplo 2* | 5485.00 | 4474.05 |\n",
442 | "| *Exemplo 3* | 10431.00 | 8059.90 |"
443 | ]
444 | },
445 | {
446 | "cell_type": "code",
447 | "execution_count": null,
448 | "metadata": {
449 | "collapsed": true
450 | },
451 | "outputs": [],
452 | "source": []
453 | }
454 | ],
455 | "metadata": {
456 | "kernelspec": {
457 | "display_name": "Python 3",
458 | "language": "python",
459 | "name": "python3"
460 | },
461 | "language_info": {
462 | "codemirror_mode": {
463 | "name": "ipython",
464 | "version": 3
465 | },
466 | "file_extension": ".py",
467 | "mimetype": "text/x-python",
468 | "name": "python",
469 | "nbconvert_exporter": "python",
470 | "pygments_lexer": "ipython3",
471 | "version": "3.6.8"
472 | }
473 | },
474 | "nbformat": 4,
475 | "nbformat_minor": 1
476 | }
477 |
--------------------------------------------------------------------------------
/05.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Abrindo a caixa de ferramentas\n",
8 | "\n",
9 | "Se você chegou até aqui, você já sabe tanto quanto a maior parte dos programadores iniciantes.\n",
10 | "\n",
11 | "Que tal saber um pouco mais? 😎\n",
12 | "\n",
13 | "## Iterando sobre coleções \n",
14 | "\n",
15 | "No roteiro 03, falamos que o `for` pode ter dois usos principais:\n",
16 | "\n",
17 | "| Estrutura | Significado |\n",
18 | "|:----:|:--|\n",
19 | "| ```for``` | Sabemos quantas vezes queremos executar um código.
Queremos iterar sobre os elementos de uma coleção.|\n",
20 | "\n",
21 | "Naquele roteiro, nós estudamos apenas o primeiro uso do `for`. \n",
22 | "\n",
23 | "Vamos ver um exemplo do segundo caso:"
24 | ]
25 | },
26 | {
27 | "cell_type": "code",
28 | "execution_count": null,
29 | "metadata": {},
30 | "outputs": [],
31 | "source": [
32 | "pares = {2, 4, 6, 8}\n",
33 | "for p in pares:\n",
34 | " print(p)"
35 | ]
36 | },
37 | {
38 | "cell_type": "markdown",
39 | "metadata": {},
40 | "source": [
41 | "> Que loucura foi essa? 😱\n",
42 | "\n",
43 | "Vamos entender uma linha de cada vez:\n",
44 | "1. Em vez de associarmos `pares` a um valor, nós associamos a um **conjunto** de valores (um `set`). Em Python, a notação para criar um `set` é listar os valores separados por vírgulas, delimitados por chaves.\n",
45 | "2. A cada iteração, o `for` associa a variável `p` a um elemento do conjunto `pares`. Uma característica do `set` é que os elementos não são armazenados em ordem. Assim, a única certeza que temos é que o `for` vai iterar sobre todos os elementos, mas não podemos confiar na ordem dessa iteração!\n",
46 | "3. A variável `p` pode ser usada dentro do escopo do `for`.\n",
47 | "\n",
48 | "> Mas se não temos garantia de ordem, qual a vantagem de usar o `for` assim? 🤔\n",
49 | "\n",
50 | "Na verdade, o `set` é apenas um dos exemplos de **coleções** de dados do Python. \n",
51 | "\n",
52 | "No caso do `set`, seu uso principal é testar se um elemento existe no conjunto."
53 | ]
54 | },
55 | {
56 | "cell_type": "code",
57 | "execution_count": null,
58 | "metadata": {},
59 | "outputs": [],
60 | "source": [
61 | "2 in pares"
62 | ]
63 | },
64 | {
65 | "cell_type": "code",
66 | "execution_count": null,
67 | "metadata": {},
68 | "outputs": [],
69 | "source": [
70 | "1 in pares"
71 | ]
72 | },
73 | {
74 | "cell_type": "markdown",
75 | "metadata": {},
76 | "source": [
77 | "Para adicionar ou remover elementos de um conjunto, usamos as opções `add()` e `remove()`. No entanto, não é possível armazenar valores repetidos em um `set`."
78 | ]
79 | },
80 | {
81 | "cell_type": "code",
82 | "execution_count": null,
83 | "metadata": {},
84 | "outputs": [],
85 | "source": [
86 | "conjunto = {1, 2}\n",
87 | "conjunto.add(3)\n",
88 | "conjunto.remove(2)\n",
89 | "print(conjunto)"
90 | ]
91 | },
92 | {
93 | "cell_type": "code",
94 | "execution_count": null,
95 | "metadata": {},
96 | "outputs": [],
97 | "source": [
98 | "duplicados = {2, 2, 4, 4}\n",
99 | "print(duplicados)\n",
100 | "conjunto.add(3)\n",
101 | "print(conjunto)"
102 | ]
103 | },
104 | {
105 | "cell_type": "markdown",
106 | "metadata": {},
107 | "source": [
108 | "Também é possível realizar operações típicas de conjuntos utilizado `sets`, como união, intersecção e diferença. "
109 | ]
110 | },
111 | {
112 | "cell_type": "code",
113 | "execution_count": null,
114 | "metadata": {
115 | "scrolled": true
116 | },
117 | "outputs": [],
118 | "source": [
119 | "impares = {1, 3, 5, 7}\n",
120 | "impares | pares"
121 | ]
122 | },
123 | {
124 | "cell_type": "code",
125 | "execution_count": null,
126 | "metadata": {
127 | "scrolled": true
128 | },
129 | "outputs": [],
130 | "source": [
131 | "impares & pares"
132 | ]
133 | },
134 | {
135 | "cell_type": "code",
136 | "execution_count": null,
137 | "metadata": {},
138 | "outputs": [],
139 | "source": [
140 | "impares - pares"
141 | ]
142 | },
143 | {
144 | "cell_type": "markdown",
145 | "metadata": {},
146 | "source": [
147 | "> `set()` é a forma como o Python representa um conjunto vazio."
148 | ]
149 | },
150 | {
151 | "cell_type": "markdown",
152 | "metadata": {},
153 | "source": [
154 | "### Exercícios de fixação"
155 | ]
156 | },
157 | {
158 | "cell_type": "markdown",
159 | "metadata": {},
160 | "source": [
161 | "1 - Crie um conjunto `primos` que contenha 5 números primos entre 2 e 100 escolhidos aleatoriamente."
162 | ]
163 | },
164 | {
165 | "cell_type": "code",
166 | "execution_count": null,
167 | "metadata": {},
168 | "outputs": [],
169 | "source": []
170 | },
171 | {
172 | "cell_type": "markdown",
173 | "metadata": {},
174 | "source": [
175 | "2 - Crie um conjunto `fibonacci` que contenha 5 números da série de Fibonacci entre 2 e 100 escolhidos aleatoriamente."
176 | ]
177 | },
178 | {
179 | "cell_type": "code",
180 | "execution_count": null,
181 | "metadata": {},
182 | "outputs": [],
183 | "source": []
184 | },
185 | {
186 | "cell_type": "markdown",
187 | "metadata": {},
188 | "source": [
189 | "3 - Verifique se algum número sorteado nos exemplos anteriores pertence ao mesmo tempo a `primos` e a `fibonacci`."
190 | ]
191 | },
192 | {
193 | "cell_type": "code",
194 | "execution_count": null,
195 | "metadata": {},
196 | "outputs": [],
197 | "source": []
198 | },
199 | {
200 | "cell_type": "markdown",
201 | "metadata": {},
202 | "source": [
203 | "## Coleções associativas"
204 | ]
205 | },
206 | {
207 | "cell_type": "markdown",
208 | "metadata": {},
209 | "source": [
210 | "Um outro tipo de coleção disponível no Python são os **dicionários** (`dict`), que além das operações básicas de conjuntos possuem também a capacidade de **associação**.\n",
211 | "\n",
212 | "Em um `dict`, um conjunto de **chaves** (`keys`) está associado a **valores** (`values`). Veja o exemplo abaixo:"
213 | ]
214 | },
215 | {
216 | "cell_type": "code",
217 | "execution_count": null,
218 | "metadata": {},
219 | "outputs": [],
220 | "source": [
221 | "Leonardo = {\"inglês\": \"fluente\", \"espanhol\": \"fluente\", \"italiano\": \"conversa\"}\n",
222 | "Júlia = {\"inglês\": \"compreende\"}"
223 | ]
224 | },
225 | {
226 | "cell_type": "markdown",
227 | "metadata": {},
228 | "source": [
229 | "Chaves:"
230 | ]
231 | },
232 | {
233 | "cell_type": "code",
234 | "execution_count": null,
235 | "metadata": {
236 | "scrolled": false
237 | },
238 | "outputs": [],
239 | "source": [
240 | "for key in Leonardo.keys():\n",
241 | " print(key)"
242 | ]
243 | },
244 | {
245 | "cell_type": "markdown",
246 | "metadata": {},
247 | "source": [
248 | "Valores:"
249 | ]
250 | },
251 | {
252 | "cell_type": "code",
253 | "execution_count": null,
254 | "metadata": {},
255 | "outputs": [],
256 | "source": [
257 | "for value in Leonardo.values():\n",
258 | " print(value)"
259 | ]
260 | },
261 | {
262 | "cell_type": "markdown",
263 | "metadata": {},
264 | "source": [
265 | "Assim como no exemplo do `set`, não há garantia de ordem ao percorrer os elementos de um `dict`.\n",
266 | "\n",
267 | "No entanto, podemos fazer todas as operações de conjuntos sobre `keys`.\n",
268 | "\n",
269 | "- Idiomas em comum:"
270 | ]
271 | },
272 | {
273 | "cell_type": "markdown",
274 | "metadata": {},
275 | "source": []
276 | },
277 | {
278 | "cell_type": "code",
279 | "execution_count": null,
280 | "metadata": {
281 | "scrolled": true
282 | },
283 | "outputs": [],
284 | "source": [
285 | "Leonardo.keys() & Júlia.keys()"
286 | ]
287 | },
288 | {
289 | "cell_type": "markdown",
290 | "metadata": {},
291 | "source": [
292 | "- Idiomas que Leonardo fala, mas Júlia não fala:"
293 | ]
294 | },
295 | {
296 | "cell_type": "code",
297 | "execution_count": null,
298 | "metadata": {
299 | "scrolled": true
300 | },
301 | "outputs": [],
302 | "source": [
303 | "Leonardo.keys() - Júlia.keys()"
304 | ]
305 | },
306 | {
307 | "cell_type": "markdown",
308 | "metadata": {},
309 | "source": [
310 | "- Júlia fala espanhol?"
311 | ]
312 | },
313 | {
314 | "cell_type": "code",
315 | "execution_count": null,
316 | "metadata": {
317 | "scrolled": true
318 | },
319 | "outputs": [],
320 | "source": [
321 | "\"espanhol\" in Júlia"
322 | ]
323 | },
324 | {
325 | "cell_type": "markdown",
326 | "metadata": {},
327 | "source": [
328 | "### Valores associados"
329 | ]
330 | },
331 | {
332 | "cell_type": "markdown",
333 | "metadata": {},
334 | "source": [
335 | "Além das operações de conjunto sobre as chaves, os valores armazenados em um dicionário podem ser acessados usando a chave correspondente:"
336 | ]
337 | },
338 | {
339 | "cell_type": "code",
340 | "execution_count": null,
341 | "metadata": {},
342 | "outputs": [],
343 | "source": [
344 | "Leonardo[\"inglês\"]"
345 | ]
346 | },
347 | {
348 | "cell_type": "markdown",
349 | "metadata": {},
350 | "source": [
351 | "Se buscarmos uma chave que não existe, teremos um erro:"
352 | ]
353 | },
354 | {
355 | "cell_type": "code",
356 | "execution_count": null,
357 | "metadata": {},
358 | "outputs": [],
359 | "source": [
360 | "Leonardo[\"alemão\"]"
361 | ]
362 | },
363 | {
364 | "cell_type": "markdown",
365 | "metadata": {},
366 | "source": [
367 | "Também é possível associar uma chave a um novo valor:"
368 | ]
369 | },
370 | {
371 | "cell_type": "code",
372 | "execution_count": null,
373 | "metadata": {},
374 | "outputs": [],
375 | "source": [
376 | "Leonardo[\"italiano\"] = \"conversação\"\n",
377 | "Leonardo[\"italiano\"]"
378 | ]
379 | },
380 | {
381 | "cell_type": "markdown",
382 | "metadata": {},
383 | "source": [
384 | "A operação de associação também aceita novas chaves. \n",
385 | "\n",
386 | "Neste caso, estamos acrescentando um novo par chave-valor ao `dict`. "
387 | ]
388 | },
389 | {
390 | "cell_type": "code",
391 | "execution_count": null,
392 | "metadata": {},
393 | "outputs": [],
394 | "source": [
395 | "Leonardo[\"alemão\"] = \"compra na Amazon\"\n",
396 | "print(Leonardo)"
397 | ]
398 | },
399 | {
400 | "cell_type": "markdown",
401 | "metadata": {},
402 | "source": [
403 | "Para remover uma chave, usamos o comando `del`:"
404 | ]
405 | },
406 | {
407 | "cell_type": "code",
408 | "execution_count": null,
409 | "metadata": {
410 | "scrolled": false
411 | },
412 | "outputs": [],
413 | "source": [
414 | "del Júlia[\"inglês\"]\n",
415 | "print(Júlia)"
416 | ]
417 | },
418 | {
419 | "cell_type": "markdown",
420 | "metadata": {},
421 | "source": [
422 | "> `{}` é a forma como o Python representa um dicionário vazio."
423 | ]
424 | },
425 | {
426 | "cell_type": "markdown",
427 | "metadata": {},
428 | "source": [
429 | "### Exercícios de fixação"
430 | ]
431 | },
432 | {
433 | "cell_type": "markdown",
434 | "metadata": {},
435 | "source": [
436 | "1 - Peça ao usuário para informar 10 números entre 0 e 30 e conte quantas vezes cada número foi informado."
437 | ]
438 | },
439 | {
440 | "cell_type": "code",
441 | "execution_count": null,
442 | "metadata": {},
443 | "outputs": [],
444 | "source": []
445 | },
446 | {
447 | "cell_type": "markdown",
448 | "metadata": {},
449 | "source": [
450 | "2 - Gere 10 números aleatórios entre 0 e 30 e conte quantas vezes cada número foi gerado."
451 | ]
452 | },
453 | {
454 | "cell_type": "code",
455 | "execution_count": null,
456 | "metadata": {},
457 | "outputs": [],
458 | "source": []
459 | },
460 | {
461 | "cell_type": "markdown",
462 | "metadata": {},
463 | "source": [
464 | "3 - Conte quantos números idênticos o usuário e o computador escolheram."
465 | ]
466 | },
467 | {
468 | "cell_type": "code",
469 | "execution_count": null,
470 | "metadata": {},
471 | "outputs": [],
472 | "source": []
473 | },
474 | {
475 | "cell_type": "markdown",
476 | "metadata": {},
477 | "source": [
478 | "## Coleções com ordem"
479 | ]
480 | },
481 | {
482 | "cell_type": "markdown",
483 | "metadata": {},
484 | "source": [
485 | "Nos exemplos de coleções que vimos até aqui, a ordem dos elementos não era preservada.\n",
486 | "\n",
487 | "**Por não preservar ordem, conjuntos e dicionários são muito rápidos em suas operações.**\n",
488 | "\n",
489 | "Em algumas situações, no entanto, precisamos usar coleções com ordem.\n",
490 | "\n",
491 | "Nesse notebook, vamos ver o caso das listas (`list`):"
492 | ]
493 | },
494 | {
495 | "cell_type": "code",
496 | "execution_count": 8,
497 | "metadata": {
498 | "scrolled": true
499 | },
500 | "outputs": [
501 | {
502 | "name": "stdout",
503 | "output_type": "stream",
504 | "text": [
505 | "3\n",
506 | "5\n",
507 | "2\n",
508 | "4\n"
509 | ]
510 | }
511 | ],
512 | "source": [
513 | "espera = [3, 5, 2, 4]\n",
514 | "for pessoa in espera:\n",
515 | " print(pessoa)"
516 | ]
517 | },
518 | {
519 | "cell_type": "markdown",
520 | "metadata": {},
521 | "source": [
522 | "Em Python, a notação para criar uma `list` é listar os valores separados por vírgulas, delimitados por colchetes.\n",
523 | "\n",
524 | "A garantia de ordem das listas abre um novo mundo de possibilidades.\n",
525 | "\n",
526 | "Agora podemos, por exemplo, inserir um elemento no meio da lista, inclusive se ele já existir na lista:"
527 | ]
528 | },
529 | {
530 | "cell_type": "code",
531 | "execution_count": 9,
532 | "metadata": {
533 | "scrolled": true
534 | },
535 | "outputs": [
536 | {
537 | "data": {
538 | "text/plain": [
539 | "[3, 5, 2, 5, 4]"
540 | ]
541 | },
542 | "execution_count": 9,
543 | "metadata": {},
544 | "output_type": "execute_result"
545 | }
546 | ],
547 | "source": [
548 | "espera.insert(3,5)\n",
549 | "espera"
550 | ]
551 | },
552 | {
553 | "cell_type": "markdown",
554 | "metadata": {},
555 | "source": [
556 | "> Opa, deu errado.. Eu mandei inserir na posição 3 ☹️"
557 | ]
558 | },
559 | {
560 | "cell_type": "markdown",
561 | "metadata": {},
562 | "source": [
563 | "Em linguagens que se prezam, a contagem de posições em uma coleção ordenada começa no índice 0. \n",
564 | "\n",
565 | "Podemos acessar posições de uma lista usando colchetes após seu nome:"
566 | ]
567 | },
568 | {
569 | "cell_type": "code",
570 | "execution_count": 10,
571 | "metadata": {},
572 | "outputs": [
573 | {
574 | "name": "stdout",
575 | "output_type": "stream",
576 | "text": [
577 | "3\n"
578 | ]
579 | }
580 | ],
581 | "source": [
582 | "print(espera[0])"
583 | ]
584 | },
585 | {
586 | "cell_type": "code",
587 | "execution_count": 11,
588 | "metadata": {},
589 | "outputs": [
590 | {
591 | "name": "stdout",
592 | "output_type": "stream",
593 | "text": [
594 | "5\n"
595 | ]
596 | }
597 | ],
598 | "source": [
599 | "print(espera[1])"
600 | ]
601 | },
602 | {
603 | "cell_type": "code",
604 | "execution_count": 12,
605 | "metadata": {},
606 | "outputs": [
607 | {
608 | "name": "stdout",
609 | "output_type": "stream",
610 | "text": [
611 | "2\n"
612 | ]
613 | }
614 | ],
615 | "source": [
616 | "print(espera[2])"
617 | ]
618 | },
619 | {
620 | "cell_type": "code",
621 | "execution_count": 13,
622 | "metadata": {
623 | "scrolled": false
624 | },
625 | "outputs": [
626 | {
627 | "name": "stdout",
628 | "output_type": "stream",
629 | "text": [
630 | "5\n"
631 | ]
632 | }
633 | ],
634 | "source": [
635 | "print(espera[3])"
636 | ]
637 | },
638 | {
639 | "cell_type": "markdown",
640 | "metadata": {},
641 | "source": [
642 | "Também é possível remover um elemento de uma determinada posição:"
643 | ]
644 | },
645 | {
646 | "cell_type": "code",
647 | "execution_count": 14,
648 | "metadata": {
649 | "scrolled": false
650 | },
651 | "outputs": [
652 | {
653 | "name": "stdout",
654 | "output_type": "stream",
655 | "text": [
656 | "[3, 5, 2, 4]\n"
657 | ]
658 | }
659 | ],
660 | "source": [
661 | "espera.pop(3)\n",
662 | "print(espera)"
663 | ]
664 | },
665 | {
666 | "cell_type": "markdown",
667 | "metadata": {},
668 | "source": [
669 | "Acessar posições de uma lista também é chamado de indexar a lista, já que usamos índices para representar as posições.\n",
670 | "\n",
671 | "Note que também seria possível iterar sobre os elementos de uma lista usando índices. \n",
672 | "\n",
673 | "Podemos fazer isso usando o procedimento `enumerate`, que permite iterar sobre uma lista tendo acesso ao índice e ao elemento ao mesmo tempo:"
674 | ]
675 | },
676 | {
677 | "cell_type": "code",
678 | "execution_count": 18,
679 | "metadata": {},
680 | "outputs": [
681 | {
682 | "name": "stdout",
683 | "output_type": "stream",
684 | "text": [
685 | "0: 3\n",
686 | "1: 5\n",
687 | "2: 2\n",
688 | "3: 4\n"
689 | ]
690 | }
691 | ],
692 | "source": [
693 | "for índice, valor in enumerate(espera):\n",
694 | " print(índice, \": \", valor, sep=\"\")"
695 | ]
696 | },
697 | {
698 | "cell_type": "markdown",
699 | "metadata": {},
700 | "source": [
701 | "Um outro caso é quando precisamos seguir uma sequência diferente da ordem dos elementos na lista (avançando ou voltando ao longo da iteração). Neste caso, usamos o laço `while` e o procedimento `len`, que calcula o tamanho da lista.\n",
702 | "\n",
703 | "O código a seguir testa se uma palavra é um palíndromo, isto é, se ele pode ser lida tanto da esquerda para direita como da direita para esquerda:"
704 | ]
705 | },
706 | {
707 | "cell_type": "markdown",
708 | "metadata": {},
709 | "source": [
710 | "> Em Python, um texto pode ser tratado como uma lista de letras! 😱😮😳"
711 | ]
712 | },
713 | {
714 | "cell_type": "code",
715 | "execution_count": 6,
716 | "metadata": {},
717 | "outputs": [],
718 | "source": [
719 | "def palíndromo(palavra):\n",
720 | " início = 0\n",
721 | " fim = len(palavra) - 1\n",
722 | " while início < fim:\n",
723 | " if palavra[início] != palavra[fim]:\n",
724 | " return False\n",
725 | " início += 1\n",
726 | " fim -= 1\n",
727 | " return True"
728 | ]
729 | },
730 | {
731 | "cell_type": "code",
732 | "execution_count": 7,
733 | "metadata": {
734 | "scrolled": true
735 | },
736 | "outputs": [
737 | {
738 | "data": {
739 | "text/plain": [
740 | "True"
741 | ]
742 | },
743 | "execution_count": 7,
744 | "metadata": {},
745 | "output_type": "execute_result"
746 | }
747 | ],
748 | "source": [
749 | "palíndromo(\"reviver\")"
750 | ]
751 | },
752 | {
753 | "cell_type": "code",
754 | "execution_count": 8,
755 | "metadata": {
756 | "scrolled": true
757 | },
758 | "outputs": [
759 | {
760 | "data": {
761 | "text/plain": [
762 | "False"
763 | ]
764 | },
765 | "execution_count": 8,
766 | "metadata": {},
767 | "output_type": "execute_result"
768 | }
769 | ],
770 | "source": [
771 | "palíndromo(\"roma\")"
772 | ]
773 | },
774 | {
775 | "cell_type": "markdown",
776 | "metadata": {},
777 | "source": [
778 | "Algumas operações são tão comuns em listas que o Python oference um atalho para elas.\n",
779 | "\n",
780 | "Pra inserir um elemento no final, por exemplo, temos a opção `append`:"
781 | ]
782 | },
783 | {
784 | "cell_type": "code",
785 | "execution_count": null,
786 | "metadata": {},
787 | "outputs": [],
788 | "source": [
789 | "espera.append(7)\n",
790 | "print(espera)"
791 | ]
792 | },
793 | {
794 | "cell_type": "markdown",
795 | "metadata": {},
796 | "source": [
797 | "### Exercícios de fixação"
798 | ]
799 | },
800 | {
801 | "cell_type": "markdown",
802 | "metadata": {},
803 | "source": [
804 | "1 - Crie uma lista `só_pares` contendo 10 números gerados aleatoriamente entre 0 e 100."
805 | ]
806 | },
807 | {
808 | "cell_type": "code",
809 | "execution_count": null,
810 | "metadata": {},
811 | "outputs": [],
812 | "source": []
813 | },
814 | {
815 | "cell_type": "markdown",
816 | "metadata": {},
817 | "source": [
818 | "2 - Processe a lista `só_pares` para que sobrem apenas números pares, utilizando uma sequência de remoções manuais."
819 | ]
820 | },
821 | {
822 | "cell_type": "code",
823 | "execution_count": null,
824 | "metadata": {},
825 | "outputs": [],
826 | "source": []
827 | },
828 | {
829 | "cell_type": "markdown",
830 | "metadata": {},
831 | "source": [
832 | "3 - Gere uma nova lista `alternados`, contendo 10 números gerados aleatoriamente entre 0 e 100. Após sua criação, processe a lista `alternados` de forma automatizada para que sobrem apenas números pares."
833 | ]
834 | },
835 | {
836 | "cell_type": "code",
837 | "execution_count": null,
838 | "metadata": {},
839 | "outputs": [],
840 | "source": []
841 | },
842 | {
843 | "cell_type": "markdown",
844 | "metadata": {},
845 | "source": [
846 | "4 - Adicione números ímpares gerados aleatoriamente a `alternados`, de forma que após entre dois números pares haja apenas um número ímpar. "
847 | ]
848 | },
849 | {
850 | "cell_type": "markdown",
851 | "metadata": {},
852 | "source": [
853 | "## Exercícios do URI"
854 | ]
855 | },
856 | {
857 | "cell_type": "markdown",
858 | "metadata": {},
859 | "source": [
860 | "[1281](https://www.urionlinejudge.com.br/judge/pt/problems/view/1281) - Dona Parcinova costuma ir regularmente à feira para comprar frutas e legumes. Ela pediu então à sua filha, Mangojata, que a ajudasse com as contas e que fizesse um programa que calculasse o valor que precisa levar para poder comprar tudo que está em sua lista de compras, considerando a quantidade de cada tipo de fruta ou legume e os preços destes itens.\n",
861 | "\n",
862 | "A primeira linha de entrada contém um inteiro N que indica a quantidade de idas à feira de dona Parcinova (que nada mais é do que o número de casos de teste que vem a seguir). Cada caso de teste inicia com um inteiro M que indica a quantidade de produtos que estão disponíveis para venda na feira. Seguem os M produtos com seus preços respectivos por unidade ou Kg. A próxima linha de entrada contém um inteiro P (1 ≤ P ≤ M) que indica a quantidade de diferentes produtos que dona Parcinova deseja comprar. Seguem P linhas contendo cada uma delas um texto e um valor inteiro, que indicam respectivamente o nome de cada produto e a quantidade deste produto.\n",
863 | "\n",
864 | "Para cada caso de teste, imprima o valor que será gasto por dona Parcinova, com 2 casas decimais, conforme o exemplo abaixo."
865 | ]
866 | },
867 | {
868 | "cell_type": "markdown",
869 | "metadata": {},
870 | "source": [
871 | "|.| Entrada | Saída |\n",
872 | "|-|:----:|:-:|\n",
873 | "| *Exemplo 1* | 4
mamao 2.19
cebola 3.10
tomate 2.80
uva 2.73
3
mamao 2
tomate 1
uva 3
| 15.37 | \n",
874 | "| *Exemplo 2* | 5
morango 6.70
repolho 1.12
brocolis 1.71
tomate 2.80
cebola 2.81
4
brocolis 2
tomate 1
cebola 1
morango 1 | 15.73 | \n",
875 | "| *Exemplo 3* | 5
ovos 8.45
pão 3.10
bacon 7.32
iogurte 2.47
coalhada 1.75
3
bacon 2
ovos 1
coalhada 4 | 30.09 | "
876 | ]
877 | },
878 | {
879 | "cell_type": "code",
880 | "execution_count": null,
881 | "metadata": {},
882 | "outputs": [],
883 | "source": []
884 | },
885 | {
886 | "cell_type": "markdown",
887 | "metadata": {},
888 | "source": [
889 | "[1104](https://www.urionlinejudge.com.br/judge/pt/problems/view/1104) - Alice e Beatriz colecionam cartas de Pokémon. As cartas são produzidas para um jogo que reproduz a batalha introduzida em um dos mais bem sucedidos jogos de videogame da história, mas Alice e Beatriz são muito pequenas para jogar, e estão interessadas apenas nas cartas propriamente ditas. Para facilitar, vamos considerar que cada carta possui um identificador único, que é um número inteiro.\n",
890 | "\n",
891 | "Cada uma das duas meninas possui um conjunto de cartas e, como a maioria das garotas de sua idade, gostam de trocar entre si as cartas que têm. Elas obviamente não têm interesse emtrocar cartas idênticas, que ambas possuem, e não querem receber cartas repetidas na troca. Além disso, as cartas serão trocadas em uma única operação de troca: Alice dá para Beatriz um sub-conjunto com N cartas distintas e recebe de volta um outro sub-conjunto com N cartas distintas.\n",
892 | "\n",
893 | "As meninas querem saber qual é o número máximo de cartas que podem ser trocadas. Por exemplo, se Alice tem o conjunto de cartas {1, 1, 2, 3, 5, 7, 8, 8, 9, 15} e Beatriz o conjunto {2, 2, 2, 3, 4, 6, 10, 11, 11}, elas podem trocar entre si no máximo quatro cartas. Escreva um código que, dados os conjuntos de cartas que Alice e Beatriz possuem, determine o número máximo de cartas que podem ser trocadas.\n",
894 | "\n",
895 | "A primeira linha da entrada contém números inteiros representando as cartas do conjunto de Alice, separados por um espaço em branco. A segunda linha contém números inteiros representando as cartas do conjunto de Beatriz. As cartas de Alice e Beatriz são apresentadas em ordem não decrescente.\n",
896 | "\n",
897 | "Imprima uma única linha, contendo um numero inteiro, indicando o número máximo de cartas que Alice e Beatriz podem trocar entre si."
898 | ]
899 | },
900 | {
901 | "cell_type": "markdown",
902 | "metadata": {},
903 | "source": [
904 | "|.| Entrada | Saída |\n",
905 | "|-|:----:|:-:|\n",
906 | "| *Exemplo 1* | 1000
1000 | 0 | \n",
907 | "| *Exemplo 2* | 1 3 5
2 4 6 8 | 3 | \n",
908 | "| *Exemplo 3* | 1 1 2 3 5 7 8 8 9 15
2 2 2 3 4 6 10 11 11 | 4 | "
909 | ]
910 | },
911 | {
912 | "cell_type": "code",
913 | "execution_count": null,
914 | "metadata": {},
915 | "outputs": [],
916 | "source": []
917 | },
918 | {
919 | "cell_type": "markdown",
920 | "metadata": {},
921 | "source": [
922 | "[1110](https://www.urionlinejudge.com.br/judge/pt/problems/view/1110) - Piotr é um canadense gente boa que veio morar no Brasil e nas horas vagas gosta de jogar cartas.\n",
923 | "\n",
924 | "Um dos jogos preferidos dele é o de adivinhar qual carta vai ficar por último no baralho, considerando as seguintes condições:\n",
925 | "- o deck de cartas contém apenas cartas de números. Se o deck tiver n cartas, essas cartas estarão numeradas de 1 a n e ordenadas, com a carta 1 no topo e a carta n no fundo. \n",
926 | "- a carta descartada é a que estiver no topo.\n",
927 | "- quando uma carta for descartada, a carta seguinte deverá ser movida para o fim do deck.\n",
928 | "\n",
929 | "Escreva um código que ajude os amigos de Piotr a derrotá-lo, descobrindo qual carta ficará por último no baralho.\n",
930 | "\n",
931 | "A entrada será um número que indicará quantas cartas têm no deck. A saída deverá ter duas linhas. Na primeira, informe as cartas descartadas, na sequência em que elas forem descartadas. Na segunda, informe a carta que ficou por último no deck."
932 | ]
933 | },
934 | {
935 | "cell_type": "markdown",
936 | "metadata": {},
937 | "source": [
938 | "|.| Entrada | Saída |\n",
939 | "|-|:----:|:-:|\n",
940 | "| *Exemplo 1* | 7 | 1 3 5 7 4 2
6 | \n",
941 | "| *Exemplo 2* | 10 | 1 3 5 7 9 2 6 10 8
4 |\n",
942 | "| *Exemplo 3* | 6 | 1 3 5 2 6
4 | "
943 | ]
944 | },
945 | {
946 | "cell_type": "code",
947 | "execution_count": null,
948 | "metadata": {},
949 | "outputs": [],
950 | "source": []
951 | },
952 | {
953 | "cell_type": "markdown",
954 | "metadata": {},
955 | "source": [
956 | "## Exercícios do UVa"
957 | ]
958 | },
959 | {
960 | "cell_type": "markdown",
961 | "metadata": {},
962 | "source": [
963 | "[10226](https://uva.onlinejudge.org/index.php?option=onlinejudge&page=show_problem&problem=1167) - Madeira de lei é o grupo botânico de árvores que têm folhas largas, produzem um fruto ou uma noz e geralmente hibernam no inverno. O carvalho e a cerejeira, por exemplo, são tipos de madeira de lei, mas são de diferentes espécies. \n",
964 | "\n",
965 | "Usando tecnologia de mapeamento por satélite, o Departamento de Recursos Naturais catalogou todas as árvores existentes. Você precisa calcular o percentual que uma determinada espécie representa em relação à população inteira de árvores.\n",
966 | "\n",
967 | "A entrada consiste de uma lista de espécies observadas pelo satélite, uma árvore por linha. \n",
968 | "\n",
969 | "Seu código deverá imprimir o nome de cada espécie e seu percentual em relação à população total, considerando 4 casas decimais."
970 | ]
971 | },
972 | {
973 | "cell_type": "markdown",
974 | "metadata": {},
975 | "source": [
976 | "|.| Entrada | Saída |\n",
977 | "|-|:----:|:-:|\n",
978 | "| *Exemplo 1* | Red Alder
Ash
Aspen
Basswood
Ash
Beech
Yellow Birch
Ash
Beech
Cottonwood | Red Alder 10.0000
Ash 30.0000
Aspen 10.0000
Basswood 10.0000
Beech 20.0000
Yellow Birch 10.0000
Cottonwood 10.0000 | \n",
979 | "| *Exemplo 2* | White Oak
Hickory
Pecan
Hard Maple
White Oak
Soft Maple
Red Oak
Red Oak
White Oak | White Oak 33.3333
Hickory 11.1111
Pecan 11.1111
Hard Maple 11.11111
Soft Maple 11.1111
Red Oak 22.2222 |\n",
980 | "| *Exemplo 3* | Ash
Cypress
Red Elm
Gum
Hackberry
Poplan
Sassafras | Ash 0.1428
Cypress 0.1428
Red Elm 0.1428
Gum 0.1428
Hackberry 0.1428
Poplan 0.1428
Sassafras 0.1428 | "
981 | ]
982 | },
983 | {
984 | "cell_type": "code",
985 | "execution_count": null,
986 | "metadata": {},
987 | "outputs": [],
988 | "source": []
989 | },
990 | {
991 | "cell_type": "markdown",
992 | "metadata": {},
993 | "source": [
994 | "[11849](https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=2949) - Jack e Jill decidiram vender alguns dos seus livros. Eles decidiram que só vão vender os livros que os dois têm em comum. De cada livro, Jack possui no máximo uma cópia, assim como Jill. Quantos livros Jack e Jill podem vender?\n",
995 | "\n",
996 | "Escreva um código que receba como entrada os livros de Jack em uma linha, identificados por um número e separados por espaço. A linha seguinte segue o mesmo padrão e informa os livros de Jill.\n",
997 | "\n",
998 | "Seu código deverá informar quantos livros Jack e Jill têm em comum."
999 | ]
1000 | },
1001 | {
1002 | "cell_type": "markdown",
1003 | "metadata": {},
1004 | "source": [
1005 | "|.| Entrada | Saída |\n",
1006 | "|-|:----:|:-:|\n",
1007 | "| *Exemplo 1* | 1 2 3
1 2 4 | 2 | \n",
1008 | "| *Exemplo 2* | 4 8 1 3 2
2 4 6 8 | 3 | \n",
1009 | "| *Exemplo 3* | 5 4 2 3 7 12 9 15
2 6 11 10 9 5 4 3 | 4 | "
1010 | ]
1011 | },
1012 | {
1013 | "cell_type": "code",
1014 | "execution_count": null,
1015 | "metadata": {},
1016 | "outputs": [],
1017 | "source": []
1018 | }
1019 | ],
1020 | "metadata": {
1021 | "kernelspec": {
1022 | "display_name": "Python 3",
1023 | "language": "python",
1024 | "name": "python3"
1025 | },
1026 | "language_info": {
1027 | "codemirror_mode": {
1028 | "name": "ipython",
1029 | "version": 3
1030 | },
1031 | "file_extension": ".py",
1032 | "mimetype": "text/x-python",
1033 | "name": "python",
1034 | "nbconvert_exporter": "python",
1035 | "pygments_lexer": "ipython3",
1036 | "version": "3.6.8"
1037 | }
1038 | },
1039 | "nbformat": 4,
1040 | "nbformat_minor": 1
1041 | }
1042 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Pensamento computacional com Python
2 |
3 | Este repositório foi pensado para quem já teve um primeiro contato com pensamento computacional (ou apenas com lógica de programação), mas ainda não tem experiência com linguagens de programação.
4 |
5 | Também pode ser útil pra quem está iniciando em programação e já teve primeiros contatos com Python ou com outra linguagem de programação.
6 |
7 | > Se você está mais avançado do que isso, dê uma olhada neste [notebook](https://github.com/ivanovitchm/datascience_one_2019_1/blob/master/Lesson%2302/Lesson%2302%20Python%20crash%20course.ipynb) ou veja essas [referências](#disclaimer) 🙃
8 |
9 | ---
10 |
11 | * [01](01.ipynb) - Primeiros passos: variáveis, expressões aritméticas, strings, I/O
12 |
13 | [](https://colab.research.google.com/github/leobezerra/python-zero/blob/master/01.ipynb)
14 | [](https://mybinder.org/v2/gh/leobezerra/python-zero/master)
15 | [](https://youtu.be/B1UkSqy3MR0)
16 | [](http://perso.crans.org/besson/LICENSE.html)
17 |
18 | ---
19 |
20 | * [02](02.ipynb) - Comparando e decidindo: operadores de comparação, operadores lógicos e estruturas de decisão (`if`-`elif`-`else`)
21 |
22 | [](https://colab.research.google.com/github/leobezerra/python-zero/blob/master/02.ipynb)
23 | [](https://mybinder.org/v2/gh/leobezerra/python-zero/master)
24 | [](https://youtu.be/Wnoc3R6j9Gg?t=747)
25 | [](http://perso.crans.org/besson/LICENSE.html)
26 |
27 | ---
28 |
29 | * [03](03.ipynb) - Repetindo sem perder o controle!: estruturas de repetição (`for`, `while`)
30 |
31 | [](https://colab.research.google.com/github/leobezerra/python-zero/blob/master/03.ipynb)
32 | [](https://mybinder.org/v2/gh/leobezerra/python-zero/master)
33 | [](https://youtu.be/YQahSgGazsg)
34 | [](http://perso.crans.org/besson/LICENSE.html)
35 |
36 | ---
37 |
38 | * [04](04.ipynb) - Procedimentos: organizando e reaproveitando seu código
39 |
40 | [](https://colab.research.google.com/github/leobezerra/python-zero/blob/master/04.ipynb)
41 | [](https://mybinder.org/v2/gh/leobezerra/python-zero/master)
42 | [](http://perso.crans.org/besson/LICENSE.html)
43 |
44 | ---
45 |
46 | * [05](05.ipynb) - Abrindo a caixa de ferramentas: coleções (`set`, `dict`, `list`)
47 |
48 | [](https://colab.research.google.com/github/leobezerra/python-zero/blob/master/05.ipynb)
49 | [](https://mybinder.org/v2/gh/leobezerra/python-zero/master)
50 | [](http://perso.crans.org/besson/LICENSE.html)
51 |
52 | ---
53 |
54 | ### Disclaimer
55 | > Este material é usado na 3a unidade da disciplina Pensamento Computacional do Instituto Metrópole Digital da Universidade Federal do Rio Grande do Norte.
56 |
57 | * Autor: Leonardo Bezerra
58 | * Materiais de referência:
59 | * [Python Lectures](https://github.com/rajathkmp/Python-Lectures.git)
60 | * [Python4Maths](https://gitlab.erc.monash.edu.au/andrease/Python4Maths.git)
61 | * [The Python Bible](https://www.udemy.com/the-python-bible/)
62 |
--------------------------------------------------------------------------------
/imgs/UOJ_1041.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/leobezerra/python-zero/4ca6c5e2db296afd452a40e63f5469f6aede8349/imgs/UOJ_1041.png
--------------------------------------------------------------------------------
/imgs/UOJ_1049_b.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/leobezerra/python-zero/4ca6c5e2db296afd452a40e63f5469f6aede8349/imgs/UOJ_1049_b.png
--------------------------------------------------------------------------------