{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"language_info": {
"name": "python"
}
},
"cells": [
{
"cell_type": "markdown",
"source": [
"# CS 277 - Algorithms and Data Structures for Data Science\n",
"\n",
"**Lecture 1**\n",
"\n",
"* Introduction(s)\n",
"* Course Logistics\n",
"* Introduction to Python\n",
"\n"
],
"metadata": {
"id": "GH_6yXV5UXNE"
}
},
{
"cell_type": "markdown",
"source": [
"# Welcome to CS 277\n",
"\n",
"I am Harsha Srimath Tirumala, the instructor for this semester's course on Algorithms and Data Structures.\n",
"\n",
"I am from India, my research interests are in theoretical computer science and my hobbies include watching/playing Football and Tennis.\n",
"\n",
"I have always dreaded programming - something you will no doubt witness at different points this semester.\n",
"\n",
"---\n",
"\n",
"\n",
"Fun fact - My favorite football teams all won something of note this past season - Barcelona, Arsenal and Spain!\n"
],
"metadata": {
"id": "qZ7ri5JrTtSi"
}
},
{
"cell_type": "markdown",
"source": [
"# Introduction\n",
"\n",
"This is a course about systematic problem solving.\n",
"\n",
"The problems we will deal with are computational problems. Our task will be to design algorithms to solve these problems in a systematic manner. We will also write programs in Python to implement these algorithms.\n",
"\n",
"Examples include -\n",
"\n",
"1. Optimal search through structured data\n",
"\n",
"2. Best sorting algorithm for a list of numbers\n",
"\n",
"3. Identifying all airports reachable from Champaign within 3 hops\n",
"\n",
"4. Establishing Linkedin connection degree (1st/2nd/3rd)\n",
"\n",
"5. Computing the cheapest flight route from Chicago to San Francisco\n",
"\n",
"6. Finding the minimum number of semesters to complete courses required for a degree\n",
"\n",
"7. Minimum edits needed to transform the word Champaign to China\n"
],
"metadata": {
"id": "2tAMXzRAJohK"
}
},
{
"cell_type": "markdown",
"source": [
"# Course Learning Goals\n",
"\n",
""
],
"metadata": {
"id": "yYrKnjd40i31"
}
},
{
"cell_type": "markdown",
"source": [
"# Course staff\n",
"\n",
"\n",
"\n",
"* Instructor - Harsha Srimath Tirumala\n",
"\n",
"* Teaching Assistants - Atharva Bhatt, Anushka Gupta, Shashwat Gupta, Ethan Luo\n",
"\n",
"* Course Assistants - Anila Chundi, Jiawen Gong,\n",
"Bhavika Kothari,\n",
"Adarsh Krishnan,\n",
"Steven Piotrowski,\n",
"Youyou Wu\n",
"\n",
"\n"
],
"metadata": {
"id": "x_k8iztpU5ZT"
}
},
{
"cell_type": "markdown",
"source": [
"# Electronic Bulletin board\n",
"\n",
"\n",
"* **Course Website** - General information, Course policy, Lecture notes, Lecture recordings\n",
"\n",
"https://courses.grainger.illinois.edu/cs277/fa2026/\n",
"\n",
"\n",
"* **Ed** - Announcements, online questions and discussion, contacting course staff\n",
"\n",
"https://edstem.org/us/courses/102969/discussion\n",
"\n",
"* **Prairielearn** - All assigned work\n",
"\n",
"https://us.prairielearn.com/\n",
"\n",
"* We will use the Massmail tool to send an email to all course participants in case of special notifications such as weather related cancellation, exam specifics etc.\n",
"\n",
"\n",
"\n",
"---\n",
"\n",
"Note - The course website is under construction and it may take a few days to get it up to date. Thanks for your patience.\n",
"\n"
],
"metadata": {
"id": "BaNYVn93VZ_f"
}
},