Lab_02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lab 02\n",
    "In this lab we will cover the following:\n",
    "1. Lists\n",
    "- boolean expressions\n",
    "- conditionals\n",
    "- while loops\n",
    "- The Method of False Position\n",
    "\n",
    "\n",
    "Instructions: This is an interactive Jupyter notebook that can be edited on the fly. There are hands on activities throughout this lab. Enter you answers and solutions into this notebook and print out a PDF of your finished lab. At the end of the lab there will be links to online programming problems, complete those and save a PDF of your results.\n",
    "\n",
    "\n",
    "Note: If Binder is taking too long, you can run the code snippets in (https://repl.it/languages/python3). Alternatively you can install Anaconda on your computer and run this notebook locally (https://www.anaconda.com/distribution/).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "\n",
    "*Lists* are an ordered collection of values that are indexed by an *Integer* between $0$ and $m-1$, where $m$ is the length, or size, of the list.\n",
    "\n",
    "We define a list using brackets ([]) around the elements, of any type, that we want in the list. In the following example we have list named $ll$ with the elements $10, 2.3$ and the *string* \"hello\".\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ll = [10, 2.3, \"hello\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can find the length of the list using the $len()$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m  = len(ll)\n",
    "print(\"length of ll is \" + str(m))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access the elements in the list using $ll[i]$ where $i$ is an *integer* between $0$ and $m-1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"element of ll at index 0 is \" + str(ll[0]))\n",
    "print(\"element of ll at index 1 is \" + str(ll[1]))\n",
    "print(\"element of ll at index 2 is \" + str(ll[2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boolean Expressions\n",
    "\n",
    "In the previous lab we discussed *expressions*, or math, in Python that mapped to either the *integers* or the *floating point* values. In this section we will talk about *expressions* that map to *boolean*, or True/False, values. \n",
    "\n",
    "First off we can assign a variable a boolean value of True or False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = True\n",
    "y = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python provides us with a handful of *operators* that evaluate to *boolean* values including the *comparison operators*, $\\lt,\\leq,=,\\geq,\\gt,\\ne$, which compare two *integer* or *floating point* values and produce a *boolean*. i.e. $3<4 = True $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Give me an integer A\")\n",
    "A = int(input())\n",
    "print(\"Give me an integer B\")\n",
    "B = int(input())\n",
    "\n",
    "# less than\n",
    "a_lt_b = (A < B)\n",
    "print(\"A <  B = \" + str(a_lt_b))\n",
    "\n",
    "# less than or equal to\n",
    "a_leq_b = (A <= B)\n",
    "print(\"A <= B = \" + str(a_leq_b))\n",
    "\n",
    "# equal\n",
    "a_eq_b = (A == B)\n",
    "print(\"A == B = \" + str(a_eq_b))\n",
    "\n",
    "# greater than or equal to\n",
    "a_geq_b = (A >= B)\n",
    "print(\"A >= B = \" + str(a_geq_b))\n",
    "\n",
    "# greater than\n",
    "a_gt_b = (A > B)\n",
    "print(\"A >  B = \" + str(a_gt_b))\n",
    "\n",
    "# not equal to\n",
    "a_ne_b = (A != B)\n",
    "print(\"A != B = \" + str(a_ne_b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python also provides us with the *logical operators* $And$, $Or$, $Exclusive Or$ and $Not$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Give me \\\"True\\\" or \\\"False\\\" for A.\")\n",
    "A = bool(input())\n",
    "print(\"Give me \\\"True\\\" or \\\"False\\\" for B.\")\n",
    "B = bool(input())\n",
    "\n",
    "# we can also do (A|B)\n",
    "a_or_b = A or B\n",
    "print(\"A or B is \" + str(a_or_b))\n",
    "\n",
    "# we can also do (A&B)\n",
    "a_and_b = A and B\n",
    "print(\"A and B is \" + str(a_and_b))\n",
    "\n",
    "# we can do exclusive or\n",
    "a_xor_b = A ^ B\n",
    "print(\"A xor B is \" + str(a_xor_b))\n",
    "\n",
    "\n",
    "anot = not(A)\n",
    "print(\"not(A) is \" + str(anot))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can code up a program to generate a *truth table* for the *And* operator as follows. Note, for this example we will change how we format our *strings* to present the values. This is an alternative form that is a bit more concise than how we were previously formatting the *strings*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "atrue_and_btrue   = True and True\n",
    "atrue_and_bfalse  = True and False\n",
    "afalse_and_btrue  = False and True\n",
    "afalse_and_bfalse = False and False\n",
    "\n",
    "\n",
    "print(\"A&B___T_____F___\")\n",
    "print(\"T | {atbt} | {atbf}\".format(atbt=atrue_and_btrue,atbf=atrue_and_bfalse))\n",
    "print(\"F | {afbt} | {afbf}\".format(afbt=afalse_and_btrue,afbf=afalse_and_bfalse))\n",
    "\n",
    "# see https://www.geeksforgeeks.org/python-format-function/ for formatting information"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hands on Activity\n",
    "\n",
    "1. Create a *Truth Table*, like the previous snippet, for the *Or* operation\n",
    "- Create a *Truth Table* for the *Xor* operation.\n",
    "- Question: What is the difference between the two operations?\n",
    "- Question: How is this different from how we use the word \"Or\" in the English language?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "####################\n",
    "## Begin Activity ##\n",
    "####################\n",
    "\n",
    "# Code for Or\n",
    "atrue_or_btrue   = # TODO \n",
    "atrue_or_bfalse  = # TODO\n",
    "afalse_or_btrue  = # TODO\n",
    "afalse_or_bfalse = # TODO\n",
    "\n",
    "\n",
    "print(\"A|B___T_____F___\")\n",
    "print(\"T | {atbt} | {atbf}\".format(atbt=atrue_or_btrue,atbf=atrue_or_bfalse))\n",
    "print(\"F | {afbt} | {afbf}\".format(afbt=afalse_or_btrue,afbf=afalse_or_bfalse))\n",
    "\n",
    "\n",
    "# Code for Xor\n",
    "atrue_xor_btrue   = # TODO \n",
    "atrue_xor_bfalse  = # TODO\n",
    "afalse_xor_btrue  = # TODO\n",
    "afalse_xor_bfalse = # TODO\n",
    "\n",
    "\n",
    "print(\"A^B___T_____F___\")\n",
    "print(\"T | {atbt} | {atbf}\".format(atbt=atrue_xor_btrue,atbf=atrue_xor_bfalse))\n",
    "print(\"F | {afbt} | {afbf}\".format(afbt=afalse_xor_btrue,afbf=afalse_xor_bfalse))\n",
    "\n",
    "##################\n",
    "## End Activity ##\n",
    "##################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control Flow\n",
    "\n",
    "Up until this point the snippets of code we have seen so far have been a sequence of *statements* executed one after another from top to bottom. i.e. $s_0,s_1,...,s_{k-1}$ where $s_i$ is a statement and each one is executed in order. Suppose we want to *condition* the execution of a *statement*, where if a *condition* $c$ is True then execute $s_0$ otherwise execute $s_1$.\n",
    "\n",
    "In this section we are going to discuss *control flow* or the change of the order of execution based on the *state* of the program, where *state* simply means the values of the variables of the program. We are going to focus on the $if$, $else$ and $else if$.\n",
    "\n",
    "An important note before we proceed is that SPACING matters. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cond0 = True\n",
    "if cond0:\n",
    "    print(\"I executed this statement!\")\n",
    "print(\"I also executed this statement!\")\n",
    "\n",
    "\n",
    "if cond0:\n",
    "    print(\"cond0 must be True!\")\n",
    "else:\n",
    "    print(\"cond0 is not True :(\")\n",
    "    \n",
    "print(\"I don't care if cond0 is True or False\")\n",
    "\n",
    "\n",
    "if cond0:\n",
    "    print(\"cond0 must be True!\")\n",
    "elif not(cond):\n",
    "    print(\"cond0 is not True :(\")\n",
    "else:\n",
    "    print(\"I will only execute if cond0 and not(cond0) are both false!\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can embed our *comparison* and *logical* operations inside the conditionals as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Feed me an integer!\")\n",
    "a = int(input())\n",
    "\n",
    "if a < 0:\n",
    "    print(\"a is a negative number.\")\n",
    "elif a == 0:\n",
    "    print(\"a is zero\")\n",
    "else:\n",
    "    print(\"a is positive\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hands On Activity\n",
    "Finding the minimum and maximum value of two input.\n",
    "1. Code: Complete the following snippet that prints the minimum and maximum of two inputs\n",
    "- Read: http://www.peachpit.com/articles/article.aspx?p=1312792&seqNum=3\n",
    "- Question: How does spacing and indentation work in Python?\n",
    "- Question: How does spacing and indentation affect the execution of the code?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "####################\n",
    "## Begin Activity ##\n",
    "####################\n",
    "\n",
    "# TODO: return r which is the minimum of a and b\n",
    "def find_min(a,b):\n",
    "    r = 0\n",
    "    # TODO\n",
    "    #if something :\n",
    "    #    r = dosomething\n",
    "    #else:\n",
    "    #    r = dosomethingelse\n",
    "    return r\n",
    "    \n",
    "\n",
    "# TODO: return r which is the maximum of a and b\n",
    "def find_max(a,b):\n",
    "    r = 0\n",
    "    # TODO\n",
    "    #if something :\n",
    "    #    r = dosomething\n",
    "    #else:\n",
    "    #    r = dosomethingelse\n",
    "    return r\n",
    "\n",
    "\n",
    "# NOTE: The difference in leading spaces\n",
    "print(\"Give me a number A!\")\n",
    "a = float(input())\n",
    "print(\"Give me a number B!\")\n",
    "b = float(input())\n",
    "\n",
    "minab = find_min(a,b)\n",
    "maxab = find_max(a,b)\n",
    "\n",
    "print(\"The min value is {m}\".format(m=minab))\n",
    "print(\"The max value is {m}\".format(m=maxab))\n",
    "\n",
    "##################\n",
    "## End Activity ##\n",
    "##################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hands On Activity\n",
    "Using our numerical knowledge and understanding of floating point number we will add three numbers in that maximizes the sum and also in an order that minimizes the sum\n",
    "\n",
    "1. Question: Why does the ordering matter when adding floating point numbers?\n",
    "- Question: What would be the case where $(a+b)+c != a+(b+c)$\n",
    "- Code: Write a program that takes three inputs a,b and c and adds them in the order that maximizes the sum. i.e. $(a+b)+c$, $a+(b+c)$ or $(a+c)+b$\n",
    "- Code: Additionally, write a program that adds the values in the order that minimizes the sum.\n",
    "- Question: When testing your code what values of a,b and c did you use?\n",
    "- Question: Why did you use those values?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "####################\n",
    "## Begin Activity ##\n",
    "####################\n",
    "\n",
    "# TODO: add a,b,c in an order that maximizes their sum\n",
    "def maximal_sum(a,b,c):\n",
    "    r = 0\n",
    "    #if a>c and b>c:\n",
    "        # r = (? + ?) + ?# TODO\n",
    "    #elif ?>? and ?>?:\n",
    "        # r = # TODO\n",
    "    #else:\n",
    "        # r = # TODO\n",
    "    return r\n",
    "\n",
    "# TODO: add a,b,c in an order that minimizes their sum\n",
    "def minimal_sum(a,b,c):\n",
    "    r = 0\n",
    "    #if a>c and b>c:\n",
    "        # r = (? + ?) + ?# TODO\n",
    "    #elif ?>? and ?>?:\n",
    "        # r = # TODO\n",
    "    #else:\n",
    "        # r = # TODO\n",
    "    return r\n",
    "\n",
    "\n",
    "print(\"Give me an A!\")\n",
    "a = float(input())\n",
    "print(\"Give me an B!\")\n",
    "b = float(input())\n",
    "print(\"Give me an C!\")\n",
    "c = float(input())\n",
    "\n",
    "maxsum = maximal_sum(a,b,c)\n",
    "minsum = minimal_sum(a,b,c)\n",
    "\n",
    "print(\"The maximal sum is {m}\".format(m=maxsum))\n",
    "print(\"The minimal sum is {m}\".format(m=minsum))\n",
    "\n",
    "##################\n",
    "## End Activity ##\n",
    "##################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Looping\n",
    "The *if* *elif* and *else* provide us with the ability to control the flow of the program, but only in one direction. Very frequently we would like to execute the same statement $s$ multiple times until a condition is met. For that we will use looping, which comes in two forms, the first being the *while* loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# first example\n",
    "cond1 = True\n",
    "\n",
    "while cond1:\n",
    "    print(\"I'm in a loop!\")\n",
    "    cond1 = False\n",
    "\n",
    "print(\"I'm out of the loop\")\n",
    "\n",
    "\n",
    "# second example\n",
    "count = 0\n",
    "stop  = 10\n",
    "\n",
    "cond2 = count < stop\n",
    "while cond2:\n",
    "    print(\"The count is {c}\".format(c=count))\n",
    "    count = count + 1\n",
    "    cond2 = count < stop\n",
    "    \n",
    "    \n",
    "# third example\n",
    "count = 0\n",
    "stop  = 10\n",
    "\n",
    "while count < stop:\n",
    "    print(\"The condition is in the while loop! ({c})\".format(c=count))\n",
    "    count = count + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In many programs we want to index through the elements of a list. This is easy to achieve using a while loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ll = [50,25,12,19,27,18]\n",
    "\n",
    "start = 0\n",
    "end   = len(ll)\n",
    "\n",
    "index = start\n",
    "while index < end:\n",
    "    val = ll[index]\n",
    "    print(\"The value of ll at index {i} is {v}\".format(i=index,v=val))\n",
    "    index+=1 # this is the same as index=index+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can go even further and nest an $if,elif,else$ statement inside of a while loop. In the following example we are going to play a guessing game."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# see https://machinelearningmastery.com/how-to-generate-random-numbers-in-python/ \n",
    "\n",
    "from random import seed\n",
    "from random import randint\n",
    "\n",
    "# seed the random number\n",
    "seed(1)\n",
    "secret_number = randint(0,100)\n",
    "\n",
    "print(\"Pick a number between 0 and 100\")\n",
    "guess = int(input())\n",
    "while secret_number != guess:\n",
    "    if guess < secret_number:\n",
    "        print(\"Too low! Guess again.\")\n",
    "    else:\n",
    "        print(\"Too high! Guess again.\")\n",
    "    guess = int(input())\n",
    "\n",
    "print(\"You guessed the right number!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hands On Activity\n",
    "The pathalogical counter. Using our knowledge of numerical and floating point number answer these questions about the following code snippet.\n",
    "1.Find the Stop bottom at the top of the Jupyter notebook, make a mental note of it.\n",
    "- Question: What is this code doing?\n",
    "- Question: This program will never terminate, why not?\n",
    "- Question: What is the smallest value of $stop$ that this will terminate for.\n",
    "- Code: Rewrite this such that it does terminate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "####################\n",
    "## Begin Activity ##\n",
    "####################\n",
    "\n",
    "increment = 0.0000000000000001\n",
    "stop      = 10\n",
    "count     = 0\n",
    "\n",
    "while count < stop:\n",
    "    count = count + increment\n",
    "    print(\"count = {c}\".format(c=count))\n",
    "\n",
    "print(\"This statement will never execute\")\n",
    "\n",
    "##################\n",
    "## End Activity ##\n",
    "##################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hands on Activity\n",
    "Summing a list of numbers.\n",
    "1. Code: Write a function that sums a list of numbers in the order of their index\n",
    "- Read: https://www.geeksforgeeks.org/python-list-sort/\n",
    "- Question: How can we sum the list in a way that maximizes the sum?\n",
    "- Code: Write a function that sums a list of numbers in an order that maximizes the sum.\n",
    "- Question: is their a difference between the two sums?\n",
    "- Question: Why or why not?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "####################\n",
    "## Begin Activity ##\n",
    "####################\n",
    "\n",
    "def normal_sum(ll):\n",
    "    result = 0\n",
    "    # TODO:\n",
    "    return result\n",
    "\n",
    "def maximal_sum(ll):\n",
    "    result = 0\n",
    "    # TODO:\n",
    "    return result\n",
    "\n",
    "\n",
    "ll2 = [3.14, 1e-10,1e10,1.000000000001]\n",
    "\n",
    "nsum = normal_sum(ll2)\n",
    "msum = maximal_sum(ll2)\n",
    "\n",
    "print(\"The normal sum of the list is {r} \".format(r=nsum))\n",
    "print(\"The maximal sum of the list is {r}\".format(r=msum))\n",
    "\n",
    "##################\n",
    "## End Activity ##\n",
    "##################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hands On Activity\n",
    "In this activity we are going to write a program that computes various statistical values.\n",
    "1. Code: Write a function that computes the Mean of a list of elements.\n",
    "- Code: Write a function that computes the Median of a list of elements.\n",
    "- Bonus: Write a function that computes the Mode of a list of elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "####################\n",
    "## Begin Activity ##\n",
    "####################\n",
    "\n",
    "def compute_mean():\n",
    "    r = 0\n",
    "    # TODO\n",
    "    return r\n",
    "\n",
    "def compute_median():\n",
    "    r = 0\n",
    "    # TODO\n",
    "    return r\n",
    "\n",
    "def compute_mode():\n",
    "    r = 0\n",
    "    # TODO\n",
    "    return r\n",
    "\n",
    "ll3 = [5,1,22,3,51,22,27,33,11,2]\n",
    "mean   = compute_mean(ll3)\n",
    "median = compute_median(ll3)\n",
    "mean   = compute_mode(ll3)\n",
    "\n",
    "print(\"The mean of the list is {m}\".format(m=mean))\n",
    "print(\"The median of the list is {m}\".format(m=mean))\n",
    "print(\"The mode of the list is {m}\".format(m=mean))\n",
    "\n",
    "##################\n",
    "## End Activity ##\n",
    "##################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hands on Activity\n",
    "In this activity we will explore the Method of False Position.\n",
    "1. Read: https://en.wikipedia.org/wiki/Regula_falsi\n",
    "- Code: Write a program that finds a $x$ for f(x)=0 using the method of false position\n",
    "- BONUS: Write a program for the Bisection Method\n",
    "- BONUS: Write a program for Newtons Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "####################\n",
    "## Begin Activity ##\n",
    "####################\n",
    "\n",
    "def f(x):\n",
    "    return x**4 - 3*x**3 + 5*x**2 - 10*x + 7\n",
    "\n",
    "\n",
    "\n",
    "# TODO: Write method of false position for 10 steps\n",
    "# k = 0\n",
    "# while k < 10\n",
    "#     c_k = \n",
    "\n",
    "\n",
    "\n",
    "##################\n",
    "## End Activity ##\n",
    "##################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assignment: Online Judge\n",
    "\n",
    "Complete the five selected problems. After you have submitted them:\n",
    "1. Create a pdf of your submissions page.\n",
    "- copy your solutions below.\n",
    "- Create a pdf of your lab and email it.\n",
    "\n",
    "\n",
    "### Complete the Selected Problems\n",
    "\n",
    "1. https://www.urionlinejudge.com.br/judge/en/problems/view/1238\n",
    "- https://www.urionlinejudge.com.br/judge/en/problems/view/1329\n",
    "- https://www.urionlinejudge.com.br/judge/en/problems/view/1249\n",
    "- https://www.urionlinejudge.com.br/judge/en/problems/view/1255\n",
    "- https://www.urionlinejudge.com.br/judge/en/problems/view/1145\n",
    "\n",
    "### Optional Pick Four Recomended Problems\n",
    "\n",
    "The URI online judge provides a recommendation engine that finds problems that it believes you can solve.\n",
    "\n",
    "https://www.urionlinejudge.com.br/judge/en/recommendations/index/1\n",
    "\n",
    "Select four problems of your choice from the recommended set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution for Combiner\n",
    "# https://www.urionlinejudge.com.br/judge/en/problems/view/1238\n",
    "\n",
    "# Copy your solution here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution for Head of Tail\n",
    "# https://www.urionlinejudge.com.br/judge/en/problems/view/1329\n",
    "\n",
    "# Copy your solution here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution for Rot13\n",
    "# https://www.urionlinejudge.com.br/judge/en/problems/view/1249\n",
    "\n",
    "# Copy your solution here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution for Letter Frequency\n",
    "# https://www.urionlinejudge.com.br/judge/en/problems/view/1255\n",
    "\n",
    "# Copy your solution here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution for Logical Sequence 2\n",
    "# https://www.urionlinejudge.com.br/judge/en/problems/view/1145\n",
    "\n",
    "# Copy your solution here"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}