Asignment 2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f47021b6",
   "metadata": {},
   "source": [
    "#                                   Python Assignment No.2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eacdce7d",
   "metadata": {},
   "source": [
    "## Name    : Chaudhari Kalyani Annasaheb\n",
    "## Div     :  A\n",
    "## Roll no :  3317"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee8a63e8",
   "metadata": {},
   "source": [
    "# "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e32554a6",
   "metadata": {},
   "source": [
    "### 1.Python program to sort Python Dictionaries by Keys.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d97ae777",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n",
      "[(1, 'John'), (2, 'baba'), (3, 'om'), (4, 'sai'), (5, 'ram'), (6, 'sham')]\n"
     ]
    }
   ],
   "source": [
    "dict1 = {3:'om' ,1:'John' ,4:'sai' ,2:'baba' ,5:'ram' ,6:'sham' }  \n",
    "print(sorted(dict1.keys()))  \n",
    "\n",
    "print(sorted(dict1.items()))    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25d52940",
   "metadata": {},
   "source": [
    "###  2. Python program to sort Python Dictionaries by Values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "efc440d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['aaba', 'baba', 'om', 'ram', 'sai', 'sham']\n",
      "{3: 'aaba', 2: 'baba', 1: 'om', 6: 'ram', 4: 'sai', 5: 'sham'}\n"
     ]
    }
   ],
   "source": [
    "dict1 = {1:'om' ,2:'baba' ,4:'sai' ,3:'aaba' ,6:'ram' ,5:'sham' }  \n",
    "print(sorted(dict1.values()))   \n",
    "sorted_dict = dict(sorted(dict1.items(), key=lambda item: item[1]))\n",
    "print(sorted_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d7a429d",
   "metadata": {},
   "source": [
    "### 3. Python program to find the sum of all items in a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b447ff89",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "66\n"
     ]
    }
   ],
   "source": [
    "dict1= {'a': 11, 'b': 22, 'c': 33}\n",
    "print(sum(dict1.values()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8799db0",
   "metadata": {},
   "source": [
    "### 4. Python program to remove a key from a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3cf50344",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 11, 'c': 33}\n"
     ]
    }
   ],
   "source": [
    "dict1= {'a': 11, 'b': 22, 'c': 33}\n",
    "del dict1['b']\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bc272a4",
   "metadata": {},
   "source": [
    "### 5. Python program to merge two Dictionaries\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "69218088",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 11, 'b': 22, 'c': 33, 'd': 44}\n"
     ]
    }
   ],
   "source": [
    "dict1 = {'a': 11, 'b': 22}\n",
    "dict2 = {'c': 33, 'd': 44}\n",
    "dict1.update(dict2)\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb9e34a3",
   "metadata": {},
   "source": [
    "### 6. Program to create grade calculator in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6f64076c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your score: 88\n",
      "Grade: A\n"
     ]
    }
   ],
   "source": [
    "def grade_calculator(score):\n",
    "    if score >= 80:\n",
    "        return 'A'\n",
    "    elif score >= 60:\n",
    "        return 'B'\n",
    "    elif score >= 50:\n",
    "        return 'C'\n",
    "    elif score >= 40:\n",
    "        return 'D'\n",
    "    else:\n",
    "        return 'F'\n",
    "\n",
    "score = int(input(\"Enter your score: \"))\n",
    "print(\"Grade:\", grade_calculator(score))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0678b618",
   "metadata": {},
   "source": [
    "### 7. Print anagrams together in Python using List and Dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "fbdc2f38",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Words:  ['act', 'cat', 'silent', 'listen']\n",
      "Anagram:  act cat silent listen \n"
     ]
    }
   ],
   "source": [
    "def Anagram(d1): \n",
    "    dict = {}  \n",
    "    for val in d1:   \n",
    "        key = ''.join(sorted(val)) \n",
    "        if key in dict.keys(): \n",
    "            dict[key].append(val) \n",
    "        else: \n",
    "            dict[key] = [] \n",
    "            dict[key].append(val) \n",
    " \n",
    "    result = \"\" \n",
    "    for key,value in dict.items(): \n",
    "        result = result + ' '.join(value) + ' '\n",
    "    return result \n",
    "  \n",
    "d1=['act', 'cat', 'silent','listen']\n",
    "print(\"Words: \",d1)\n",
    "print(\"Anagram: \",Anagram(d1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55f818b5",
   "metadata": {},
   "source": [
    "### 8. Check if binary representations of two numbers are an anagram."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "a9f78dce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def are_binary_anagrams(n1, n2):\n",
    "    bin1 = bin(n1)[2:]\n",
    "    bin2 = bin(n2)[2:]\n",
    "    return sorted(bin1) == sorted(bin2)\n",
    "\n",
    "print(are_binary_anagrams(10, 12))  \n",
    "print(are_binary_anagrams(10, 15))  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5272249f",
   "metadata": {},
   "source": [
    "### 9. Python Counter to find the size of the largest subset of anagram words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "f5fe2c51",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "def largest_anagram_subset(words):\n",
    "    counter = Counter()\n",
    "    for word in words:\n",
    "        sorted_word = \"\".join(sorted(word))\n",
    "        counter[sorted_word] += 1\n",
    "    return max(counter.values())\n",
    "\n",
    "words = [\"cat\", \"dog\", \"tac\", \"god\", \"good\", \"act\"]\n",
    "print(largest_anagram_subset(words))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a158de9",
   "metadata": {},
   "source": [
    "### 10. Python Dictionary to find mirror characters in a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a45ea6ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "javzmklrmg\n"
     ]
    }
   ],
   "source": [
    "    def mirror_compute(st, n):  \n",
    "        reverse_string = \"zyxwvutsrqponmlkjihgfedcba\"  \n",
    "        l = len(st)  \n",
    "          \n",
    "        result = \"\"  \n",
    "        for i in range(0, n):  \n",
    "            result = result + st[i];  \n",
    "                   \n",
    "        for i in range(n, l):  \n",
    "            result = (result +  \n",
    "            reverse_string[ord(st[i]) - ord('a')]);  \n",
    "               \n",
    "        return result;  \n",
    "       \n",
    "    st = \"javaTpoint\"  \n",
    "    n = 4  \n",
    "    answer = mirror_compute(st, n - 1)  \n",
    "    print(answer)  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85f01325",
   "metadata": {},
   "source": [
    "### 11. Counting the frequencies in a list using a dictionary in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "791222d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({4: 4, 3: 3, 2: 2, 1: 1})\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "def count_frequencies(lst):\n",
    "    return Counter(lst)\n",
    "\n",
    "lst = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]\n",
    "print(count_frequencies(lst))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd396771",
   "metadata": {},
   "source": [
    "### 12. Python program to convert a list of Tuples into Dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "87be9ea1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 'b': 2, 'c': 3}\n"
     ]
    }
   ],
   "source": [
    "def tuples_to_dict(tuples):\n",
    "    return dict(tuples)\n",
    "\n",
    "tuples = [(\"a\", 1), (\"b\", 2), (\"c\", 3)]\n",
    "print(tuples_to_dict(tuples))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b9d248d",
   "metadata": {},
   "source": [
    "### 13. Scraping And Finding Ordered Words In A Dictionary using Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9bc2ab51",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['hops', 'hopsd', 'hopsssss', 'hopsegh']\n"
     ]
    }
   ],
   "source": [
    "def is_ordered_word(word, sequence):\n",
    "    seq_idx = 0\n",
    "    for letter in word:\n",
    "        if letter == sequence[seq_idx]:\n",
    "            seq_idx += 1\n",
    "        if seq_idx == len(sequence):\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "dictionary = [\"hope\", \"slope\", \"posh\", \"lopes\",\"hops\",\"hopsd\",\"hospital\",\"abcs\",\"hopsssss\",\"hopsegh\"]\n",
    "sequence = \"hops\"\n",
    "ordered_words = [word for word in dictionary if is_ordered_word(word, sequence)]\n",
    "\n",
    "print(ordered_words)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96c38e79",
   "metadata": {},
   "source": [
    "### 14. Create a list of tuples from the given list having a number and its cube in each tuple "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "6e66f9bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 6\n",
      "[(1, 1), (2, 8), (3, 27), (4, 64), (5, 125), (6, 216)]\n"
     ]
    }
   ],
   "source": [
    "def number_and_cube(n):\n",
    "    return [(i, i**3) for i in range(1, n+1)]\n",
    "\n",
    "n = int(input(\"Enter a number: \"))\n",
    "print(number_and_cube(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "793bad10",
   "metadata": {},
   "source": [
    "### 15. Sort a list of tuples by the second Item."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "1a81b0e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(2, 1), (3, 2), (1, 3)]\n"
     ]
    }
   ],
   "source": [
    "def sort_tuples(tuples):\n",
    "    return sorted(tuples, key=lambda x: x[1])\n",
    "\n",
    "tuples = [(1, 3), (2, 1), (3, 2)]\n",
    "print(sort_tuples(tuples))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "394ad1b2",
   "metadata": {},
   "source": [
    "### 16. Python Program for Insertion Sort."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5e8ae268",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The unsorted list is: [10, 5, 13, 8, 2]\n",
      "The sorted list1 is: [2, 5, 8, 10, 13]\n"
     ]
    }
   ],
   "source": [
    "def insertion_sort(list1):   \n",
    "        for i in range(1, len(list1)):  \n",
    "            value = list1[i]  \n",
    "            j = i - 1  \n",
    "            while j >= 0 and value < list1[j]:  \n",
    "                list1[j + 1] = list1[j]  \n",
    "                j -= 1  \n",
    "            list1[j + 1] = value  \n",
    "        return list1   \n",
    "  \n",
    "list1 = [10, 5, 13, 8, 2]  \n",
    "print(\"The unsorted list is:\", list1)  \n",
    "  \n",
    "print(\"The sorted list1 is:\", insertion_sort(list1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f7ba610",
   "metadata": {},
   "source": [
    "### 17. Python Program for SelectionSort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "00eb314b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorted list: [11, 12, 22, 25, 34, 64, 90]\n"
     ]
    }
   ],
   "source": [
    "def selection_sort(lst):\n",
    "    for i in range(len(lst)):\n",
    "        min_index = i\n",
    "        for j in range(i+1, len(lst)):\n",
    "            if lst[j] < lst[min_index]:\n",
    "                min_index = j\n",
    "        lst[i], lst[min_index] = lst[min_index], lst[i]\n",
    "    return lst\n",
    "\n",
    "lst = [64, 34, 25, 12, 22, 11, 90]\n",
    "print(\"Sorted list:\", selection_sort(lst))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7af72117",
   "metadata": {},
   "source": [
    "### 18. Python Program for Bubble Sort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "53f8c677",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorted list: [11, 12, 22, 25, 34, 64, 90]\n"
     ]
    }
   ],
   "source": [
    "def bubble_sort(lst):\n",
    "    n = len(lst)\n",
    "    for i in range(n):\n",
    "        for j in range(0, n-i-1):\n",
    "            if lst[j] > lst[j+1]:\n",
    "                lst[j], lst[j+1] = lst[j+1], lst[j]\n",
    "    return lst\n",
    "\n",
    "lst = [64, 34, 25, 12, 22, 11, 90]\n",
    "print(\"Sorted list:\", bubble_sort(lst))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b9dc2c1",
   "metadata": {},
   "source": [
    "### 19. Python Program for Merge Sort."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "c6b71b07",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorted list: [11, 12, 22, 25, 34, 64, 90]\n"
     ]
    }
   ],
   "source": [
    "def merge_sort(lst):\n",
    "    if len(lst) <= 1:\n",
    "        return lst\n",
    "    mid = len(lst) // 2\n",
    "    left = merge_sort(lst[:mid])\n",
    "    right = merge_sort(lst[mid:])\n",
    "    return merge(left, right)\n",
    "\n",
    "def merge(left, right):\n",
    "    result = []\n",
    "    while len(left) > 0 and len(right) > 0:\n",
    "        if left[0] <= right[0]:\n",
    "            result.append(left.pop(0))\n",
    "        else:\n",
    "            result.append(right.pop(0))\n",
    "    result.extend(left)\n",
    "    result.extend(right)\n",
    "    return result\n",
    "\n",
    "lst = [64, 34, 25, 12, 22, 11, 90]\n",
    "print(\"Sorted list:\", merge_sort(lst))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21d988f1",
   "metadata": {},
   "source": [
    "### 20. Python Program for QuickSortSort."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "7556ab45",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorted list: [11, 12, 22, 25, 34, 64, 90]\n"
     ]
    }
   ],
   "source": [
    "def quick_sort(lst):\n",
    "    if len(lst) <= 1:\n",
    "        return lst\n",
    "    pivot = lst[0]\n",
    "    less = [x for x in lst[1:] if x <= pivot]\n",
    "    greater = [x for x in lst[1:] if x > pivot]\n",
    "    return quick_sort(less) + [pivot] + quick_sort(greater)\n",
    "\n",
    "lst = [64, 34, 25, 12, 22, 11, 90]\n",
    "print(\"Sorted list:\", quick_sort(lst))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}