Ineuron_Python_Advanced_Programming06.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Ineuron_Python_Advanced_Programming06.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AotsmwRPm2Xh"
      },
      "source": [
        "# Ineuron Python Advanced Programming 06"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YvUGBJKunFtF"
      },
      "source": [
        ">Q. 1. You are given two strings s and t. String t is generated by randomly\n",
        "shuffling string s and then adding one more letter at a random position.\n",
        "Return the letter that was added to t.\n",
        "Examples\n",
        "find_the_difference('abcd', 'abcde') ➞ 'e'\n",
        "find_the_difference('', 'y') ➞ 'y'\n",
        "find_the_difference('ae', 'aea') ➞ 'a'"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Yc86A9OImW2O"
      },
      "source": [
        "def find_the_difference(s,t):\n",
        "    sumS = 0\n",
        "    sumT = 0\n",
        "    for i in range(len(s)):\n",
        "        sumS = sumS + (ord(s[i]))\n",
        "    for j in range(len(t)):\n",
        "        sumT = sumT + ord(t[j])\n",
        "    dif = abs(sumS-sumT)\n",
        "    return chr(dif)"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "LnuG3i6QnJ4n",
        "outputId": "8b9bdb8c-4891-47ca-e3a5-265b2ea2bd76"
      },
      "source": [
        "find_the_difference('abcd', 'abcde')\n"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'e'"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "ncuJ4jDMnLM8",
        "outputId": "6a81c0d7-45b9-485a-91af-2fb7446b55a4"
      },
      "source": [
        "find_the_difference('', 'y')\n"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'y'"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "DDs6joHsnMaw",
        "outputId": "a9974fd2-0867-45ec-b669-a9f0beb743f6"
      },
      "source": [
        "find_the_difference('ae', 'aea')\n"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'a'"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sb7q02nrnQEo"
      },
      "source": [
        ">Q. 2. Given a function that accepts unlimited arguments, check and count how\n",
        "many data types are in those arguments. Finally return the total in a list.\n",
        "List order is:\n",
        "[int, str, bool, list, tuple, dictionary]\n",
        "Examples\n",
        "count_datatypes(1, 45, 'Hi', False) ➞ [2, 1, 1, 0, 0, 0]\n",
        "count_datatypes([10, 20], ('t', 'Ok'), 2, 3, 1) ➞ [3, 0, 0, 1, 1, 0]\n",
        "count_datatypes('Hello', 'Bye', True, True, False, {'1': 'One', '2': 'Two'}, [1,\n",
        "3], {'Brayan': 18}, 25, 23) ➞ [2, 2, 3, 1, 0, 2]\n",
        "count_datatypes(4, 21, ('ES', 'EN'), ('a', 'b'), False, [1, 2, 3], [4, 5, 6]) ➞ [2,\n",
        "0, 1, 2, 2, 0]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M42VB_QqnN1h"
      },
      "source": [
        "def count_datatypes(*args):\n",
        "    intCnt = 0\n",
        "    strCnt = 0\n",
        "    boolCnt = 0\n",
        "    listCnt = 0\n",
        "    tupleCnt = 0\n",
        "    dictCnt = 0\n",
        "    count_list = [0,0,0,0,0,0]\n",
        "    for i in args:\n",
        "        if type(i) == int:\n",
        "            count_list[0] += 1\n",
        "        elif type(i) == str:\n",
        "            count_list[1] += 1\n",
        "        elif type(i) == bool:\n",
        "            count_list[2] += 1\n",
        "        elif type(i) == list:\n",
        "            count_list[3] += 1\n",
        "        elif type(i) == tuple:\n",
        "            count_list[4] += 1\n",
        "        elif type(i) == dict:\n",
        "            count_list[5] += 1\n",
        "\n",
        "    print(count_list)"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eF7sFHFGnTZi",
        "outputId": "ca482d36-24b4-410c-9168-d113a78234e6"
      },
      "source": [
        "count_datatypes(1, 45, 'Hi', False)\n"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2, 1, 1, 0, 0, 0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TN-pJI1tnUm_",
        "outputId": "0f26bb58-dd4a-4b0e-a2dd-876e06e3c174"
      },
      "source": [
        "count_datatypes([10, 20], ('t', 'Ok'), 2, 3, 1)\n"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[3, 0, 0, 1, 1, 0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ymi8w6wFnV8c",
        "outputId": "0b9bc2f8-5183-4166-94a6-4104d073cfca"
      },
      "source": [
        "count_datatypes('Hello', 'Bye', True, True, False, {'1': 'One', '2': 'Two'}, [1, 3], {'Brayan': 18}, 25, 23)\n"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2, 2, 3, 1, 0, 2]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6tO8LmJjnXte",
        "outputId": "a3c6b1ff-2294-4f4b-fba3-b159508b5811"
      },
      "source": [
        "count_datatypes(4, 21, ('ES', 'EN'), ('a', 'b'), False, [1, 2, 3], [4, 5, 6])\n"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2, 0, 1, 2, 2, 0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-O52DxkznbUP"
      },
      "source": [
        ">Q. 3. A Fibonacci string is a precedence of the Fibonacci series. It works with\n",
        "any two characters of the English alphabet (as opposed to the numbers 0 and\n",
        "1 in the Fibonacci series) as the initial items and concatenates them together\n",
        "as it progresses in a similar fashion as the Fibonacci series.\n",
        "Examples\n",
        "fib_str(3, ['j', 'h']) ➞ 'j, h, hj'\n",
        "fib_str(5, ['e', 'a']) ➞ 'e, a, ae, aea, aeaae'\n",
        "fib_str(6, ['n', 'k']) ➞ 'n, k, kn, knk, knkkn, knkknknk'"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6jyzzo5vnZH0"
      },
      "source": [
        "def fib_str(num, lst):\n",
        "    num = num-1\n",
        "    count = 0\n",
        "    sum = 0\n",
        "    f1 , f2 = lst[0],lst[1]\n",
        "    fiboStr = []\n",
        "    if num <= 0:\n",
        "        print(\"Not a positive number\")\n",
        "    elif num == 1:\n",
        "        print(\"Fibonacci series upto \",num+1, \":\")        \n",
        "        return a\n",
        "    else:\n",
        "        print(\"Fibonacci series upto \",num+1, \":\")\n",
        "        while count <= num:   \n",
        "            fiboStr.append(f1)\n",
        "            count+=1\n",
        "            if count > num:\n",
        "                return ', '.join(fiboStr)\n",
        "            fth = f2 + f1\n",
        "            f1,f2 = f2, fth"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "id": "9Ak6aG5EneF9",
        "outputId": "890de611-7541-4594-df1a-9af41f6be03d"
      },
      "source": [
        "fib_str(3,['j','h'])\n"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Fibonacci series upto  3 :\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'j, h, hj'"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "id": "OqX6lbE0nfUO",
        "outputId": "7144e8fd-8d33-4374-99ab-abefefc8196f"
      },
      "source": [
        "fib_str(5, ['e', 'a'])\n"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Fibonacci series upto  5 :\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'e, a, ae, aea, aeaae'"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "id": "VGIg8lF8nhSS",
        "outputId": "beca581e-60e2-464f-ba44-6717d41707ef"
      },
      "source": [
        "fib_str(6, ['n', 'k'])\n"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Fibonacci series upto  6 :\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'n, k, kn, knk, knkkn, knkknknk'"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mbDhqiqrnl57"
      },
      "source": [
        ">Q. 4. Given an integer between 0 and 26, make a variable (self.answer). That\n",
        "variable would be assigned to a string in this format:\n",
        "'nines:your answer, threes:your answer, ones:your answer'\n",
        "You need to find out how many ones, threes, and nines it would at least take\n",
        "for the number of each to add up to the given integer when multiplied by one,\n",
        "three or nine (depends).\n",
        "Examples\n",
        "ones_threes_nines(10) ➞ 'nines:1, threes:0, ones:1'\n",
        "ones_threes_nines(15) ➞ 'nines:1, threes:2, ones:0'\n",
        "ones_threes_nines(22) ➞ 'nines:2, threes:1, ones:1'\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a1ViEbmlnljR"
      },
      "source": [
        "def ones_threes_nines(num):\n",
        "    dict = {'nines':0,'threes' : 0,'ones':0 }\n",
        "    strDict = ''\n",
        "    while(num > 0):\n",
        "        if num // 9 > 0:\n",
        "            dict['nines'] = num // 9\n",
        "            num = num % 9\n",
        "        elif num // 3 > 0:\n",
        "            dict['threes'] = num // 3\n",
        "            num = num % 3\n",
        "        else:\n",
        "            dict['ones'] = num // 1\n",
        "            num = num % 1\n",
        "    for k,v in dict.items():\n",
        "        strDict = strDict + k + \":\" + str(v) + \" \"\n",
        "    return ', '.join(strDict.strip().split())"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "ones_threes_nines(10)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "_eQoKOnQeYNz",
        "outputId": "3a52a541-6233-4d9d-a61c-41e5b8f7f73b"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'nines:1, threes:0, ones:1'"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "C58WFR51nrLX",
        "outputId": "f073a8cc-2ba9-4129-8e36-0f67ef180415"
      },
      "source": [
        "ones_threes_nines(15)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'nines:1, threes:2, ones:0'"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "yh2VTEcknsg3",
        "outputId": "2e1372dd-5c07-4a6b-8716-c992a63f5179"
      },
      "source": [
        "ones_threes_nines(22)"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'nines:2, threes:1, ones:1'"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VYvwmzQfnwSw"
      },
      "source": [
        ">Q. 5. The Fibonacci sequence is a classic use case for recursive functions since\n",
        "the value of the sequence at a given index is dependent on the sum of the\n",
        "last two values. However, the recursion tree created by solving the Fibonacci\n",
        "sequence recursively can grow quite fast. Therefore it can be important to\n",
        "think about the implications of running a function recursively. Depending on\n",
        "the size of n needed and the capabilities of the system in question you might\n",
        "want to take a different approach.\n",
        "Write a non-recursive function that takes an integer n and returns the\n",
        "Fibonacci sequence's value at index n.\n",
        "Examples\n",
        "fib(6) ➞ 8\n",
        " 0 + 1 = 1, 1 + 1 = 2, 1 + 2 = 3, 2 + 3 = 5, 3 + 5 = 8\n",
        "fib(1) ➞ 1\n",
        "fib(2) ➞ 1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v4hmCcHMntl-"
      },
      "source": [
        "def fib(num):\n",
        "    count = 0\n",
        "    sum = 0\n",
        "    f1 , f2 = 0,1\n",
        "    if num <= 0:\n",
        "        print(\"Not a positive number\")\n",
        "    elif num == 1:\n",
        "        print(\"nth Fibonacci series upto \",num, \":\")        \n",
        "        return num\n",
        "    else:\n",
        "        print(\"nth Fibonacci series upto \",num, \":\")\n",
        "        while count <= num:   \n",
        "            count+=1\n",
        "            if count > num:\n",
        "                return f1\n",
        "            fth = f1 + f2\n",
        "            f1,f2 = f2, fth"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YtxYq8fVn5K2",
        "outputId": "85f5e474-4b09-4ed3-9b95-0633e532261e"
      },
      "source": [
        "fib(6)\n"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "nth Fibonacci series upto  6 :\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s9tr_0Van6lQ",
        "outputId": "0c3aceca-2ac6-4d85-e414-a5977fe4cebc"
      },
      "source": [
        "fib(1)\n"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "nth Fibonacci series upto  1 :\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CGBfGYvgn72I",
        "outputId": "005540a1-59cf-4aa4-a956-b19e79dd0bbf"
      },
      "source": [
        "fib(2)\n"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "nth Fibonacci series upto  2 :\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    }
  ]
}