
{
"cell_type": "markdown",
"source": [
"# Resources for class material\n",
"\n",
"**Prerequisites**\n",
"\n",
"STAT 207, Calculus. Prior programming experience in Python from STAT 207 and CS/STAT 107.\n",
"\n",
"**Textbooks**\n",
"\n",
"1. Algorithms by Dasgupta, Papadimitriou and Vazirani (MAIN)\n",
"\n",
"2. Data Structures and Algorithms in Python by Goodrich, Tamassia and Goldwasser (Coding reference)\n",
"\n",
""
],
"metadata": {
"id": "6LJKH4eKZRYx"
}
},
{
"cell_type": "markdown",
"source": [
"# Grading policy\n",
"\n",
"Total score for the course (100) will be based on -\n",
"\n",
"* Labs - 25%\n",
"* Homeworks - 25%\n",
"* Midterm exams - 33.33%\n",
"* Final exam - 16.67%\n",
"\n",
"\n",
"Final Grades -\n",
"\n",
"* A : [93,100]\n",
"* A- : [90,93)\n",
"* B+ : [87,90)\n",
"* B : [83,87)\n",
"* C+ : [77,80)\n",
"* C : [73,77)\n",
"* C- : [70,73)\n",
"* D : [60,70)\n",
"* D- : [50,60)\n",
"* F : [0,50)\n",
"\n",
"Note - These scores guarantee the respective letter grade. The final grading scheme (per instructor's discretion) may be more generous depending on factors such as unusual circumstances, diffculty of exams etc.\n",
"\n"
],
"metadata": {
"id": "6qitZzDEeqIA"
}
},
{
"cell_type": "markdown",
"source": [
"# Labs\n",
"\n",
"* Every week Labs are on Fridays 3:30pm to 4:45pm in DCL 1320\n",
"\n",
"* Autograded programming and algorithm exercises on\n",
"PrairieLearn\n",
"\n",
"* Start working during Friday meeting and complete by\n",
"Thursday the following week\n",
"\n",
"* Allowed to submit one lab upto a week late; required to inform\n",
"us within 24 hours of the homework deadline.\n",
"\n",
"(more information on Course webpage)\n",
"\n",
"* Any lab can be submitted one day late for 90% credit\n",
"\n",
"* **Individual submissions**\n",
"\n",
"* Schedule on course webpage - expected to have 11 labs"
],
"metadata": {
"id": "z29Zpqujgsa0"
}
},
{
"cell_type": "markdown",
"source": [
"# Homework\n",
"\n",
"* One homework every two weeks : Assigned on Monday and due\n",
"two weeks later on Monday.\n",
"\n",
"* Allowed to submit one homework upto a week late; required to\n",
"inform us within 24 hours of the homework deadline.\n",
"\n",
"* Any homework can be submitted one day late for 90% credit\n",
"\n",
"* Solved in **groups of size at most 3** on PrairieLearn\n",
"\n",
"* Homework schedule on course webpage - 6 in total\n"
],
"metadata": {
"id": "jpaV-otJhYiL"
}
},
{
"cell_type": "markdown",
"source": [
"# Examinations\n",
"\n",
"* To be held at Computer Based Testing Facility\n",
"\n",
"* Tentative schedule (awaiting CBTF confirmation) -\n",
"\n",
"1. Midterm 1 (50 minutes) Oct 1 - Oct 4\n",
"2. Midterm 2 (50 minutes) Oct 29 - Nov 1\n",
"3. Final Exam (50 minutes + 50 minutes) Dec 11 - Dec 17\n",
"\n",
"During the slot for the final exam, **you can choose to retake either exam 1 or exam 2 (or neither)**.\n",
"\n",
"* Each exam only tests topics covered since previous exam.\n",
"\n",
"* No conflict exams unless there are extraordinary circumstances."
],
"metadata": {
"id": "kUzpAISUiUEF"
}
},
{
"cell_type": "markdown",
"source": [
"# Course Overview\n",
"\n",
"* How to solve computational problems efficiently and\n",
"communicate that your solution is effective and correct\n",
"\n",
"* Different algorithms can solve a computation problem with\n",
"drastically different performance\n",
"\n",
"* Learn how to break a complex problem into subproblems, use\n",
"abstraction to identify algorithmic solutions\n",
"\n",
"* Algorithmic paradigms: divide and conquer, dynamic\n",
"programming, greedy, . . .\n",
"\n",
"* Not a programming class though you will be expected to write\n",
"small snippets of Python code\n",
"\n"
],
"metadata": {
"id": "UZH6qZpQ1n-v"
}
},