Exercises3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before you turn this problem in, make sure everything runs as expected. First, **restart the kernel** (in the menubar, select Kernel$\\rightarrow$Restart) and then **run all cells** (in the menubar, select Cell$\\rightarrow$Run All).\n",
    "\n",
    "Make sure you fill in any place that says `YOUR CODE HERE` or \"YOUR ANSWER HERE\", as well as your name and collaborators below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "NAME = \"Sreya Dhar\"\n",
    "COLLABORATORS = \"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "25f6a7f1d63ec58603ca94aacd6dc72a",
     "grade": false,
     "grade_id": "cell-8abe173ecc588e38",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.46"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ex1\n",
    "def average_word_len_in_sentence(sent):\n",
    "    # Complete this function to calculate the average\n",
    "    # word length in a sentence\n",
    "    # Input: sentence\n",
    "    # Output: average word length in sentence\n",
    "    # Hint: count punctuations with whatever word they are `touching`\n",
    "    # Hint: round the average to two decimal places\n",
    "   \n",
    "    # YOUR CODE HERE\n",
    "    sentences = sent.split('.,')\n",
    "    sentences = [sent.split() for sentence in sentences if len(sentence)]\n",
    "    average = [sum(len(word) for word in sent)/len(sent) for sent in sentences]\n",
    "    ave = average[0]\n",
    "    return round(ave, 2)\n",
    "\n",
    "average_word_len_in_sentence('This is a test sentence!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b6c4aff20366d1aa657fc1abdd1c3a79",
     "grade": true,
     "grade_id": "cell-88eb75a67af14058",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert average_word_len_in_sentence('This is a test sentence!') == 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "4a6a913749ee0e1376198ef5317952f6",
     "grade": true,
     "grade_id": "cell-9a48ceb083442619",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Hidden test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "04307ddf21b6b2cb8586ce84b089c09f",
     "grade": false,
     "grade_id": "cell-9cd6ed6844d07523",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(50, 643, 4298)"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Ex2\n",
    "def wc(filename):\n",
    "    # Complete this function to count the number of lines, words, and chars in a file. \n",
    "    # Input: filename\n",
    "    # Output: a tuple with line count, word count, and char count -- in this order\n",
    "\n",
    "    # YOUR CODE HERE\n",
    "    num_lines = 0\n",
    "    num_words = 0\n",
    "    num_chars = 0\n",
    "\n",
    "    with open(filename, 'r') as f:\n",
    "        data = f.read()\n",
    "        line = data.splitlines()\n",
    "        words = data.split()\n",
    "        spaces = data.split(\" \")\n",
    "        charc = len(data) \n",
    "        \n",
    "        \n",
    "    return len(line), len(words), charc \n",
    "        \n",
    "        \n",
    "wc('ex2_data.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9ac41fa90e6c0d04ec38067a4fe5b7c5",
     "grade": true,
     "grade_id": "cell-9784281c8327eef5",
     "locked": true,
     "points": 4,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert wc('ex2_data.txt') == (50, 643, 4298)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "970c1231f2b5edee86f32f5594426586",
     "grade": false,
     "grade_id": "cell-4cbfe85e128613b1",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Ex3a\n",
    "def is_leap(year):\n",
    "    # Complete this function to check if year is a leap year\n",
    "    # Input: year\n",
    "    # Output: True or False (Boolean)\n",
    "\n",
    "    # YOUR CODE HERE\n",
    "        # YOUR CODE HERE\n",
    "        leapy = False\n",
    "    \n",
    "    # logic here\n",
    "        if year % 400 == 0:\n",
    "            leapy = True\n",
    "        elif year % 100 == 0:\n",
    "            leapy = False\n",
    "        elif year % 4 == 0:\n",
    "            leapy = True\n",
    "    \n",
    "        return leapy\n",
    "\n",
    "is_leap(2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "90ae8ad84e566dc8730438d14b86d1f6",
     "grade": true,
     "grade_id": "cell-b9a05e2e268a2c6a",
     "locked": true,
     "points": 4,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert is_leap(1800) == False\n",
    "assert is_leap(1900) == False\n",
    "assert is_leap(1600) == True\n",
    "assert is_leap(2000) == True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "3c2629ae2b4fd05fd89217dfc715475b",
     "grade": false,
     "grade_id": "cell-8b0875e64766bf5f",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Ex3b\n",
    "import datetime \n",
    "def is_date_valid(month, day, year):\n",
    "    # Complete this function to check if a data is valid, given month, day, and year.  \n",
    "    # For example, 5/24/1962 is valid, but 9/31/2000 is not\n",
    "    # Inputs: month, day, year\n",
    "    # Output: True or False (Boolean)\n",
    "    # Hint: Use is leap year function\n",
    "\n",
    "    # YOUR CODE HERE\n",
    "    isValidDate = True\n",
    "      \n",
    "    try : \n",
    "        datetime.datetime(int(year),  \n",
    "                          int(month), int(day)) \n",
    "          \n",
    "    except ValueError : \n",
    "        isValidDate = False\n",
    "    \n",
    "    return isValidDate\n",
    "          \n",
    "\n",
    "is_date_valid(5, 24, 1962)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e7460c27f269c1a2e45f5da2c847e5f4",
     "grade": true,
     "grade_id": "cell-0af99a4a4a8d91ee",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert is_date_valid(5, 24, 1962) == True\n",
    "assert is_date_valid(9, 31, 2000) == False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "25104c7bbecd3939510759effcf7addd",
     "grade": true,
     "grade_id": "cell-72635d6da9df7e2b",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Hidden tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f87041afba39d2c6cd87b512347e37cb",
     "grade": false,
     "grade_id": "cell-cdb696c1bc3474fa",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Ex4\n",
    "def is_leap(month, day, year):\n",
    "        leap = False\n",
    "        if year % 4 ==0:\n",
    "            if year % 100 !=0 or year % 400 == 0:\n",
    "                leap = True\n",
    "        return leap\n",
    "\n",
    "def is_date_valid(month, day, year):\n",
    "        is_valid = True\n",
    "        thirtyone_day_months = [1,3,5,7,8,10,12]\n",
    "        #print(month, day, year)\n",
    "\n",
    "        month =int(month)\n",
    "        day = int(day)\n",
    "        year = int(year)\n",
    "\n",
    "        if month >12 or month <1 or day >31 or day <1 or year <1:\n",
    "            is_valid = False\n",
    "        elif month not in thirtyone_day_months and day ==31:\n",
    "            is_valid = False\n",
    "\n",
    "        elif is_leap(month, day, year) and month ==2 and day ==30:\n",
    "            is_valid = False\n",
    "        elif not is_leap(month, day, year) and month ==2 and day > 28:\n",
    "            is_valid = False\n",
    "        else:\n",
    "            is_valid = True\n",
    "            \n",
    "        return  is_valid    \n",
    "\n",
    "def day_number(month, day, year):\n",
    "    # Complete this function to calculate the day_number given month, day, and year.\n",
    "    # Information: The days of the year are often numbered from 1 through 365 (or 366).\n",
    "    # This number can be computed in three steps using int arithmetic:\n",
    "    # (a) - day_num = 31 * (month - 1) + day\n",
    "    # (b) - if the month is after February subtract (4*(month)+23)//10\n",
    "    # (c) - if it's a leap year and after February 29, add 1\n",
    "    # Hint: First verify the input date is valid, return False if it is not valid; use is_date_valid\n",
    "    # Hint: Also use the is_leap function\n",
    "    # Inputs: month, day, year\n",
    "    # Output: the day number or False (boolean) if the date is invalid. \n",
    "    \n",
    "    # YOUR CODE HERE\n",
    "    if not is_date_valid(month, day, year):\n",
    "        return False\n",
    "    \n",
    "    elif (month > 2 and year % 4 == 0 and \n",
    "       (year % 100 != 0 or year % 400 == 0)): \n",
    "        day += 1; \n",
    "    \n",
    "    days = [31, 28, 31, 30, 31, 30, \n",
    "        31, 31, 30, 31, 30, 31];\n",
    "    # Add the days in the previous months \n",
    "    month -= 1; \n",
    "    while (month > 0): \n",
    "        day = day + days[month - 1]; \n",
    "        month -= 1; \n",
    "    return day; \n",
    "    \n",
    "\n",
    "day_number(2, 29, 1800)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "916039ba5b390e02f3349fe97b76608c",
     "grade": true,
     "grade_id": "cell-411ea3b17d1adb33",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert day_number(9, 31, 2000) == False\n",
    "assert day_number(2, 13, 2020) == 44"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "36330ee47884979f892a02194cccb294",
     "grade": false,
     "grade_id": "cell-e03020ec7bc1b440",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Ex5\n",
    "def years_to_double_investment(apr):\n",
    "    # Complete this function to use a while loop to determine how long it takes for an investment \n",
    "    # to double at a given interest rate. The input to this function, apr, is the annualized interest rate\n",
    "    # and the output is the number of years it takes an investment to double. Note: The amount of the initial \n",
    "    # investment (principal) does not matter; you can use $1. \n",
    "    # Hint: principal is the amount of money being invested. \n",
    "    # apr is the annual percentage rate expressed as a decimal number.  \n",
    "    # Relationship: value after one year is given by principal * (1+ apr)\n",
    "    principle = 1\n",
    "    #rate = input(\"Please enter the annual interest rate: \")\n",
    "    year = 0\n",
    "    total = principle\n",
    "    \n",
    "    while total <= principle * 2 :\n",
    "        \n",
    "        total = total + (total * float(apr))\n",
    "        year = year + 1\n",
    "\n",
    "    return year\n",
    "\n",
    "\n",
    "years_to_double_investment(0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "fefc4d591b3ac497bb6864dab731aec6",
     "grade": true,
     "grade_id": "cell-37833043ebab338a",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert years_to_double_investment(0.06) == 12\n",
    "assert years_to_double_investment(0.1) == 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "3ffa2a09dccc83aeb749d3deaff0dde1",
     "grade": true,
     "grade_id": "cell-00925de994310b09",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Hidden tests\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "years_to_double_investment(0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e6f75d03290dc1d97c6db5980d498d50",
     "grade": false,
     "grade_id": "cell-915174ac3c531b23",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "111"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Ex6 \n",
    "def stopping_time(n):\n",
    "    # Complete this function to return the number of steps taken to reach 1 in\n",
    "    # the Collatz sequence (https://en.wikipedia.org/wiki/Collatz_conjecture)\n",
    "    step_seq = [n]\n",
    "    if n < 1:\n",
    "        return []\n",
    "    while n > 1:\n",
    "        if n % 2 == 0:\n",
    "             n = n / 2\n",
    "        else:\n",
    "             n = 3 * n + 1\n",
    "    # Added line\n",
    "        step_seq.append(n)    \n",
    "    return len(step_seq)-1\n",
    "\n",
    "stopping_time(27)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "9dafcc4d9080dbb4e15d188cc1609983",
     "grade": true,
     "grade_id": "cell-cb2141fe7de88db3",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert stopping_time(12) == 9\n",
    "assert stopping_time(27) == 111"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7713a5279e0c13dc42965d288ab7d70a",
     "grade": true,
     "grade_id": "cell-a6ca4ec347d83750",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# hidden tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "100870c95e35b7ac29603477e3e9f44e",
     "grade": false,
     "grade_id": "cell-d5c69bc0cb4c6837",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Ex7\n",
    "def is_prime(n):\n",
    "    # A positive whole number > 2 is prime if no number between 2 and sqrt(n)\n",
    "    # (include) evenly divides n. Write a program that accepts a value of n as\n",
    "    # input and determine if the value is prime. If n is not prime, your program should\n",
    "    # return False (boolean) as soon as it finds a value that evenly divides n.\n",
    "    # Hint: if number is 2, return False\n",
    "\n",
    "    import math\n",
    "    \n",
    "    # YOUR CODE HERE\n",
    "    if n <= 2:\n",
    "        return False\n",
    "\n",
    "    i = 2\n",
    "    for i in range(2, int(math.sqrt(n) + 1)):\n",
    "        if (n % i == 0):\n",
    "            return False\n",
    "\n",
    "    return True\n",
    "\n",
    "is_prime(25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ad5edf1b21109841edbaeaf0743f8cc3",
     "grade": true,
     "grade_id": "cell-da18c35e0a5d579e",
     "locked": true,
     "points": 4,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert is_prime(2) == False\n",
    "assert is_prime(3) == True\n",
    "assert is_prime(5) == True\n",
    "assert is_prime(25) == False\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "dbca4e91c4e1785d402204bc966c5c2b",
     "grade": false,
     "grade_id": "cell-ad04b1135365e292",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 5]"
      ]
     },
     "execution_count": 313,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Ex8\n",
    "def all_primes(n):\n",
    "#     # Complete this function to return all the primes as a list less than or equal to n\n",
    "#     # Input: n\n",
    "#     # Output: a list of numbers\n",
    "\n",
    "#     # YOUR CODE HERE\n",
    "\n",
    "    out = list()\n",
    "    sieve = [True] * (n+1)\n",
    "    for m in range(2, n+1):\n",
    "        if (sieve[m]):\n",
    "            out.append(m)\n",
    "            for i in range(m, n+1, m):\n",
    "                sieve[i] = False\n",
    "    x=len(out)\n",
    "    return out[-x+1:]\n",
    "\n",
    "all_primes(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c016edf398c92b85f38456d8e996c71f",
     "grade": true,
     "grade_id": "cell-3e7dbc25ba03421c",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert all_primes(5) == [3, 5]\n",
    "assert all_primes(25) == [3, 5, 7, 11, 13, 17, 19, 23]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "30fd92f0d496bccaa88823d615d71618",
     "grade": false,
     "grade_id": "cell-d6cdbdb6ba20e916",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 310,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Ex9\n",
    "def gcd(m,n):\n",
    "    # Complete this function to determine the greatest common divisor (GCD). \n",
    "    # The GCD of two values can be computed using Euclid's algorithm. Starting with the values\n",
    "    # m and n, we repeatedly apply the formula: n, m = m, n%m until m is 0. At this point, n is the GCD\n",
    "    # of the original m and n. \n",
    "    # Inputs: m and n which are both natural numbers\n",
    "    # Output: gcd\n",
    "\n",
    "    # YOUR CODE HERE\n",
    "    while n:\n",
    "        m,n = n, m%n\n",
    "    return m\n",
    "\n",
    "gcd(25,75)\n",
    "gcd(3,13)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "94c4dba12d76cb641e31c447d5f10676",
     "grade": true,
     "grade_id": "cell-9a4f50a09e28d52d",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert gcd(25,75) == 25\n",
    "assert gcd(3,13) == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1c1cde2cab2cd2abfe743064c89cd77b",
     "grade": true,
     "grade_id": "cell-6bba97d2c8fa2d9f",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7b05a017f73870e704b42e1fcc850aad",
     "grade": false,
     "grade_id": "cell-2e1d0f8cbd0fefe2",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('student733', 86.2, 'student202', 65.4)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Ex10\n",
    "import statistics\n",
    "def determine_min_max_average(filename):\n",
    "    # Complete this function to read grades from a file and determine the student with the highest average \n",
    "    # test grades and the lowest average test grades. \n",
    "    # Input: filename\n",
    "    # Output: a tuple containing four elements: name of student with highest average, their average, \n",
    "    # name of the student with the lowest test grade, and their average. Example ('Student1', 99.50, 'Student5', 65.50)\n",
    "    # Hint: Round to two decimal places\n",
    "\n",
    "    # YOUR CODE HERE\n",
    "    \n",
    "    file =open(filename)\n",
    "    ave_list = []\n",
    "    name_list = []\n",
    "    for line in file:\n",
    "        if line.strip('\\n'):\n",
    "            line = line.strip('\\n').split(',')\n",
    "            name = line[0]\n",
    "            #print(name)\n",
    "            grades = [int(i) for i in line[1:] ]\n",
    "            #print(grades)\n",
    "            average = statistics.mean(grades)\n",
    "            #print(average)\n",
    "            ave_list.append(average)\n",
    "            name_list.append(name)\n",
    "    #print(name_list)\n",
    "    average_max = max(ave_list)\n",
    "    average_min = min(ave_list)\n",
    "    indi_max = ave_list.index(average_max)\n",
    "    indi_min = ave_list.index(average_min)\n",
    "    name_max = name_list[int(indi_max)]\n",
    "    name_min = name_list[int(indi_min)]\n",
    "    \n",
    "    \n",
    "    \n",
    "            \n",
    "        #print(average)\n",
    "    return name_max, average_max, name_min, average_min \n",
    "        \n",
    "\n",
    "\n",
    "determine_min_max_average('ex10_data.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "df746ce1e06b5143e83565d7ad7baf3d",
     "grade": true,
     "grade_id": "cell-c8ec04f59adc84af",
     "locked": true,
     "points": 4,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert determine_min_max_average('ex10_data.txt') == ('student733', 86.2, 'student202', 65.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "4c9483024a3ae36b4b22959d246b6228",
     "grade": false,
     "grade_id": "cell-423f49b4dbb9cda6",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Invalid'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def is_license_plate_valid(plate):\n",
    "\n",
    "    # In a particular jurisdiction, older license plates consist of three uppercase\n",
    "    # letters followed by three digits. When all of the license plates following\n",
    "    # that pattern had been used, the format was changed to four digits followed by\n",
    "    # three uppercase letters. \n",
    "\n",
    "    # Complete this function whose only input is a license plate and its output\n",
    "    # is: 1) Older/Valid 2) Newer/Valid 3) Invalid\n",
    "    # input: plate (str)\n",
    "    # output: 'Older/Valid' or 'Newer/Valid' or 'Invalid'\n",
    "\n",
    "    # YOUR CODE HERE\n",
    "    letters = [\"A\",\"B\",\"C\",\"D\",\"E\",\"F\",\"G\",\"H\",\"I\",\"J\",\"K\",\"L\",\"M\",\"N\",\"O\",\"P\",\"Q\",\"R\",\"S\",\"T\",\"U\",\"V\",\"W\",\"X\",\"Y\",\"Z\"]\n",
    "    numbers = [\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\",\"0\"]\n",
    "\n",
    "    \n",
    "    if len(plate)==7:\n",
    "\n",
    "        if plate[0] in numbers and plate[1] in numbers and plate[2] in numbers and plate[3] in numbers and plate[4] in letters and plate[5] in letters and plate[6] in letters:\n",
    "            \n",
    "            return \"Newer/Valid\"\n",
    "        \n",
    "        else:\n",
    "            plate not in plate.upper()\n",
    "            return \"Invalid\"\n",
    "        \n",
    "\n",
    "    elif len(plate)==6:\n",
    "\n",
    "        if plate[3] in numbers and plate[4] in numbers and plate[5] in numbers and plate[0] in letters and plate[1] in letters and plate[2] in letters:\n",
    "            \n",
    "            return \"Older/Valid\"\n",
    "          \n",
    "        else:\n",
    "            plate not in plate.upper()\n",
    "            return \"Invalid\"     \n",
    "    else:\n",
    "        return \"Invalid\"\n",
    "\n",
    "is_license_plate_valid('bTR342')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "89755b80aa5c11d74e49d0879687d54b",
     "grade": true,
     "grade_id": "cell-1900e84b3f513c64",
     "locked": true,
     "points": 4,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert is_license_plate_valid('ABC123') == 'Older/Valid'\n",
    "assert is_license_plate_valid('GHE952') == 'Older/Valid'\n",
    "assert is_license_plate_valid('1934ABT') == 'Newer/Valid'\n",
    "assert is_license_plate_valid('bTR342') == 'Invalid'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "7aaed0e525c967395c14984de90d1c1c",
     "grade": true,
     "grade_id": "cell-cfcb59d207e5d3cd",
     "locked": true,
     "points": 4,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "929aab07b474fd62a8e12d2572b433f3",
     "grade": false,
     "grade_id": "cell-859f437c63175722",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "def year_last_two_digits(number, digits_count=2):\n",
    "    return abs(number) % (10**digits_count)\n",
    "\n",
    "# Ex12: Magic dates\n",
    "def is_magic_date(date):\n",
    "    # A magic date is a date where the day multiplied by the month is equal \n",
    "    # to the two digit year. For example, June 10, 1960 is a magic date because\n",
    "    # June is the sixth month, and 6 times 10 is 60, which is equal to the two\n",
    "    # digit year. Complete this function to determine whether or not a date is\n",
    "    # a magic date.\n",
    "\n",
    "    # input: date (str -- month/day/year)\n",
    "    # output: True or False (bool)\n",
    "\n",
    "    date_1= date.split(\"/\") #('month/day/year')\n",
    "        \n",
    "    month = int (date_1[0])\n",
    "    day = int (date_1[1])\n",
    "    year = int (date_1[2])\n",
    "    \n",
    "    \n",
    "    # print (date_1)\n",
    "    \n",
    "    # YOUR CODE HERE\n",
    "    if day > 31 or day < 1 or month > 12 or month < 1 or (year % 100) > 99 or (year % 100) < 0:\n",
    "        return False\n",
    "   \n",
    "    else:\n",
    "        dayTimesMonth = day * month\n",
    "    \n",
    "        if dayTimesMonth == (year % 100):\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "    \n",
    "is_magic_date('6/8/2020')  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "42885a1231b3160f8c03b89ea28be0b9",
     "grade": true,
     "grade_id": "cell-7a1fa98499aba445",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert is_magic_date('6/10/1960') == True\n",
    "assert is_magic_date('6/8/1948') == True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "cae484990e04a474c435c3665808f41b",
     "grade": false,
     "grade_id": "cell-22929b608ed4e3ba",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Ex13\n",
    "import pandas as pd\n",
    "from scipy import stats\n",
    "def remove_outliers(data, num_outliers):\n",
    "    # When analyzing data collected as a part of a science experiment it \n",
    "    # may be desriable to remove the most extreme values before performing\n",
    "    # other calculations. Complete this function which takes a list of\n",
    "    # values and an non-negative integer, num_outliers, as its parameters.\n",
    "    # The function should create a new copy of the list with the num_outliers \n",
    "    # largest elements and the num_outliers smallest elements removed. \n",
    "    # Then it should return teh new copy of the list as the function's only \n",
    "    # result. The order of the elements in the returned list does not have to\n",
    "    # match the order of the lemetns in the original list.\n",
    "    # input1: data (list)\n",
    "    # input2: num_outliers (int)\n",
    "\n",
    "    # output: list\n",
    "        \n",
    "    # YOUR CODE HERE\n",
    "    \n",
    "    for i in range(num_outliers):\n",
    "        data.remove(min(data))\n",
    "        data.remove(max(data))\n",
    "    \n",
    "    # print(data)\n",
    "    return sorted(data)\n",
    "    \n",
    "    \n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ab0a2036a0338a47f9281b9130cee5ee",
     "grade": true,
     "grade_id": "cell-f37107e0e303a5ca",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "import random\n",
    "random.seed(1234)\n",
    "data = [random.randint(50, 150) for ele in range(100)]\n",
    "data[45] = 1\n",
    "data[46] = 2\n",
    "data[90] = 250\n",
    "data[34] = 300\n",
    "\n",
    "result = [50, 50, 51, 52, 52, 52, 53, 53, 54, \n",
    "55, 55, 55, 55, 56, 58, 58, 59, 59, 59, 60, 61, 61, \n",
    "61, 62, 64, 64, 64, 68, 68, 68, 69, 69, 69, 70, 71, \n",
    "72, 73, 75, 77, 80, 81, 81, 84, 84, 84, 85, 88, 88, 89, \n",
    "92, 94, 94, 95, 95, 98, 103, 106, 108, 108, 109, 109, 109, \n",
    "110, 111, 111, 112, 113, 114, 115, 115, 117, 117, 119, 121, \n",
    "124, 124, 125, 126, 128, 129, 132, 132, 133, 134, 135, 135, \n",
    "135, 136, 138, 140, 141, 148, 148, 149, 149, 150]\n",
    "\n",
    "assert remove_outliers(data, 2) == result\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "088ff4b6fe107f7af39440b096e2fdc3",
     "grade": true,
     "grade_id": "cell-f584e176be7f53bc",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b6ef99c46e33ca1a0aa4e49c9b11408b",
     "grade": false,
     "grade_id": "cell-76c8326115a8aee3",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8]"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ex14: Removing duplicates\n",
    "\n",
    "def remove_duplicates(words):\n",
    "    # Complete this function to remove duplicates from the words list using a loop\n",
    "    # input: words (list)\n",
    "    # output: a list without duplicates\n",
    "\n",
    "    # YOUR CODE HERE\n",
    "    res = [i for n, i in enumerate(words) if i not in words[:n]] \n",
    "    return res\n",
    "            \n",
    "\n",
    "remove_duplicates([1,2,3,3,3,4,5,6,7,7,8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "6eda2d72f58746a42a2459a45a06d186",
     "grade": true,
     "grade_id": "cell-0b3ad78a5f56ef26",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert remove_duplicates([1,2,3,3,3,4,5,6,7,7,8]) == [1, 2, 3, 4, 5, 6, 7, 8]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "fbc76dd31d1bfc8ca526c71cde0a0043",
     "grade": true,
     "grade_id": "cell-6f1773c6eb139b8d",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "bced68ade0b6942be0db92e49469b8af",
     "grade": false,
     "grade_id": "cell-3b7cdbf9f92b6fb9",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 4, 7, 14]"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ex15: List of proper divisors\n",
    "\n",
    "def proper_divisors(n):\n",
    "    # A proper divisor ofa  positive integer, n, is a positive integer less than n which divides\n",
    "    # evenly into n. Complete this function to compute all the proper divisors of a positive\n",
    "    # integer. The integer is passed to this function as the only parameter. The function will\n",
    "    # return a list of containing all of the proper divisors as its only reult. \n",
    "\n",
    "    # input: n (int)\n",
    "    # output: list\n",
    "\n",
    "    # YOUR CODE HERE\n",
    "    for i in range(n):\n",
    "        x = [i for i in range(1,n) if not n % i]\n",
    "    return x\n",
    "\n",
    "proper_divisors(28)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a6ddd7713b235be9c7e3306126c046a6",
     "grade": true,
     "grade_id": "cell-13e6b6403196da76",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert proper_divisors(28) == [1, 2, 4, 7, 14]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a9e88dc49e714491ccab1d96706fe335",
     "grade": true,
     "grade_id": "cell-e7223c2aeb9c5d36",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "689af51205a65cc9efeab336925c523e",
     "grade": false,
     "grade_id": "cell-a94951aac16e950f",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Ex16: Perfect Numbers\n",
    "def is_number_perfect(n):\n",
    "    # An integer, n, is said to be perfect when the sum of all of the proper divisors \n",
    "    # of n is equal to n. For example, 28 is a perfect number because its proper divisors\n",
    "    # are 1, 2, 4, 7, and 14 = 28 \n",
    "    # Complete this function to determine if a the number a perfect number or not. \n",
    "    # input: n (int)\n",
    "    # output: True or False (bool)\n",
    "\n",
    "\n",
    "    # YOUR CODE HERE\n",
    "    sum = 0\n",
    "    for x in range(1, n):\n",
    "        if n % x == 0:\n",
    "            sum += x\n",
    "    return sum == n\n",
    "\n",
    "is_number_perfect(28)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1139be1a7ed4f1c87927b732096c6678",
     "grade": true,
     "grade_id": "cell-14d8cfff6ced5461",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "assert is_number_perfect(28) == True\n",
    "assert is_number_perfect(76) == False\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "67fc474052dea83d135c40f1da9aea1c",
     "grade": true,
     "grade_id": "cell-14eb44447e299251",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "05b1d500f7e689806d47d82a883160b0",
     "grade": false,
     "grade_id": "cell-21d1d1b24e27c644",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Ex17: Line of Best Fit\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "def best_line(points):\n",
    "    # Complete this function to determine the best line. \n",
    "    # https://www.varsitytutors.com/hotmath/hotmath_help/topics/line-of-best-fit\n",
    "    # input: points (list of tuples contain x, y values)\n",
    "    # output: (m, b) # round both values to two decimal places\n",
    "\n",
    "    # YOUR CODE HERE\n",
    "    df = pd.DataFrame(points, columns =['X', 'Y'])  \n",
    "    X= df[\"X\"].values\n",
    "    Y= df[\"Y\"].values\n",
    "    # Mean X and Y\n",
    "    mean_x = np.mean(X)\n",
    "    mean_y = np.mean(Y)\n",
    " \n",
    "    # Total number of values\n",
    "    n = len(X)\n",
    "    # Using the formula to calculate 'm' and 'b'\n",
    "    numer = 0\n",
    "    denom = 0\n",
    "    for i in range(n):\n",
    "        numer += (X[i] - mean_x) * (Y[i] - mean_y)\n",
    "        denom += (X[i] - mean_x) ** 2\n",
    "        m = numer / denom\n",
    "        b = mean_y - (m * mean_x)\n",
    "        \n",
    "    return round(m,2), round(b,2)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "06de236fe9c94cf5c816a600a374d1dc",
     "grade": true,
     "grade_id": "cell-386bd6a9301a19da",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "points = (\n",
    "    (8, 3),\n",
    "    (2, 10),\n",
    "    (11, 3),\n",
    "    (6, 6),\n",
    "    (5, 8),\n",
    "    (4, 12),\n",
    "    (12, 1),\n",
    "    (9, 4),\n",
    "    (6, 9),\n",
    "    (1, 14),\n",
    ")\n",
    "\n",
    "assert best_line(points) == (-1.11, 14.08)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "fdf441c9adfbbdacedb91a46b6f2ff52",
     "grade": true,
     "grade_id": "cell-e3b40327cdd21344",
     "locked": true,
     "points": 2,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}