16. Quiz 2 .ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "ED_Quiz 2 (AI and IoT).ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mTSqs5OUSh5l"
      },
      "source": [
        "#1."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3xLJ1P57Sd_G"
      },
      "source": [
        "##Q. Find duplicate\n",
        "Write a function that takes a list as input and returns the element that repeats. (You may assume that atmost one element of the list will repeat.)\n",
        "\n",
        "Eg., l = [1, 2, 3, 1, 4] <br>\n",
        "find_duplicate(l) -> 1\n",
        "l = ['a', 'bar', 'c', 'bar', 'd']\n",
        "find_duplicate(l) -> 'bar'\n",
        "\n",
        "If no element is repeating, then return None"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S8LEYE7AR5Ry"
      },
      "source": [
        "def find_duplicate(l):\n",
        "  c=0\n",
        "  for i in range(0,len(l)):\n",
        "    i=l[0]\n",
        "    l.remove(i)\n",
        "    if(i in l):\n",
        "      return(i)\n",
        "      break\n",
        "    else:\n",
        "      c+=1\n",
        "  if(c==len(l)):\n",
        "    return(None)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yxg6LQh6ThL-"
      },
      "source": [
        "#2."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tCXRnWUXTiz0"
      },
      "source": [
        "##Q. All possible permutations\n",
        "Write a function that takes a string ```s``` and returns a list of all possible permutations of ```s```. (You can put the permutations in any order in the list)\n",
        "\n",
        "Eg., s = 'him' <br>\n",
        "all_possible_permutations(s) = ['him', 'hmi', 'imh', 'ihm', 'mih', 'mhi']"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DfWiJuagU0zZ"
      },
      "source": [
        "from itertools import permutations\n",
        "def all_possible_permutations(s):\n",
        "  perms = [''.join(p) for p in permutations(s)]\n",
        "  return(perms)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QI00BRt5U6kY"
      },
      "source": [
        "#3"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YyaVw4bZU89I"
      },
      "source": [
        "##Q. 4 tuple Sum\n",
        "Write a function that takes two arguments, an integer ```num``` and a list of integers ```l``` and returns a list of all tuples of size ```4``` formed from elements of ```l``` that add up to the number ```num```. (Elements of tuple should be sorted) (Order of tuples in the list may vary)\n",
        "\n",
        "If no such tuples exist, return ```None```\n",
        "\n",
        "Eg., l = [0, 1, 2, 3, 4, 5] <br>\n",
        "n_tuple_sum(l, 5) -> None <br>\n",
        "n_tuple_sum(l, 10) -> [(1, 2, 3, 4), (0, 2, 3, 5), (0, 1, 4, 5)] <br>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QoUgNk1CU6Cn"
      },
      "source": [
        "from itertools import combinations\n",
        "def tuple_sum(l,n):\n",
        "  result=[]\n",
        "  l1=num_of_combination(l)\n",
        "  s=sum_of_combination(l1)\n",
        "  for i in range(len(s)):\n",
        "    if s[i]==n:\n",
        "      result.append(l1[i])\n",
        "  if len(result)==0:\n",
        "    return None\n",
        "  else:\n",
        "    return result\n",
        "def num_of_combination(m):\n",
        "  return list(combinations(m,4))\n",
        "def sum_of_combination(l):\n",
        "  sum_l=[]\n",
        "  for i in range(0,len(l)):\n",
        "    s=0\n",
        "    for j in l[i]:\n",
        "      s+=j\n",
        "    sum_l.append(s)\n",
        "  return sum_l"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R57yKsRMXv0E"
      },
      "source": [
        "#4"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mCWYb75XXxfp"
      },
      "source": [
        "##Q. Count Dictionary\n",
        "Write a function that takes a list ```l``` and returns a dictionary count_dict in which keys are uniuqe elements of ```l``` and corresponding values are count of number of times that element occurs in ```l```\n",
        "\n",
        "Eg., l = [1, 'a', 1, 'b', 1, 'a'] <br>\n",
        "count_dict(l) -> {1: 3, 'a': 2, 'b':1}"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4sz9BSuHZbFG"
      },
      "source": [
        "def count_dict(l):\n",
        "  u= []\n",
        "  d=[]\n",
        "  for x in l:\n",
        "    if x not in u:\n",
        "      u.append(x) \n",
        "  for i in range(0,len(u)):\n",
        "    c=0\n",
        "    for j in range(0,len(l)):\n",
        "      if u[i]==l[j]:\n",
        "        c+=1\n",
        "    d.append(u[i])\n",
        "    d.append(c)\n",
        "  res_dct = {d[i]: d[i + 1] for i in range(0, len(d), 2)} \n",
        "  return(res_dct)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "serUEJ4IZoxc"
      },
      "source": [
        "#5."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rLZnGFuoZs8C"
      },
      "source": [
        "##Q. Map over list\n",
        "Write a function ```mapl``` that takes two arguments - \n",
        "- a list of integers ```l``` \n",
        "- a function ```f``` that takes an integer as argument and returns an integer <br>\n",
        "```mapl``` returns a list in which the elements are obtained by applying f over the elements of ```l```\n",
        "\n",
        "Eg., l = [1, 2, 3, 4]\n",
        "```\n",
        "def square(x):\n",
        "  return x*x\n",
        "```\n",
        "mapl(square, l) -> [1, 4, 9, 16]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b0SlFaBoZq6d"
      },
      "source": [
        "def mapl(f, l):\n",
        "  res_list=[]\n",
        "  for i in l:\n",
        "    res_list.append(f(i))\n",
        "  return res_list"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y6JfyChbS7eD"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}