scripts.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3f23edd1",
   "metadata": {},
   "source": [
    "#### Say \"Hello, World!\" With Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e87dffb",
   "metadata": {},
   "outputs": [],
   "source": [
    "if __name__ == '__main__':\n",
    "    print(\"Hello, World!\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "beb24e91",
   "metadata": {},
   "source": [
    "#### Arithmetic Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "003ce614",
   "metadata": {},
   "outputs": [],
   "source": [
    "if __name__ == '__main__':\n",
    "    \n",
    "    a = int(input())\n",
    "    b = int(input())\n",
    "    \n",
    "    print(a+b)\n",
    "    print(a-b)\n",
    "    print(a*b)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6303f0a0",
   "metadata": {},
   "source": [
    "#### Python: Division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28bedb7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "if __name__ == '__main__':\n",
    "    a = int(input())\n",
    "    b = int(input())\n",
    "    \n",
    "    print(a//b)\n",
    "    print(a/b)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "048bb132",
   "metadata": {},
   "source": [
    "#### Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d41fd72",
   "metadata": {},
   "outputs": [],
   "source": [
    "if __name__ == '__main__':\n",
    "    n = int(input())\n",
    "    \n",
    "    for x in range(0, n):\n",
    "        print(x*x)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2288ef02",
   "metadata": {},
   "source": [
    "#### Write a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e43fea39",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_leap(year):\n",
    "    leap = False\n",
    "    \n",
    "    if year%4==0 and year%100 != 0 or year%400==0:\n",
    "        leap = True\n",
    "    \n",
    "    return leap\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61ac1c81",
   "metadata": {},
   "source": [
    "#### Print Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3583de5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "if __name__ == '__main__':\n",
    "    n = int(input())\n",
    "    consec = \"\"\n",
    "    for x in range(1,n+1):\n",
    "        consec = consec + str(x)\n",
    "    print (consec)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e58cd868",
   "metadata": {},
   "source": [
    "#### Python If-Else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55a7acd4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/bin/python3\n",
    "\n",
    "import math\n",
    "import os\n",
    "import random\n",
    "import re\n",
    "import sys\n",
    "\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    n = int(input().strip())\n",
    "    \n",
    "    if n%2!=0 : print(\"Weird\")\n",
    "    elif n in range(2,6) : print(\"Not Weird\")\n",
    "    elif n in range(6,21) : print(\"Weird\")\n",
    "    elif n>20: print(\"Not Weird\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6f4702b",
   "metadata": {},
   "source": [
    "#### Find the Runner-Up Score!  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48bd54fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "if __name__ == '__main__':\n",
    "    n = int(input())\n",
    "    arr = list(map(int, input().split()))\n",
    "    #listone = list(arr)\n",
    "    #listone.sort()\n",
    "    #app = 0\n",
    "    \n",
    "    #for i in listone:\n",
    "    #    if app < i:\n",
    "    #        c = app\n",
    "    #        app = i\n",
    "    #print (c)\n",
    "    print(max([x for x in arr if x != max(arr)]))\n",
    " \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d2e44c7",
   "metadata": {},
   "source": [
    "#### Finding the percentage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26095018",
   "metadata": {},
   "outputs": [],
   "source": [
    "if __name__ == '__main__':\n",
    "    n = int(input())\n",
    "    student_marks = {}\n",
    "    for _ in range(n):\n",
    "        name, *line = input().split()\n",
    "        scores = list(map(float, line))\n",
    "        student_marks[name] = scores\n",
    "    query_name = input()\n",
    "    \n",
    "    if query_name in student_marks:\n",
    "        somma = 0\n",
    "        voti = student_marks[query_name]\n",
    "        for votes in voti: \n",
    "            somma = votes + somma\n",
    "        avg = somma/len(voti)\n",
    "        \n",
    "        print(\"{:.2f}\".format(avg))\n",
    "        \n",
    "    else: print(\"No name found\")\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d18bb38",
   "metadata": {},
   "source": [
    "#### List Comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c116154",
   "metadata": {},
   "outputs": [],
   "source": [
    "if __name__ == '__main__':\n",
    "    x = int(input())\n",
    "    y = int(input())\n",
    "    z = int(input())\n",
    "    n = int(input())\n",
    "    \n",
    "    results = [[i,j,k] for i in range(0, x+1) for j in range(0, y+1) for k in range(0, z+1) if i+j+k != n]\n",
    "    print(results)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89f7968c",
   "metadata": {},
   "source": [
    "#### String Split and Join"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5575f01",
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_and_join(line):\n",
    "    line = \"-\".join(line.split())\n",
    "    return line\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2700edee",
   "metadata": {},
   "source": [
    "#### What's Your Name?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e75d453",
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# Complete the 'print_full_name' function below.\n",
    "#\n",
    "# The function is expected to return a STRING.\n",
    "# The function accepts following parameters:\n",
    "#  1. STRING first\n",
    "#  2. STRING last\n",
    "#\n",
    "\n",
    "def print_full_name(first, last):\n",
    "    print(\"Hello {} {}! You just delved into python.\".format(first, last))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c484939",
   "metadata": {},
   "source": [
    "#### Mutations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89371e4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def mutate_string(string, position, character):\n",
    "    s = list(string)\n",
    "    s[position] = character\n",
    "    string = ''.join(s)\n",
    "    return string\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "536020d3",
   "metadata": {},
   "source": [
    "#### Find a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b8971c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_substring(string, sub_string):\n",
    "    count = 0\n",
    "    for i in range (0, len(string)):\n",
    "        if string[i: i+len(sub_string)] == sub_string:\n",
    "            count+=1\n",
    "    return count\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40db287e",
   "metadata": {},
   "source": [
    "#### String Validators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1330e248",
   "metadata": {},
   "outputs": [],
   "source": [
    "if __name__ == '__main__':\n",
    "    s = input()\n",
    "\n",
    "    print(any([strin.isalnum() for strin in s]))\n",
    "    print(any([strin.isalpha() for strin in s]))\n",
    "    print(any([strin.isdigit() for strin in s]))\n",
    "    print(any([strin.islower() for strin in s]))\n",
    "    print(any([strin.isupper() for strin in s]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7dc68760",
   "metadata": {},
   "source": [
    "#### sWAP cASE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9986d488",
   "metadata": {},
   "outputs": [],
   "source": [
    "def swap_case(s):\n",
    "    \n",
    "    return (s.swapcase())\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3370efdb",
   "metadata": {},
   "source": [
    "#### Text Alignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd4fa4a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Replace all ______ with rjust, ljust or center. \n",
    "\n",
    "thickness = int(input()) #This must be an odd number\n",
    "c = 'H'\n",
    "\n",
    "#Top Cone\n",
    "for i in range(thickness):\n",
    "    print((c*i).rjust(thickness-1)+c+(c*i).ljust(thickness-1))\n",
    "\n",
    "#Top Pillars\n",
    "for i in range(thickness+1):\n",
    "    print((c*thickness).center(thickness*2)+(c*thickness).center(thickness*6))\n",
    "\n",
    "#Middle Belt\n",
    "for i in range((thickness+1)//2):\n",
    "    print((c*thickness*5).center(thickness*6))    \n",
    "\n",
    "#Bottom Pillars\n",
    "for i in range(thickness+1):\n",
    "    print((c*thickness).center(thickness*2)+(c*thickness).center(thickness*6))    \n",
    "\n",
    "#Bottom Cone\n",
    "for i in range(thickness):\n",
    "    print(((c*(thickness-i-1)).rjust(thickness)+c+(c*(thickness-i-1)).ljust(thickness)).rjust(thickness*6))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11a31f49",
   "metadata": {},
   "source": [
    "#### Text Wrap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8350be75",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def wrap(string, max_width):\n",
    "    #textwrap.fill(textwrap.wrap(string, max_width))\n",
    "    return (textwrap.fill(string, max_width))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9e11534",
   "metadata": {},
   "source": [
    "#### Capitalize!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db122ba5",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import string\n",
    "\n",
    "# Complete the solve function below.\n",
    "def solve(s):\n",
    "    l = s.split(' ')\n",
    "    res = []\n",
    "    for w in l:\n",
    "        res.append(w.capitalize())\n",
    "    return ' '.join(res)\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71c6bb61",
   "metadata": {},
   "source": [
    "#### String Formatting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc4b3f54",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_formatted(number):\n",
    "    \n",
    "    l1 = len(bin(number)[2:])\n",
    "    \n",
    "    for i in range(1,number+1):\n",
    "        print(str(i).rjust(l1,' '),end=\" \")\n",
    "        print(oct(i)[2:].rjust(l1,' '),end=\" \")\n",
    "        print(((hex(i)[2:]).upper()).rjust(l1,' '),end=\" \")\n",
    "        print(bin(i)[2:].rjust(l1,' '),end=\"\\n\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1bd5bf2",
   "metadata": {},
   "source": [
    "#### String Formatting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73062acb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_formatted(number):\n",
    "    \n",
    "    l1 = len(bin(number)[2:])\n",
    "    \n",
    "    for i in range(1,number+1):\n",
    "        print(str(i).rjust(l1,' '),end=\" \")\n",
    "        print(oct(i)[2:].rjust(l1,' '),end=\" \")\n",
    "        print(((hex(i)[2:]).upper()).rjust(l1,' '),end=\" \")\n",
    "        print(bin(i)[2:].rjust(l1,' '),end=\"\\n\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08353912",
   "metadata": {},
   "source": [
    "#### Alphabet Rangoli"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ad234c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import string\n",
    "\n",
    "def print_rangoli(size):\n",
    "    \n",
    "    design = string.ascii_lowercase\n",
    "    L = []\n",
    "    for i in range(n):\n",
    "        s = \"-\".join(design[i:n])\n",
    "        L.append((s[::-1]+s[1:]).center(4*n-3, \"-\"))\n",
    "        \n",
    "    print('\\n'.join(L[:0:-1]+L))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "036a57b8",
   "metadata": {},
   "source": [
    "#### Alphabet Rangoli"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00ad1a9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import string\n",
    "\n",
    "def print_rangoli(size):\n",
    "    \n",
    "    design = string.ascii_lowercase\n",
    "    L = []\n",
    "    for i in range(n):\n",
    "        s = \"-\".join(design[i:n])\n",
    "        L.append((s[::-1]+s[1:]).center(4*n-3, \"-\"))\n",
    "        \n",
    "    print('\\n'.join(L[:0:-1]+L))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bb0edc2",
   "metadata": {},
   "source": [
    "#### Designer Door Mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a814c5bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "altezza, lunghezza = map(int, input().split())\n",
    "for i in range(altezza//2):\n",
    "    s = '.|.'*(i*2+1)\n",
    "    print(s.center(lunghezza, '-'))\n",
    "print('WELCOME'.center(lunghezza, '-'))\n",
    "for i in range(altezza //2-1, -1,-1):\n",
    "    s = '.|.'*(i*2+1)\n",
    "    print(s.center(lunghezza, '-'))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1aac53d",
   "metadata": {},
   "source": [
    "#### Introduction to Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3882c05f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def average(array):\n",
    "    somma = sum(set(array))\n",
    "    num = len(set(array))\n",
    "    return (somma/num)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35f89455",
   "metadata": {},
   "source": [
    "#### Set .add() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16be109d",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input())\n",
    "\n",
    "c = set()\n",
    "\n",
    "for i in range(n):\n",
    "    c.add(input())\n",
    "    \n",
    "print(len(c))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4cc4e4b",
   "metadata": {},
   "source": [
    "#### Set .discard(), .remove() & .pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acb13720",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input())\n",
    "s = set(map(int, input().split()))\n",
    "for i in range(int(input())):\n",
    "    string = input().split()\n",
    "    if string[0] == 'pop':\n",
    "        s.pop()\n",
    "    elif string[0] == 'remove':\n",
    "        s.remove(int(string[1]))\n",
    "    elif string[0] == 'discard':\n",
    "        s.discard(int(string[1]))\n",
    "print(sum(s))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b71c258f",
   "metadata": {},
   "source": [
    "#### Set .union() Operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8bee967a",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = input()\n",
    "a=set(input().split())\n",
    "n = input()\n",
    "b=set(input().split())\n",
    "print(len(a.union(b)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc41ac6c",
   "metadata": {},
   "source": [
    "#### Set .union() Operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fde695ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = input()\n",
    "a=set(input().split())\n",
    "n = input()\n",
    "b=set(input().split())\n",
    "print(len(a.union(b)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0d4538c",
   "metadata": {},
   "source": [
    "#### Set .intersection() Operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d76426ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input())\n",
    "set1 = set(input().split())\n",
    "n = int(input())\n",
    "set2 = set(input().split())\n",
    "print(len(set1.intersection(set2)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82fb6db7",
   "metadata": {},
   "source": [
    "#### Set .difference() Operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca4508e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = input()\n",
    "set1 = set(input().split())\n",
    "n = input()\n",
    "set2 = set(input().split())\n",
    "print(len(set1.difference(set2)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c513f40",
   "metadata": {},
   "source": [
    "#### Set .symmetric_difference() Operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a7a3a11",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = input()\n",
    "set1 = set(input().split())\n",
    "n = input()\n",
    "set2 = set(input().split())\n",
    "print(len(set1.symmetric_difference(set2)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a2d0e25",
   "metadata": {},
   "source": [
    "#### Set Mutations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e24cc466",
   "metadata": {},
   "outputs": [],
   "source": [
    "a=int(input())\n",
    "s=set(map(int,input().split()))\n",
    "n=int(input())\n",
    "\n",
    "for i in range(n):\n",
    "    x,y=input().split()\n",
    "    if x=='intersection_update':\n",
    "       s.intersection_update(set(map(int,input().split())))\n",
    "    \n",
    "    elif x=='update':\n",
    "        s.update(set(map(int,input().split())))    \n",
    "    \n",
    "    elif x=='symmetric_difference_update':\n",
    "        s.symmetric_difference_update(set(map(int,input().split())))\n",
    "    \n",
    "    elif x=='difference_update':\n",
    "        s.difference_update(set(map(int,input().split())))\n",
    "\n",
    "print(sum(s))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24803dde",
   "metadata": {},
   "source": [
    "#### Set Mutations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ae33e58",
   "metadata": {},
   "outputs": [],
   "source": [
    "a=int(input())\n",
    "s=set(map(int,input().split()))\n",
    "n=int(input())\n",
    "\n",
    "for i in range(n):\n",
    "    x,y=input().split()\n",
    "    if x=='intersection_update':\n",
    "       s.intersection_update(set(map(int,input().split())))\n",
    "    \n",
    "    elif x=='update':\n",
    "        s.update(set(map(int,input().split())))    \n",
    "    \n",
    "    elif x=='symmetric_difference_update':\n",
    "        s.symmetric_difference_update(set(map(int,input().split())))\n",
    "    \n",
    "    elif x=='difference_update':\n",
    "        s.difference_update(set(map(int,input().split())))\n",
    "\n",
    "print(sum(s))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cf14f02",
   "metadata": {},
   "source": [
    "#### Symmetric Difference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ecedc65",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = input()\n",
    "s = set(map(int,input().split()))\n",
    "n = input()\n",
    "z = set(map(int,input().split()))\n",
    "print(*sorted(s.symmetric_difference(z)), sep='\\n')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a189788",
   "metadata": {},
   "source": [
    "#### Check Subset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3d86cd4",
   "metadata": {},
   "outputs": [],
   "source": [
    "T =int(input())\n",
    "for i in range(T):\n",
    "    n=input()\n",
    "    A = set(input().split())\n",
    "    n =input()\n",
    "    B = set(input().split())\n",
    "    C = set(A.union(B))\n",
    "    if (C == B):\n",
    "        print(\"True\")\n",
    "    else:\n",
    "        print(\"False\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e650dae8",
   "metadata": {},
   "source": [
    "#### Check Strict Superset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8dbbe0cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = set(map(int, input().split()))\n",
    "n=int(input())\n",
    "x = \"True\"\n",
    "\n",
    "for i in range(n):\n",
    "    s2 = set(map(int, input().split()))\n",
    "    if not s2.issubset(s):\n",
    "        x=\"False\"\n",
    "        \n",
    "print(x)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69970cf2",
   "metadata": {},
   "source": [
    "#### itertools.permutations()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8c88c5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import permutations\n",
    "\n",
    "n = input().split()\n",
    "txt = n[0]\n",
    "num = int(n[1])\n",
    "perm = sorted(list(permutations(txt, num)))\n",
    "for i in range(len(perm)):\n",
    "    p = perm[i]\n",
    "    print((''.join(p)), end='\\n')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8df40611",
   "metadata": {},
   "source": [
    "#### itertools.combinations()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3734148a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import combinations\n",
    "s , n  = input().split()\n",
    "\n",
    "for i in range(1, int(n)+1):\n",
    "    for j in combinations(sorted(s), i):\n",
    "        print(''.join(j))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0acc246b",
   "metadata": {},
   "source": [
    "#### itertools.combinations_with_replacement()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d22fa7fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import combinations_with_replacement\n",
    "\n",
    "S,k = input().split()\n",
    "k = int(k)\n",
    "\n",
    "print ('\\n'.join(sorted(''.join(sorted(c)) for c in combinations_with_replacement(S,k))))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "855491ca",
   "metadata": {},
   "source": [
    "#### DefaultDict Tutorial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fce01005",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "d = defaultdict(list)\n",
    "n,m = map(int, input().split())\n",
    "for i in range(1,n+1):\n",
    "    d[input()].append(str(i))\n",
    "for i in range(m):\n",
    "    b = input()\n",
    "    if b in d: print(' '.join(d[b]))\n",
    "    else: print(-1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56aadca9",
   "metadata": {},
   "source": [
    "#### Collections.namedtuple()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02f00f06",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import namedtuple\n",
    "\n",
    "n = int(input())\n",
    "fields = input().split()\n",
    "tot = 0\n",
    "for i in range(n):\n",
    "    students = namedtuple('student', fields)\n",
    "    MARKS, CLASS, NAME, ID = input().split()\n",
    "    student = students(MARKS, CLASS, NAME, ID)\n",
    "    tot += int(student.MARKS)\n",
    "print('{:.2f}'.format(tot/n))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b1d63f7",
   "metadata": {},
   "source": [
    "#### Collections.OrderedDict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a38ca196",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import OrderedDict\n",
    "n = int(input())\n",
    "order = OrderedDict()\n",
    "for _ in range(n):\n",
    "    item, item2, price = input().rpartition(' ')\n",
    "    order[item] = order.get(item, 0) + int(price)\n",
    "for item, price in order.items():\n",
    "    print(item, price)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3171919b",
   "metadata": {},
   "source": [
    "#### Word Order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8a0da9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import OrderedDict;\n",
    "\n",
    "n = int(input())\n",
    "d = OrderedDict()\n",
    "\n",
    "for i in range(n):\n",
    "    word = input()\n",
    "    if word in d:\n",
    "        d[word] +=1\n",
    "    else:\n",
    "        d[word] = 1\n",
    "\n",
    "print(len(d));\n",
    "\n",
    "for key, value in d.items():\n",
    "    print(value, end = \" \");\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99984a96",
   "metadata": {},
   "source": [
    "#### Collections.deque()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80b34875",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "\n",
    "n = int(input())\n",
    "d=deque()\n",
    "\n",
    "for i in range(n):\n",
    "    text = input().split()\n",
    "    if text[0] == 'append': d.append(text[1])\n",
    "    elif text[0] == 'popleft': d.popleft()\n",
    "    elif text[0] == 'appendleft': d.appendleft(text[1])\n",
    "    elif text[0] == 'pop': d.pop()\n",
    "print(' '.join(d))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f4d84ef",
   "metadata": {},
   "source": [
    "#### Collections.deque()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c80c3f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "\n",
    "n = int(input())\n",
    "d=deque()\n",
    "\n",
    "for i in range(n):\n",
    "    text = input().split()\n",
    "    if text[0] == 'append': d.append(text[1])\n",
    "    elif text[0] == 'popleft': d.popleft()\n",
    "    elif text[0] == 'appendleft': d.appendleft(text[1])\n",
    "    elif text[0] == 'pop': d.pop()\n",
    "print(' '.join(d))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "628f916f",
   "metadata": {},
   "source": [
    "#### Piling Up!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21cecaae",
   "metadata": {},
   "outputs": [],
   "source": [
    "ANS = []\n",
    "T = int(input())\n",
    "for _ in range(T):\n",
    "    n = int(input())\n",
    "    sl = list(map(int, input().split()))\n",
    "    for _ in range(n-1):\n",
    "        if sl[0] >= sl[len(sl)-1]:\n",
    "            a = sl[0]\n",
    "            sl.pop(0)\n",
    "        elif sl[0] < sl[len(sl)-1]:\n",
    "            a = sl[len(sl)-1]\n",
    "            sl.pop(len(sl)-1)\n",
    "        else:\n",
    "            pass\n",
    "        if len(sl) == 1:\n",
    "            ANS.append(\"Yes\")\n",
    "        if((sl[0] > a) or (sl[len(sl)-1] > a)):\n",
    "            ANS.append(\"No\")\n",
    "            break\n",
    "print(\"\\n\".join(ANS))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ab7151f",
   "metadata": {},
   "source": [
    "#### Company Logo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b0e31a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/bin/python3\n",
    "\n",
    "import math\n",
    "import os\n",
    "import random\n",
    "import re\n",
    "import sys\n",
    "from collections import Counter\n",
    "\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    s = input()\n",
    "    s = sorted(s)\n",
    "    \n",
    "    freq = Counter(list(s))\n",
    "    \n",
    "    for key, value in freq.most_common(3):\n",
    "        print(key, value)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f23175da",
   "metadata": {},
   "source": [
    "#### Calendar Module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "091255ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "import calendar\n",
    "\n",
    "date = input().split()\n",
    "dd = int(date[1])\n",
    "mm = int(date[0])\n",
    "yy = int(date[2])\n",
    "print((calendar.day_name[calendar.weekday(yy, mm, dd)]).upper())\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef98b191",
   "metadata": {},
   "source": [
    "#### Time Delta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f273503e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/bin/python3\n",
    "\n",
    "import math\n",
    "import os\n",
    "import random\n",
    "import re\n",
    "import sys\n",
    "import datetime\n",
    "\n",
    "def time_delta(t1, t2):\n",
    "    \n",
    "    format_string = \"%a %d %b %Y %H:%M:%S %z\"\n",
    "    parsed_t1 = datetime.datetime.strptime(t1, format_string)\n",
    "    parsed_t2 = datetime.datetime.strptime(t2, format_string)\n",
    "    diff = parsed_t2 - parsed_t1\n",
    "    return (str(int(abs(diff.total_seconds()))))\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    fptr = open(os.environ['OUTPUT_PATH'], 'w')\n",
    "\n",
    "    t = int(input())\n",
    "\n",
    "    for t_itr in range(t):\n",
    "        t1 = input()\n",
    "\n",
    "        t2 = input()\n",
    "\n",
    "        delta = time_delta(t1, t2)\n",
    "\n",
    "        fptr.write(delta + '\\n')\n",
    "\n",
    "    fptr.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5144a30",
   "metadata": {},
   "source": [
    "#### Exceptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd2007db",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input())\n",
    "for i in range(n):\n",
    "    try:\n",
    "        a, b = map(int, input().split())\n",
    "        print(a//b)\n",
    "    except Exception as e:\n",
    "        print (\"Error Code:\", e)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3ecc595",
   "metadata": {},
   "source": [
    "#### Tuples "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00d9600c",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input())\n",
    "print(hash(tuple(map(int, input().split()))))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96872224",
   "metadata": {},
   "source": [
    "#### Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "863008c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "if __name__ == '__main__':\n",
    "    output = []\n",
    "    for i in range(int(input())):\n",
    "        inp = input().split();\n",
    "        if inp[0] == \"print\": print(output)\n",
    "        elif inp[0] == \"insert\": output.insert(int(inp[1]),int(inp[2]))\n",
    "        elif inp[0] == \"remove\": output.remove(int(inp[1]))\n",
    "        elif inp[0] == \"pop\": output.pop();\n",
    "        elif inp[0] == \"append\": output.append(int(inp[1]))\n",
    "        elif inp[0] == \"sort\": output.sort();\n",
    "        else: output.reverse();\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbfdc3cf",
   "metadata": {},
   "source": [
    "#### Nested Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94b0bbd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "score_list = [];\n",
    "for _ in range(int(input())):\n",
    "    name = input()\n",
    "    score = float(input())\n",
    "    score_list.append([name, score])\n",
    "    \n",
    "second_highest = sorted(set([score for name, score in score_list]))[1]\n",
    "\n",
    "print('\\n'.join(sorted([name for name, score in score_list if score == second_highest])))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e1f44b1",
   "metadata": {},
   "source": [
    "#### Zipped!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "918c38fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "n,x = map(int, input().split())\n",
    "marks = []\n",
    "for i in range(x):\n",
    "    marks.append(map(float, input().split()))\n",
    "for i in zip(*marks):\n",
    "    print(sum(i)/len(i))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9187e7d8",
   "metadata": {},
   "source": [
    "#### Map and Lambda Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17d37845",
   "metadata": {},
   "outputs": [],
   "source": [
    "cube = lambda x: x**3\n",
    "\n",
    "def fibonacci(n):\n",
    "    n1, n2 = 0, 1\n",
    "    a=[n1,n2]\n",
    "    if n>1:\n",
    "        for i in range(2,n):\n",
    "            n3 = n1 + n2\n",
    "            n1 = n2\n",
    "            n2 = n3\n",
    "            a.append(n3)  \n",
    "        return(a)\n",
    "    elif n==1:\n",
    "        return[n1]\n",
    "    else:\n",
    "        return[]\n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34f94501",
   "metadata": {},
   "source": [
    "#### XML 1 - Find the Score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71565ca3",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def get_attr_number(node):\n",
    "    s = 0\n",
    "    for elem in node.iter():\n",
    "        t = elem.attrib\n",
    "        s += len(t)\n",
    "    return s\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2c02533",
   "metadata": {},
   "source": [
    "#### Re.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74053962",
   "metadata": {},
   "outputs": [],
   "source": [
    "regex_pattern = r\",|\\.\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f813646f",
   "metadata": {},
   "source": [
    "#### XML2 - Find the Maximum Depth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c64917df",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "maxdepth = 0\n",
    "def depth(elem, level):\n",
    "    global maxdepth\n",
    "    if level == maxdepth :\n",
    "        maxdepth+=1\n",
    "    for child in elem:\n",
    "        depth(child, level+1)\n",
    "            \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe3d8c52",
   "metadata": {},
   "source": [
    "#### Re.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33045b5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "regex_pattern = r\",|\\.\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "109afdf2",
   "metadata": {},
   "source": [
    "#### Group(), Groups() & Groupdict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1815707f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "n = input()\n",
    "\n",
    "txt = re.findall(r\"([A-Za-z0-9])\\1+\", n)\n",
    "if len(txt)==0: print(-1)\n",
    "else: print(txt[0])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6779e633",
   "metadata": {},
   "source": [
    "#### Re.findall() & Re.finditer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13fcf1b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "n = input()\n",
    "txt = re.findall(r'(?<=[qwrtypsdfghjklzxcvbnm])([aeiou]{2,})(?=[qwrtypsdfghjklzxcvbnm])',n,re.IGNORECASE)\n",
    "\n",
    "if txt:\n",
    "    for i in txt:\n",
    "        print(i)\n",
    "else:\n",
    "    print(-1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adda1a1f",
   "metadata": {},
   "source": [
    "#### Detect Floating Point Number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84631f52",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "n = int(input())\n",
    "for x in range(n):\n",
    "    print(re.search(r'^([-\\+])?\\d*\\.\\d+$', input()) is not None)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0861c694",
   "metadata": {},
   "source": [
    "#### Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c668ed3",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def arrays(arr):\n",
    "    arr2 = numpy.array(arr[::-1], float)\n",
    "    return arr2\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7d67cff",
   "metadata": {},
   "source": [
    "#### Shape and Reshape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02ef4c9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "\n",
    "\n",
    "myarr = numpy.array(input().split(), int)\n",
    "print (numpy.reshape(myarr, (3,3)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "192e101b",
   "metadata": {},
   "source": [
    "#### Transpose and Flatten"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05f57020",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "\n",
    "row, col = input().split()\n",
    "myarr = numpy.array([input().split() for i in range(int(row))], int)\n",
    "myarrt = numpy.transpose(myarr)\n",
    "print(myarrt)\n",
    "print(myarr.flatten())\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37ad68ac",
   "metadata": {},
   "source": [
    "#### Concatenate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6608fca",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "\n",
    "dimA, dimB, dimC = input().split()\n",
    "arrayA = numpy.array([input().split() for i in range(int(dimA))], int)\n",
    "arrayB = numpy.array([input().split() for i in range(int(dimB))], int)\n",
    "arrayC = numpy.concatenate((arrayA, arrayB),axis =0)\n",
    "print(arrayC)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a065c8b",
   "metadata": {},
   "source": [
    "#### Zeros and Ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "734459af",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "\n",
    "nums = tuple(map(int, input().split()))\n",
    "print (numpy.zeros(nums, dtype = int))\n",
    "print (numpy.ones(nums, dtype = int))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a875ebe",
   "metadata": {},
   "source": [
    "#### Eye and Identity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72655989",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "np.set_printoptions(legacy='1.13')\n",
    "\n",
    "n,m = map(int, input().split())\n",
    "\n",
    "print(np.eye(n,m, k=0))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a96002ee",
   "metadata": {},
   "source": [
    "#### Array Mathematics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd0e5cf7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "n,m = map(int, input().split())\n",
    "a = np.array([input().split() for i in range(n)], int)\n",
    "b = np.array([input().split() for i in range(n)], int)\n",
    "\n",
    "print (np.add(a,b))\n",
    "print (np.subtract(a,b))\n",
    "print (np.multiply(a,b))\n",
    "print (np.floor_divide(a,b))\n",
    "print (np.mod(a,b))\n",
    "print (np.power(a,b))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb451ee2",
   "metadata": {},
   "source": [
    "#### Floor, Ceil and Rint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea4da4b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "np.set_printoptions(legacy = '1.13')\n",
    "n = input().split()\n",
    "myarr = np.array(n, dtype=float)\n",
    "\n",
    "print(np.floor(myarr))\n",
    "print(np.ceil(myarr))\n",
    "print(np.rint(myarr))\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59bcf6dc",
   "metadata": {},
   "source": [
    "#### Sum and Prod"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75faac1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "\n",
    "n,m = map(int, input().split())\n",
    "a = numpy.array([input().split() for _ in range(n)],int)\n",
    "print(numpy.prod(numpy.sum(a, axis=0), axis=0))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec468c53",
   "metadata": {},
   "source": [
    "#### Min and Max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2385bc2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "n, m = map(int,input().split())\n",
    "lista = [list (map (int, input().split())) for i in range(n)]\n",
    "arr=np.array(lista)\n",
    "\n",
    "print(max(np.min(arr, axis=1)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86dc86a2",
   "metadata": {},
   "source": [
    "#### Dot and Cross"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b908816",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "n = int(input())\n",
    "\n",
    "matA = np.array([input().split() for i in range(n)], dtype=int)\n",
    "matB = np.array([input().split() for i in range(n)], dtype=int)\n",
    "\n",
    "print(np.dot(matA, matB))\n",
    "    \n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd29a7fe",
   "metadata": {},
   "source": [
    "#### Inner and Outer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0c87fd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "A = np.array([input().split()], dtype=int)\n",
    "B = np.array([input().split()], dtype=int)\n",
    "\n",
    "print (int(np.inner(A,B)))\n",
    "print (np.outer(A,B))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e4da1ef",
   "metadata": {},
   "source": [
    "#### Inner and Outer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ab795e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "A = np.array([input().split()], dtype=int)\n",
    "B = np.array([input().split()], dtype=int)\n",
    "\n",
    "print (int(np.inner(A,B)))\n",
    "print (np.outer(A,B))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08e40e72",
   "metadata": {},
   "source": [
    "#### Polynomials"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf621679",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "poly = list(map(float, input().split()))\n",
    "x = float(input())\n",
    "\n",
    "print(float(np.polyval(poly, x)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "623239f9",
   "metadata": {},
   "source": [
    "#### Linear Algebra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5bc0e994",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "n = int(input())\n",
    "mat = np.array([input().split()for i in range(n)], dtype= float)\n",
    "\n",
    "print(round(np.linalg.det(mat),2))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a73d3bf",
   "metadata": {},
   "source": [
    "#### collections.Counter()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbba8da0",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input())\n",
    "lista = list(map(int,input().split()))\n",
    "n2 = int(input())\n",
    "somma = 0\n",
    "for _ in range(n2):\n",
    "    a, b = tuple(map(int,input().split()))\n",
    "    if a in lista:\n",
    "        somma += b\n",
    "        lista.remove(a)\n",
    "print(somma)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfb4a107",
   "metadata": {},
   "source": [
    "#### No Idea!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c84e299c",
   "metadata": {},
   "outputs": [],
   "source": [
    "happiness = 0\n",
    "n, m = map(int,input().split())\n",
    "a = list(map(int,input().split()))\n",
    "A = set(map(int,input().split()))\n",
    "B = set(map(int,input().split()))\n",
    "\n",
    "\n",
    "for x in a:\n",
    "    if x in A and x not in B:\n",
    "        happiness += 1\n",
    "    elif x in B and x not in A:\n",
    "        happiness -= 1\n",
    "    else:\n",
    "        pass\n",
    "print(happiness)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c194f833",
   "metadata": {},
   "source": [
    "#### Merge the Tools!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42894a72",
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_the_tools(string, k):\n",
    "    for i in range(0, len(string), k):\n",
    "        output = ''\n",
    "        for x in range(i, i+k):\n",
    "            if string[x] not in output:\n",
    "                output += string[x]\n",
    "        print(output)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7da46e29",
   "metadata": {},
   "source": [
    "#### Decorators 2 - Name Directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "220de1cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def person_lister(f):\n",
    "    def inner(people):\n",
    "        for x in people:\n",
    "            x[2] = int(x[2])\n",
    "        people.sort(key=operator.itemgetter(2))\n",
    "        return[f(i) for i in people]\n",
    "    return inner\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "918d7f1d",
   "metadata": {},
   "source": [
    "#### Validating phone numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8e0d1cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input())\n",
    "arr = [input() for i in range(n)]\n",
    "for num in arr:\n",
    "    if len(num)==10 and num[0] in ['7','8','9'] and num.isnumeric() == True:            result = 'YES' \n",
    "    else: result = 'NO' \n",
    "    print(result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce663e38",
   "metadata": {},
   "source": [
    "#### Validating and Parsing Email Addresses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45d5625b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "pattern = re.compile(r\"<[a-z][a-zA-Z0-9\\-\\.\\_]+\\@[a-zA-Z]+\\.[a-zA-Z]{1,3}>\")\n",
    "\n",
    "\n",
    "for i in range(int(input())):\n",
    "    s = input().split()\n",
    "    m = pattern.search(s[1])\n",
    "    if m:\n",
    "        print(s[0], m.string)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5fe6c06",
   "metadata": {},
   "source": [
    "#### Hex Color Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac18d416",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "pattern = re.compile(r\"[\\s:](#(?:[0-9A-Fa-f]{3}){1,2})\")\n",
    "n = int(input())\n",
    "\n",
    "for i in range(n):\n",
    "    s = input()\n",
    "    m = pattern.findall(s)\n",
    "    for i in m:\n",
    "        print(i)\n",
    "   \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3e66c65",
   "metadata": {},
   "source": [
    "#### Birthday Cake Candles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44350dd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/bin/python3\n",
    "\n",
    "import math\n",
    "import os\n",
    "import random\n",
    "import re\n",
    "import sys\n",
    "\n",
    "#\n",
    "# Complete the 'birthdayCakeCandles' function below.\n",
    "#\n",
    "# The function is expected to return an INTEGER.\n",
    "# The function accepts INTEGER_ARRAY candles as parameter.\n",
    "#\n",
    "\n",
    "def birthdayCakeCandles(candles):\n",
    "    tot = 0\n",
    "    maxalt = max(candles)\n",
    "    for i in range(len(candles)):\n",
    "        if candles[i] == maxalt: tot +=1\n",
    "    return tot\n",
    "    \n",
    "if __name__ == '__main__':\n",
    "    fptr = open(os.environ['OUTPUT_PATH'], 'w')\n",
    "\n",
    "    candles_count = int(input().strip())\n",
    "\n",
    "    candles = list(map(int, input().rstrip().split()))\n",
    "\n",
    "    result = birthdayCakeCandles(candles)\n",
    "\n",
    "    fptr.write(str(result) + '\\n')\n",
    "\n",
    "    fptr.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2643877b",
   "metadata": {},
   "source": [
    "#### Number Line Jumps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8aa48edd",
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/bin/python3\n",
    "\n",
    "import math\n",
    "import os\n",
    "import random\n",
    "import re\n",
    "import sys\n",
    "\n",
    "#\n",
    "# Complete the 'kangaroo' function below.\n",
    "#\n",
    "# The function is expected to return a STRING.\n",
    "# The function accepts following parameters:\n",
    "#  1. INTEGER x1\n",
    "#  2. INTEGER v1\n",
    "#  3. INTEGER x2\n",
    "#  4. INTEGER v2\n",
    "#\n",
    "\n",
    "def kangaroo(x1, v1, x2, v2):\n",
    "    pos1 = x1\n",
    "    pos2 = x2\n",
    "    for x in range(10000):\n",
    "        if pos1 == pos2:\n",
    "            return \"YES\"\n",
    "        pos1 += v1\n",
    "        pos2 += v2\n",
    "    return \"NO\"    \n",
    "\n",
    "if __name__ == '__main__':\n",
    "    fptr = open(os.environ['OUTPUT_PATH'], 'w')\n",
    "\n",
    "    first_multiple_input = input().rstrip().split()\n",
    "\n",
    "    x1 = int(first_multiple_input[0])\n",
    "\n",
    "    v1 = int(first_multiple_input[1])\n",
    "\n",
    "    x2 = int(first_multiple_input[2])\n",
    "\n",
    "    v2 = int(first_multiple_input[3])\n",
    "\n",
    "    result = kangaroo(x1, v1, x2, v2)\n",
    "\n",
    "    fptr.write(result + '\\n')\n",
    "\n",
    "    fptr.close()\n"
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 5
}