DAA_LAB1_PART2.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "kiN1fMlTzcs3"
      },
      "outputs": [],
      "source": [
        "import time\n",
        "import random\n",
        "import matplotlib.pyplot as plt\n",
        "import heapq"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#1.Comparing sorting algorithms:\n",
        "# Bubble Sort\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",
        "# Insertion Sort\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",
        "# Selection Sort\n",
        "def selection_sort(arr):\n",
        "    n = len(arr)\n",
        "    for i in range(n):\n",
        "        min_idx = i\n",
        "        for j in range(i+1, n):\n",
        "            if arr[j] < arr[min_idx]:\n",
        "                min_idx = j\n",
        "        arr[i], arr[min_idx] = arr[min_idx], arr[i]\n",
        "\n",
        "# Radix Sort\n",
        "def radix_sort(arr):\n",
        "    RADIX = 10\n",
        "    maxLength = False\n",
        "    tmp, placement = -1, 1\n",
        "\n",
        "    while not maxLength:\n",
        "        maxLength = True\n",
        "        buckets = [list() for _ in range(RADIX)]\n",
        "\n",
        "        for i in arr:\n",
        "            tmp = i // placement\n",
        "            buckets[tmp % RADIX].append(i)\n",
        "            if maxLength and tmp > 0:\n",
        "                maxLength = False\n",
        "\n",
        "        a = 0\n",
        "        for b in range(RADIX):\n",
        "            buck = buckets[b]\n",
        "            for i in buck:\n",
        "                arr[a] = i\n",
        "                a += 1\n",
        "\n",
        "        placement *= RADIX\n",
        "\n",
        "# Heap Sort\n",
        "def heapify(arr, n, i):\n",
        "    largest = i\n",
        "    l = 2 * i + 1\n",
        "    r = 2 * i + 2\n",
        "\n",
        "    if l < n and arr[l] > arr[largest]:\n",
        "        largest = l\n",
        "\n",
        "    if r < n and arr[r] > arr[largest]:\n",
        "        largest = r\n",
        "\n",
        "    if largest != i:\n",
        "        arr[i], arr[largest] = arr[largest], arr[i]\n",
        "        heapify(arr, n, largest)\n",
        "\n",
        "def heap_sort(arr):\n",
        "    n = len(arr)\n",
        "\n",
        "    for i in range(n // 2 - 1, -1, -1):\n",
        "        heapify(arr, n, i)\n",
        "\n",
        "    for i in range(n - 1, 0, -1):\n",
        "        arr[i], arr[0] = arr[0], arr[i]\n",
        "        heapify(arr, i, 0)\n",
        "\n",
        "# Bucket Sort\n",
        "def bucket_sort(arr):\n",
        "    buckets = [[] for _ in range(10)]\n",
        "    for num in arr:\n",
        "        idx = num // 1000\n",
        "        buckets[idx].append(num)\n",
        "    for i in range(10):\n",
        "        buckets[i].sort()\n",
        "    arr.clear()\n",
        "    for bucket in buckets:\n",
        "        arr.extend(bucket)\n",
        "\n",
        "# Merge Sort\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",
        "# Quick Sort\n",
        "def part(arr, low, high):\n",
        "    i = (low - 1)\n",
        "    pivot = arr[high]\n",
        "\n",
        "    for j in range(low, high):\n",
        "        if arr[j] <= pivot:\n",
        "            i = i + 1\n",
        "            arr[i], arr[j] = arr[j], arr[i]\n",
        "\n",
        "    arr[i + 1], arr[high] = arr[high], arr[i + 1]\n",
        "    return (i + 1)\n",
        "\n",
        "def quick_sort(arr, low, high):\n",
        "    if low < high:\n",
        "        pi = part(arr, low, high)\n",
        "        quick_sort(arr, low, pi - 1)\n",
        "        quick_sort(arr, pi + 1, high)\n",
        "\n",
        "# Main function to compare sorting algorithms\n",
        "def compare_sortalgos(A, n):\n",
        "    sort_algo = {\n",
        "        \"Bubble Sort\": bubble_sort,\n",
        "        \"Insertion Sort\": insertion_sort,\n",
        "        \"Selection Sort\": selection_sort,\n",
        "        \"Radix Sort\": radix_sort,\n",
        "        \"Heap Sort\": heap_sort,\n",
        "        \"Bucket Sort\": bucket_sort,\n",
        "        \"Merge Sort\": merge_sort,\n",
        "        \"Quick Sort\": quick_sort\n",
        "    }\n",
        "\n",
        "    time_taken = {}\n",
        "\n",
        "    for algoname, algo in sort_algo.items():\n",
        "        arr = A.copy()\n",
        "        start_time = time.time()\n",
        "        if algoname == \"Quick Sort\":\n",
        "            algo(arr, 0, n - 1)  # Pass initial values for low and high\n",
        "        else:\n",
        "            algo(arr)\n",
        "        end_time = time.time()\n",
        "        time_taken[algoname] = end_time - start_time\n",
        "\n",
        "    return time_taken\n",
        "\n",
        "\n",
        "# Plot the time taken by each sorting algorithm\n",
        "def plot_time_taken(time_taken):\n",
        "    plt.figure(figsize=(12, 6))\n",
        "    plt.bar(time_taken.keys(), time_taken.values(), color='skyblue')\n",
        "    plt.xlabel('Sorting Algorithm')\n",
        "    plt.ylabel('Time Taken (seconds)')\n",
        "    plt.title('Comparison of Sorting Algorithms')\n",
        "    plt.xticks(rotation=45, ha='right')\n",
        "    plt.show()\n",
        "\n",
        "# Number of random integers\n",
        "n = 100\n",
        "arr=[random.randint(1, 10000) for _ in range(n)]\n",
        "\n",
        "# Compare sorting algorithms\n",
        "time_taken = compare_sortalgos(arr,n)\n",
        "\n",
        "# Plot the time taken by each sorting algorithm\n",
        "plot_time_taken(time_taken)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 628
        },
        "id": "6BZpXMLO0QgW",
        "outputId": "e807c1a4-754f-4d55-a6eb-c1acebe1f28d"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def merge_sorted_lists(lists):\n",
        "    merged_list = []\n",
        "    pointer = [0] * len(lists)  # Pointers to keep track of the current index\n",
        "\n",
        "    while True:\n",
        "        min_val = float('inf')\n",
        "        min_idx = None\n",
        "\n",
        "        # minimum value in all lists\n",
        "        for i, lst in enumerate(lists):\n",
        "            if pointer[i] < len(lst) and lst[pointer[i]] < min_val:\n",
        "                min_val = lst[pointer[i]]\n",
        "                min_idx = i\n",
        "\n",
        "        # If minimum value is infinity, then all lists have been traversed\n",
        "        if min_val == float('inf'):\n",
        "            break\n",
        "\n",
        "        # Append the minimum value to the merged list and move pointer to the next element in the respective list\n",
        "        merged_list.append(min_val)\n",
        "        pointer[min_idx] += 1\n",
        "\n",
        "    return merged_list\n",
        "\n",
        "# Input from user\n",
        "m = int(input(\"Enter the number of sorted lists: \"))\n",
        "n = int(input(\"Enter the number of elements in each list: \"))\n",
        "\n",
        "# Taking input for sorted lists from user\n",
        "sorted_lists = []\n",
        "for i in range(m):\n",
        "    lst = list(map(int, input(f\"Enter the elements of list {i+1} separated by space: \").split()))\n",
        "    sorted_lists.append(lst)\n",
        "\n",
        "# Merge the sorted lists\n",
        "merged_result = merge_sorted_lists(sorted_lists)\n",
        "print(\"Merged sorted list:\", merged_result)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6SXUlIOE2yp-",
        "outputId": "1493f191-a70f-41dd-c9be-0b4c8b9ec080"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter the number of sorted lists: 3\n",
            "Enter the number of elements in each list: 4\n",
            "Enter the elements of list 1 separated by space: 1 3 3 5\n",
            "Enter the elements of list 2 separated by space: 3 4 5 6\n",
            "Enter the elements of list 3 separated by space: 0 0 1 1\n",
            "Merged sorted list: [0, 0, 1, 1, 1, 3, 3, 3, 4, 5, 5, 6]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def heapify(arr, n, i):\n",
        "    largest = i\n",
        "    l = 2 * i + 1\n",
        "    r = 2 * i + 2\n",
        "\n",
        "    if l < n and arr[l] > arr[largest]:\n",
        "        largest = l\n",
        "\n",
        "    if r < n and arr[r] > arr[largest]:\n",
        "        largest = r\n",
        "\n",
        "    if largest != i:\n",
        "        arr[i], arr[largest] = arr[largest], arr[i]\n",
        "        heapify(arr, n, largest)\n",
        "\n",
        "def build_heap(arr):\n",
        "    n = len(arr)\n",
        "    for i in range(n // 2 - 1, -1, -1):\n",
        "        heapify(arr, n, i)\n",
        "\n",
        "def extract_max(arr):\n",
        "    if not arr:\n",
        "        return None\n",
        "    root = arr[0]\n",
        "    arr[0] = arr[-1]\n",
        "    arr.pop()\n",
        "    heapify(arr, len(arr), 0)\n",
        "    return root\n",
        "\n",
        "def k_largest_elements(arr, k):\n",
        "    build_heap(arr)\n",
        "    result = []\n",
        "    for _ in range(k):\n",
        "        max_element = extract_max(arr)\n",
        "        if max_element is not None:\n",
        "            result.append(max_element)\n",
        "        else:\n",
        "            break\n",
        "    return result\n",
        "\n",
        "# Example usage\n",
        "arr = [3, 10, 4, 7, 6, 9, 1]\n",
        "k = int(input(\"Enter value of k: \"))\n",
        "if(k>len(arr)):\n",
        "  print(\"Enter the valid value of k. k<n\")\n",
        "else:\n",
        "  print(k_largest_elements(arr, k))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cutMcbP_3OO4",
        "outputId": "1a2a5a56-cd39-4451-c017-bd099c272e26"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter value of k: 2\n",
            "[10, 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#4.maximum number of activities performed by a single person\n",
        "#first sort by end time for more activities\n",
        "def sort_endTime(a):\n",
        "    a.sort(key=lambda x: x[1])\n",
        "\n",
        "def max_activities(A):\n",
        "    sort_endTime(A)\n",
        "    count = 1\n",
        "    end_time = A[0][1]\n",
        "    sel_A = [A[0]]\n",
        "    for i in range(1, len(A)):\n",
        "        if A[i][0] >= end_time:\n",
        "            count += 1\n",
        "            end_time = A[i][1]\n",
        "            sel_A.append(A[i])\n",
        "    return count, sel_A\n",
        "\n",
        "# Example usage\n",
        "activity = [(1, 4), (3, 5), (0, 6), (5, 7), (3, 8), (5, 9), (6, 10), (8, 11),(4, 5)]\n",
        "count, select_activity = max_activities(activity)\n",
        "print(\"Maximum number of activities:\", count)\n",
        "print(\"Order for Activities:\")\n",
        "print(select_activity)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Jgueued9Gqr_",
        "outputId": "9c1272d9-ad86-42bf-f8b9-0b47081eac9f"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Maximum number of activities: 4\n",
            "Order for Activities:\n",
            "[(1, 4), (4, 5), (5, 7), (8, 11)]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#5.Given a set of intervals, print all non-overlapping intervals after merging the overlapping intervals\n",
        "def merge_intervals(inter):\n",
        "    merged = []\n",
        "    inter.sort(key=lambda x: x[0])\n",
        "    for i in inter:\n",
        "        if not merged or merged[-1][1] < i[0]:\n",
        "            merged.append(i)\n",
        "        else:\n",
        "            merged[-1][1] = max(merged[-1][1], i[1])\n",
        "    return merged\n",
        "\n",
        "intervals = [[1,3],[2,7],[8,10],[15,18]]\n",
        "print(merge_intervals(intervals))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D011Pk_3JsfD",
        "outputId": "0b90db5d-5a6b-4e51-c678-aaa9c1d7f483"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1, 7], [8, 10], [15, 18]]\n"
          ]
        }
      ]
    }
  ]
}