
{
"cell_type": "markdown",
"source": [
"# Introduction to Python and Recursion\n",
"\n",
"A good source for an overview on Python is chapter 1 of the textbook \"Data Structures and Algorithms in Python\" by Goodrich, Tamassia, and Goldwasser. This lecture is based on material in that chapter.\n",
"\n",
"## Identifiers and Assignment\n",
"\n",
"*Identifiers* are \"names\" of memory locations that store values that are used used byt he program during the computation.\n",
"\n",
"The *assignment* statement assigns a value to an identifier.\n",
"\n",
"For example, temperature = 98.6 establishes temperature as an identifier and associates it with the object expressed on the right of the \"=\".\n",
"* Identifiers are case sensitive. temperature is a different identifier than Temperature.\n",
"\n",
"## Built-in Classes\n",
"\n",
"### bool class\n",
"\n",
"**Values:** True and False\n",
"\n",
"**Operations:**\n",
"* a and b evaluates to True exactly if **both** a and b evaluate to True\n",
"* a or b evaluates to True exactly if **at least** one of a or b evaluate to True\n",
"* not a evaluates to True exactly when a evaluates to False.\n",
"\n",
"### int class\n",
"\n",
"**Values:** -4, -2, 0, 1, 2, 5, ...\n",
"\n",
"**Operations:** + (addition), - (subtraction), * (multiplication), / (division), // (integer division), % (modulo), ** (exponentiation), ...\n",
"\n",
"### float class\n",
"\n",
"**Values:** 1.0, 0.5, -25.5, ...\n",
"\n",
"**Operations:** + (addition), - (subtraction), * (multiplication), / (division), ...\n",
"\n",
"### sequence classes\n",
"\n",
"**string:** any sequence of characters, \"hello\", `world'\n",
"\n",
"**list:** any sequence of objects, [0,1,100], [\"hello\", 1.5]\n",
"\n",
"**tuple:** immutable version of lists, (0,1,100), (\"hello\",1.5)\n",
"\n",
"**Other classes:** dict, set, ...\n",
"\n",
"**Operations:**\n",
"* s + t *concatenates* s and t\n",
"* k * s: concatenate s with itself k times\n",
"* s[i]: ith element of s\n",
"* s[i,j]: portion of s from ith element to jth element (not including the jth element)\n",
"* val in s: checks if val is in sequence s\n",
"* val not in s: checks if val is not in sequence s\n"
],
"metadata": {
"id": "Slv96BJU4G1n"
}
},
{
"cell_type": "markdown",
"source": [
"## Input and Output\n",
"\n",
"**print:** outputs a sequence of characters on the console\n",
"\n",
"**input:** way to get information from the user. prints an optional prompt and then waits for the user to enter information."
],
"metadata": {
"id": "lElT5lNk4iTG"
}
},
{
"cell_type": "code",
"source": [
"# hello world\n",
"print(\"Hello World!\")"
],
"metadata": {
"id": "QtGlDCH0UfFr"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# simple assignment and operations\n",
"a = 5\n",
"b = a\n",
"print(\"a =\", a, \"b =\", b)\n",
"\n",
"b = 2\n",
"print(\"a =\", a, \"b =\", b)\n",
"\n",
"print(\"a/b =\", a/b, \"a//b =\", a//b)\n",
"print(\"a%b =\", a%b)\n",
"\n",
"s =\"cat\"\n",
"print(s+s)\n",
"print(2*s)\n",
"print(s[0],s[1])\n",
"\n",
"l = [0, \"hello\", 1.5]\n",
"print(l[2])\n",
"print(l)\n"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "qlcwvxoe4sBx",
"outputId": "88e8a98b-3a7e-42ee-a307-be2ff00c80fa"
},
"execution_count": 11,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"a = 5 b = 5\n",
"a = 5 b = 2\n",
"a/b = 2.5 a//b = 2\n",
"a%b = 1\n",
"catcat\n",
"catcat\n",
"c a\n",
"1.5\n",
"[0, 'hello', 1.5]\n"
]
}
]
},