DAA ASSIG - 01 PART 2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# PART - 02 \n",
    "#19CSE302 – Design and Analysis of Algorithms          Lab Assignment 1\n",
    "\n",
    "#1. Generate 1000 integer random numbers between 1 and 10000. Compare the sorting algorithms learnt in the class using \n",
    "# the same set of numbers generated. Plot the time taken for them to complete the process.\n",
    "\n",
    "import random\n",
    "import timeit\n",
    "import matplotlib.pyplot as plt\n",
    "random_numbers = [random.randint(1, 10000) for _ in range(1000)]\n",
    "def bubble_sort(arr):\n",
    "    n = len(arr)\n",
    "    for i in range(n):\n",
    "        for j in range(0, n-i-1):\n",
    "            if arr[j] > arr[j+1]:\n",
    "                arr[j], arr[j+1] = arr[j+1], arr[j]\n",
    "\n",
    "def insertion_sort(arr):\n",
    "    for i in range(1, len(arr)):\n",
    "        key = arr[i]\n",
    "        j = i - 1\n",
    "        while j >= 0 and key < arr[j]:\n",
    "            arr[j + 1] = arr[j]\n",
    "            j -= 1\n",
    "        arr[j + 1] = key\n",
    "\n",
    "def merge_sort(arr):\n",
    "    if len(arr) > 1:\n",
    "        mid = len(arr) // 2\n",
    "        L = arr[:mid]\n",
    "        R = arr[mid:]\n",
    "        \n",
    "        merge_sort(L)\n",
    "        merge_sort(R)\n",
    "        \n",
    "        i = j = k = 0\n",
    "        \n",
    "        while i < len(L) and j < len(R):\n",
    "            if L[i] < R[j]:\n",
    "                arr[k] = L[i]\n",
    "                i += 1\n",
    "            else:\n",
    "                arr[k] = R[j]\n",
    "                j += 1\n",
    "            k += 1\n",
    "        \n",
    "        while i < len(L):\n",
    "            arr[k] = L[i]\n",
    "            i += 1\n",
    "            k += 1\n",
    "        \n",
    "        while j < len(R):\n",
    "            arr[k] = R[j]\n",
    "            j += 1\n",
    "            k += 1\n",
    "\n",
    "def quick_sort(arr):\n",
    "    if len(arr) <= 1:\n",
    "        return arr\n",
    "    else:\n",
    "        pivot = arr[0]\n",
    "        less_than_pivot = [x for x in arr[1:] if x <= pivot]\n",
    "        greater_than_pivot = [x for x in arr[1:] if x > pivot]\n",
    "        return quick_sort(less_than_pivot) + [pivot] + quick_sort(greater_than_pivot)\n",
    "bubble_time = timeit.timeit(lambda: bubble_sort(random_numbers.copy()), number=1)\n",
    "insertion_time = timeit.timeit(lambda: insertion_sort(random_numbers.copy()), number=1)\n",
    "merge_time = timeit.timeit(lambda: merge_sort(random_numbers.copy()), number=1)\n",
    "quick_time = timeit.timeit(lambda: quick_sort(random_numbers.copy()), number=1)\n",
    "algorithms = ['Bubble Sort', 'Insertion Sort', 'Merge Sort', 'Quick Sort']\n",
    "times = [bubble_time, insertion_time, merge_time, quick_time]\n",
    "\n",
    "plt.bar(algorithms, times, color=['blue', 'green', 'red', 'purple'])\n",
    "plt.xlabel('Sorting Algorithm')\n",
    "plt.ylabel('Time Taken (seconds)')\n",
    "plt.title('Comparison of Sorting Algorithms')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 15, 20, 25, 27, 29, 30, 32, 33, 35, 37, 40, 48, 93]\n"
     ]
    }
   ],
   "source": [
    "import heapq\n",
    "\n",
    "def merge_sorted_lists(lists):\n",
    "    result = []\n",
    "\n",
    "    heap = []\n",
    "    \n",
    "    for i, lst in enumerate(lists):\n",
    "        if lst:\n",
    "            heapq.heappush(heap, (lst[0], i, 0)) \n",
    "    while heap:\n",
    "        val, list_index, element_index = heapq.heappop(heap)\n",
    "        result.append(val)\n",
    "        if element_index + 1 < len(lists[list_index]):\n",
    "            heapq.heappush(heap, (lists[list_index][element_index + 1], list_index, element_index + 1))\n",
    "\n",
    "    return result\n",
    "lists = [\n",
    "    [10, 20, 30, 40],\n",
    "    [15, 25, 35],\n",
    "    [27, 29, 37, 48, 93],\n",
    "    [32, 33]\n",
    "]\n",
    "merged_list = merge_sorted_lists(lists)\n",
    "print(merged_list)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "K largest elements: [10, 15, 20]\n"
     ]
    }
   ],
   "source": [
    "import heapq\n",
    "\n",
    "def find_k_largest_elements(nums, k):\n",
    "    heap = nums[:k]\n",
    "    heapq.heapify(heap)\n",
    "    for num in nums[k:]:\n",
    "        if num > heap[0]:\n",
    "            heapq.heappop(heap)\n",
    "            heapq.heappush(heap, num)\n",
    "    return heap\n",
    "arr = [3, 10, 4, 7, 15, 20, 8]\n",
    "k = 3\n",
    "result = find_k_largest_elements(arr, k)\n",
    "print(\"K largest elements:\", result)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum number of activities performed by a single person:\n",
      "[(1, 4), (5, 7), (8, 11), (12, 14)]\n"
     ]
    }
   ],
   "source": [
    "def max_activities(activities):\n",
    "    activities.sort(key=lambda x: x[1])\n",
    "    \n",
    "\n",
    "    selected_activities = [activities[0]]\n",
    "    prev_finish_time = activities[0][1]\n",
    "    \n",
    "    \n",
    "    for activity in activities[1:]:\n",
    "        \n",
    "        if activity[0] >= prev_finish_time:\n",
    "            selected_activities.append(activity)\n",
    "            prev_finish_time = activity[1]\n",
    "    \n",
    "    return selected_activities\n",
    "\n",
    "activities = [\n",
    "    (1, 4), (3, 5), (0, 6), (5, 7), (3, 8), (5, 9), (6, 10), (8, 11), (8, 12), (2, 13), (12, 14)\n",
    "]\n",
    "\n",
    "max_activities_list = max_activities(activities)\n",
    "print(\"Maximum number of activities performed by a single person:\")\n",
    "print(max_activities_list)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Merged intervals:\n",
      "[(1, 5), (6, 9)]\n"
     ]
    }
   ],
   "source": [
    "def merge_intervals(intervals):\n",
    "    intervals.sort(key=lambda x: x[0])\n",
    "    merged = []\n",
    "    for interval in intervals:\n",
    "        \n",
    "        if not merged or interval[0] > merged[-1][1]:\n",
    "            merged.append(interval)\n",
    "        else:\n",
    "        \n",
    "            merged[-1] = (merged[-1][0], max(merged[-1][1], interval[1]))\n",
    "    \n",
    "    return merged\n",
    "\n",
    "intervals = [\n",
    "    (1, 4), (2, 5), (7, 8), (6, 9)\n",
    "]\n",
    "\n",
    "merged_intervals = merge_intervals(intervals)\n",
    "\n",
    "print(\"Merged intervals:\")\n",
    "print(merged_intervals)\n"
   ]
  }
 ],
 "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}