Merge pull request OpenDevUFCG#85 from jonathantvrs/jupyter-notebooks-p1

Adiciona notebooks com tutorias de Programação I.

.gitignore

@@ -326,4 +326,8 @@ $RECYCLE.BIN/
 # Windows shortcuts
 *.lnk
 
+### JupyterNotebook ###
+.ipynb_checkpoints
+*/.ipynb_checkpoints/*
+
 # End of https://www.gitignore.io/api/c,c++,java,linux,macos,python,windows,haskell,visualstudiocode

prog1/README.md

@@ -7,3 +7,4 @@
 - [Implementações](implementacoes)
 - [Links Úteis](linksUteis.md)
 - [Visão Geral e Dicas](visaoGeralEDicas.md)
+- [Tutoriais](tutoriais)*

prog1/tutoriais/README.md

@@ -0,0 +1,63 @@
+# Tutoriais
+
+Tutoriais com assuntos ensinados em Programação 1 e Laboratório de Programação 1.
+
+## O que tem?
+Para seguir a mesma ordem no qual os assuntos são ensinados na disciplina, siga esse roteiro:
+
+1. [Hello World](helloWorld.ipynb)
+2. [Formatação de Strings](formatacaoDeStrings.ipynb)
+3. [Estruturas de Condição](estruturasDeCondicao.ipynb)
+4. [Estruturas de Repetição](estruturasDeRepeticao.ipynb)
+5. [Funções](funcoes.ipynb)
+6. [Listas](listas.ipynb)
+7. [Matrizes](matrizes.ipynb)
+8. [Algoritmos de Ordenação](algoritmosOrdenacao.ipynb)
+9.  [Dicionários](dicionarios.ipynb)
+
+
+## Como rodar
+Os tutoriais são feitos usando Jupyter notebooks, que são estruturas que permitem que adicionememos blocos de código, de texto, imagens e etc. São mais poderosos que arquivos `.py` e facilitam o aprendizado.
+
+Aqui no github você consegue vê-los de maneira estática, mas caso você queira se aventurar, modificar o código e ver saídas novas, você precisar rodar os notebooks.
+
+Para rodar os notebooks, vocês tem duas opções: Usando [Jupyter Notebook](https://jupyter.org/) localmente ou usando o [Google Colab](https://colab.research.google.com/)
+
+### Google Colab
+
+O Google Colab é uma plataforma cloud gratuita que permite rodar código Python. Para utilizá-lo nesse repositório e visualizar os notebooks, siga os passos:
+
+#### Plugin
+Usando este [plugin](https://chrome.google.com/webstore/detail/open-in-colab/iogfkhleblhcpcekbiedikdehleodpjo) é a maneira mais fácil e rápida para abrir os notebooks. Basta ter uma conta no [Google Colab](https://colab.research.google.com/), adicionar este plugin ao seu navegador e ir para o tutorial que você deseja abrir.
+
+#### Pelo site
+
+No site, você vai pedir para que ele abra os Notebooks do nosso repositório, seguindo os passos:
+
+1. Entre no site do [Google Colab](https://colab.research.google.com/) e faça seu login.
+2. Ele vai pedir para você importar notebooks de algum lugar, escolha a opção *Github*
+3. Coloque nossa URL `https://github.com/OpenDevUFCG/Tamburetei` e confirme.
+4. Pronto agora você pode mexer nos notebooks a vontade!
+
+### Localmente
+
+Para rodar os notebooks localmente no seu computador, você vai precisar clonar este repositório ou baixá-lo.
+
+Clonando:
+
+```sh
+git clone https://github.com/OpenDevUFCG/Tamburetei/
+```
+
+Caso você não queira usar o terminal, você pode usar o [Github Desktop](https://desktop.github.com/).
+
+Após você ter o repositório baixado na sua máquina, você deve instalar o **Jupyter Notebook**, você pode seguir esse [tutorial](https://medium.com/horadecodar/como-instalar-o-jupyter-notebook-windows-e-linux-20701fc583c).
+
+Agora é só você ir para este repositório no terminal e rodar o *jupyter*:
+
+```sh
+cd Tamburetei/
+jupyter notebook
+```
+
+Caso tenha dúvidas, abra uma issue que a gente te ajuda!

prog1/tutoriais/algoritmosOrdenacao.ipynb

@@ -0,0 +1,275 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "WpzpsMsncWz2"
+   },
+   "source": [
+    "Algoritmos de ordenação\n",
+    "====== \n",
+    "\n",
+    "Algoritmos de ordenação são blocos de código que tem como objetivo organizar os elementos de uma dada sequência em uma certa ordem, em outras palavras, efetua a ordenação completa ou parcial de uma lista. O parâmetro de ordem mais utilizado para estes algoritmos é ordem numérica."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "WpzpsMsncWz2"
+   },
+   "source": [
+    "## Introdução\n",
+    "\n",
+    "Em diversas aplicações, tanto científicas, quanto comerciais, é muito comum que existam problemas de ordenação, por exemplo, ordenar números em ordem crescente ou decrescente, ordenar nomes por ordem alfabética, etc. Para ordenar os elementos de uma maneira eficaz é necessário o uso de um algoritmo de ordenação. Existem diversos deles, e é de suma importância que um programador tenha ciência de boa parte, já que, conhecendo esses algoritmos, ele poderá escolher o melhor de acordo com a necessidade, melhorando o desempenho da aplicação.\n",
+    "\n",
+    "Nas disciplinas de *Programação 1* e *Laboratório de Programação 1* do curso de Ciência da Computação da UFCG, os estudantes são apresentados a três desses algoritmos, os mais básicos: `bubble sort`, `insertion sort` e `selection sort`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "WpzpsMsncWz2"
+   },
+   "source": [
+    "## Bubble Sort\n",
+    "\n",
+    "O bubble sort é o algoritmo de ordenação mais simples. A ideia é percorrer a lista várias vezes e, a cada passagem, compara-se os elementos adjacentes (dois a dois) e fazer com que, em caso de uma ordenação crescente, que o menor fique à esquerda e o maior à direita. Por exemplo: compara-se o último elemento da lista com o seu antecessor, se este for maior que o último, eles devem trocar de posição, fazendo com que o menor dos dois fique na posição da esquerda, e o maior à direita. Vejamos o exemplo de uma passagem pela lista:\n",
+    "\n",
+    "| Posição           | 0       | 1       | 2        | 3        | 4        |                   |\n",
+    "|:----------------: | :-----: | :-----: | :------: | :------: | :------: | :---------------: |\n",
+    "| Situação da lista | 200     | 0       | 95       | **752**  | **190**  | Compara           |\n",
+    "| Situação da lista | 200     | 0       | 95       | **190**  | **752**  | Troca             |\n",
+    "| Situação da lista | 200     | 0       | **95**   | **190**  | 752      | Compara           |\n",
+    "| Situação da lista | 200     | 0       | **95**   | **190**  | 752      | Não troca         |\n",
+    "| Situação da lista | 200     | **0**   | **95**   | 190      | 752      | Compara           |\n",
+    "| Situação da lista | 200     | **0**   | **95**   | 190      | 752      | Não troca         |\n",
+    "| Situação da lista | **200** | **0**   | 95       | 190      | 752      | Compara           |\n",
+    "| Situação da lista | **0**   | **200** | 95       | 190      | 752      | Troca             |\n",
+    "| Situação da lista | 0       | 200     | 95       | 190      | 752      | Final da iteração |\n",
+    "\n",
+    "Note que, no exemplo acima, garantimos que **o menor elemento da lista foi jogado para o início**. Ao fazer isso diversas vezes, seguindo o algoritmo bubble sort, teremos ao final do processo a lista inteiramente ordenada.\n",
+    "\n",
+    "Observe abaixo a implementação do algoritmo:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[54, 26, 93, 17, 77, 31, 44, 55, 20]\n",
+      "[17, 54, 26, 93, 20, 77, 31, 44, 55]\n",
+      "[17, 20, 54, 26, 93, 31, 77, 44, 55]\n",
+      "[17, 20, 26, 54, 31, 93, 44, 77, 55]\n",
+      "[17, 20, 26, 31, 54, 44, 93, 55, 77]\n",
+      "[17, 20, 26, 31, 44, 54, 55, 93, 77]\n",
+      "[17, 20, 26, 31, 44, 54, 55, 77, 93]\n",
+      "[17, 20, 26, 31, 44, 54, 55, 77, 93]\n",
+      "[17, 20, 26, 31, 44, 54, 55, 77, 93]\n",
+      "[17, 20, 26, 31, 44, 54, 55, 77, 93]\n"
+     ]
+    }
+   ],
+   "source": [
+    "lista = [54, 26, 93, 17, 77, 31, 44, 55, 20]\n",
+    "\n",
+    "# Início do algoritmo Bubble Sort\n",
+    "for i in range(len(lista)):\n",
+    "    \n",
+    "    print(lista)\n",
+    "    # Imprimindo o estado atual da lista\n",
+    "    \n",
+    "    for j in range(len(lista) - 1, i, -1):\n",
+    "        \n",
+    "        if (lista[j] < lista[j - 1]):\n",
+    "            \n",
+    "            # Realiza a troca, caso o elemento seja maior que o outro\n",
+    "            lista[j], lista[j - 1] = lista[j - 1], lista[j]\n",
+    "\n",
+    "print(lista)\n",
+    "# Imprimindo o estado final da lista (ordenada)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "WpzpsMsncWz2"
+   },
+   "source": [
+    "## Insertion Sort\n",
+    "\n",
+    "A ordenação por inserção parte do princípio que uma lista com apenas um elemento está, por natureza, ordenada. Ou seja, a sub-lista formada pelo primeiro elemento da lista está ordenada. A partir do segundo elemento, o algoritmo vai \"trazendo\" para a sua posição apropriada entre aqueles já ordenados. O elemento é inserido na posição adequada movendo-se todos os elementos maiores para posição seguinte do vetor. Observe o exemplo:\n",
+    "\n",
+    "| Posição           | 0       | 1       | 2        | 3        | 4        |                              |\n",
+    "|:----------------: | :-----: | :-----: | :------: | :------: | :------: | :--------------------------: |\n",
+    "| Situação da lista | **200** | 0       | 95       | 752      | 190      | Em negrito: ordenado         |\n",
+    "| Situação da lista | **200** | **0**   | 95       | 752      | 190      | Levar o 0 até sua posição    |\n",
+    "| Situação da lista | **0**   | **200** | 95       | 752      | 190      | Em negrito: ordenado         |\n",
+    "| Situação da lista | **0**   | **200** | **95**   | 752      | 190      | Levar o 95 até sua posição   |\n",
+    "| Situação da lista | **0**   | **95**  | **200**  | 752      | 190      | Em negrito: ordenado         |\n",
+    "| Situação da lista | **0**   | **95**  | **200**  | **752**  | 190      | O 752 já está em sua posição |\n",
+    "| Situação da lista | **0**   | **95**  | **200**  | **752**  | 190      | Em negrito: ordenado         |\n",
+    "| Situação da lista | **0**   | **95**  | **200**  | **752**  | **190**  | Levar o 190 até sua posição  |\n",
+    "| Situação da lista | **0**   | **95**  | **190**  | **200**  | **752**  | Em negrito: ordenado         |\n",
+    "| Situação da lista | 0       | 95      | 190      | 200      | 752      | Lista ordenada               |\n",
+    "\n",
+    "\n",
+    "Note que, no exemplo acima, já pudemos ilustrar o processo completo do insertion sort, e no final do exemplo encontramos a lista ordenada.\n",
+    "\n",
+    "Observe abaixo a implementação do algoritmo:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[54, 26, 93, 17, 77, 31, 44, 55, 20]\n",
+      "[54, 26, 93, 17, 77, 31, 44, 55, 20]\n",
+      "[26, 54, 93, 17, 77, 31, 44, 55, 20]\n",
+      "[26, 54, 93, 17, 77, 31, 44, 55, 20]\n",
+      "[17, 26, 54, 93, 77, 31, 44, 55, 20]\n",
+      "[17, 26, 54, 77, 93, 31, 44, 55, 20]\n",
+      "[17, 26, 31, 54, 77, 93, 44, 55, 20]\n",
+      "[17, 26, 31, 44, 54, 77, 93, 55, 20]\n",
+      "[17, 26, 31, 44, 54, 55, 77, 93, 20]\n",
+      "[17, 20, 26, 31, 44, 54, 55, 77, 93]\n"
+     ]
+    }
+   ],
+   "source": [
+    "lista = [54, 26, 93, 17, 77, 31, 44, 55, 20]\n",
+    "\n",
+    "# Início do algoritmo Insertion Sort\n",
+    "for i in range(len(lista)):\n",
+    "    \n",
+    "    print(lista)\n",
+    "    # Imprimindo o estado atual da lista\n",
+    "    \n",
+    "    j = i - 1\n",
+    "    \n",
+    "    valor = lista[i]\n",
+    "    \n",
+    "    while(j >= 0 and lista[j] > valor):\n",
+    "        \n",
+    "        # Realiza a troca enquanto o elemento que vem antes for maior\n",
+    "        lista[j], lista[j + 1] = lista[j + 1], lista[j]\n",
+    "        \n",
+    "        # Decrementa o valor de j\n",
+    "        j  -= 1\n",
+    "\n",
+    "print(lista)\n",
+    "# Imprimindo o estado final da lista (ordenada)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "colab_type": "text",
+    "id": "WpzpsMsncWz2"
+   },
+   "source": [
+    "## Selection Sort\n",
+    "\n",
+    "A ordenação por seleção, se feita num modelo em que a ordenação é feita do menor par o maior, se baseia em se passar sempre o menor valor do vetor para a primeira posição, depois o de segundo menor valor para a segunda posição, e assim é feito sucessivamente com os elementos restantes. Em resumo, sua ideia consiste em ordenar a lista “selecionando” a cada iteração o menores itens possíveis e os posicionando da esquerda para a direita na lista. Observe o exemplo:\n",
+    "\n",
+    "| Posição           | 0       | 1       | 2        | 3        | 4        |                              |\n",
+    "|:----------------: | :-----: | :-----: | :------: | :------: | :------: | :--------------------------: |\n",
+    "| Situação da lista | 200     | 0       | 95       | 752      | 190      | Estado inicial               |\n",
+    "| Situação da lista | **0**   | 200     | 95       | 752      | 190      | Leva o 0 para a 1ª posição   |\n",
+    "| Situação da lista | **0**   | **95**  | 200      | 752      | 190      | Leva o 95 para a 2ª posição  |\n",
+    "| Situação da lista | **0**   | **95**  | **190**  | 200      | 752      | Leva o 190 para a 3ª posição |\n",
+    "| Situação da lista | **0**   | **95**  | **190**  | **200**  | 752      | Deixa o 200 na 4ª posição    |\n",
+    "| Situação da lista | **0**   | **95**  | **190**  | **200**  | **752**  | Deixa o 752 na 5ª posição    |\n",
+    "| Situação da lista | 0       | 95      | 190      | 200      | 752      | Lista ordenada               |\n",
+    "\n",
+    "\n",
+    "\n",
+    "Note que, no exemplo acima, já pudemos ilustrar o processo completo do selection sort, e no final do exemplo encontramos a lista ordenada.\n",
+    "\n",
+    "Observe abaixo a implementação do algoritmo:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[54, 26, 93, 17, 77, 31, 44, 55, 20]\n",
+      "[17, 26, 93, 54, 77, 31, 44, 55, 20]\n",
+      "[17, 20, 93, 54, 77, 31, 44, 55, 26]\n",
+      "[17, 20, 26, 54, 77, 31, 44, 55, 93]\n",
+      "[17, 20, 26, 31, 77, 54, 44, 55, 93]\n",
+      "[17, 20, 26, 31, 44, 54, 77, 55, 93]\n",
+      "[17, 20, 26, 31, 44, 54, 77, 55, 93]\n",
+      "[17, 20, 26, 31, 44, 54, 55, 77, 93]\n",
+      "[17, 20, 26, 31, 44, 54, 55, 77, 93]\n",
+      "[17, 20, 26, 31, 44, 54, 55, 77, 93]\n"
+     ]
+    }
+   ],
+   "source": [
+    "lista = [54, 26, 93, 17, 77, 31, 44, 55, 20]\n",
+    "\n",
+    "# Início do algoritmo Selection Sort\n",
+    "for i in range(len(lista)):\n",
+    "    \n",
+    "    print(lista)\n",
+    "    # Imprimindo o estado atual da lista\n",
+    "    \n",
+    "    pos_menor = i # Declarando a variável que vai guardar a posição do menor valor\n",
+    "    \n",
+    "    for j in range(i + 1, len(lista)):\n",
+    "        \n",
+    "        if (lista[j] < lista[pos_menor]):\n",
+    "            \n",
+    "            # Atribuindo o novo valor para pos_menor caso um elemento menor seja encontrado dentro da lista\n",
+    "            pos_menor = j\n",
+    "    \n",
+    "    # Leva os menores elementos para suas respectivas posições\n",
+    "    lista[i], lista[pos_menor] = lista[pos_menor], lista[i]\n",
+    "        \n",
+    "    \n",
+    "print(lista)\n",
+    "# Imprimindo o estado final da lista"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 2",
+   "language": "python",
+   "name": "python2"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}