Subjective Assignment - 4 - Python Dictionaries and arrays.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q1. Write the Python program to create an instance of an OrderedDict \n",
    "using the given dictionary and sort dictionary during the\n",
    "creation and print members of the dictionary in reverse order?\n",
    "\n",
    "    Expected OutputAngola 244.\n",
    "    Andorra 376.\n",
    "    Algeria 213.\n",
    "    Afghanistan 93.\n",
    "    Albania 355.\n",
    "    In reverse orderAlbania 355.\n",
    "    Afghanistan 93.\n",
    "    Algeria 213.\n",
    "    Andorra 376.\n",
    "    Angola 244."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Afghanistan 93\n",
      "Albania 355\n",
      "Algeria 213\n",
      "Andorra 376\n",
      "Angola 244\n",
      "\n",
      "In reverse order:\n",
      "Angola 244\n",
      "Andorra 376\n",
      "Algeria 213\n",
      "Albania 355\n",
      "Afghanistan 93\n"
     ]
    }
   ],
   "source": [
    "from collections import OrderedDict\n",
    "dict = {'Afghanistan': 93, 'Albania': 355, 'Algeria': 213, 'Andorra': 376, 'Angola': 244}\n",
    "new_dict = OrderedDict(dict.items())\n",
    "for key in new_dict:\n",
    "    print (key, new_dict[key])\n",
    "\n",
    "print(\"\\nIn reverse order:\")\n",
    "for key in reversed(new_dict):\n",
    "    print (key, new_dict[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q2. Write the Python program to compare two unordered lists (not\n",
    "sets)?\n",
    " \n",
    "     Expected Output: False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "n1 = [20, 10, 30, 10, 20, 30]\n",
    "n2 = [30, 20, 10, 30, 20, 50]\n",
    "if Counter(n1) == Counter(n2):\n",
    "    print(True)\n",
    "else:\n",
    "    print(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q3. Write the Python program to get an array buffer information?\n",
    "\n",
    "    Expected OutputArray buffer start address in memory and number of elements.\n",
    "    (25855056, 2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array buffer start address in memory and number of elements\n",
      " (139661213670128, 2)\n"
     ]
    }
   ],
   "source": [
    "from array import array\n",
    "a = array('I', (12, 13))\n",
    "print(\"Array buffer start address in memory and number of elements\\n\", a.buffer_info())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q4. Write the Python program to convert an array to an array of\n",
    "machine values and return the bytes representation?\n",
    "\n",
    "    Expected OutputOriginal arrayA1: array('i', [1, 2, 3, 4, 5, 6])\n",
    "    Array of bytes:\n",
    "    b'010000000200000003000000040000000500000006000000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array of bytes\n",
      " b'\\x01\\x00\\x00\\x00\\x02\\x00\\x00\\x00\\x03\\x00\\x00\\x00\\x04\\x00\\x00\\x00\\x05\\x00\\x00\\x00\\x06\\x00\\x00\\x00'\n"
     ]
    }
   ],
   "source": [
    "from array import *\n",
    "a = array('i', [1, 2, 3, 4, 5, 6])\n",
    "print('Array of bytes\\n', a.tobytes())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q5. Write the Python program to read a string and interpreting the\n",
    "string as an array of machine values?\n",
    "\n",
    "    Expected Outputarray1- array('i', [7, 8, 9, 10])\n",
    "    Bytes- b'0700000008000000090000000a000000'\n",
    "    array2- array('i', [7, 8, 9, 10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array1: array('i', [7, 8, 9, 10])\n",
      "Bytes: b'0700000008000000090000000a000000'\n",
      "array2: array('i', [7, 8, 9, 10])\n"
     ]
    }
   ],
   "source": [
    "from array import array\n",
    "import binascii\n",
    "array1 = array('i', [7, 8, 9, 10])\n",
    "print('array1:', array1)\n",
    "as_bytes = array1.tobytes()\n",
    "print('Bytes:', binascii.hexlify(as_bytes))\n",
    "array2 = array('i')\n",
    "array2.frombytes(as_bytes)\n",
    "print('array2:', array2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q6. Write the Python program to push three items into the heap and\n",
    "return the smallest item from the heap. Also, return and pop the\n",
    "smallest item from the heap?\n",
    "    \n",
    "    Expected OutputItems in the heap-\n",
    "    ('VI', 1).\n",
    "    ('VII', 3).\n",
    "    ('VIII', 2).\n",
    "    ----------------------\n",
    "    The smallest item in the heap:\n",
    "    ('VI', 1).\n",
    "     ----------------------\n",
    "    Pop the smallest item in the heap:\n",
    "    ('VII', 2).\n",
    "    ('VIII', 3)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Items in the heap-\n",
      "\n",
      "('VI', 1)\n",
      "('VII', 3)\n",
      "('VIII', 2)\n",
      "---------------\n",
      "The smallest item in the heap: \n",
      " ('VI', 1)\n",
      "---------------\n",
      "Pop the smallest item in the heap:\n",
      "('VII', 3)\n",
      "('VIII', 2)\n"
     ]
    }
   ],
   "source": [
    "import heapq\n",
    "heap = []\n",
    "heapq.heappush(heap, ('VI', 1))\n",
    "heapq.heappush(heap, ('VII', 3))\n",
    "heapq.heappush(heap, ('VIII', 2))\n",
    "\n",
    "print('Items in the heap-\\n')\n",
    "for a in heap:\n",
    "    print(a)\n",
    "print('---------------')\n",
    "print('The smallest item in the heap: \\n', heap[0])\n",
    "print('---------------')\n",
    "\n",
    "print('Pop the smallest item in the heap:')\n",
    "heapq.heappop(heap)\n",
    "\n",
    "for a in heap:\n",
    "    print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q7. Write the Python program to locate the left insertion point for a\n",
    "specified value in sorted order?\n",
    "\n",
    "    Expected Output:\n",
    "    4\n",
    "    2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "import bisect\n",
    "def index(a, x):\n",
    "    i = bisect.bisect_left(a, x)\n",
    "    return i\n",
    "    \n",
    "a = [1,2,4,5]\n",
    "print(index(a, 6))\n",
    "print(index(a, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q8. Write the Python program to create the FIFO queue?\n",
    "\n",
    "    Expected Output:\n",
    "    0 1 2 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 "
     ]
    }
   ],
   "source": [
    "import queue\n",
    "\n",
    "q = queue.Queue()\n",
    "for i in range(4):\n",
    "    q.put(str(i))\n",
    "while not q.empty():\n",
    "    print(q.get(), end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q9. Write the Python program to calculate the harmonic sum of n-1.\n",
    " Note: The harmonic sum is the sum of reciprocals of the positive\n",
    "Integers?\n",
    "\n",
    "    Example:\n",
    "    1+1/2+1/3+1/4+1/5+...."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter n: 5\n",
      "2.083333333333333\n"
     ]
    }
   ],
   "source": [
    "num = int(input('Enter n: '))\n",
    "b = float(0)\n",
    "for i in range(1, num):\n",
    "    b += 1/i\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Great Job!"
   ]
  }
 ],
 "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}