Project-1-CC-PatKearns.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"http://imgur.com/1ZcRyrc.png\" style=\"float: left; margin: 20px; height: 55px\">\n",
    "\n",
    "# Project 1: Python Coding Exercises\n",
    "\n",
    "_Authors: Joseph Nelson (DC) _\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code challenges are drawn from common exercises used in technical interviews.\n",
    "\n",
    "Note there may be several ways to approach each challenge!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challenge 1.1: Largest Palindrome\n",
    "A palindromic number reads the same both ways. For example, 1234321 is a palindrome. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99. Find the largest palindrome made from the product of two 3-digit numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "906609"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#write a function to test for palindrome\n",
    "def palindrome(n):\n",
    "    if n == n[::-1]:\n",
    "        return True\n",
    "    else:\n",
    "        False\n",
    "\n",
    "#create two lists so we can multiply them together to get combinations of products\n",
    "#i skipped 100-800, assuming those would not be the largest palindrome found\n",
    "list_1 = range(900,1000)\n",
    "list_2 = range(900,1000)\n",
    "\n",
    "list_3 = [x*y for x in list_1 for y in list_2] #creates a longgg list of all products from list_1 and list_2\n",
    "\n",
    "final_list = [] #empty list\n",
    "for n in list_3: #iterate through list_3\n",
    "    if str(n) == str(n)[::-1]: #use slicing to give us back the same string, but backwards and compare\n",
    "        final_list.append(n) #add to final_list if it is a palindrome\n",
    "max(final_list) #give us the largest number from the final list\n",
    "#906609"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Challenge 1.2: Summation of primes\n",
    "The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17. Find the sum of all the primes below two-thousand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "277050\n"
     ]
    }
   ],
   "source": [
    "#write a function to find prime numbers\n",
    "def is_prime(number):\n",
    "    amount_of_factors = 0  #empty count for how many factors a number has\n",
    "    for candidate_factor in range(1, number+1): #range of numbers to try factors\n",
    "        if number % candidate_factor == 0:\n",
    "            amount_of_factors += 1 #increase count if number divisible by other numbers\n",
    "    if amount_of_factors == 2: # if amount of factors is 2 (one and itself) factor is prime\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "prime_total = 0 #empty count\n",
    "for number in range(2,2001): #list of 2 to 2000\n",
    "    if is_prime(number):\n",
    "        prime_total += number # if true, increase total by that amount\n",
    "print prime_total\n",
    "\n",
    "#answer = 277050"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challenge 1.3: Multiples of 3 and 5\n",
    "If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23. Find the sum of all the multiples of 3 or 5 below 1000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "233168\n"
     ]
    }
   ],
   "source": [
    "divisible = [] #empty list to capture numbers\n",
    "for num in range(3,1000):\n",
    "    if num % 3 == 0:\n",
    "        if num % 5 == 0: #find numbers that are divisible by both 3 and 5\n",
    "            divisible.append(num) #add to the list\n",
    "    if num % 3 == 0:\n",
    "        if num % 5 != 0: #find numbers that are divisble by only 3\n",
    "            divisible.append(num)\n",
    "    if num % 5 == 0:\n",
    "        if num % 3 != 0: #find numbers that are divisible by only 5\n",
    "            divisible.append(num)\n",
    "# print divisible (used to check list)\n",
    "sum_numbers = 0 #empty sum\n",
    "for number in divisible: #iterate over list, sum\n",
    "    sum_numbers += number\n",
    "print sum_numbers\n",
    "#answer 233168\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challenge 2: Fizz Buzz\n",
    "Write a program that prints all the numbers from 1 to 100. For multiples of 3, instead of the number, print \"Fizz\", for multiples of 5 print \"Buzz\". For numbers which are multiples of both 3 and 5, print \"FizzBuzz\". Bonus: If that's too easy, create three unique solutions. Sometimes you'll encounter unexpected constraints, so make sure you're able to think creatively!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "Fizz\n",
      "4\n",
      "Buzz\n",
      "Fizz\n",
      "7\n",
      "8\n",
      "Fizz\n",
      "Buzz\n",
      "11\n",
      "Fizz\n",
      "13\n",
      "14\n",
      "Fizzbuzz\n",
      "16\n",
      "17\n",
      "Fizz\n",
      "19\n",
      "Buzz\n",
      "Fizz\n",
      "22\n",
      "23\n",
      "Fizz\n",
      "Buzz\n",
      "26\n",
      "Fizz\n",
      "28\n",
      "29\n",
      "Fizzbuzz\n",
      "31\n",
      "32\n",
      "Fizz\n",
      "34\n",
      "Buzz\n",
      "Fizz\n",
      "37\n",
      "38\n",
      "Fizz\n",
      "Buzz\n",
      "41\n",
      "Fizz\n",
      "43\n",
      "44\n",
      "Fizzbuzz\n",
      "46\n",
      "47\n",
      "Fizz\n",
      "49\n",
      "Buzz\n",
      "Fizz\n",
      "52\n",
      "53\n",
      "Fizz\n",
      "Buzz\n",
      "56\n",
      "Fizz\n",
      "58\n",
      "59\n",
      "Fizzbuzz\n",
      "61\n",
      "62\n",
      "Fizz\n",
      "64\n",
      "Buzz\n",
      "Fizz\n",
      "67\n",
      "68\n",
      "Fizz\n",
      "Buzz\n",
      "71\n",
      "Fizz\n",
      "73\n",
      "74\n",
      "Fizzbuzz\n",
      "76\n",
      "77\n",
      "Fizz\n",
      "79\n",
      "Buzz\n",
      "Fizz\n",
      "82\n",
      "83\n",
      "Fizz\n",
      "Buzz\n",
      "86\n",
      "Fizz\n",
      "88\n",
      "89\n",
      "Fizzbuzz\n",
      "91\n",
      "92\n",
      "Fizz\n",
      "94\n",
      "Buzz\n",
      "Fizz\n",
      "97\n",
      "98\n",
      "Fizz\n",
      "Buzz\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,101): #iterate over range 1 to 100\n",
    "    if i%3 == 0:\n",
    "        if i%5 == 0:\n",
    "            print'Fizzbuzz' #same as above, if number is divisible by 3 and 5\n",
    "        else:\n",
    "            print 'Fizz' #if number is divisible only by 3\n",
    "    elif i%5 == 0:\n",
    "        print 'Buzz' #if number is divisible by only 5\n",
    "    else:\n",
    "        print i #not divisible by those, print number\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Challenge 3: String Compressor\n",
    "Implement a method to perform basic string compression using the counts of repeated characters. (This is called Run-Length Encoding.) For example, the string 'aabcccccaaa' would become a2b1c5a3. If the “compressed” string would not become smaller than the original string, your method should return the original string. You can assume the string has only uppercase and lowercase letters (a-z). Specify whether your solution is case-sensitive or case-insensitive, and what you would need to change to make it the other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a5b3j2d1j4'"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "def compress(text):\n",
    "    if not text:\n",
    "        return \"\"\n",
    "    else:\n",
    "        last_char = text[0]\n",
    "        max_index = len(text)\n",
    "        i = 1\n",
    "        while i < max_index and last_char == text[i]:\n",
    "            i += 1\n",
    "        if len(last_char + str(i) + encode(text[i:])) > len(text):\n",
    "            return text\n",
    "        else:\n",
    "            return last_char + str(i) + encode(text[i:])\n",
    "\n",
    "compress(\"aaaaabbbjjdjjjj\")\n",
    "# a5b3j2d1j4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}