2022-11-28-our.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unit 3 Sections 3-4 \n",
    "\n",
    "- title: Mathematical Expressions and Strings\n",
    "- comments: true\n",
    "- permalink: /jupyter/lesson2\n",
    "- categories: [jupyter]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is an Algorithm?\n",
    "\n",
    "**An algorithm:** a set of instructions that can accomplish a specific task.\n",
    "\n",
    "### An Algorithm Has Three Components\n",
    "\n",
    "1. **Sequencing:** Algorithms do tasks in the order of specification.\n",
    "\n",
    "![img1](https://github.com/manigggg18/manimani/blob/master/images/first.jpg?raw=true)\n",
    "\n",
    "2. **Selection:** Helps choose two different outcomes based off a decision.\n",
    "\n",
    "![img1](https://github.com/manigggg18/manimani/blob/master/images/1234.png?raw=true)\n",
    "\n",
    "3. **Iteration:** If a condition is true, then the code can repeat. \n",
    "\n",
    "![img1](https://github.com/manigggg18/manimani/blob/master/images/123.png?raw=true)\n",
    "\n",
    "### Algorithms Can Be Represented in Two Ways\n",
    "\n",
    "1. **Flowcharts:** Use shapes and arrows to represent the steps of an algorithm. \n",
    "\n",
    "![img1](https://github.com/manigggg18/manimani/blob/master/images/123456.png?raw=true)\n",
    "\n",
    "![img1](https://github.com/manigggg18/manimani/blob/master/images/12345.png?raw=true)\n",
    "\n",
    "2. **Pseudocode:** A blend of human language and coding format. \n",
    "\n",
    "### Hacks: Jamboard Flowchart\n",
    "\n",
    "[Click on this link for a group activity](https://jamboard.google.com/d/1qpPFYt9cyjJOSzpT4ODND8Jj6gk8DUWPbLAksaOTCvA/viewer?f=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "---\n",
    "\n",
    "## Arithmetic Operations\n",
    "\n",
    "Arithmetic operations exist in most programming languages.\n",
    "\n",
    "### Basic Operations\n",
    "\n",
    "**Subtraction**:\n",
    "\n",
    "- Represented by “-\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num1 = 2 - 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Addition**: \n",
    "\n",
    "- Represented by \"+\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num1 = 2 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Multiplication**: \n",
    "\n",
    "- Represented by “*”"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num1 = 2 * 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Division**: \n",
    "\n",
    "- Represented by “/”"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num1 = 2 / 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Getting the Remainder**: \n",
    "\n",
    "- Represented by “MOD” (% in python)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num1 = 5 % 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Different Uses\n",
    "\n",
    "> Items can be numbers or variables.\n",
    "\n",
    "Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num1 = 10\n",
    "num2 = num1 - 25\n",
    "num3 = 100 * num1\n",
    "num4 = num1 / num2\n",
    "num5 = 9 % num4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Order of Operations\n",
    "\n",
    "Arithmetic operations in programming are performed in the same order as operations in mathematics:\n",
    "\n",
    "- Operations in parentheses should be done first.\n",
    "\n",
    "- Division and multiplication should be done before addition and subtraction.\n",
    "\n",
    "- Modulus works similar to multiplication and division.\n",
    "\n",
    "Example: Evaluate num1\t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.0\n"
     ]
    }
   ],
   "source": [
    "num1 = 9 % 2 * ( 8 - 2 ) + 8 / ( 6 - 4 )\n",
    "print(num1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "---\n",
    "\n",
    "## Variables\n",
    "\n",
    "### Different Ways Values are Stored in Variables\n",
    "\n",
    "1. Numerical value stored in a variable\n",
    "   \n",
    "2. Value of another variable stored in a variable \n",
    "   \n",
    "3. Result of an operation stored in a variable \n",
    "\n",
    "4. Result of a procedure call stored in a variable "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "score = 0   # 1\n",
    "score = newScore    # 2\n",
    "score = newScore + 2    # 3\n",
    "avgScore = allscores(20, 60, 80)    # 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sequencing is Important!\n",
    "\n",
    "Changing the order of the steps changes the overall outcome, since every time the value assigned to a variable is changed, it overrides the last value which was assigned to the same variable. That is why it is important to track the value of variables, especially in code where the value is constantly changing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num1 = 2\n",
    "num2 = 4\n",
    "num3 = 6\n",
    "num1 = num2 + num3      # num1 is now 4 + 6, which is 10\n",
    "num2 = num1 + num3      # num2 is now (the new num1) 10 + 6, which is 16\n",
    "# output: num1 = 10, num2 = 16, num3 = 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**VS**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num1 = 2\n",
    "num2 = 4\n",
    "num3 = 6\n",
    "num2 = num1 + num3  #num2 is now 8\n",
    "num1 = num2 + num3  # num1 is now 14\n",
    "# output: num1 = 14, num2 = 8, num3 = 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tracking Variables\n",
    "\n",
    "Tracking variables is a common question found on AP exams and is an important thing to keep in mind when writing any code. If the value of your variables changes a lot, not accounting for these changes can result in an unwanted outcome."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var1 = 9\n",
    "var2 = 7\n",
    "var3 = 2\n",
    "\n",
    "#var = var1 + 5\n",
    "#var2 = var1 - var3\n",
    "#var1 = var2\n",
    "#var3 = (var1 + var2) / 2\n",
    "#var2 = 6\n",
    "\n",
    "print(var1)\n",
    "print(var2)\n",
    "print(var3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hacks/Homework\n",
    "\n",
    "#### Evaluate the variable \"result\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "Num1 = 50\n",
    "Num2 = Num1 % 9 + 15\n",
    "Num3 = Num2 / Num1 + ( Num2 * 2 )\n",
    "Num4 = Num3 + Num1 / 5 - 10\n",
    "Result = Num4 - Num2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "Num1 = 10\n",
    "Num2 = Num1 % 3 * 4\n",
    "Num1 = Num2\n",
    "Num3 = Num1 * 3\n",
    "Result = Num3 % 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valueA = 4\n",
    "valueB = 90\n",
    "valueC = 17\n",
    "valueB = valueC - valueA\n",
    "valueA = valueA * 10\n",
    "if valueB > 10:\n",
    "    print(valueC)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type = \"curly\"\n",
    "color = \"brown\"\n",
    "length = \"short\"\n",
    "type = \"straight\"\n",
    "hair = type + color + length\n",
    "print(hair)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "---\n",
    "\n",
    "## Strings\n",
    "\n",
    "### What is a String?\n",
    "\n",
    "**A String**: A string is a collection of characters. What is a character as character can be anything from numbers, letters, spaces, special symbols, etc.\n",
    "\n",
    "A string is a collection of characters. What is a character as character can be anything from numbers, letters, spaces, special symbols, etc.\n",
    "\n",
    "Certain procedures may be used with strings and they vary from programming language to language Python examples\n",
    "\n",
    "`len()` to find the length of a string\n",
    "\n",
    "`lower()` to convert to lowercase\n",
    "\n",
    "etc. Pseudocode examples\n",
    "\n",
    "`len()` returns the length of a string\n",
    "\n",
    "`concat()` returns a string made up of the concatenated strings ex. concat(\"string1\", \"string2\") would return string1string2\n",
    "\n",
    "`substring()` returns the characters from the string beginning at the at the first position to the last so an example of this would be substring `(\"abcdefghijk\", 2, 5)` would print `bcde` (pseudocode starts at 1)\n",
    "\n",
    "### String Concatenation\n",
    "\n",
    "What is string concatenation?\n",
    "\n",
    "String concatenation is combining 2 or more strings to make a new strings in order to create a new string\n",
    "\n",
    "`concat()` in pseudocode and varys from language to language can be used to combine to strings such as `concat(\"cookie\",\"monster\")` returns `cookiemonster`\n",
    "\n",
    "### Substrings\n",
    "\n",
    "**What is a substring?**\n",
    "\n",
    "A substring is a part of and already existing string.\n",
    "\n",
    "In pseudocode `substring()` method is used for instance for `concat(\"Mr.Mortenson is very handsome\" 1, 2)` the system would return `Mr` (remember that pseudocode starts at 1)\n",
    "\n",
    "### Hacks\n",
    "\n",
    "#### Find the result of the following problems. Then convert the pseudocode to working python code using your knowledge of python string operators.\n",
    "\n",
    "**Problem 1**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Noun = \"Mr.Mortenson\" \n",
    "Adjective = \"handsome\" \n",
    "Adjective2 = \"Very\" \n",
    "Verb = \"is\" \n",
    "abrev = subtring(Noun, 1, 7) \n",
    "yoda = concat(Adjective2, \" \", Adjective, \" \", abrev, \" \",Verb, \".\") \n",
    "print(yoda)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem 2**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cookie = \"choclate\" \n",
    "cookie2 = \"rasin\" \n",
    "len1 = cookie / 2 \n",
    "len2 = cookie2 * 45 \n",
    "vote1 = (cookie, \"vote\", len2) \n",
    "vote2 = (cookie2, \"vote\", len1) \n",
    "votes = (concat(vote1, \" \", vote2)) \n",
    "print(votes)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.12 ('base')",
   "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.9.12"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "33c078916551e7df06d6239c31e0a5ca0c0782cc8455a487fd402e7e7dd73d0b"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}