Python_Coding_Test1.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "5c423408-2b86-45dc-95ea-12e64c511ab8",
      "metadata": {
        "id": "5c423408-2b86-45dc-95ea-12e64c511ab8"
      },
      "source": [
        "**Question 1**\n",
        "\n",
        "Given the Following Nested List. Write a Python Code to Extract the number 10 from the nested list."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8a813086-5fe1-41bd-a9b8-8c4c5717716e",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8a813086-5fe1-41bd-a9b8-8c4c5717716e",
        "outputId": "1dee4747-62ed-4673-81f2-1087eef8246f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n"
          ]
        }
      ],
      "source": [
        "data = [\n",
        "    [1, 2, [3, 4], 5],\n",
        "    [6, [7, 8, [9, 10]], 11],\n",
        "    [12, 13, 14]\n",
        "]\n",
        "\n",
        "num_10_extraction = data[1][1][2][1]\n",
        "\n",
        "print(num_10_extraction)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "23190ae9-0c65-40ba-9ab0-fe3a2f1433f5",
      "metadata": {
        "id": "23190ae9-0c65-40ba-9ab0-fe3a2f1433f5"
      },
      "source": [
        "**Question 2**\n",
        "\n",
        "Given the following nested dictionary. Write a Python Code to retrieve the plus4 value of the zipcode."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c3a0e7bf-fc84-4e02-aea4-b3f903226ea8",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c3a0e7bf-fc84-4e02-aea4-b3f903226ea8",
        "outputId": "606f11bc-ce36-44d4-e423-bc170893ba03"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1234\n"
          ]
        }
      ],
      "source": [
        "person = {\n",
        "    'name': 'Alice',\n",
        "    'age': 30,\n",
        "    'address': {\n",
        "        'city': 'New York',\n",
        "        'zipcode': {\n",
        "            'main': 10001,\n",
        "            'plus4': 1234\n",
        "        }\n",
        "    }\n",
        "}\n",
        "\n",
        "retrieving_plus4_value = person['address']['zipcode']['plus4']\n",
        "\n",
        "print(retrieving_plus4_value)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c258778b-1cd6-4937-8fe1-d165f99d942a",
      "metadata": {
        "id": "c258778b-1cd6-4937-8fe1-d165f99d942a"
      },
      "source": [
        "**Question 3**\n",
        "\n",
        "Use a while loop to sum all the even numbers between 1 and 100"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# initializing variables (sum) and (n), for adding even numbers and handling the iteration process, respectively\n",
        "sum = 0\n",
        "n = 0\n",
        "\n",
        "# performing iteration till 99\n",
        "while (n < 100):\n",
        "  sum+=n\n",
        "  n+=2\n",
        "\n",
        "print(f\"Sum of all even numbers between 1 and 100 : {sum}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G-s7yv8benvE",
        "outputId": "b845ea53-e4fc-4953-dcca-de7022c8479e"
      },
      "id": "G-s7yv8benvE",
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sum of all even numbers between 1 and 100 : 2450\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e453507f-1c9c-4e54-a47c-072989ade670",
      "metadata": {
        "id": "e453507f-1c9c-4e54-a47c-072989ade670"
      },
      "source": [
        "**Question 4**\n",
        "\n",
        "Given a deeply nested list. Write a Python Code to Flatten this nested list into a single list: [1, 2, 3, 4, 5]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5e902e53-fefd-4bc3-aa7e-c1caea48b9d3",
      "metadata": {
        "id": "5e902e53-fefd-4bc3-aa7e-c1caea48b9d3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "21323f97-08ec-475d-9f69-c8c626705005"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3, 4, 5]\n"
          ]
        }
      ],
      "source": [
        "nested_list = [1, [2, [3, [4, [5]]]]]\n",
        "\n",
        "new_list = []\n",
        "\n",
        "new_list.append(nested_list[0])\n",
        "new_list.append(nested_list[1][0])\n",
        "new_list.append(nested_list[1][1][0])\n",
        "new_list.append(nested_list[1][1][1][0])\n",
        "new_list.append(nested_list[1][1][1][1][0])\n",
        "\n",
        "print(new_list)\n",
        "\n",
        "# a, [b, [c, [d, [e]]]] = nested_list\n",
        "# ls = []\n",
        "# ls.append(a)\n",
        "# ls.append(b)\n",
        "# ls.append(c)\n",
        "# ls.append(d)\n",
        "# ls.append(e)\n",
        "# print(ls)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b37d56d0-ec0c-41a5-9585-9c4ef8701f9a",
      "metadata": {
        "id": "b37d56d0-ec0c-41a5-9585-9c4ef8701f9a"
      },
      "source": [
        "**Question 5**\n",
        "\n",
        "You are given a list of sets, where each set contains integers. Write a Python code that finds the elements that are common to at least half of the sets in the list."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5596332f-48ee-4374-8454-6e07fd444388",
      "metadata": {
        "id": "5596332f-48ee-4374-8454-6e07fd444388",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0c71ab78-7b18-4bb1-d88d-0f477e48afce"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{5}\n"
          ]
        }
      ],
      "source": [
        "sets_list = [\n",
        "    {1, 2, 3, 4, 5},\n",
        "    {4, 5, 6, 7, 8},\n",
        "    {5, 6, 7, 8, 9},\n",
        "    {1, 5, 9, 10, 11},\n",
        "    {5, 11, 12, 13, 14}\n",
        "]\n",
        "\n",
        "# unpacking the list\n",
        "s1, s2, s3, s4, s5 = sets_list\n",
        "\n",
        "# perfoming set operation (intersection)\n",
        "common_element = s1 & s2 & s3 & s4 & s5\n",
        "\n",
        "# printing common element from all the sets (s1, s2, s3, s4, s5)\n",
        "print(common_element)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5d014064-b0c4-4c8f-b796-5ae331780915",
      "metadata": {
        "id": "5d014064-b0c4-4c8f-b796-5ae331780915"
      },
      "source": [
        "**Question 6**\n",
        "\n",
        "Write a Python program using a while loop to reverse the digits of a given positive integer."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9906f531-028b-4818-b6ff-a0f5217dd757",
      "metadata": {
        "id": "9906f531-028b-4818-b6ff-a0f5217dd757",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "20deef86-6152-43ad-a363-a042381d272f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reverse of 12345 : 54321\n"
          ]
        }
      ],
      "source": [
        "n = 12345\n",
        "# declaring and initializing variables, (num) and (rev_num), to store original number n and to store the reverse number, respectively.\n",
        "num = n\n",
        "rev_num = 0\n",
        "\n",
        "# performing iteration to till (int)n is greater than 0, and doing two tasks:\n",
        "# 1) taking reminder of n at each iteration and adding that to the (rev_num * 10)\n",
        "# 2) reducing the n by dividing it with 10\n",
        "# Note: (int(n)) is being used, because n is becoming floating variable (value contains decimals)\n",
        "while (int(n) > 0):\n",
        "  rem = int(n % 10)\n",
        "  rev_num = (rev_num * 10) + rem\n",
        "  n /= 10\n",
        "\n",
        "print(f\"Reverse of {num} : {rev_num}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "26270911-e89e-4c43-9d96-f139224d8a27",
      "metadata": {
        "id": "26270911-e89e-4c43-9d96-f139224d8a27"
      },
      "source": [
        "**Question 7**\n",
        "\n",
        "Write a Python program using a while loop that repeatedly sums the digits of a given positive integer until the result is a single digit.\n",
        "\n",
        "For example, for n=9875, sum1=9+8+7+5=29 sum2=2+9=11 sum3=1+1=2 . So Answer is 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "81910959-6620-4d8d-80d2-b3a61dc2b77e",
      "metadata": {
        "id": "81910959-6620-4d8d-80d2-b3a61dc2b77e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "88589760-e964-4f6d-dbc2-7c8e78716281"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n"
          ]
        }
      ],
      "source": [
        "# perform_sum() function will do summation of digits of number (x), passed as a parameter\n",
        "def perform_sum(x):\n",
        "  sum = 0\n",
        "  while (int(x) > 0):\n",
        "    rem = int(x % 10)\n",
        "    sum += rem\n",
        "    x /= 10\n",
        "\n",
        "  return sum\n",
        "\n",
        "\n",
        "n = 9875\n",
        "# performing iteration till the summation of digit of number (n) results in single digit\n",
        "while True:\n",
        "  n = perform_sum(n)\n",
        "  # breaking condition to break the loop, when the resultant sum is in single digit\n",
        "  if n < 10:\n",
        "    break\n",
        "\n",
        "print(n)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "13b00005-4e24-4019-8208-d702415a8cf6",
      "metadata": {
        "id": "13b00005-4e24-4019-8208-d702415a8cf6"
      },
      "source": [
        "**Question 8**\n",
        "\n",
        "Write Python code to extract and print the names of people who have a salary greater than 70000."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e7aa0235-2a94-4aac-8e03-01b1606388c5",
      "metadata": {
        "id": "e7aa0235-2a94-4aac-8e03-01b1606388c5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8af41463-b655-4e21-f118-9070bc699825"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Names of people whose salary is greater than 70000 : ['Eve', 'Grace', 'Ivy']\n"
          ]
        }
      ],
      "source": [
        "nested_tuple = (\n",
        "    ('Alice', 50000),\n",
        "    ('Bob', 60000),\n",
        "    ('Charlie', 45000),\n",
        "    ('David', 70000),\n",
        "    (('Eve', 80000), ('Frank', 55000)),\n",
        "    (('Grace', 75000), ('Helen', 65000)),\n",
        "    ((('Ivy', 72000), ('Jack', 58000)), (('Kate', 68000), ('Larry', 63000)))\n",
        ")\n",
        "\n",
        "# unpacking the nested_tuple\n",
        "a, b, c, d, (e,f), (g,h), ((i,j),(k,l)) = nested_tuple\n",
        "\n",
        "# declaring and manually appending the tuples into the list\n",
        "ls = []\n",
        "ls.append(a)\n",
        "ls.append(b)\n",
        "ls.append(c)\n",
        "ls.append(d)\n",
        "ls.append(e)\n",
        "ls.append(f)\n",
        "ls.append(g)\n",
        "ls.append(h)\n",
        "ls.append(i)\n",
        "ls.append(j)\n",
        "ls.append(k)\n",
        "ls.append(l)\n",
        "\n",
        "# using list comprehension, extracting the names of people whose salary is greater than 70000\n",
        "people_whose_salary_more_than_70000 = [n for (n,s) in ls if s > 70000]\n",
        "\n",
        "# printing the name of people whose salary greater than 70000\n",
        "print(f\"Names of people whose salary is greater than 70000 : {people_whose_salary_more_than_70000}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "18eb3f9a-23f2-4ad4-916b-cd4bdf3d6501",
      "metadata": {
        "id": "18eb3f9a-23f2-4ad4-916b-cd4bdf3d6501"
      },
      "source": [
        "**Question 9**\n",
        "\n",
        "Write Python code using dictionary comprehension to extract and print the names of cities with a total population greater than or equal to 3000000."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4977748c-d48a-4a4f-95bb-6d5061e4ad34",
      "metadata": {
        "id": "4977748c-d48a-4a4f-95bb-6d5061e4ad34"
      },
      "outputs": [],
      "source": [
        "# from os import popen\n",
        "nested_dict = {\n",
        "    'New York': {\n",
        "        'Manhattan': 1636268,\n",
        "        'Brooklyn': 2559903,\n",
        "        'Queens': 2253858,\n",
        "        'Bronx': 1418207,\n",
        "        'Staten Island': 476015\n",
        "    },\n",
        "    'Los Angeles': {\n",
        "        'Central LA': 1253400,\n",
        "        'Westside': 1297759,\n",
        "        'San Fernando Valley': 1764282,\n",
        "        'South LA': 1114964\n",
        "    },\n",
        "    'Chicago': {\n",
        "        'Downtown': 2716000,\n",
        "        'North Side': 1973000,\n",
        "        'South Side': 1745000\n",
        "    }\n",
        "}\n",
        "\n",
        "# City_population = {City : population for (City, SmallTown) in nested_dict.items() for population in SmallTown.values()}\n",
        "# print(City_population)\n",
        "\n",
        "## Unable to solve!"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4ba59c5c-c904-471c-8696-ad39cfe73098",
      "metadata": {
        "id": "4ba59c5c-c904-471c-8696-ad39cfe73098"
      },
      "source": [
        "**Question 10**\n",
        "\n",
        "Write a Python program that takes a list of integers as input, sorts the list in descending order, and returns a list containing only the distinct elements from the sorted list."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ba907256-44c8-4299-ab5c-7a58a6ff91ec",
      "metadata": {
        "id": "ba907256-44c8-4299-ab5c-7a58a6ff91ec",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "18b4744a-e945-4dca-8bea-a4dab18ac52d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3, 4, 5]\n"
          ]
        }
      ],
      "source": [
        "arr = [3, 1, 5, 2, 4, 1, 3, 5]\n",
        "\n",
        "# using .sort(reverse = True), sorting the list in descending order\n",
        "arr.sort(reverse=True)\n",
        "\n",
        "# converting the 'arr' list into set and then again into list, to extract distinct elements\n",
        "distinct_element_list = list(set(arr))\n",
        "print(distinct_element_list)"
      ]
    }
  ],
  "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.11.8"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}