Ineuron_Python_Advanced_Programming15.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Ineuron_Python_Advanced_Programming15.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n_F5PMXRY6_S"
      },
      "source": [
        "#Ineuron Python Advanced Programming 15"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BxSo8UMHZAPk"
      },
      "source": [
        ">Q. 1. Write a function that returns True if a given name can generate an array of words.\n",
        "\n",
        "Examples\n",
        "\n",
        "anagram(\"Justin Bieber\", [\"injures\", \"ebb\", \"it\"]) ➞ True\n",
        "\n",
        "anagram(\"Natalie Portman\", [\"ornamental\", \"pita\"]) ➞ True\n",
        "\n",
        "anagram(\"Chris Pratt\", [\"chirps\", \"rat\"]) ➞ False\n",
        "Not all letters are used\n",
        "\n",
        "anagram(\"Jeff Goldblum\", [\"jog\", \"meld\", \"bluffs\"]) ➞ False\n",
        "\"s\" does not exist in the original name"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tbs6tfqpSRZ5"
      },
      "source": [
        "def anagram(s,l):\n",
        "    length = 0\n",
        "    s1=''\n",
        "    for i in l:\n",
        "        length = length+len(i)\n",
        "        if i:\n",
        "            s1 +=i\n",
        "    s1=s1.lower()\n",
        "\n",
        "    s = s.replace(\" \", \"\")\n",
        "    s=s.lower()\n",
        "    if sorted(list(s)) == sorted(list(s1)):\n",
        "        return True\n",
        "    else:\n",
        "        return False"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1eDMfnJbZD1D",
        "outputId": "1f7d1413-4c0e-42e2-f629-a56dd6379e25"
      },
      "source": [
        "anagram(\"Justin Bieber\", [\"injures\", \"ebb\", \"it\"])\n"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uDLVHb_dZFLC",
        "outputId": "7166a9c3-c4a7-4f7a-9629-5476c51b2769"
      },
      "source": [
        "anagram(\"Natalie Portman\", [\"ornamental\", \"pita\"])\n"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SRL3-t3fZGrq",
        "outputId": "31f66a5e-bd4b-48cf-e363-936fbd718083"
      },
      "source": [
        "anagram(\"Chris Pratt\", [\"chirps\", \"rat\"])\n"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2vQuz0EKZH4G",
        "outputId": "66be416e-b261-42cc-9223-e502d618b3a1"
      },
      "source": [
        "anagram(\"Jeff Goldblum\", [\"jog\", \"meld\", \"bluffs\"])\n"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wgg2Ab8XZNCr"
      },
      "source": [
        ">Q. 2. Given an array of users, each defined by an object with the following properties: name, score, reputation create a function that sorts the array to form the correct leaderboard.\n",
        "\n",
        "The leaderboard takes into consideration the score of each user of course, but an emphasis is put on their reputation in the community, so to get the trueScore, you should add the reputation multiplied by 2 to the score.\n",
        "\n",
        "Once you know the trueScore of each user, sort the array according to it in descending ord"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gtamyxt8ZJuA"
      },
      "source": [
        "def leaderboards(l):\n",
        "    p=l\n",
        "    t=[]\n",
        "    j=0\n",
        "    for i in p:\n",
        "        x=(2*i[\"reputation\"]) + i[\"score\"]\n",
        "        t.append(x)\n",
        "        i.update(trueScore = x) \n",
        "    p = sorted(p, key = lambda i: i['trueScore'],reverse=True)\n",
        "    t= sorted(t,reverse=True)\n",
        "    for i in p:\n",
        "        i.pop('trueScore')\n",
        "        print(\"{0} , #trueScore = {1}\".format(p[j], t[j]))\n",
        "        j+=1"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N2lfjx17ZRwo",
        "outputId": "e4bda054-901d-4c10-a12c-17602e1799e0"
      },
      "source": [
        "leaderboards([\n",
        "  { \"name\": \"a\", \"score\": 100, \"reputation\": 20 },\n",
        "  { \"name\": \"b\", \"score\": 90, \"reputation\": 40 },\n",
        "  { \"name\": \"c\", \"score\": 115, \"reputation\": 30 },\n",
        "])"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'name': 'c', 'score': 115, 'reputation': 30} , #trueScore = 175\n",
            "{'name': 'b', 'score': 90, 'reputation': 40} , #trueScore = 170\n",
            "{'name': 'a', 'score': 100, 'reputation': 20} , #trueScore = 140\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CZ2OZMu4ZWQg"
      },
      "source": [
        ">Q. 3. Create a function that, given a phrase and a number of letters guessed, returns a string with hyphens - for every letter of the phrase not guessed, and each letter guessed in place.\n",
        "\n",
        "Examples\n",
        "\n",
        "hangman(\"helicopter\", [\"o\", \"e\", \"s\"]) ➞ \"-e---o--e-\"\n",
        "\n",
        "hangman(\"tree\", [\"r\", \"t\", \"e\"]) ➞ \"tree\"\n",
        "\n",
        "hangman(\"Python rules\", [\"a\", \"n\", \"p\", \"r\", \"z\"]) ➞ \"P----n r----\"\n",
        "\n",
        "hangman(\"He\"s a very naughty boy!\", [\"e\", \"a\", \"y\"]) ➞ \"-e\"- a -e-y -a----y –y!\""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UEn0gQWmZTKU"
      },
      "source": [
        "def hangman(s,l):\n",
        "    Temp = \"\"\n",
        "    for letter in s:\n",
        "        if letter in l:\n",
        "            Temp += letter\n",
        "        else:\n",
        "            Temp += \"-\"\n",
        "    return Temp"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "VxEuQn6rZccD",
        "outputId": "83a9f5db-d2c6-4ba5-e09c-7487eee383f7"
      },
      "source": [
        "hangman(\"helicopter\", [\"o\", \"e\", \"s\"])\n"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'-e---o--e-'"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "wzZfF8mEZdui",
        "outputId": "191255fe-6cc4-4b29-a805-a812859d9642"
      },
      "source": [
        "hangman(\"tree\", [\"r\", \"t\", \"e\"])\n"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'tree'"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "mgqo-xE1ZfH6",
        "outputId": "ff3f68c3-b253-4f13-d9d4-c8d16fd37ab4"
      },
      "source": [
        "hangman(\"Python rules\", [\"a\", \"n\", \"p\", \"r\", \"z\"])\n"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'-----n-r----'"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "fVZ4S2JcZhBH",
        "outputId": "1e2668f9-92f2-43d7-f39c-23db42eb5bd3"
      },
      "source": [
        "hangman(\"He's a very naughty boy!\", [\"e\", \"a\", \"y\"])\n"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'-e---a--e-y--a----y---y-'"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1kFKFjMdZlLb"
      },
      "source": [
        ">Q. 4. The Collatz sequence is as follows:\n",
        "\n",
        "  - Start with some given integer n.\n",
        "  - If it is even, the next number will be n divided by 2.\n",
        "  - If it is odd, multiply it by 3 and add 1 to make the next number.\n",
        "  - The sequence stops when it reaches 1.\n",
        "\n",
        "According to the Collatz conjecture, it will always reach 1. If that's true, you can construct a finite sequence following the aforementioned method for any given integer.\n",
        "\n",
        "Write a function that takes in an integer n and returns the highest integer in the corresponding Collatz sequence."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d1vdiutvZiZO"
      },
      "source": [
        "\n",
        "def max_collatz(n):\n",
        "    l=[]\n",
        "    l.append(n)\n",
        "    while(n!= 1):\n",
        "        if n%2 ==0:\n",
        "            n=int(n/2)\n",
        "        else:\n",
        "            n= (3*n)+1\n",
        "        l.append(n)\n",
        "\n",
        "    print(\"# Collatz sequence:\",l)\n",
        "    return max(l)"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XwwqkSaWZo4b",
        "outputId": "7caa9a16-6d4b-479c-e81d-9e273aee85dd"
      },
      "source": [
        "max_collatz(10)\n"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "# Collatz sequence: [10, 5, 16, 8, 4, 2, 1]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "16"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Nxa6k26tZqFH",
        "outputId": "846dfc76-d3a2-404d-c9af-78fc395caf5f"
      },
      "source": [
        "max_collatz(32)\n"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "# Collatz sequence: [32, 16, 8, 4, 2, 1]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "32"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rpkphfUNZr0D",
        "outputId": "3510ca8c-b70a-4af5-8932-176a175efa24"
      },
      "source": [
        "max_collatz(85)\n"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "# Collatz sequence: [85, 256, 128, 64, 32, 16, 8, 4, 2, 1]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "256"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ke0K8ml5ZyLX"
      },
      "source": [
        ">Q. 5. Write a function that sorts a list of integers by their digit length in descending order, then settles ties by sorting numbers with the same digit length in ascending order.\n",
        "\n",
        "Examples\n",
        "\n",
        "digit_sort([77, 23, 5, 7, 101])\n",
        "➞ [101, 23, 77, 5, 7]\n",
        "\n",
        "digit_sort([1, 5, 9, 2, 789, 563, 444])\n",
        "➞ [444, 563, 789, 1, 2, 5, 9]\n",
        "\n",
        "digit_sort([53219, 3772, 564, 32, 1])\n",
        "➞ [53219, 3772, 564, 32, 1]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LiLAyPc8ZtBT"
      },
      "source": [
        "def digit_sort(l):\n",
        "    l=sorted(l,reverse = True)\n",
        "    l = [str(i) for i in l]\n",
        "    i= len(l)\n",
        "    for k in range (i):\n",
        "        for j in range(0,i-1):\n",
        "            if len(l[j])==len(l[j+1]):\n",
        "                if l[j]>l[j+1]:\n",
        "                    temp = l[j]\n",
        "                    l[j] =l[j+1]\n",
        "                    l[j+1]=temp\n",
        "    return l"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L1JCpN_9Z1Om",
        "outputId": "b14aeb0b-eedd-42ec-8d5b-1551cfc8e803"
      },
      "source": [
        "digit_sort([77, 23, 5, 7, 101])\n"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['101', '23', '77', '5', '7']"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xCByI5NqZ2bH",
        "outputId": "116adb29-1294-4abf-d659-96e2c20ff673"
      },
      "source": [
        "digit_sort([1, 5, 9, 2, 789, 563, 444])\n"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['444', '563', '789', '1', '2', '5', '9']"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EvWMlHkDZ3iB",
        "outputId": "ba1a6169-2cf6-41df-d581-406d5b29c339"
      },
      "source": [
        "digit_sort([53219, 3772, 564, 32, 1])\n"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['53219', '3772', '564', '32', '1']"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    }
  ]
}