solutions/paired_programming_activity_solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Paired programming activity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 1:** Define a function char_counts that, given a string, counts and reports how many times each letter appears. Example string: \"computing is too important to be left to men\" (credit: Karen Sparck Jones). *Hint:* if you loop over a string, it goes through each character. *Challenge:* How short can you make your code and have it still work?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "def char_counts(s):\n",
    "    return(Counter(''.join(filter(str.isalpha, s))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test: char_counts(\"computing is too important to be left to men\")\n",
      "Counter({'t': 7, 'o': 6, 'm': 3, 'i': 3, 'n': 3, 'e': 3, 'p': 2, 'c': 1, 'u': 1, 'g': 1, 's': 1, 'r': 1, 'a': 1, 'b': 1, 'l': 1, 'f': 1})\n"
     ]
    }
   ],
   "source": [
    "# Check your function\n",
    "print('test: char_counts(\\\"computing is too important to be left to men\\\")')\n",
    "string = \"computing is too important to be left to men\"\n",
    "print(char_counts(string))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 2:** Define a function maximum that takes two numbers as arguments and returns the largest of them. Hint: use if-then-else. (python has a max function built in, but write your own)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def maximum(x,y):\n",
    "    # takes 2 numbers as arguments and returns the largest of them\n",
    "    if x > y:\n",
    "        return(x)\n",
    "    else:\n",
    "        return(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test: maximum(1,2)\n",
      "2\n",
      "test: maximum(2.1,2)\n",
      "2.1\n"
     ]
    }
   ],
   "source": [
    "# Check your function\n",
    "print('test: maximum(1,2)')\n",
    "print(maximum(1,2))\n",
    "print('test: maximum(2.1,2)')\n",
    "print(maximum(2.1,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 3:** Define a function max_of_three that takes three numbers as arguments and returns the largest of them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def max_of_three(x,y,z):\n",
    "    # takes 3 numbers as arguments and returns the largest of them\n",
    "    if x > y and x > z:\n",
    "        return(x)\n",
    "    elif y > z:\n",
    "        return(y)\n",
    "    else:\n",
    "        return(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test: max_of_three(1,2,3)\n",
      "3\n",
      "test: max_of_three(2.1,2,1)\n",
      "2.1\n",
      "test: max_of_three(1.1,2,1)\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# Check your function\n",
    "print('test: max_of_three(1,2,3)')\n",
    "print(max_of_three(1,2,3))\n",
    "print('test: max_of_three(2.1,2,1)')\n",
    "print(max_of_three(2.1,2,1))\n",
    "print('test: max_of_three(1.1,2,1)')\n",
    "print(max_of_three(1.1,2,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 4:** Define a function length that computes the length of a given list or string. (again, python has the len function, but write your own)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def length(x):\n",
    "    # takes a list or string and computes the length\n",
    "    c = 0\n",
    "    for i in x:\n",
    "        c += 1\n",
    "    return(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test: length('mystring')\n",
      "8\n",
      "test: length([0,1,2,3,4,5])\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "# Check your function\n",
    "print('test: length(\\'mystring\\')')\n",
    "print(length('mystring'))\n",
    "print('test: length([0,1,2,3,4,5])')\n",
    "print(length([0,1,2,3,4,5]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 5:** Write a function is_vowel that takes a character (i.e. a string of length 1) and returns True if it is a vowel, False otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def is_vowel(x):\n",
    "    # takes a character and returns true if it is a vowel\n",
    "    vowels = ['A','a','E','e','I','i','O','o','U','u']\n",
    "    if x in vowels:\n",
    "        return(True)\n",
    "    else:\n",
    "        return(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test: is_vowel('A')\n",
      "True\n",
      "test: is_vowel('x')\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Check your function\n",
    "print('test: is_vowel(\\'A\\')')\n",
    "print(is_vowel('A'))\n",
    "print('test: is_vowel(\\'x\\')')\n",
    "print(is_vowel('x'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 6:** Define a sum_all function and a multiply_all function that sums and multiplies (respectively) all the numbers in a list of numbers. For example, sum([1, 2, 3, 4]) should return 10, and multiply([1, 2, 3, 4]) should return 24. (again, these exist in python but write your own)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def sum_all(x):\n",
    "    # takes a list of numbers and returns the sum\n",
    "    s = 0\n",
    "    for i in x:\n",
    "        s += i\n",
    "    return(s)\n",
    "\n",
    "def multiply_all(x):\n",
    "    # takes a list of numbers and returns the product\n",
    "    p = 1\n",
    "    for i in x:\n",
    "        p *= i\n",
    "    return(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test: sum_all([1,2,3,4])\n",
      "10\n",
      "test: multiply_all([1,2,3,4])\n",
      "24\n"
     ]
    }
   ],
   "source": [
    "# Check your functions\n",
    "print('test: sum_all([1,2,3,4])')\n",
    "print(sum_all([1,2,3,4]))\n",
    "print('test: multiply_all([1,2,3,4])')\n",
    "print(multiply_all([1,2,3,4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 7:** Define a function reverse that computes the reversal of a string. So if you give it “this is too much” it will give you “hcum oot si siht”"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def reverse(x):\n",
    "    # takes a string and returns the reverse of the string\n",
    "    rev = ''\n",
    "    for i in range(len(x)):\n",
    "        rev += x[len(x)-i-1]\n",
    "    return(rev)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test: reverse('this is too much')\n",
      "hcum oot si siht\n"
     ]
    }
   ],
   "source": [
    "# Check your function\n",
    "print('test: reverse(\\'this is too much\\')')\n",
    "print(reverse('this is too much'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 8:** Define a function is_palindrome that recognizes palindromes. You can test with “a man a plan a canal panama” or “radar”."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def is_palindrome(x):\n",
    "    # takes a string and returns whether it is a palindrome\n",
    "    x = x.replace(' ','')\n",
    "    if x == reverse(x):\n",
    "        return(True)\n",
    "    else:\n",
    "        return(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test: is_palindrome('a man a plan a canal panama')\n",
      "True\n",
      "test: is_palindrome('radar')\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Check your function\n",
    "print('test: is_palindrome(\\'a man a plan a canal panama\\')')\n",
    "print(is_palindrome('a man a plan a canal panama'))\n",
    "print('test: is_palindrome(\\'radar\\')')\n",
    "print(is_palindrome('radar'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 9:** Write a function add_line_numbers that given a text file will create a new text file in which all the lines from the original file are numbered from 1 to n (where n is the number of lines in the file)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import re\n",
    "def add_line_numbers(file):\n",
    "    # takes a file and makes a new file with lines numbered\n",
    "    newfile = file.split('.',1)[0] + '_w_lines.txt'\n",
    "    c = 0\n",
    "    with open(file) as f:\n",
    "        with open(newfile,'w') as out:\n",
    "            for line in f:\n",
    "                c += 1\n",
    "                newline = str(c) + ' ' + line\n",
    "                out.write(newline) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test: add_line_numbers(\"paired_programming_testfile.txt\")\n"
     ]
    }
   ],
   "source": [
    "# Check your function\n",
    "print('test: add_line_numbers(\\\"paired_programming_testfile.txt\\\")')\n",
    "add_line_numbers(\"paired_programming_testfile.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 10:** Write a function avg_word_len that given a text file will calculate the average word length of a text stored in a file (i.e the sum of all the lengths of the word tokens in the text, divided by the number of word tokens)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def avg_word_len(file):\n",
    "    # takes a file and returns the average length of the words in the file\n",
    "    with open(file) as f:\n",
    "        words = []\n",
    "        for line in f:\n",
    "            words.append(line.split())\n",
    "    words = [x for sublist in words for x in sublist]\n",
    "    word_lengths = [len(x) for x in words]\n",
    "    print('Average word length:')\n",
    "    print(sum(word_lengths)/len(words))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test: avg_word_len(\"paired_programming_testfile.txt\")\n",
      "Average word length:\n",
      "4.3515625\n"
     ]
    }
   ],
   "source": [
    "# Check your function\n",
    "print('test: avg_word_len(\\\"paired_programming_testfile.txt\\\")')\n",
    "avg_word_len(\"paired_programming_testfile.txt\")"
   ]
  }
 ],
 "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}