
{
"cell_type": "code",
"source": [
"# understanding input\n",
"a = input(\"What is a? \")\n",
"b = input(\"What is b? \")\n",
"print(\"a+b is\", a+b)\n",
"\n",
"a = int(input(\"What is a? \"))\n",
"b = int(input(\"What is b? \"))\n",
"\n",
"print(\"a+b is\", a+b)"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "tlB0AIcZ4wN8",
"outputId": "c1de8ca4-d615-497e-c5e2-4b3fae33a6a8"
},
"execution_count": 8,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"What is a? 7\n",
"What is b? 3\n",
"a+b is 73\n",
"What is a? 7\n",
"What is b? 3\n",
"a+b is 10\n"
]
}
]
},
{
"cell_type": "code",
"source": [
"# swapping numbers\n",
"a = 5\n",
"b = 6\n",
"print(a,b)\n",
"\n",
"a = 5\n",
"b = 6\n",
"a = b\n",
"b = a\n",
"print(a,b)\n",
"\n",
"a = 5\n",
"b = 6\n",
"a,b = b,a\n",
"print(a,b)"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "jNFIsfwH42Om",
"outputId": "d7029660-b703-4075-aa44-c5b31a7067c1"
},
"execution_count": 7,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"5 6\n",
"6 6\n",
"6 5\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"## Control Flow\n",
"\n",
"Conditional constructs (also known as if statements) provide a way to execute a chosen block of code based on the run-time evaluation of one or more Boolean expressions. In Python, the most general form is\n",
"\n",
"```\n",
"if :\n",
" \n",
"elif :\n",
" \n",
"elif :\n",
" \n",
"else:\n",
" \n",
"```"
],
"metadata": {
"id": "RRegz_GA4_ex"
}
},
{
"cell_type": "code",
"source": [
"# find maximum of 3 numbers\n",
"a = int(input(\"What is a? \"))\n",
"b = int(input(\"What is b? \"))\n",
"c = int(input(\"What is c? \"))\n",
"if a > b:\n",
" # a is greater than b\n",
" if a > c:\n",
" print(\"maximum is a and is equal to\", a)\n",
" else:\n",
" print(\"maximum is c and is equal to\", c)\n",
"else:\n",
" # b >= a\n",
" if b > c:\n",
" print(\"maximum is b and is equal to\", b)\n",
" else:\n",
" print(\"maximum is c and is equal to\", c)"
],
"metadata": {
"id": "hnxSvzr85EBI"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"## Loops\n",
"\n",
"Loops allow one to execute a sequence of statements repeatedly. Python offers two forms of loops: ```while``` loops and ```for``` loops. General form of these loops is\n",
"\n",
"```\n",
"while :\n",
" \n",
"\n",
"for in :\n",
" \n"
],
"metadata": {
"id": "IPIJghr25Hd-"
}
},
{
"cell_type": "code",
"source": [
"# find the sum of the first 5 squares\n",
"n = 0\n",
"sum = 0\n",
"while n < 100:\n",
" sum = sum + n*n\n",
" n = n+1\n",
"\n",
"print(sum)"
],
"metadata": {
"id": "Fm4sGjXc48eF"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# find the sum of the first 5 squares\n",
"l = [0,1,2,3,4]\n",
"\n",
"sum = 0\n",
"for i in l:\n",
" sum += i*i\n",
"print(sum)"
],
"metadata": {
"id": "Ly9RU1Jk5Rzs"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"# range\n",
"n = int(input(\"What is n? \"))\n",
"sum = 0\n",
"for i in range(n):\n",
" sum += i*i\n",
"print(sum)\n",
"\n",
"# range(n) = [0,1,2,3,...,(n-1)]"
],
"metadata": {
"id": "0qcukvaM5Xtx"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"## break and continue\n",
"\n",
"**break:** immediate termination of the loop when executed within its body\n",
"\n",
"**continue:** causes the current iteration of a loop body to stop, but with subsequent passes of the loop proceeding as expected\n"
],
"metadata": {
"id": "axDWDBWP5adk"
}
},