STUDENT EECS Day Lab - Connect Four.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "20be1efc",
   "metadata": {},
   "source": [
    "<img src=\"Resources/eecs-day-header.png\" width=\"600px\" style=\"float: left\"/> <br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa810832",
   "metadata": {},
   "source": [
    "**Hosted by HKN**\n",
    "\n",
    "Written by Aayush Gupta and Owen Thompson (2022), with adaptations from Hermish Mehta (2019), Kenny Wang (2023)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96962c7b",
   "metadata": {},
   "source": [
    "# Intro / Instructions\n",
    "\n",
    "In this lab, we'll learn the basics of programming in Python, with the eventual goal of making a Connect 4 game! The first half will focus on giving you a crash course in Python, and the second half will go into actually creating Connect 4. Don't worry if you can't finish the whole thing, the lab is designed to be challenging. We'll send out a link so you can complete it at home if you like!\n",
    "\n",
    "_<font color='green'>If you are already comfortable coding in Python, you can jump straight to the (pretty hard) Connect Four part of the lab!</font>_ Otherwise, you should start here.\n",
    "\n",
    "Feel free to go through this notebook at your own pace depending on your familiarity with Python and programming in general. <font color='blue'>If you have any questions along the way, don't be afraid to ask!</font>\n",
    "\n",
    "Code in Jupyter notebooks is written in cells which you can run individually, but data from one can be used in another. First, locate this set of buttons in the toolbar above.\n",
    "\n",
    "<img src=\"Resources/toolbar.png\" width=\"130px\" style=\"float: left\"/> <br><br>\n",
    "\n",
    "To run a cell, click on the cell, then click the leftmost button in that group, the \"Run Cell\" button. Or to use our preferred shortcut, click on the cell and hit `SHIFT+ENTER`. Often, cells will depend on code from previous cells. Try running the code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a3c9a76",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is a code cell! You can click here to write/edit Python code\n",
    "# then click on the \"Run\" button above or press SHIFT+ENTER to run it.\n",
    "\n",
    "print(\"Hello, world! Welcome to EECS Day!\")\n",
    "\n",
    "# You can also try to write your own message by filling in the blank below!\n",
    "print(\"_____________\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4749193a",
   "metadata": {},
   "source": [
    "#### Woah, that did a thing!\n",
    "\n",
    "`print()` displays the message between the parentheses below the code cell. `print()` statements are very useful! You'll also soon see why the message is in quotes.\n",
    "\n",
    "And Python can do many more things, as we'll see shortly. First, though, there are two more buttons in the toolbar group above. You shouldn't need the rightmost one, but the center one (with the square) may be helpful. This is the \"Stop Cell\" button, and it can be used to stop the cell you've clicked from running.\n",
    "\n",
    "**<font color='blue'>Even if a cell doesn't have any code for you to write or edit, you should run it anyway! Later parts may depend on code from earlier parts.</font>**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4a2a823",
   "metadata": {},
   "source": [
    "<img src=\"Resources/warnings.png\" width=\"700px\" style=\"float: left\"/> <br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "253ec4ad",
   "metadata": {},
   "source": [
    "#### Comments: A Comment\n",
    "\n",
    "Additionally, we should introduce <font color='green'><b>comments,</b></font> which you may have noticed above.\n",
    "Anything after a hashtag (**#**) in a line of Python code isn't actually run; it's just there as a note by the programmer. These are really useful to explain what code does, and using them is considered *really* good coding practice."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5811445",
   "metadata": {},
   "source": [
    "<img src=\"Resources/variables.png\" width=\"400px\" style=\"float: left\"/> <br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "235b581a",
   "metadata": {},
   "source": [
    "We're going to jump right into **variables.** You can think of a variable like a box that has a name and holds a value. You can change the value of a variable (putting something new in the box), but not the name! Variables can stand in for numbers, strings of text (called **strings,** of course) and much more.\n",
    "\n",
    "Variables in Python are defined or changed with an equals sign (=), with the name of the variable on the left and the initial value on the right. Fill in the variables in the code cell below!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1be53d36",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fill in your first and last name below by filling in the blanks!\n",
    "# These are string types, and when you type string values they're surrounded\n",
    "# with quotes.\n",
    "\n",
    "first_name = \"________\"\n",
    "last_name = \"________\"\n",
    "\n",
    "# Strings can be combined using the + operator This is called string\n",
    "# concatenation.\n",
    "full_name = first_name + \" \" + last_name\n",
    "\n",
    "# While we're at it, what's your favorite color?\n",
    "favorite_color = \"Purple\"\n",
    "\n",
    "# Now, what's your favorite number? This is a number type. Notice it doesn't\n",
    "# have quotes? Numbers don't have them.\n",
    "favorite_number = 0\n",
    "# Try filling in the blank below with another number! Make sure to remove the line, it should just be a number \n",
    "another_number = ___\n",
    "\n",
    "# Is this lab cool? This is called a boolean type, it can either be True or\n",
    "# False (mind the capitalization). The correct answer here is True, by the way ;)\n",
    "lab_cool = True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a4fbf75",
   "metadata": {},
   "source": [
    "Run the cell above, and you'll notice it doesn't seem to do anything yet. Let's fix that! Run the following cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a045850e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can view the values of variables with print()\n",
    "print(\"Full name:\", full_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7675773",
   "metadata": {},
   "source": [
    "Try playing around with the print() statement above. See if you can get it to print out the other variables you declared above. Once you're satisfied, feel free to move on."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4091442",
   "metadata": {},
   "source": [
    "<img src=\"Resources/lists.png\" width=\"600px\" style=\"float: left\"/> <br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e4ab7e4",
   "metadata": {},
   "source": [
    "Python also has something called a **list**, (an **array** in some other languages) which allows us to store multiple values in one variable. You can then access the values by *indexing* into the list, using brackets [] as we'll see below. Note that because computer scientists wanted to be edgy and weird, the first index is actually position *zero.* Run the following cells to see how lists work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4fcff483",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We create a list called info here, putting your first and last name in the\n",
    "# first two positions. Notice how we can use values and variables\n",
    "# interchangeably.\n",
    "info = [first_name, last_name, \"Hello!\"]\n",
    "\n",
    "# We print out the first value of the list, by indexing into position zero\n",
    "print(\"info[0]: \" + info[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3fb8af9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can also select and change the value at a particular index in the list. Try\n",
    "# filling in the blank with a nickname to replace your first name!\n",
    "info[0] = \"______\"\n",
    "\n",
    "print(\"info[0], updated: \" + info[0])\n",
    "# Notice how the value at info[0] changed?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2e9eb91",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can also just print out the whole list!\n",
    "print(\"info:\", info)\n",
    "\n",
    "# Using the len() function, we can also check to see how long a list is.\n",
    "print(\"Length: \", len(info))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01a7dce4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can even add your favorite color!\n",
    "# Note that info is a list while favorite_color is a string\n",
    "# In Python you can add lists to join them, but you can't add a list to a\n",
    "# string directly which is why we use \"[\" and \"]\" around favorite_color\n",
    "# in order to first make it into a list with one element.\n",
    "info = info + [favorite_color]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01a7dcf5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try adding another value below by filling in the blank!\n",
    "# It could be a string, a number, or a boolean.\n",
    "info = info + [___]\n",
    "\n",
    "print(\"info:\", info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "909887ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Another common way to add an element to the end of a list is to use the \n",
    "# .append() method. One difference is that this changes the list without you having\n",
    "# to assign the list to anything.\n",
    "info.append(favorite_number)\n",
    "\n",
    "print(\"info:\", info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04f36753",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try appending something by filling in the blank below!\n",
    "# Remember, it should be a string, a number, or a boolean.\n",
    "info.append(___)\n",
    "\n",
    "print(\"info:\", info)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d838300",
   "metadata": {},
   "source": [
    "## Mini Exercise 1\n",
    "\n",
    "To review a bit of what we've covered so far, let's try a small exercise. \n",
    "\n",
    "Part 1: \n",
    "\n",
    "Create a list that contains the days of the week. Then print out the third day of the week using the list. \n",
    "\n",
    "Part 2: \n",
    "\n",
    "Using the list that you created, print out your two favorite days in the following format: \n",
    "\"My favorite days are _______ and _______.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b35008bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your code here!\n",
    "# Part 1\n",
    "list = _____\n",
    "print(_____)\n",
    "# Hint: How do we select a specific item from a list? What number do we start counting from?\n",
    "\n",
    "# Part 2\n",
    "# YOUR CODE HERE\n",
    "# Hint: How do we build a bigger string from smaller ones?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0836b0da",
   "metadata": {},
   "source": [
    "<img src=\"Resources/conditionals.png\" width=\"500px\" style=\"float: left\"/> <br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6e48611",
   "metadata": {},
   "source": [
    "Next we're going to discuss conditional statements, which are *very important* in programming. We'll start with an example. Try running this cell with different values of `i`.\n",
    "\n",
    "**WARNING:** Note that some of these lines are **indented** (they start further to the right), using the TAB key. Python cares that things inside conditional statements are indented properly!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b591869",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try different values of i and see what's printed!\n",
    "# Make sure i is just a number with no lines below.\n",
    "i = ___\n",
    "\n",
    "if i < 0: # Checked first\n",
    "    print(\"Negative\")\n",
    "elif i > 0: # Checked next\n",
    "    print(\"Positive\")\n",
    "else: # Last\n",
    "    print(\"Zero\")\n",
    "    \n",
    "# If we wanted to directly check whether i were equal to 0, we could have\n",
    "# used the '==' operator. Similarly, to check that it was not equal to \n",
    "# some value, we could use the '!=' operator. Here are a few examples:\n",
    "if i == 2:\n",
    "    print(\"Two\")\n",
    "if i != 3:\n",
    "    print(\"Not three\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b835fb2f",
   "metadata": {},
   "source": [
    "We have another tool for complex conditional statements: `and` and `or` statements.\n",
    "These do exactly what you'd think: they let you check whether one thing AND another are true, or if one thing OR another are true. Here are some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "148c355e",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = _  # fill in b with a single number! \n",
    "\n",
    "if b == 2 and b != 3:\n",
    "    print(\"b is 2 and not 3\")\n",
    "\n",
    "if b == 10 or b == 11:\n",
    "    print(\"b is either 10 or 11\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1489ccf4",
   "metadata": {},
   "source": [
    "Based on the value we chose for `i` and `b` we were able to see different outputs from the program.\n",
    "Conditionals are helpful when we want to run different pieces of code based on a certain value."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a82cfdc8",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "Python has many built-in functions which *do things.* Functions take inputs that we call *arguments*, which are the comma-separated values in between the parentheses following the function name. The function can do something to this input to give you a new output. You can even write your own functions, but we'll get into that later.\n",
    "\n",
    "We've already seen the `print()` function, which \"prints out\" its arguments, but there are many more. For now, however, we'll mostly be using `print()` and functions to manipulate data. Speaking of which..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f5f121c",
   "metadata": {},
   "source": [
    "<img src=\"Resources/loops.png\" width=\"500px\" style=\"float: left\"/> <br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecc52273",
   "metadata": {},
   "source": [
    "Let's say that we wanted to print out the numbers 0 through 4, we could do something like this (Try running it!):\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e056a3b",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(0)\n",
    "print(1)\n",
    "print(2)\n",
    "print(3)\n",
    "print(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a0c202b",
   "metadata": {},
   "source": [
    "That wasn't too bad, but what if we wanted to print out numbers 0 through 1,000? We'd have to write 1001 print statements!\n",
    "Instead, we can simplify the code by using *loops.* There are two popular types of loops, `for` and `while` loops. First we'll take a look at the `for` loop.\n",
    "\n",
    "<font color = 'red'>**WARNING**: Again, be careful about **indenting**!</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f06e1af9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This loop prints the numbers 0 through 4\n",
    "for i in range(0, 5, 1):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aafb0250",
   "metadata": {},
   "source": [
    "Wow, that loop did so much stuff! Let's break it down.\n",
    "\n",
    "- First, you probably noticed that the `print()` function call above is indented. Python uses indentation to identify the *body* of the loop, so everything indented by one or more tabs under the `for` declaration will be looped over.\n",
    "- For loops starts with the `for` keyword that's highlighted in color. \n",
    "- Next is the variable name `i` which stores the current loop value. `in` is another necessary keyword. \n",
    "- Finally, we have the function `range(start, stop, step)` that takes in three arguments. `range()` returns numbers from `start` up to, but not including, `stop`, incrementing by size `step`. `step` is an optional argument, as the default value for `step` is `1`. We really only need to include that argument if our step size is not 1.\n",
    "\n",
    "Try playing with the arguments to the `range` function! Can you print out every even number from 0 to 10 inclusive? </br><br>\n",
    "Try to also do this without the `step` argument. You can do that by using the modulo operator `%`. This operator gives you the remainder of a division. For example, `9 % 3 == 0` since 9 is a multiple of 3. But `9 % 2 == 1`, since 9 / 2 = 4 remainder 1. The modulo just gives you the remainder.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34e1a199",
   "metadata": {},
   "outputs": [],
   "source": [
    "### YOUR CODE HERE ###"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28b6a7ce",
   "metadata": {},
   "source": [
    "We can even `for` loop over the contents of a list!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d21374f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here we loop over the contents of this list building up the variable\n",
    "# \"combined\" as we go\n",
    "\n",
    "loop_over_me = [first_name, last_name, \"is\", \"the\", \"best\"]\n",
    "\n",
    "combined = \"\"\n",
    "for element in loop_over_me:\n",
    "    combined = combined + element + \" \" # Think about what this step does to combined\n",
    "    print(element)\n",
    "\n",
    "print(\"Combined string:\", combined)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b9bb69d",
   "metadata": {},
   "source": [
    "There will be 5 iterations of the for loop above (meaning that the indented code inside of the for loop will execute 5 times).\n",
    "For each iteration of the loop, the `element` variable will be set to the current item in the `loop_over_me` loop. This means\n",
    "that for the first iteration `element = first_name`, then for the second iteration `element = last_name`, and finally for the last iteration\n",
    "of the loop `element = \"best\"`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fd1bbc5",
   "metadata": {},
   "source": [
    "`For` loops are great for looping for a *known* number of times. But what if we don't know how long we need to loop for? Introducing `while` loops!\n",
    "\n",
    "Let's make a simple dice game: We have a die, and we win if we roll a 6. We want to see how many rolls it takes to win. Let's use a `while` loop to do this! Run the following cell to see one in action."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f01a402",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import random as random # we'll use a function from this module to simulate a 6-sided die\n",
    "rolled_number = random.randrange(1,7) # picks numbers randomly from 1 (inclusive) to 7 (exclusive)\n",
    "attempts = 1\n",
    "\n",
    "while rolled_number != 6:\n",
    "    print(\"You rolled a\", rolled_number)\n",
    "    attempts += 1\n",
    "    rolled_number = random.randrange(1,7) # This step rolls the die again to get a new number\n",
    "\n",
    "print(\"You rolled a\", rolled_number)\n",
    "print(\"It took you:\", attempts, \"attempts to roll a 6!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f08c01f",
   "metadata": {},
   "source": [
    "Wow, that loop was awesome! Let's examine what's happening here:\n",
    "- Again, everything that we want in the `while` loops is indented.\n",
    "- `while` loops work by checking a *condition* after each iteration. Here, we are checking if our rolled number was a 6.\n",
    "- Notice how we had no idea when we would roll a 6––this is when `while` loops come in handy and are better than `for` loops!\n",
    "- If we did not roll a 6, we rolled again, while incrementing the number of attempts we made by 1.\n",
    "- Once we finally roll a 6, then we exit the while loop and run the print statements that come afterwards"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecbd3807",
   "metadata": {},
   "source": [
    "## Functions, Part 2\n",
    "\n",
    "At this point, you've used plenty of other people's functions, such as `print`. But it turns out you can also write your own!\n",
    "\n",
    "<font color='green'>Functions allow you to write a section of code once and easily reuse it elsewhere in your program.</font> Like loops and conditional statements, functions use indentation to group lines of code together. In Python, you *define* a function with a `def` statement.\n",
    "The function below prints every number from 1 up until some input `end`. Run the code cell below for an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3650e97a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def range_print(end):\n",
    "    for i in range(0, end + 1):\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b3a80b8",
   "metadata": {},
   "source": [
    "Well that's strange, it didn't *do anything*. <font color='blue'>The code above *defines* a function, but we haven't actually haven't yet told Python that we want to execute that code.</font>\n",
    "This makes sense because we haven't told Python what the value of end will be.\n",
    "Run the code below to actually call the function that we defined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91765e41",
   "metadata": {},
   "outputs": [],
   "source": [
    "range_print(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f8cd7f2",
   "metadata": {},
   "source": [
    "**Woah, look at that!**\n",
    "\n",
    "Functions are even more powerful though. Instead of just printing things, they can also *return* data back to the function caller with the `return` keyword. Run this example to see:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b99bdf0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def range_return(start, end):\n",
    "    lst = []\n",
    "    for i in range(start, end + 1):\n",
    "        lst = lst + [i]\n",
    "    return lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e374e639",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(range_return(1, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04a8202d",
   "metadata": {},
   "source": [
    "*So what's happening here?*\n",
    "\n",
    "The function `range_return()` returns a list of values in the specified range (inclusive on both bounds, try to figure out why). Then, the `print()` function takes that list as an argument and prints the list!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3710049",
   "metadata": {},
   "source": [
    "## Mini Exercise 2\n",
    "\n",
    "Let's try another exercise to practice loops and conditionals! \n",
    "\n",
    "Part 1: \n",
    "\n",
    "Using a loop, make a function that sums up all numbers from 1 to N, with N being the input for the function.\n",
    "\n",
    "Part 2: \n",
    "\n",
    "Using a loop, make a function that, given a number N and list of strings, returns the number of strings in the given list that have length N.\n",
    "\n",
    "\n",
    "There is a little bit of skeleton code below if you need a little help getting started."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c6e5f44",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Part 1\n",
    "\n",
    "def sumToN(N): \n",
    "    sum = 0\n",
    "    #Your code here!\n",
    "\n",
    "    return sum\n",
    "\n",
    "#Part 2\n",
    "\n",
    "#If strings = [\"chi\", \"app\", \"apple\", \"closet\"] and N = 3, then countNSizedStrings should return 3. \n",
    "def countNSizedStrings(strings, N):\n",
    "    count = 0\n",
    "    #Your code here!\n",
    " # Hints: how do we get the length of a string? How do we compare this to a number?\n",
    "\n",
    "    return count"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d658f10b",
   "metadata": {},
   "source": [
    "<img src=\"Resources/lists-pt2.png\" width=\"500px\" style=\"float: left\"/> <br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31f86b32",
   "metadata": {},
   "source": [
    "## Lists, part 2\n",
    "\n",
    "So far, we've seen 1-D lists, but how could we represent something 2-dimensional like a Connect 4 board? The answer is creating a list of lists! Rather than storing a value like a number or string in the list, the elements of a 2-D list are themselves lists. Let's take a look at an example:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de7c98da",
   "metadata": {},
   "source": [
    "There are many ways to create a 2-D list in Python, the simplest  being to simply nest the lists within an outer list. The following list consists of students' names, ages, and favorite foods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70c819b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "student_data = [[\"John\", \"15\", \"Pizza\"], \n",
    "                [\"Alice\", \"14\", \"Tacos\"], \n",
    "                [\"Bob\", \"16\", \"Burgers\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01fcfc06",
   "metadata": {},
   "source": [
    "Much like before, we can print out the first value of the list by  indexing into position zero. To get a specific value in the 2-D list, we must index into it twice, once for the outer list and once for the inner. Run the following cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7591a54f",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"student_data[0]: \", student_data[0])\n",
    "print(\"Alice's favorite food is \" + student_data[1][2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8887c6c0",
   "metadata": {},
   "source": [
    "We can similarly change the value at a particular index in the list.\n",
    "Try replacing Bob's student data with your own by filling in the blanks with the appropriate values. Also try adding a new entry to the student data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa8c8ccb",
   "metadata": {},
   "outputs": [],
   "source": [
    " student_data[2][_] = _ # Pick a value in Bob's list to change!\n",
    " student_data = student_data + [_] # Add a new list entry to the overall student_data list!\n",
    "\n",
    "print(\"Updated student data: \", student_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec3f821a",
   "metadata": {},
   "source": [
    "We can also use loops to help set the values in a 2-D list. The loops below set up a grid so that each element is the product of its row and column indices. Run the cell to see how it works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "824716fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "grid = [[0,0,0,0,0],\n",
    "        [0,0,0,0,0],\n",
    "        [0,0,0,0,0],\n",
    "        [0,0,0,0,0]]\n",
    "\n",
    "for i in range(4):\n",
    "    for j in range(5):\n",
    "        grid[i][j] = i*j\n",
    "        \n",
    "print(grid)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a519191",
   "metadata": {},
   "source": [
    "Notice how the outer for loop ends at 4, which corresponds to the number of rows, while the inner for loop ends at 5 which corresponds to the columns."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66511f2d",
   "metadata": {},
   "source": [
    "## Putting it All Together"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "301666c1",
   "metadata": {},
   "source": [
    "Below are some practice exercises to help you feel more comfortable with Python and put together everything we've covered so far!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d09f457c",
   "metadata": {},
   "source": [
    "1) Write a function which takes in an integer n and returns a list of length n `li` where `li[i]` equals:\n",
    "* `\"fizz\"` if i is divisible 3\n",
    "* `\"buzz\"` if i is divisible by 5\n",
    "* `\"fizzbuzz\"` is i is divisible by 15\n",
    "* `i` otherwise.\n",
    "\n",
    "For example, fizzbuzz(6) should return `['fizzbuzz', 1, 2, 'fizz', 4, 'buzz', 'fizz']`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a63cc23b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fizz_buzz(n):\n",
    "    ### YOUR CODE HERE ###\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "002a8408",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(fizz_buzz(15)) # this will work once you finish the function fizz_buzz!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eac61545",
   "metadata": {},
   "source": [
    "2) Write a function that takes in a Connect 4 board (i.e. a 2-D list) of pieces which are either `'red'` or `'yellow'` and returns the number of pieces which are red. Just fill in the blanks by replacing the underscores \"\\_\\_\\_\" with code.\n",
    "\n",
    "Hint: You will probably need to increment a variable for this problem. In other words, something like adding 1 to a variable. You can do that by writing: `variable = variable + 1`, or also `variable += 1`; they both mean the same thing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b9d2422",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "# The following creates a random 5x5 grid of 'red' and 'yellow' pieces. \n",
    "grid = [['red' if val == 1 else \"yellow\" for val in np.random.binomial(size=5, n=1, p= 0.5)] for i in range(5)]\n",
    "grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "788f4bf8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_red_pieces(grid):\n",
    "    ### YOUR CODE HERE ###\n",
    "    count = 0\n",
    "    \n",
    "    for ___ in ___: # loop through each row\n",
    "        for ___ in ___: # loop through each col\n",
    "            if ___:\n",
    "                count += 1\n",
    "    \n",
    "    return count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a30f0346",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(count_red_pieces(grid))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4fb0ac6",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "We know that was a lot of information, but feel free to look over this notebook again or ask us any questions! If there is time left, feel free to try the Connect 4 notebook below for more advanced Python programming!\n",
    "\n",
    "If you're already comfortable with coding in Python, you can also jump straight to coding the Connect Four part!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a1631e0",
   "metadata": {},
   "source": [
    "# Connect Four\n",
    "<img src=\"Resources/connect-four.png\" width=\"800px\" style=\"float: left\"/> <br><br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6cf18150",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "This code block is setup for later. Just run it, you don't need to do anything here!\n",
    "\"\"\"\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as patch\n",
    "\n",
    "def draw_grid():\n",
    "    #set axis limits of plot (x=0 to 4, y=0 to 4)\n",
    "    plt.axis([0, 4, 0, 4])\n",
    "\n",
    "    #vertical lines\n",
    "    plt.axline((1, 0), (1, 6))\n",
    "    plt.axline((2, 0), (2, 6))\n",
    "    plt.axline((3, 0), (3, 6))\n",
    "    plt.axline((4, 0), (4, 6))\n",
    "    plt.axline((5, 0), (5, 6))\n",
    "    plt.axline((6, 0), (6, 6))\n",
    "\n",
    "    #horizontal lines\n",
    "    plt.axline((0, 1), (7, 1))\n",
    "    plt.axline((0, 2), (7, 2))\n",
    "    plt.axline((0, 3), (7, 3))\n",
    "    plt.axline((0, 4), (7, 4))\n",
    "    plt.axline((0, 5), (7, 5))\n",
    "    \n",
    "    for col in range(len(connect_four_grid)):\n",
    "        for piece in range(len(connect_four_grid[col])):\n",
    "            draw_circle(col, piece, connect_four_grid[col][piece])\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "def draw_circle(x_gridsquare, y_gridsquare, color):\n",
    "    #add circle to plot (gca means \"get current axis\")\n",
    "    plt.gca().add_artist(patch.Ellipse((.5+(x_gridsquare), .5+(y_gridsquare)), .7, .9, facecolor=color))\n",
    "    \n",
    "def ask_input(name):\n",
    "    print(\"What column do you want to put your piece in, \" + name + \"?\")\n",
    "    return input()\n",
    "\n",
    "def check_win():\n",
    "    return False\n",
    "\n",
    "def play_connectfour():\n",
    "    print(\"What is player 1's name?\")\n",
    "    p1name = input()\n",
    "    print(\"What is player 2's name?\")\n",
    "    p2name = input()\n",
    "    p1turn = True\n",
    "    gameWon = False\n",
    "    while not gameWon:\n",
    "        if p1turn:\n",
    "            chosen_col = ask_input(p1name)\n",
    "            if chosen_col == \"quit\":\n",
    "                gameWon = True\n",
    "            else:\n",
    "                while not add_piece_to_board(int(chosen_col), 'red'):\n",
    "                    chosen_col = ask_input(p1name)\n",
    "                gameWon = check_win()\n",
    "            p1turn ^= True\n",
    "        else:\n",
    "            chosen_col = ask_input(p2name)\n",
    "            if chosen_col == \"quit\":\n",
    "                gameWon = True\n",
    "            else:\n",
    "                while not add_piece_to_board(int(chosen_col), 'blue'):\n",
    "                    chosen_col = ask_input(p2name)\n",
    "                gameWon = check_win()\n",
    "            p1turn ^= True\n",
    "        draw_grid()\n",
    "    if gameWon:\n",
    "        print(\"Game over!\")\n",
    "\n",
    "connect_four_grid = [\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    []\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d858309",
   "metadata": {},
   "source": [
    "As you can see, we have a grid now set up in the shape of a connect four board. But, we don't have any pieces! We will demonstrate how we can use a function to place pieces in the grid. Then, you'll work on creating a game that you and a friend can play!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9fa60bdf",
   "metadata": {},
   "outputs": [],
   "source": [
    "draw_circle(1, 0, 'red')\n",
    "draw_circle(1, 1, 'blue')\n",
    "draw_grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72936f00",
   "metadata": {},
   "source": [
    "In the example above, we use two functions in a specific order to create the game board. draw_circle has 3 arguments, an x value, a y value, and a color string. draw_grid has no arguments, and we have to call it last to draw the board correctly. Notice that the x and y values start counting from 0 instead of 1.\n",
    "\n",
    "In the cell below, try to draw a circle of your favorite color anywhere on the grid by filling in the blanks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c191ec9",
   "metadata": {},
   "outputs": [],
   "source": [
    "#draw_circle(_, _, _)\n",
    "draw_grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53b75f3d",
   "metadata": {},
   "source": [
    "Now, let's talk about how we can play the game. Below, we've provided a function that will run through like a normal game of connect four. However, it doesn't work quite right just yet. Your task is to work through and fix the different things we will need in order to play the game!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78600ff0",
   "metadata": {},
   "source": [
    "## Step 1 - Adding pieces to the grid"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23dc8857",
   "metadata": {},
   "source": [
    "First, we need a function that allows us to put a piece in the column we want. In real connect four, it's not possible to simply put a piece anywhere you want. Instead, you can only choose what column to put a piece in, and in our case we have to adapt this to 2-D lists like you've seen before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc262da0",
   "metadata": {},
   "outputs": [],
   "source": [
    "connect_four_grid = [\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    []\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d05535ae",
   "metadata": {},
   "source": [
    "This 2-D list represents our grid, and each of the inner lists represents a _column_ of pieces. So, for example, a list that looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0cffe413",
   "metadata": {},
   "outputs": [],
   "source": [
    "connect_four_grid = [\n",
    "    ['red', 'red', 'red', 'blue'],\n",
    "    [],\n",
    "    ['yellow'],\n",
    "    ['purple', 'red']\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8ba97cd",
   "metadata": {},
   "source": [
    "Would show up like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97e8dfa5",
   "metadata": {},
   "outputs": [],
   "source": [
    "draw_grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "713cfe99",
   "metadata": {},
   "source": [
    "But since we don't know ahead of time where the players want to put their pieces, we will make use of a function to handle this for us. Your job is to fill in the `add_piece_to_board` function below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dbb36718",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_piece_to_board(column, color):\n",
    "    # column is a number representing which column we want to put a piece in.\n",
    "    \n",
    "    # There will be 2 cases: what to do normally, and what to do if the column is already full.\n",
    "    # If the add succeeds, let's return True, and if not, return False.\n",
    "    \n",
    "    # We'll start with what to do normally.\n",
    "    # First, we need to make sure that the column isn't full yet.\n",
    "    # In other words, check that the len() function of the column isn't 4 or more.\n",
    "    # In that case, we need to add the given color into the column we have\n",
    "    # been given. For that, try using the function append().\n",
    "    # Then, we want to return a value that means that your move worked, so return True.\n",
    "    \n",
    "    # HINT: In your solution, you'll need to reference connect_four_grid in your solution.\n",
    "    # This is a 2-D list, like earlier, containing either 'red' or 'blue'.\n",
    "    \n",
    "    ### YOUR CODE HERE ###\n",
    "        \n",
    "    # If the column is already full, though, we need a way to tell the player they can't do that.\n",
    "    # In this case, you don't need to add anything to the column or change it. You could just return False.\n",
    "    \n",
    "    ### YOUR CODE HERE ###"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4a2e4cc",
   "metadata": {},
   "source": [
    "You can check your work with the cell below, to see if you can place your pieces right in a game."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc6550b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "connect_four_grid = [\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    []\n",
    "]\n",
    "\n",
    "play_connectfour()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7abff5c3",
   "metadata": {},
   "source": [
    "## Step 2 - Checking if somebody has won the game"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bf0e47f",
   "metadata": {},
   "source": [
    "Great! Now it's time to check if someone won the game. In the interest of keeping it reasonable, let's only consider vertical and horizontal wins. But first, let's demonstrate the .count() function with lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a963811",
   "metadata": {},
   "outputs": [],
   "source": [
    "# If we have a list like so:\n",
    "mylist = ['a', 'b', 'c', 'a']\n",
    "# I can quickly figure out how many 'a's I have in the list with:\n",
    "number_of_a = mylist.count('a')\n",
    "print(number_of_a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60abcf7f",
   "metadata": {},
   "source": [
    "As you can see in the example above, we can use the .count() function to determine how many of something is in a list. Now, let's try to use that to figure out if someone has won or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "944a634b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_win(): # Return TRUE if there is a row or column of four, and FALSE if not\n",
    "    # Let's start by considering vertical wins first.\n",
    "    # You can use the array .count() function here to check how many of something there is in\n",
    "    # an array.\n",
    "    ### YOUR CODE HERE ###\n",
    "\n",
    "    # Now let's look at horizontal wins.\n",
    "    # This works much like the previous column wins, except since we're looking at rows,\n",
    "    # we have to use the transpose of the grid. The transpose is formed by flipping the\n",
    "    # grid on its diagonal so its rows become columns and its columns become rows.\n",
    "    # (google it for an explanation)\n",
    "    connect_four_grid_transpose = [list(i) for i in zip(*connect_four_grid)]\n",
    "    ### YOUR CODE HERE ###\n",
    "    \n",
    "    # And finally, if there is no win, remember to return False."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69f85aa9",
   "metadata": {},
   "source": [
    "## Playing the game"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5e8428a",
   "metadata": {},
   "source": [
    "Now it's time to test all the parts together. See if you can play the game!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acd1cd11",
   "metadata": {},
   "outputs": [],
   "source": [
    "connect_four_grid = [\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    []\n",
    "]\n",
    "\n",
    "play_connectfour()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d20dd220",
   "metadata": {},
   "source": [
    "## Extra Challenges"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14f11342",
   "metadata": {},
   "source": [
    "Below, we have some extra challenges you can try if you have time. These are just for fun, so don't worry if you don't have time/aren't sure how to complete them."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36fccb94",
   "metadata": {},
   "source": [
    "### Extra challenge - Diagonal wins"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75c2158f",
   "metadata": {},
   "source": [
    "The check_win() function you wrote doesn't check for diagonal wins. Can you come up with a way to do this on a 4x4 board? Revisit that function above to try it out."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83a32807",
   "metadata": {},
   "source": [
    "### Extra challenge - Full sized board"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "266f23c2",
   "metadata": {},
   "source": [
    "In this version, we only have a 4x4 connect four grid. However, the real game is 7x6. In the Advanced version below, you can try to redo this lab with a full sized board for an extra challenge!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb2dd1e1",
   "metadata": {},
   "source": [
    "# Connect Four - Advanced"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc817d3a",
   "metadata": {},
   "source": [
    "In this version of connect four, you'll take on the task of rewriting it to use a 7x6 grid instead of a 4x4!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ca142b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "This code block is setup for later. You don't need to do anything here!\n",
    "\"\"\"\n",
    "\n",
    "def draw_grid_adv():\n",
    "    #set axis limits of plot (x=0 to 7, y=0 to 6)\n",
    "    plt.axis([0, 7, 0, 6])\n",
    "\n",
    "    #vertical lines\n",
    "    plt.axline((1, 0), (1, 6))\n",
    "    plt.axline((2, 0), (2, 6))\n",
    "    plt.axline((3, 0), (3, 6))\n",
    "    plt.axline((4, 0), (4, 6))\n",
    "    plt.axline((5, 0), (5, 6))\n",
    "    plt.axline((6, 0), (6, 6))\n",
    "\n",
    "    #horizontal lines\n",
    "    plt.axline((0, 1), (7, 1))\n",
    "    plt.axline((0, 2), (7, 2))\n",
    "    plt.axline((0, 3), (7, 3))\n",
    "    plt.axline((0, 4), (7, 4))\n",
    "    plt.axline((0, 5), (7, 5))\n",
    "    \n",
    "    for col in range(len(connect_four_grid_adv)):\n",
    "        for piece in range(len(connect_four_grid_adv[col])):\n",
    "            draw_circle(col, piece, connect_four_grid_adv[col][piece])\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "def draw_circle(x_gridsquare, y_gridsquare, color):\n",
    "    #add circle to plot (gca means \"get current axis\")\n",
    "    plt.gca().add_artist(patch.Ellipse((.5+(x_gridsquare), .5+(y_gridsquare)), .7, .9, facecolor=color))\n",
    "    \n",
    "def ask_input(name):\n",
    "    print(\"What column do you want to put your piece in, \" + name + \"?\")\n",
    "    return input()\n",
    "\n",
    "def check_win_adv():\n",
    "    return False\n",
    "\n",
    "def play_connectfour_adv():\n",
    "    print(\"What is player 1's name?\")\n",
    "    p1name = input()\n",
    "    print(\"What is player 2's name?\")\n",
    "    p2name = input()\n",
    "    p1turn = True\n",
    "    gameWon = False\n",
    "    while not gameWon:\n",
    "        if p1turn:\n",
    "            chosen_col = ask_input(p1name)\n",
    "            if chosen_col == \"quit\":\n",
    "                gameWon = True\n",
    "            else:\n",
    "                while not add_piece_to_board_adv(int(chosen_col), 'red'):\n",
    "                    chosen_col = ask_input(p1name)\n",
    "                gameWon = check_win_adv()\n",
    "            p1turn ^= True\n",
    "        else:\n",
    "            chosen_col = ask_input(p2name)\n",
    "            if chosen_col == \"quit\":\n",
    "                gameWon = True\n",
    "            else:\n",
    "                while not add_piece_to_board_adv(int(chosen_col), 'blue'):\n",
    "                    chosen_col = ask_input(p2name)\n",
    "                gameWon = check_win_adv()\n",
    "            p1turn ^= True\n",
    "        draw_grid_adv()\n",
    "    if gameWon:\n",
    "        print(\"Game over!\")\n",
    "\n",
    "connect_four_grid_adv = [\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    []\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14694915",
   "metadata": {},
   "source": [
    "As you can see, we have a grid now set up in the shape of a connect four board. But, we don't have any pieces! We will demonstrate how we can use a function to place pieces in the grid. Then, you'll work on creating a game that you and a friend can play!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56e02098",
   "metadata": {},
   "outputs": [],
   "source": [
    "draw_circle(1, 0, 'red')\n",
    "draw_circle(1, 1, 'blue')\n",
    "draw_grid_adv()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cad85b00",
   "metadata": {},
   "source": [
    "In the example above, we use two functions in a specific order to create the game board. draw_circle has 3 arguments, an x value, a y value, and a color string. draw_grid has no arguments, and we have to call it last to draw the board correctly. Notice that the x and y values start counting from 0 instead of 1.\n",
    "\n",
    "In the cell below, try to draw a circle of your favorite color anywhere on the grid by filling in the blanks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "552b6b34",
   "metadata": {},
   "outputs": [],
   "source": [
    "#draw_circle(_, _, _)\n",
    "draw_grid_adv()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f12b57b",
   "metadata": {},
   "source": [
    "Now, let's talk about how we can play the game. Below, we've provided a function that will run through like a normal game of connect four. However, it doesn't work quite right just yet. Your task is to work through and fix the different things we will need in order to play the game!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f558ece",
   "metadata": {},
   "source": [
    "## Step 1 - Adding pieces to the grid"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38efd306",
   "metadata": {},
   "source": [
    "First, we need a function that allows us to put a piece in the column we want. In real connect four, it's not possible to simply put a piece anywhere you want. Instead, you can only choose what column to put a piece in, and in our case we have to adapt this to 2-D lists like you've seen before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e80b0f8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "connect_four_grid_adv = [\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    []\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d6801c1",
   "metadata": {},
   "source": [
    "This 2-D list represents our grid, and each of the inner lists represents a _column_ of pieces. So, for example, a list that looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfdbbac8",
   "metadata": {},
   "outputs": [],
   "source": [
    "connect_four_grid_adv = [\n",
    "    ['red', 'red', 'red', 'blue'],\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    ['yellow'],\n",
    "    [],\n",
    "    ['purple', 'red']\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c19a13b",
   "metadata": {},
   "source": [
    "Would show up like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3b82a76",
   "metadata": {},
   "outputs": [],
   "source": [
    "draw_grid_adv()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0cdc564f",
   "metadata": {},
   "source": [
    "But since we don't know ahead of time where the players want to put their pieces, we will make use of a function to handle this for us. Your job is to fill in the `add_piece_to_board` function below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97d0829f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_piece_to_board_adv(column, color):\n",
    "    # column is a number representing which column we want to put a piece in.\n",
    "    \n",
    "    # There will be 2 cases: what to do normally, and what to do if the column is already full.\n",
    "    # If the add succeeds, let's return True, and if not, return False.\n",
    "    \n",
    "    # We'll start with what to do normally.\n",
    "    # First, we need to make sure that the column isn't full yet.\n",
    "    # In other words, check that the len() function of the column isn't 6 or more.\n",
    "    # In that case, we need to add the given color into the column we have\n",
    "    # been given. For that, try using the function append().\n",
    "    # Then, we want to return a value that means that your move worked, so return True.\n",
    "    \n",
    "    # HINT: In your solution, you'll need to reference connect_four_grid in your solution.\n",
    "    # This is a 2-D list, like earlier, containing either 'red' or 'blue'.\n",
    "    \n",
    "    ### YOUR CODE HERE ###\n",
    "        \n",
    "    # If the column is already full, though, we need a way to tell the player they can't do that.\n",
    "    # In this case, you don't need to add anything to the column or change it. You could just return False.\n",
    "    \n",
    "    ### YOUR CODE HERE ###"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fd76679",
   "metadata": {},
   "source": [
    "You can check your work with the cell below, to see if you can place your pieces right in a game."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d47d960",
   "metadata": {},
   "outputs": [],
   "source": [
    "connect_four_grid_adv = [\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    []\n",
    "]\n",
    "\n",
    "play_connectfour_adv()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ca6ba5b",
   "metadata": {},
   "source": [
    "## Step 2 - Checking if somebody has won the game"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d4a3098",
   "metadata": {},
   "source": [
    "Great! Now it's time to check if someone won the game. Since this is the advanced section, try to consider vertical, horizontal, and diagonal wins."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99bb4817",
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_win_adv(): # Return TRUE if there is a row or column or diagonal of four, and FALSE if not\n",
    "    # Note that you shouldn't have to use the transpose for this, but here it is just in case:\n",
    "    connect_four_grid_transpose_adv = [list(i) for i in zip(*connect_four_grid_adv)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "677c2624",
   "metadata": {},
   "source": [
    "## Playing the game"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcf12476",
   "metadata": {},
   "source": [
    "Now it's time to test all the parts together. See if you can play the game!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e72a5d6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "connect_four_grid_adv = [\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    [],\n",
    "    []\n",
    "]\n",
    "\n",
    "play_connectfour_adv()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.4"
  },
  "vscode": {
   "interpreter": {
    "hash": "b0fa6594d8f4cbf19f97940f81e996739fb7646882a419484c72d19e05852a7e"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}