Python_Questions_Set1.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "207633df-1925-4e59-af4f-2723dbf93095",
      "metadata": {
        "id": "207633df-1925-4e59-af4f-2723dbf93095"
      },
      "source": [
        "# Set 1: Data Sense Presents: Python Zero to Hero Question Series (200 Questions)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d8c30e5a-31d5-4b5d-9ee3-5efd0b7bba29",
      "metadata": {
        "id": "d8c30e5a-31d5-4b5d-9ee3-5efd0b7bba29"
      },
      "source": [
        "**10 Questions (List Comprehension, Linear Search, Two pointer Algorithm**"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d19ffc90-672e-4532-8ec4-0e3227b887fb",
      "metadata": {
        "id": "d19ffc90-672e-4532-8ec4-0e3227b887fb"
      },
      "source": [
        "**Question 1:(Movie Tickets):**\n",
        "\n",
        "You are managing a movie theater's ticket booking system. A list of booked seat numbers is given, and you need to find if a particular seat is booked. Write a Python function to perform a search on the list of booked seats. **The function should return the index of the seat if booked, otherwise, it should return -1.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "86051152-a17d-458a-ba28-d3b967597ea0",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "86051152-a17d-458a-ba28-d3b967597ea0",
        "outputId": "7cb05fff-3e9f-4390-9857-c2f05601c419"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Seat number 30 is booked in [10, 25, 30, 42, 55] at index 2\n",
            "Seat number 30 is booked in [100, 200, 300, 400, 500] at index -1\n"
          ]
        }
      ],
      "source": [
        "# function to find and return the index of seat\n",
        "def find_index_of_seat(A, x):\n",
        "  for i in range(len(A)):\n",
        "    if (A[i] == x):\n",
        "      return i\n",
        "  # returning -1 in-case of the seat is not booked!\n",
        "  return -1\n",
        "\n",
        "# main() code\n",
        "booked_seats1 = [10, 25, 30, 42, 55]  #Output: 2\n",
        "booked_seats2 = [100, 200, 300, 400, 500] #output: -1\n",
        "\n",
        "seat_number = 30\n",
        "\n",
        "print(f\"Seat number {seat_number} is booked in {booked_seats1} at index {find_index_of_seat(booked_seats1, seat_number)}\")\n",
        "print(f\"Seat number {seat_number} is booked in {booked_seats2} at index {find_index_of_seat(booked_seats2, seat_number)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0199c0f2-027f-4f99-8cfa-5a781c9ab31c",
      "metadata": {
        "id": "0199c0f2-027f-4f99-8cfa-5a781c9ab31c"
      },
      "source": [
        "**Question 2: School Grades**\n",
        "\n",
        "In a school, the grades of students in a class are recorded in a list. Write a Python function that takes this list of **student names and their respective grades**, and returns a dictionary where the **keys are the student names and the values are their grades.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9312ab11-65e5-4a2f-a856-473831a19d78",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9312ab11-65e5-4a2f-a856-473831a19d78",
        "outputId": "03353d3b-35b2-405b-992b-4a2dead8af8f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'Ravi': 85, 'Priya': 92, 'Anil': 78}\n"
          ]
        }
      ],
      "source": [
        "def converting_list_of_tuples_of_grades_into_dictionary(L):\n",
        "  return dict((x,y) for x,y in L)\n",
        "\n",
        "students_grades = [(\"Ravi\", 85), (\"Priya\", 92), (\"Anil\", 78)]\n",
        "\n",
        "#output: {'Ravi': 85, 'Priya': 92, 'Anil': 78}\n",
        "\n",
        "print(f\"{converting_list_of_tuples_of_grades_into_dictionary(students_grades)}\")\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e2ed4ceb-75d8-44b5-910c-499b9f7a4405",
      "metadata": {
        "id": "e2ed4ceb-75d8-44b5-910c-499b9f7a4405"
      },
      "source": [
        "**Question 3: Business Profit**\n",
        "\n",
        "In a business case study, you are given a sorted list of daily profits and need to find **if there are two consecutive days where the total profit matches a target value.** Solve this problem."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d041c172-f7e7-40bf-b7be-226241284ff8",
      "metadata": {
        "id": "d041c172-f7e7-40bf-b7be-226241284ff8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2932e34b-5577-41f1-b874-6b8cea3dc62d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True, There exists two consecutive days where the total profit matches to 700\n"
          ]
        }
      ],
      "source": [
        "# function to check whether there exists any two consecutive days profit-sum equals to target in given list of daily profits\n",
        "def check_two_consecutive_days_have_target_profit(List_Profit, x):\n",
        "\n",
        "  # if the target value is smaller than first value in list of daily profits, simply return False\n",
        "  if (List_Profit[0] > x):\n",
        "    return False\n",
        "\n",
        "  slow_pointer = 0\n",
        "\n",
        "  while (slow_pointer) < (len(List_Profit) - 1):\n",
        "\n",
        "    if ((List_Profit[slow_pointer] + List_Profit[slow_pointer + 1]) == x):\n",
        "      return True\n",
        "\n",
        "    slow_pointer += 1\n",
        "\n",
        "  return False\n",
        "\n",
        "# main() code\n",
        "profits = [100, 200, 300, 400, 500]\n",
        "target = 700\n",
        "\n",
        "#Output: True\n",
        "\n",
        "if (check_two_consecutive_days_have_target_profit(profits, target)) == True:\n",
        "  print(f\"{check_two_consecutive_days_have_target_profit(profits, target)}, There exists two consecutive days where the total profit matches to {target}\")\n",
        "else:\n",
        "  print(f\"{check_two_consecutive_days_have_target_profit(profits, target)}, There does not exist any two consecutive days where the total profits matches to {target}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9eb8d053-3dba-45f6-b67b-aaf3ef1eb8f7",
      "metadata": {
        "id": "9eb8d053-3dba-45f6-b67b-aaf3ef1eb8f7"
      },
      "source": [
        "**Question 4: Business Revenue**\n",
        "\n",
        "In a business case study, you are given a dictionary where keys are product names and values are lists of monthly revenues. Write a Python function to create a new dictionary with the **product names as keys and their total annual revenue as values**."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4accf202-8fb4-4856-b54a-a5a1bb4d6d57",
      "metadata": {
        "id": "4accf202-8fb4-4856-b54a-a5a1bb4d6d57",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "865e4c5e-079b-4168-d0e2-72997c4fee66"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Total Annual Revenue with Product : {'ProductA': 600, 'ProductB': 750, 'ProductC': 900}\n"
          ]
        }
      ],
      "source": [
        "def generating_new_dictionary_of_product_total_annual_revenue(Dictionary_P):\n",
        "  return { K : sum(V) for K, V in Dictionary_P.items()}\n",
        "\n",
        "\n",
        "# main() code\n",
        "products = {\n",
        "    \"ProductA\": [100, 200, 300],\n",
        "    \"ProductB\": [150, 250, 350],\n",
        "    \"ProductC\": [200, 300, 400]\n",
        "}\n",
        "\n",
        "\n",
        "#Output: {'ProductA': 600, 'ProductB': 750, 'ProductC': 900}\n",
        "\n",
        "print(f\"Total Annual Revenue with Product : {generating_new_dictionary_of_product_total_annual_revenue(products)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "142c24ac-07d9-4f7e-8f2f-80013a0849be",
      "metadata": {
        "id": "142c24ac-07d9-4f7e-8f2f-80013a0849be"
      },
      "source": [
        "**Question 5: Treasure Hunt**\n",
        "\n",
        "In a treasure hunt game, players must find hidden items scattered across a list of locations. Write a Python function to **find the first and last occurrence of a particular item in the list**. If the item is not found, return (-1, -1)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "80ef132e-6167-40f0-a50b-412cb27fc0f4",
      "metadata": {
        "id": "80ef132e-6167-40f0-a50b-412cb27fc0f4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "55380c4d-7862-4830-a513-53d8b9c6f702"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "'rock' has first and last occurrence at indices (1, 5) in given list of locations ['tree', 'rock', 'cave', 'rock', 'lake', 'rock']\n",
            "'rock' has first and last occurrence at indices (3, 3) in given list of locations ['tree', 'water', 'cave', 'rock', 'lake', 'air']\n"
          ]
        }
      ],
      "source": [
        "def finding_first_and_last_occurrence(List_Location, x_item):\n",
        "\n",
        "  first_occurrence = -1\n",
        "\n",
        "  for i in range(len(List_Location)):\n",
        "    if ((List_Location[i]) == x_item):\n",
        "      first_occurrence = i\n",
        "      break\n",
        "\n",
        "  if (first_occurrence == -1):\n",
        "    return (-1,-1)\n",
        "\n",
        "  last_occurrence = -1\n",
        "  j = len(List_Location) - 1\n",
        "  while j >= i:\n",
        "    if ((List_Location[j]) == x_item):\n",
        "      last_occurrence = j\n",
        "      break\n",
        "    j -= 1\n",
        "\n",
        "  return (first_occurrence, last_occurrence)\n",
        "\n",
        "# main() code\n",
        "locations1 = [\"tree\", \"rock\", \"cave\", \"rock\", \"lake\", \"rock\"] #Output: (1, 5)\n",
        "locations2 = [\"tree\", \"water\", \"cave\", \"rock\", \"lake\", \"air\"] #Output: (-1,-1)\n",
        "item = \"rock\"\n",
        "\n",
        "\n",
        "print(f\"'{item}' has first and last occurrence at indices {finding_first_and_last_occurrence(locations1, item)} in given list of locations {locations1}\")\n",
        "\n",
        "print(f\"'{item}' has first and last occurrence at indices {finding_first_and_last_occurrence(locations2, item)} in given list of locations {locations2}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f9abfbd3-c2e0-4c1f-a536-644836beb078",
      "metadata": {
        "id": "f9abfbd3-c2e0-4c1f-a536-644836beb078"
      },
      "source": [
        "**Question 6: Chess**\n",
        "\n",
        "You are developing a chess game and need to create a list of all possible coordinates on an 8x8 chessboard. Write a Python function to generate this list using nested list comprehension.\n",
        "\n",
        "**No Input Required**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9799dc77-8aab-4df4-ba53-29791f7dc1aa",
      "metadata": {
        "id": "9799dc77-8aab-4df4-ba53-29791f7dc1aa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1b1d2da9-0b22-4076-c5c7-35faa5f32d89"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), (4, 7), (5, 0), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), (5, 7), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6), (6, 7), (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7)]\n"
          ]
        }
      ],
      "source": [
        "# function to find and return all possible coordinate combinations on n x n chessboard\n",
        "def all_possible_coordinate_combinations(n):\n",
        "  return [(x,y) for x in range(n) for y in range(n)]\n",
        "\n",
        "# main() code\n",
        "num_of_coordinates = 8\n",
        "print(all_possible_coordinate_combinations(num_of_coordinates))\n",
        "\n",
        "#Output\n",
        "#[\n",
        "#   (0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7),\n",
        "#    (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7),\n",
        "#    ...\n",
        "#    (7, 0), (7, 1), (7, 2), (7, 3), (7, 4), (7, 5), (7, 6), (7, 7)\n",
        "#]"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "07f67529-f7fc-481c-81d7-a4005f36885e",
      "metadata": {
        "id": "07f67529-f7fc-481c-81d7-a4005f36885e"
      },
      "source": [
        "**Question 7: 3 Sum Closest**\n",
        "\n",
        "Given an integer array nums of length n and an integer target, find three integers in nums such that the sum is closest to target.\n",
        "\n",
        "Return the sum of the three integers.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3e59bd2e-d0ee-4059-8f71-a4472a627ca9",
      "metadata": {
        "id": "3e59bd2e-d0ee-4059-8f71-a4472a627ca9"
      },
      "source": [
        "**Example 1:**\n",
        "\n",
        "Input: nums = [-1,2,1,-4], target = 1\n",
        "\n",
        "Output: 2\n",
        "\n",
        "Explanation: The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).\n",
        "\n",
        "**Example 2:**\n",
        "\n",
        "Input: nums = [0,0,0], target = 1\n",
        "\n",
        "Output: 0\n",
        "\n",
        "Explanation: The sum that is closest to the target is 0. (0 + 0 + 0 = 0).\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2a11ace7-d926-4126-8f01-3aff550910fb",
      "metadata": {
        "id": "2a11ace7-d926-4126-8f01-3aff550910fb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c6eea45e-67eb-4160-f05b-04abfbf1bdd1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The sum that is closest to 1 in [-1, 2, 1, -4] is 2\n"
          ]
        }
      ],
      "source": [
        "# function to find the minimum value's index from a given array/list\n",
        "def index_of_abs_close_sum(arr):\n",
        "  min_val = arr[0]\n",
        "  index_min_val = 0\n",
        "\n",
        "  for i in range(1, len(arr)):\n",
        "    if (arr[i] < min_val):\n",
        "      min_val = arr[i]\n",
        "      index_min_val = i\n",
        "\n",
        "  return index_min_val\n",
        "\n",
        "\n",
        "# function to find sum close to target\n",
        "def find_closet_sum_of_three_nums(N, x):\n",
        "  # list to store sum of all pairs (three-elements as one pair/collection)\n",
        "  sum_of_all_pairs = []\n",
        "\n",
        "  for i in range(len(N) - 2):\n",
        "    for j in range(i+1, len(N) - 1):\n",
        "      for k in range(j+1, len(N)):\n",
        "        sum_of_all_pairs.append(N[i] + N[j] + N[k])\n",
        "\n",
        "  # finding the absolute difference of each sum value with given target\n",
        "  abs_closest_sum_values = [abs(target - val) for val in sum_of_all_pairs]\n",
        "\n",
        "  # finding the minimum value's index from abs_closest_sum_values and returning that index value from sum of all pairs/collection\n",
        "  return sum_of_all_pairs[index_of_abs_close_sum(abs_closest_sum_values)]\n",
        "\n",
        "\n",
        "\n",
        "# main() code\n",
        "nums = [-1, 2, 1, -4]\n",
        "target = 1\n",
        "\n",
        "print(f\"The sum that is closest to {target} in {nums} is {find_closet_sum_of_three_nums(nums, target)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1bfa5b60-1fd8-4721-882e-d05461963ee7",
      "metadata": {
        "id": "1bfa5b60-1fd8-4721-882e-d05461963ee7"
      },
      "source": [
        "**Question 8: Find K-th Smallest Pair Distance**\n",
        "\n",
        "The distance of a pair of integers a and b is defined as the absolute difference between a and b.\n",
        "\n",
        "Given an integer array nums and an integer k, return the kth smallest distance among all the pairs nums[i] and nums[j] where 0 <= i < j < nums.length.\n",
        "\n",
        "\n",
        "\n",
        "**Example 1:**\n",
        "\n",
        "Input: nums = [1,3,1], k = 1\n",
        "\n",
        "Output: 0\n",
        "\n",
        "Explanation: Here are all the pairs:\n",
        "\n",
        "(1,3) -> 2\n",
        "\n",
        "(1,1) -> 0\n",
        "\n",
        "(3,1) -> 2\n",
        "\n",
        "Then the 1st smallest distance pair is (1,1), and its distance is 0.\n",
        "\n",
        "**Example 2:**\n",
        "\n",
        "Input: nums = [1,1,1], k = 2\n",
        "\n",
        "Output: 0\n",
        "\n",
        "**Example 3:**\n",
        "\n",
        "\n",
        "Input: nums = [1,6,1], k = 3\n",
        "\n",
        "Output: 5"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def find_kth_smallest_distance_among_all_pairs(N, x):\n",
        "\n",
        "  pairs_distance_list = []\n",
        "\n",
        "  for i in range((len(N)-1)):\n",
        "    for j in range(i+1, len(N)):\n",
        "      pairs_distance_list.append(abs(N[i] - N[j]))\n",
        "\n",
        "  pairs_distance_list.sort()\n",
        "\n",
        "  return pairs_distance_list[x - 1]\n",
        "\n",
        "\n",
        "# main() code\n",
        "\n",
        "print(\"Test Case 1 Running...\")\n",
        "nums = [1, 3, 1]\n",
        "k = 1\n",
        "\n",
        "if (k == 1):\n",
        "  print(f\"The {k}st smallest distance of all pairs in {nums} is {find_kth_smallest_distance_among_all_pairs(nums, k)}\")\n",
        "elif (k == 2):\n",
        "  print(f\"The {k}nd smallest distance of all pairs in {nums} is {find_kth_smallest_distance_among_all_pairs(nums, k)}\")\n",
        "elif (k == 3):\n",
        "  print(f\"The {k}rd smallest distance of all pairs in {nums} is {find_kth_smallest_distance_among_all_pairs(nums, k)}\")\n",
        "else:\n",
        "  print(f\"The {k}th smallest distance of all pairs in {nums} is {find_kth_smallest_distance_among_all_pairs(nums, k)}\")\n",
        "print(\"Test Case 1 Passed!\")\n",
        "\n",
        "print()\n",
        "\n",
        "print(\"Test Case 2 Running...\")\n",
        "nums = [1,1,1]\n",
        "k = 2\n",
        "\n",
        "if (k == 1):\n",
        "  print(f\"The {k}st smallest distance of all pairs in {nums} is {find_kth_smallest_distance_among_all_pairs(nums, k)}\")\n",
        "elif (k == 2):\n",
        "  print(f\"The {k}nd smallest distance of all pairs in {nums} is {find_kth_smallest_distance_among_all_pairs(nums, k)}\")\n",
        "elif (k == 3):\n",
        "  print(f\"The {k}rd smallest distance of all pairs in {nums} is {find_kth_smallest_distance_among_all_pairs(nums, k)}\")\n",
        "else:\n",
        "  print(f\"The {k}th smallest distance of all pairs in {nums} is {find_kth_smallest_distance_among_all_pairs(nums, k)}\")\n",
        "print(\"Test Case 2 Passed!\")\n",
        "\n",
        "print()\n",
        "\n",
        "print(\"Test Case 3 Running...\")\n",
        "nums = [1,6,1]\n",
        "k = 3\n",
        "\n",
        "if (k == 1):\n",
        "  print(f\"The {k}st smallest distance of all pairs in {nums} is {find_kth_smallest_distance_among_all_pairs(nums, k)}\")\n",
        "elif (k == 2):\n",
        "  print(f\"The {k}nd smallest distance of all pairs in {nums} is {find_kth_smallest_distance_among_all_pairs(nums, k)}\")\n",
        "elif (k == 3):\n",
        "  print(f\"The {k}rd smallest distance of all pairs in {nums} is {find_kth_smallest_distance_among_all_pairs(nums, k)}\")\n",
        "else:\n",
        "  print(f\"The {k}th smallest distance of all pairs in {nums} is {find_kth_smallest_distance_among_all_pairs(nums, k)}\")\n",
        "print(\"Test Case 3 Passed!\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NHiDXEXOs2_o",
        "outputId": "629d226f-d6a4-4026-d780-5d6094cf78cc"
      },
      "id": "NHiDXEXOs2_o",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Case 1 Running...\n",
            "The 1st smallest distance of all pairs in [1, 3, 1] is 0\n",
            "Test Case 1 Passed!\n",
            "\n",
            "Test Case 2 Running...\n",
            "The 2nd smallest distance of all pairs in [1, 1, 1] is 0\n",
            "Test Case 2 Passed!\n",
            "\n",
            "Test Case 3 Running...\n",
            "The 3rd smallest distance of all pairs in [1, 6, 1] is 5\n",
            "Test Case 3 Passed!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6a44fd20-12b9-40a5-873e-59db0476e376",
      "metadata": {
        "id": "6a44fd20-12b9-40a5-873e-59db0476e376"
      },
      "source": [
        "**Question 9: Stock Market**\n",
        "\n",
        "In a stock market analysis, you are given an unsorted list of daily stock prices. Write a Python function to **find the longest subarray where the sum of stock prices equals a given target value**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4448ef4b-debd-480d-a616-fcb57d5a4ee1",
      "metadata": {
        "id": "4448ef4b-debd-480d-a616-fcb57d5a4ee1"
      },
      "outputs": [],
      "source": [
        "#Output: Subarray [2,3,7] has sum 12 and length 3\n",
        "\n",
        "# main() code\n",
        "prices = [1, 2, 3, 7, 5]\n",
        "target = 12\n",
        "\n",
        "# find_longest_subarray_whose_sum_equals_target(prices, target)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ecbe94ab-1c7a-480a-bea4-b183722c9de3",
      "metadata": {
        "id": "ecbe94ab-1c7a-480a-bea4-b183722c9de3"
      },
      "source": [
        "**Question 10: Company Sales Data**\n",
        "\n",
        "You are given a list of dictionaries where each dictionary represents sales data for different regions with keys \"region\", \"sales\", and \"quarter\". Write a Python function to calculate the total sales for each region for the entire year"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "529e9fc8-f648-4248-9d31-f8b149968cab",
      "metadata": {
        "id": "529e9fc8-f648-4248-9d31-f8b149968cab",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "beb0f191-7708-4556-d211-15e378494edf"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Total sales of each region : {'North': 600, 'South': 750}\n"
          ]
        }
      ],
      "source": [
        "def calculating_total_sales_for_each_region(List_sales):\n",
        "\n",
        "  each_region_total_sales = {}\n",
        "\n",
        "  for i in range(len(List_sales)):\n",
        "    if (List_sales[i]['region']) in each_region_total_sales:\n",
        "      each_region_total_sales[List_sales[i]['region']] += List_sales[i]['sales']\n",
        "    else:\n",
        "      each_region_total_sales[List_sales[i]['region']] = List_sales[i]['sales']\n",
        "\n",
        "  return each_region_total_sales\n",
        "\n",
        "# main() code\n",
        "sales_data = [\n",
        "    {'region': 'North', 'sales': 100, 'quarter': 'Q1'},\n",
        "    {'region': 'South', 'sales': 150, 'quarter': 'Q1'},\n",
        "    {'region': 'North', 'sales': 200, 'quarter': 'Q2'},\n",
        "    {'region': 'South', 'sales': 250, 'quarter': 'Q2'},\n",
        "    {'region': 'North', 'sales': 300, 'quarter': 'Q3'},\n",
        "    {'region': 'South', 'sales': 350, 'quarter': 'Q3'}\n",
        "]\n",
        "\n",
        "print(f\"Total sales of each region : {calculating_total_sales_for_each_region(sales_data)}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "6762150f-a780-43a9-bd05-e26a60a766c6",
      "metadata": {
        "id": "6762150f-a780-43a9-bd05-e26a60a766c6"
      },
      "outputs": [],
      "source": [
        "# Output {'North': 600, 'South': 750}\n"
      ]
    }
  ],
  "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"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}