
{
"cell_type": "code",
"source": [
"print(\"Running loop with break\")\n",
"for n in range(10):\n",
" if (n == 5):\n",
" break\n",
" print(n)\n",
"\n",
"print(\"Running loop with continue\")\n",
"for n in range(10):\n",
" if (n == 5):\n",
" continue\n",
" print(n)"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "Z18eynNw5ezc",
"outputId": "c228eb00-0f63-430c-a622-8437e2702272"
},
"execution_count": 12,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Running loop with break\n",
"0\n",
"1\n",
"2\n",
"3\n",
"4\n",
"Running loop with continue\n",
"0\n",
"1\n",
"2\n",
"3\n",
"4\n",
"6\n",
"7\n",
"8\n",
"9\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"## Mutable and Immutable Classes\n",
"\n",
"Assignments to variables with an immutable type, an assignment does not modify the existing object; instead it creates a new object and assigns the identifier to that value.\n",
"\n",
"In contrast, assignments to mutable types, modifies the existing object.\n",
"\n",
"**Immutable types:** bool, int, float, string, tuple\n",
"\n",
"**Mutable types:** list, dict, set"
],
"metadata": {
"id": "4scChOCb5hbq"
}
},
{
"cell_type": "code",
"source": [
"a = 5\n",
"b = a\n",
"print(\"a =\",a, \"b =\", b)\n",
"b += 1\n",
"print(\"a =\",a, \"b =\", b)\n",
"s = \"hello\"\n",
"#s[1] = \"a\" # Will generate an error because strings are not mutable\n",
"l = list(\"hello\")\n",
"print(\"l =\", l)\n",
"l[1] = \"a\"\n",
"print(\"l =\", l)\n",
"m = l\n",
"print(\"m =\", m)\n",
"m[3] = \"o\"\n",
"print(\"l =\", l)\n",
"l[3] = \"l\"\n",
"l += \"o\"\n",
"print(\"m =\", m)\n"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "dilhWgUI5kBT",
"outputId": "5bc01bb9-dd0a-4d96-d5d6-8f6346498010"
},
"execution_count": 17,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"a = 5 b = 5\n",
"a = 5 b = 6\n",
"l = ['h', 'e', 'l', 'l', 'o']\n",
"l = ['h', 'a', 'l', 'l', 'o']\n",
"m = ['h', 'a', 'l', 'l', 'o']\n",
"l = ['h', 'a', 'l', 'o', 'o']\n",
"m = ['h', 'a', 'l', 'l', 'o', 'o']\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"## Functions\n",
"\n",
"A *function* serves as a self-contained, reusable block of code designed to perform a specific, defined task. The take inputs and produce an output which is the result of the computation."
],
"metadata": {
"id": "CFW0LUQZ5mg8"
}
},
{
"cell_type": "code",
"source": [
"# Function to compute the sum of squares\n",
"def sum_of_squares(n):\n",
" sum = 0\n",
" for i in range(n):\n",
" sum += i*i\n",
" return sum\n",
"\n",
"print (sum_of_squares(5))"
],
"metadata": {
"id": "aqA-neXv5pI6"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"## Scope and Namespaces\n",
"\n",
"Scope refers to the region of the program where a variable is defined. Variables assignments within the body of a function, are local to that function call."
],
"metadata": {
"id": "DSC-2HNG5r-a"
}
},
{
"cell_type": "code",
"source": [
"g = 2\n",
"x = 2\n",
"\n",
"def foo (x):\n",
" print(\"g =\",g)\n",
" print(\"x =\", x)\n",
" y = x + 1\n",
" print(\"y =\", y)\n",
" return x\n",
"\n",
"def bar (x):\n",
" print(\"y =\", y)\n",
" return y\n",
"\n",
"foo(1)\n",
"#bar(0)"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "3VnEjhLl5vSZ",
"outputId": "15bc5d34-9f14-48a8-98f6-0ac953d75fb3"
},
"execution_count": 4,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"g = 2\n",
"x = 1\n",
"y = 2\n"
]
},
{
"output_type": "execute_result",
"data": {
"text/plain": [
"1"
]
},
"metadata": {},
"execution_count": 4
}
]
}
]
}