assignment-2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0c0040e6",
   "metadata": {},
   "source": [
    "# Assignment 02"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86edcf3a",
   "metadata": {},
   "source": [
    "Please solve the problems below.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc91cfa9",
   "metadata": {},
   "outputs": [],
   "source": [
    "Run the following code to enable `%verify_problem` magic command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7cfcff1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pipal_magic"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdd2e8ac",
   "metadata": {},
   "source": [
    "## Problem 1: Barchart"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60a3daf5",
   "metadata": {},
   "source": [
    "Write a function barchart that takes a list of numbers and prints them as a barchart.\n",
    "\n",
    "```\n",
    ">>> barchart([2, 5, 4, 3])\n",
    "|==\n",
    "|=====\n",
    "|====\n",
    "|===\n",
    "```\n",
    "\n",
    "\n",
    "You can verify your solution using:<br>\n",
    "`%verify_problem barchart`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0cef2cf8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d45a323",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3741bd04",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "755ca691",
   "metadata": {},
   "outputs": [],
   "source": [
    "%verify_problem barchart"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f97a02a0",
   "metadata": {},
   "source": [
    "## Problem 2: Generate Password"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d02bbc1b",
   "metadata": {},
   "source": [
    "Write a function `generate_password` to generate random password of given length.\n",
    "\n",
    "The function should take length `n` as argument and generate a password using mix of letters from lowercase, uppercase from English alphabet and digits. It should not have any other characters.\n",
    "\n",
    "```\n",
    ">>> generate_password(8)\n",
    "'rBZLcP8V'\n",
    ">>> generate_password(25)\n",
    "'JU938tUT36QRvVEPh9OLrxlrB'\n",
    "```\n",
    "\n",
    "**Hint**\n",
    "\n",
    "* See `random.choice` function from the `random` module\n",
    "* See `string.ascii_letters` and `string.digits` from the string module\n",
    "\n",
    "You can verify your solution using:<br>\n",
    "`%verify_problem generate-password`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed8d6414",
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4517356e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5cf1ea63",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a7a2f2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "%verify_problem generate-password"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9aeda15d",
   "metadata": {},
   "source": [
    "## Problem 3: Flatten the list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b438aa3",
   "metadata": {},
   "source": [
    "Write a function `flatten` which combines nested lists into a single list. It takes a list of lists as an argument and returns a list of all elements from nested lists.\n",
    "\n",
    "```\n",
    ">>> flatten([[1,2,3],[4,5],[6,7,8,9]])\n",
    "[1,2,3,4,5,6,7,8,9]\n",
    "```\n",
    "\n",
    "\n",
    "You can verify your solution using:<br>\n",
    "`%verify_problem flatten`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "970d8528",
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "937ffbea",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4fdccf7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "937d3933",
   "metadata": {},
   "outputs": [],
   "source": [
    "%verify_problem flatten"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "170ad779",
   "metadata": {},
   "source": [
    "## Problem 4: Group"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8310fc1",
   "metadata": {},
   "source": [
    "Write a function `group` that take a list of values and splits into smaller lists of given size.\n",
    "\n",
    "```\n",
    ">>> group([1, 2, 3, 4, 5, 6, 7, 8, 9], 3)\n",
    "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "\n",
    ">>> group([1, 2, 3, 4, 5, 6, 7, 8, 9], 4)\n",
    "[[1, 2, 3, 4], [5, 6, 7, 8], [9]]\n",
    "```\n",
    "\n",
    "You can verify your solution using:<br>\n",
    "`%verify_problem group`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73d82913",
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "636faaa6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e534cf33",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49324175",
   "metadata": {},
   "outputs": [],
   "source": [
    "%verify_problem group"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6172f69",
   "metadata": {},
   "source": [
    "## Problem 5: Count Increased"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a47e5d54",
   "metadata": {},
   "source": [
    "Given a list of numbers, count the number of times a number in the list increases from the previous number.\n",
    "\n",
    "For example:\n",
    "\n",
    "Given the list of numbers as `[3, 5, 4, 9, 2, 8]`\n",
    "\n",
    "\n",
    "```\n",
    "3 (N/A - no previous number)\n",
    "5 (increased)\n",
    "4 (decreased)\n",
    "9 (increased)\n",
    "2 (decreased)\n",
    "8 (increased)\n",
    "```\n",
    "\n",
    "So the number of times a number increased from the previous number is 3.\n",
    "\n",
    "Write a function `count_increased` that takes a list of numbers as arguments and returns the number of times a number in that list is increased from the previous one.\n",
    "\n",
    "```\n",
    ">>> count_increased([3, 5, 4, 9, 2, 8])\n",
    "3\n",
    "```\n",
    "\n",
    "Credits: this problem is modelled after [Day 1 problem of Advent of Code 2021][1].\n",
    "\n",
    "[1]: https://adventofcode.com/2021/day/1\n",
    "\n",
    "You can verify your solution using:<br>\n",
    "`%verify_problem count-increased`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48075270",
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53af542c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c4df7dee",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7dc78e25",
   "metadata": {},
   "outputs": [],
   "source": [
    "%verify_problem count-increased"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa0e8a5c",
   "metadata": {},
   "source": [
    "## Problem 6: Product API"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "458a9415",
   "metadata": {},
   "source": [
    "Write a function `product` to compute the product of a list of numbers using the product API.\n",
    "\n",
    "```\n",
    "$ curl -H 'Content-type: application/json' -d '{\"numbers\": [1, 2, 3, 4, 5]}' https://numbers.apps.pipal.in/product\n",
    "{\"result\": 120}\n",
    "```\n",
    "\n",
    "Write a function `product` that takes a list of numbers as argument and computes their product using the product API.\n",
    "\n",
    "```python\n",
    ">>> product([1, 2, 3, 4])\n",
    "24\n",
    ">>> product([10, 2, 50])\n",
    "1000\n",
    "```\n",
    "\n",
    "You can verify your solution using:<br>\n",
    "`%verify_problem product-api`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aaf92b89",
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6f162b0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5d16595",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "738c80e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "%verify_problem product-api"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56b04545",
   "metadata": {},
   "source": [
    "## Problem 7: Countdown"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2927ec26",
   "metadata": {},
   "source": [
    "Write a program countdown.py to print numbers from n to 1.\n",
    "\n",
    "The program should take the number `n` as command-line argument.\n",
    "\n",
    "```\n",
    "$ python countdown.py 5\n",
    "5\n",
    "4\n",
    "3\n",
    "2\n",
    "1\n",
    "```\n",
    "\n",
    "You can verify your solution using:<br>\n",
    "`%verify_problem countdown`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02b7ddd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%file countdown.py\n",
    "# your code here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f33f289",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a5fa855",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41db4717",
   "metadata": {},
   "outputs": [],
   "source": [
    "%verify_problem countdown"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a580e6f",
   "metadata": {},
   "source": [
    "## Problem 8: Grep Command"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f6c0b7f",
   "metadata": {},
   "source": [
    "Implement Unix command grep in Python.\n",
    "\n",
    "Write a program `grep.py` that takes a pattern and a file as command-line arguments and print all the lines in the file that contain that pattern.\n",
    "\n",
    "The pattern could be any text and there is no need to support regular expressions.\n",
    "\n",
    "```\n",
    "$ cat files/zen-of-python.txt\n",
    "The Zen of Python, by Tim Peters\n",
    "\n",
    "Beautiful is better than ugly.\n",
    "Explicit is better than implicit.\n",
    "Simple is better than complex.\n",
    "Complex is better than complicated.\n",
    "Flat is better than nested.\n",
    "Sparse is better than dense.\n",
    "Readability counts.\n",
    "Special cases aren't special enough to break the rules.\n",
    "Although practicality beats purity.\n",
    "Errors should never pass silently.\n",
    "Unless explicitly silenced.\n",
    "In the face of ambiguity, refuse the temptation to guess.\n",
    "There should be one-- and preferably only one --obvious way to do it.\n",
    "Although that way may not be obvious at first unless you're Dutch.\n",
    "Now is better than never.\n",
    "Although never is often better than *right* now.\n",
    "If the implementation is hard to explain, it's a bad idea.\n",
    "If the implementation is easy to explain, it may be a good idea.\n",
    "Namespaces are one honking great idea -- let's do more of those!\n",
    "\n",
    "$ python grep.py never files/zen-of-python.txt\n",
    "Errors should never pass silently.\n",
    "Now is better than never.\n",
    "Although never is often better than *right* now.\n",
    "\n",
    "$ grep the files/zen-of-python.txt\n",
    "Special cases aren't special enough to break the rules.\n",
    "In the face of ambiguity, refuse the temptation to guess.\n",
    "If the implementation is hard to explain, it's a bad idea.\n",
    "If the implementation is easy to explain, it may be a good idea.\n",
    "```\n",
    "\n",
    "You can verify your solution using:<br>\n",
    "`%verify_problem grep`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e63cf50f",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%file grep.py\n",
    "# your code here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f9d8e2e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98d27f9d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a093f32",
   "metadata": {},
   "outputs": [],
   "source": [
    "%verify_problem grep"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6db8e66",
   "metadata": {},
   "source": [
    "## Problem 9: Sequence of Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa425ae8",
   "metadata": {},
   "source": [
    "Write a program `seq.py` that takes a number `n` as argument and prints numbers from `1` to `n`. It should support the following two flags.\n",
    "\n",
    "\n",
    "```\n",
    "-s START --start START\n",
    "    print number from START to n instead of 1 to n\n",
    "\n",
    "-r --reverse\n",
    "    print the numbers in the reverse order\n",
    "```\n",
    "\n",
    "The program should also print approprate help message when used with `-h` or `--help` flags.\n",
    "\n",
    "Use the standard library module `argparse` for doing this. You may want to checkout the argparse tutorial to know how to use that module.\n",
    "\n",
    "Expected Output:\n",
    "\n",
    "```\n",
    "$ python seq.py 5\n",
    "1\n",
    "2\n",
    "3\n",
    "4\n",
    "5\n",
    "\n",
    "$ python seq.py -s 3 5\n",
    "3\n",
    "4\n",
    "5\n",
    "\n",
    "$ python seq.py -r -s 3 5\n",
    "5\n",
    "4\n",
    "3\n",
    "```\n",
    "\n",
    "\n",
    "You can verify your solution using:<br>\n",
    "`%verify_problem seq`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f626b33d",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%file seq.py\n",
    "# your code here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3acbda9b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71551533",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78c6b780",
   "metadata": {},
   "outputs": [],
   "source": [
    "%verify_problem seq"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "962a686b",
   "metadata": {},
   "source": [
    "## Problem 10: Split a File"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04d7eb1b",
   "metadata": {},
   "source": [
    "Write a program `split.py` that splits a large file into multiple smaller files. The program should take a filename and the number of lines as arguments and write multiple small files each containing the specified number of lines (The last one may have smaller number of lines).\n",
    "\n",
    "Suppose you have a file `100.txt` in the current directory. (you can copy it from files/100.txt).\n",
    "\n",
    "```\n",
    "$ cp files/100.txt 100.txt\n",
    "```\n",
    "\n",
    "When you run split.py with that, it should split that into multiple small files.\n",
    "\n",
    "```\n",
    "$ python split.py 100.txt 30\n",
    "writing 100-part1.txt\n",
    "writing 100-part2.txt\n",
    "writing 100-part3.txt\n",
    "writing 100-part4.txt\n",
    "```\n",
    "\n",
    "You can verify your solution using:<br>\n",
    "`%verify_problem split`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7bcefda",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%file split.py\n",
    "# your code here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17d3968e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2ebec4f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "776d8ad3",
   "metadata": {},
   "outputs": [],
   "source": [
    "%verify_problem split"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}