ADM_hw1_ex1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Say \"Hello, World!\" With Python\n",
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Python If-Else\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==1:\n",
    "        print(\"Weird\")\n",
    "    else:\n",
    "        if n>=2 and n<=5:\n",
    "            print(\"Not Weird\")\n",
    "        elif n>=6 and n<=20:\n",
    "            print(\"Weird\")\n",
    "        elif n>20: \n",
    "            print(\"Not Weird\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Arithmetic Operators\n",
    "if __name__ == '__main__':\n",
    "    a = int(input())\n",
    "    b = int(input())\n",
    "\n",
    "print(a+b)\n",
    "print(a-b)\n",
    "print(a*b)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Python: Division\n",
    "if __name__ == '__main__':\n",
    "    a = int(input())\n",
    "    b = int(input())\n",
    "    \n",
    "print(a//b)\n",
    "print(a/b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Loops\n",
    "if __name__ == '__main__':\n",
    "    n = int(input())\n",
    "    \n",
    "import math\n",
    "for i in range(n):\n",
    "    print(i*i)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Write a function\n",
    "def is_leap(year):\n",
    "    leap = False\n",
    "    if year%4==0 and not year%100==0 or year%400==0:\n",
    "        leap= True \n",
    "    return leap\n",
    "\n",
    "year = int(input())\n",
    "print(is_leap(year))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Print Function\n",
    "if __name__ == '__main__':\n",
    "    n = int(input())\n",
    "    \n",
    "s = ''\n",
    "for i in range(1,n+1):\n",
    "    s+=str(i)\n",
    "\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#List Comprehensions\n",
    "if __name__ == '__main__':\n",
    "    x = int(input())\n",
    "    y = int(input())\n",
    "    z = int(input())\n",
    "    n = int(input())\n",
    "    \n",
    "    print([[i,j,k] for i in range(x+1) for j in range(y+1) for k in range(z+1) if i+j+k!=n])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Find the Runner-Up Score!\n",
    "if __name__ == '__main__':\n",
    "    n = int(input())\n",
    "    arr = map(int, input().split())\n",
    "    \n",
    "    scores=list(arr)\n",
    "    M=max(scores)\n",
    "    s1=[x for x in scores if x!=M]\n",
    "    print(max(s1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Nested Lists\n",
    "if __name__ == '__main__':\n",
    "    studgrades=[]\n",
    "    grades=[]\n",
    "    for _ in range(int(input())):\n",
    "        name = input()\n",
    "        score = float(input())\n",
    "        studgrades.append([name, score])\n",
    "        grades.append(score)\n",
    "    \n",
    "    \n",
    "    m=min(grades)\n",
    "    grades=[x for x in grades if x!=m]\n",
    "    m=min(grades)\n",
    "    \n",
    "    names=[x[0] for x in studgrades if x[1]==m]\n",
    "    names.sort()\n",
    "    print(*names, sep=\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Finding the percentage\n",
    "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",
    "    av=sum(student_marks[query_name])/len(student_marks[query_name])\n",
    "    print(\"%.2f\" % av)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Lists\n",
    "def command(comm, l):\n",
    "    if comm=='pop': \n",
    "        l.pop()\n",
    "    elif comm=='print':\n",
    "        print(l)\n",
    "    elif comm=='reverse':\n",
    "        l.reverse()\n",
    "    elif comm=='sort':\n",
    "        l.sort()\n",
    "    elif 'insert' in comm:\n",
    "        comm=comm[7:]\n",
    "        comm=list(map(int, comm.split()))\n",
    "        l.insert(int(comm[0]), int(comm[1]))\n",
    "    elif 'remove' in comm:\n",
    "        comm=comm[7:]\n",
    "        comm=list(map(int, comm.split()))\n",
    "        l.remove(int(comm[0]))\n",
    "    elif 'append' in comm:\n",
    "        comm=comm[7:]\n",
    "        comm=list(map(int, comm.split()))\n",
    "        l.append(comm[0])\n",
    "    return l\n",
    "    \n",
    "    \n",
    "if __name__ == '__main__':\n",
    "    N = int(input())\n",
    "    l=[]\n",
    "    \n",
    "    for i in range(N): \n",
    "        command(input(), l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Tuples\n",
    "N=int(input())\n",
    "t=()\n",
    "I=input()\n",
    "\n",
    "for n in range(-2, N, 2):\n",
    "    t=t + ( int(I[n+2]), )\n",
    "\n",
    "print(hash(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Introduction to Sets\n",
    "def average(array):\n",
    "    array=list(set(array))\n",
    "    return sum(array)/len(array)\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    n = int(input())\n",
    "    arr = list(map(int, input().split()))\n",
    "    result = average(arr)\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#No Idea!\n",
    "inp_list=list(map(int, input().split()))\n",
    "n=inp_list[0]\n",
    "m=inp_list[1]\n",
    "\n",
    "arr=list(map(int, input().split()))\n",
    "A=set(map(int, input().split()))\n",
    "B=set(map(int, input().split()))\n",
    "\n",
    "score=0\n",
    "for x in arr:\n",
    "    if x in A:\n",
    "        score+=1\n",
    "    if x in B:\n",
    "        score-=1\n",
    "        \n",
    "print(score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Symmetric Difference\n",
    "M=int(input())\n",
    "l=list(map(int,input().split()))\n",
    "set1=set(l)\n",
    "\n",
    "N=int(input())\n",
    "l=list(map(int,input().split()))\n",
    "set2=set(l)\n",
    "sym_diff=list(set1.symmetric_difference(set2))\n",
    "sym_diff.sort()\n",
    "\n",
    "print(*sym_diff, sep=\"\\n\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Set .add()\n",
    "N=int(input())\n",
    "stamps= set()\n",
    "i=0\n",
    "\n",
    "while i<N:\n",
    "    stamps.add(input())\n",
    "    i+=1\n",
    "\n",
    "print(len(stamps))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Set .discard(), .remove() & .pop()\n",
    "n = int(input()) #len(s)\n",
    "s = set(map(int, input().split()))\n",
    "N=int(input())\n",
    "\n",
    "for i in range(N):\n",
    "    comm=input()\n",
    "    if 'remove' in comm:\n",
    "        s.remove(int(comm[7]))\n",
    "    elif 'discard' in comm:\n",
    "        s.discard(int(comm[8]))\n",
    "    elif 'pop' in comm:\n",
    "        s.pop()\n",
    "\n",
    "print(sum(list(s)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Sset.union() Operation\n",
    "n = int(input()) #number of English newspaper subscribers\n",
    "eng_sub = set(list(map(int, input().split())))\n",
    "\n",
    "b = int(input()) #number of French newspaper subscribers\n",
    "fr_sub = set(list(map(int, input().split())))\n",
    "\n",
    "print(len(eng_sub.union(fr_sub)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Set.intersection()  Operation\n",
    "\n",
    "n = int(input()) #number of English newspaper subscribers\n",
    "eng_sub = set(list(map(int, input().split())))\n",
    "\n",
    "\n",
    "b = int(input()) #number of French newspaper subscribers\n",
    "fr_sub = set(list(map(int, input().split())))\n",
    "\n",
    "print(len(eng_sub.intersection(fr_sub)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Set.difference() Operation\n",
    "\n",
    "n=int(input())                                                  #number of English newspaper subscribers\n",
    "eng_sub=set(list(map(int, input().split())))\n",
    "\n",
    "b=int(input())                                                  #number of French newspaper subscribers\n",
    "\n",
    "print(len(eng_sub.difference(list(map(int, input().split()))))) #difference operates on iterables, so there's no need to build the set of the French newspaper's subscribers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Set.symmetric_difference() Operation\n",
    "\n",
    "n = int(input())                                                             #number of English newspaper subscribers\n",
    "eng_sub = set(list(map(int, input().split())))\n",
    "\n",
    "b = int(input())                                                              #number of French newspaper subscribers\n",
    "\n",
    "print(len(eng_sub.symmetric_difference(list(map(int, input().split())))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Set Mutations\n",
    "\n",
    "\n",
    "def get_command(set1, operation, set2):\n",
    "    if operation == 'update':\n",
    "        A.update(set2)\n",
    "    elif operation == 'intersection_update':\n",
    "        A.intersection_update(set2)\n",
    "    elif operation == 'difference_update':\n",
    "        A.difference_update(set2)\n",
    "    elif operation == 'symmetric_difference_update':\n",
    "        A.symmetric_difference_update(set2)\n",
    "    \n",
    "    return(A)\n",
    "\n",
    "\n",
    "n = int(input())                             # number of elements of A\n",
    "A = set(list(map(int, input().split())))\n",
    "N = int(input())                             #number of other sets\n",
    "\n",
    "for i in range(N):\n",
    "    input_array = input().split()\n",
    "    op = input_array[0]                         #name of the operation to perform on A\n",
    "    m = int(input_array[1])                     #cardinality of the i-th new set \n",
    "    B = set(list(map(int, input().split())))    #i-th new set\n",
    "\n",
    "    get_command(A, op, B)\n",
    "    \n",
    "print(sum(A))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#The Captain's Room\n",
    "\n",
    "k = int(input())\n",
    "rooms = list(map(int, input().split()))\n",
    "rooms_nodupl = set(rooms)\n",
    "\n",
    "occurrencies = {room : 0 for room in rooms_nodupl}\n",
    "\n",
    "for room in rooms:\n",
    "    occurrencies[room] += 1\n",
    "\n",
    "for key in occurrencies:\n",
    "    if occurrencies[key] == 1:\n",
    "        print(key)\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Check Subset\n",
    "\n",
    "T = int(input())           # number of test cases\n",
    "\n",
    "for _ in range(T):\n",
    "    n = int(input())       # cardinality of A\n",
    "    A = set(map(int, input().split())) \n",
    "\n",
    "    m = int(input())       #cardinality of B\n",
    "    B = set(map(int, input().split())) \n",
    "    \n",
    "    print(A.issubset(B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Check Strict Superset\n",
    "\n",
    "A = set(map(int, input().split()))\n",
    "n = int(input())    #number of sets to check\n",
    "\n",
    "issuper = True\n",
    "for _ in range(n):\n",
    "    subset = set(map(int, input().split()))\n",
    "    if not A.issuperset(subset) and A.difference(subset) != set():\n",
    "        issuper = False\n",
    "        break\n",
    "\n",
    "print(issuper)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#sWAP cASES\n",
    "\n",
    "def swap_case(s):\n",
    "   return s.swapcase()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#String Split and Join\n",
    "\n",
    "def split_and_join(line):\n",
    "    return(\"-\".join(line.split(\" \")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#What's your name?\n",
    "\n",
    "def print_full_name(first, last):\n",
    "    print('Hello ' + first +' '+ last + '! You just delved into python.')\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Mutations\n",
    "\n",
    "def mutate_string(string, position, character):\n",
    "    l = list(string)\n",
    "    l[position] = character\n",
    "    return ''.join(l)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Find a string\n",
    "\n",
    "def count_substring(string, sub_string):\n",
    "    k = len(sub_string)\n",
    "    occ = 0                                              #occurencies of sub_string in string\n",
    "    i = 0\n",
    "\n",
    "    while i < len(string) - k +1:\n",
    "        if string[i:i+k] == sub_string:\n",
    "            occ += 1\n",
    "        i+=1\n",
    "\n",
    "    return occ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#String Validators\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    s = input()\n",
    "    l = list(s)\n",
    "    \n",
    "    alnum = False\n",
    "    alpha = False\n",
    "    digit = False\n",
    "    lower = False\n",
    "    upper = False\n",
    "\n",
    "    for e in l:\n",
    "        if e.isalnum():\n",
    "            alnum = True\n",
    "        if e.isalpha():\n",
    "            alpha = True\n",
    "        if e.isdigit():\n",
    "            digit = True\n",
    "        if e.islower():\n",
    "            lower = True\n",
    "        if e.isupper():\n",
    "            upper = True\n",
    "    \n",
    "    print(alnum)\n",
    "    print(alpha)\n",
    "    print(digit)\n",
    "    print(lower)\n",
    "    print(upper)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Text Alignment\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)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Text Wrap\n",
    "\n",
    "def wrap(string, max_width):\n",
    "    new = ''\n",
    "    for i in range(len(string) // max_width) :\n",
    "        new += string[i*max_width : (i+1)*max_width] + '\\n'\n",
    "    \n",
    "    \n",
    "    if not len(string) % max_width == 0:\n",
    "        new += string[- (len(string) % max_width) :]\n",
    "        \n",
    "    return new"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Designer Door Mat\n",
    "\n",
    "I = list(map(int, input().split()))\n",
    "N, M = I[0], I[1]\n",
    "\n",
    "#Upper half triangle\n",
    "for i in range(1, (N-1), 2):\n",
    "    print(('.|.' * i).center(M, '-'))\n",
    "\n",
    "#Welcome \n",
    "print('WELCOME'.center(M, '-'))\n",
    "\n",
    "#Lower half triangle\n",
    "for i in range(1, N, 2):\n",
    "    print(('.|.' * (N-1- i)).center(M, '-'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#String Formatting\n",
    "\n",
    "def print_formatted(number):\n",
    "\n",
    "    l = len(bin(number)) -2 \n",
    "    for i in range(1, number + 1):\n",
    "        print(str(i).rjust(l), oct(i)[2:].rjust(l), hex(i)[2:].rjust(l), bin(i)[2:].rjust(l))    \n",
    "\n",
    "if __name__ == '__main__':\n",
    "    n = int(input())\n",
    "    print_formatted(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Alphabet Rangoli\n",
    "\n",
    "def print_rangoli(size):\n",
    "\n",
    "    import string\n",
    "\n",
    "    length = (size-1) * 4 + 1\n",
    "\n",
    "    #upper half\n",
    "    for i in range(1, size):\n",
    "        fake_line =  string.ascii_lowercase[ size - 1: size - i : -1 ] + string.ascii_lowercase[ size - i : size ]\n",
    "        line = '-'.join([x for x in fake_line])\n",
    "        print(line.center(length, '-'))\n",
    "    \n",
    "    #central line\n",
    "    fake_line = string.ascii_lowercase[ size -1 :  : -1 ] + string.ascii_lowercase[ 1 : size ]\n",
    "    print('-'.join([x for x in fake_line]).center(length, '-'))\n",
    "\n",
    "\n",
    "    #lower half\n",
    "    for i in range(size-1 , 0, -1):\n",
    "        fake_line =  string.ascii_lowercase[ size - 1: size - i : -1 ] + string.ascii_lowercase[ size - i : size ]\n",
    "        line = '-'.join([x for x in fake_line])\n",
    "        print(line.center(length, '-'))\n",
    "\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Capitalize!\n",
    "\n",
    "def solve(s):\n",
    "    \n",
    "    capitalized = s.title()\n",
    "\n",
    "    for e in s.split():\n",
    "        if e[0].isdigit() and len(e) > 1:\n",
    "            capitalized = capitalized.replace(e.title(), e.lower())     \n",
    "\n",
    "    return capitalized \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#The Minion Game\n",
    "\n",
    "def minion_game(string):\n",
    "\n",
    "    vowels = 'AEIOU'\n",
    "    consonants = 'BCDFGHJKLMNPQRSTVWXYZ'\n",
    "\n",
    "    n = len(string)\n",
    "    c_words = 0\n",
    "    v_words = 0\n",
    "\n",
    "    for i in range(n):\n",
    "        if string[i] in consonants:\n",
    "            c_words += n-i   #n-i is the number of all possible substrings starting from s[i]\n",
    "        \n",
    "        if string[i] in vowels:\n",
    "            v_words += n-i\n",
    "\n",
    "    if c_words > v_words :\n",
    "        print('Stuart', c_words )\n",
    "    elif c_words < v_words :\n",
    "        print('Kevin', v_words )\n",
    "    else: \n",
    "        print('Draw')\n",
    "    \n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Merge the Tools!\n",
    "\n",
    "def merge_the_tools(string, k):\n",
    "    m = len(string)//k\n",
    "    for i in range(m):\n",
    "        t = string[i*k : (i+1)*k] #sliicing sbagliato\n",
    "        print(t)\n",
    "        print(delete_duplicates(t))\n",
    "    \n",
    "    return\n",
    "\n",
    "def delete_duplicates(string):\n",
    "    no_duplicates = ''\n",
    "    for e in string:\n",
    "        if e not in no_duplicates:\n",
    "            no_duplicates += e\n",
    "    \n",
    "    return no_duplicates\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Collections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#collections.Counter()\n",
    "\n",
    "from collections import Counter\n",
    "\n",
    "X = int(input())     #number of shoes\n",
    "sizes_list = list(map(int, input().split()))\n",
    "available_sizes = Counter(sizes_list)\n",
    "\n",
    "N = int(input())      #number of customers\n",
    "profit = 0\n",
    "\n",
    "for _ in range(N):\n",
    "    customer_details = list(map(int, input().split()))      #desired size, bid\n",
    "    if customer_details[0] in available_sizes and available_sizes[customer_details[0]] > 0:\n",
    "        profit += customer_details[1]\n",
    "        available_sizes[customer_details[0]] -= 1\n",
    "\n",
    "print(profit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#DefaultDict Tutorial\n",
    "\n",
    "from collections import defaultdict\n",
    "\n",
    "n, m = map(int,input().split())     #number of words of group A, number of words of group B\n",
    "A=defaultdict(list)\n",
    "\n",
    "for i in range(n):\n",
    "    A[input()].append(i+1)\n",
    "\n",
    "for _ in range(m):\n",
    "    word = input()\n",
    "    if not word in A:\n",
    "        print(-1)\n",
    "    else:\n",
    "        print(' '.join(A[word]))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Collections.namedtuple()\n",
    "\n",
    "from collections import namedtuple\n",
    "\n",
    "N = int(input())     #number of students\n",
    "columns = input()\n",
    "students = namedtuple('students', columns)\n",
    "marks = []\n",
    "\n",
    "for _ in range(N):\n",
    "    student = students._make(input().split())\n",
    "    marks.append(int(getattr(student, 'MARKS')))\n",
    "\n",
    "print('{:.2f}'.format(sum(marks)/N))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Collections.OrderedDict()\n",
    "\n",
    "from collections import OrderedDict\n",
    "from collections import defaultdict\n",
    "\n",
    "N = int(input())     #number of items \n",
    "\n",
    "items_prices = OrderedDict()\n",
    "items_occ = defaultdict(int)\n",
    "\n",
    "for _ in range(N):\n",
    "    item = input().split()\n",
    "    price = int(item[-1])\n",
    "    name = ' '.join(item[:-1])\n",
    "\n",
    "    items_prices[name] = int(price)\n",
    "    items_occ[name] +=1\n",
    "\n",
    "for e in items_prices:\n",
    "    print(e, items_prices[e]*items_occ[e])     #net_price[e] = items_prices[e]*items_occ[e]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Word Order\n",
    "\n",
    "from collections import Counter\n",
    "\n",
    "n = int(input())\n",
    "words = []\n",
    "\n",
    "for _ in range(n):\n",
    "    words.append(input())\n",
    "\n",
    "occurrencies = Counter(words)\n",
    "\n",
    "print(len(occurrencies))\n",
    "print(' '.join(map(str, occurrencies.values())))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#collections.deque()\n",
    "\n",
    "from collections import deque\n",
    "\n",
    "d = deque()\n",
    "N = int(input())     # lines of code following in input\n",
    "\n",
    "for _ in range(N):\n",
    "    command_line = input().split()\n",
    "    if 'pop' in command_line:\n",
    "        d.pop()\n",
    "    \n",
    "    if 'popleft' in command_line:\n",
    "        d.popleft()\n",
    "        \n",
    "    if 'clear' in command_line:\n",
    "        d.clear()\n",
    "    \n",
    "    if 'append' in command_line:\n",
    "        d.append(command_line[1])\n",
    "\n",
    "    if 'appendleft' in command_line:\n",
    "        d.appendleft(command_line[1])\n",
    "    \n",
    "    if 'count' in command_line:\n",
    "        d.count(command_line[1])\n",
    "    \n",
    "    if 'extend' in command_line:\n",
    "        d.extend(command_line[1])\n",
    "    \n",
    "    if 'extendleft' in command_line:\n",
    "        d.extendleft(command_line[1])\n",
    "    \n",
    "    if 'remove' in command_line:\n",
    "        d.remove(command_line[1])\n",
    "\n",
    "    if 'reverse' in command_line:\n",
    "        d.reverse()\n",
    "    \n",
    "    if 'rotate' in command_line:\n",
    "        d.rotate(n = command_line[1])\n",
    "    \n",
    "    print(' '.join([e for e in d]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Piling Up!\n",
    "\n",
    "from collections import deque\n",
    "\n",
    "T = int(input())                            #number of test cases\n",
    "\n",
    "for _ in range(T):\n",
    "    n = int(input())                         #number of cubes\n",
    "    blocks = deque(list(map(int, input().split())))\n",
    "    \n",
    "    pile = 'Yes'\n",
    "    prev = 2**31     #cubes' length <=2**31 (hackerrank bound)\n",
    "    while len(blocks) > 0:\n",
    "        if blocks[0] >= blocks[-1] and prev >= blocks[0]:\n",
    "            prev = blocks[0]\n",
    "            blocks.popleft()\n",
    "        \n",
    "        elif blocks[-1] >= blocks[0] and prev >= blocks[-1]: \n",
    "            prev = blocks[-1]\n",
    "            blocks.pop()\n",
    "        \n",
    "        else:\n",
    "            pile = 'No'\n",
    "            break\n",
    "\n",
    "    print(pile)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Company Logo\n",
    "\n",
    "from collections import Counter\n",
    "\n",
    "s = input()\n",
    "mostcommon3 = Counter(sorted([x for x in s])).most_common(3)\n",
    "\n",
    "for e in mostcommon3:\n",
    "    print(e[0], e[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Date and Time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Calendar Module\n",
    "import calendar\n",
    "\n",
    "date = list(map(int, input().split()))   #date input format: MM DD YYYY\n",
    "print(calendar.day_name[calendar.weekday(date[2], date[0], date[1])].upper()) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Time Delta\n",
    "def time_delta(t1, t2):\n",
    "    from datetime import datetime\n",
    "    t_1 = datetime.strptime(t1, '%a %d %b %Y %H:%M:%S %z')\n",
    "    t_2 = datetime.strptime(t2, '%a %d %b %Y %H:%M:%S %z')\n",
    "    return str(abs(int(t_1 - t_2).total_seconds()))    #str format for output compatibility and int for formatting, but it doesnt actually work (:)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exceptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Exceptions\n",
    "\n",
    "T = int(input())    #number of test cases \n",
    "\n",
    "for _ in range(T):\n",
    "    a_b = input().split()\n",
    "    try:\n",
    "        print(int(a_b[0])//int(a_b[1]))\n",
    "    except ZeroDivisionError as e:\n",
    "        print(\"Error Code:\",e)\n",
    "    except ValueError as e:\n",
    "        print(\"Error Code:\",e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Built-ins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Zipped!\n",
    "\n",
    "N, X = list(map(int, input().split()))   # N = number of students, X = number of subjects\n",
    "\n",
    "marks_table = []\n",
    "for _ in range(X):\n",
    "    marks = list(map(float, input().split()))\n",
    "    marks_table += [marks]\n",
    "      \n",
    "marks_per_student = list(zip(*marks_table))\n",
    "\n",
    "for student in range(N):\n",
    "    print(sum(marks_per_student[student])/X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Athlete Sort\n",
    "\n",
    "from operator import itemgetter\n",
    "\n",
    "N, M = list(map(int, input().split()))    # N = number of athletes, M = number of atrributes\n",
    "all_athletes = []\n",
    "\n",
    "for _ in range(N):\n",
    "    athlete = list(map(int, input().split()))\n",
    "    all_athletes += [athlete]\n",
    "\n",
    "\n",
    "K = int(input())      # index for ordering (?)\n",
    "\n",
    "athletes_sorted = sorted(all_athletes, key=itemgetter(K))\n",
    "\n",
    "\n",
    "for e in athletes_sorted:\n",
    "    print(' '.join([str(x) for x in e]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#ginortS\n",
    "\n",
    "s = input()\n",
    "\n",
    "even = []\n",
    "odd = []\n",
    "lowercase = []\n",
    "uppercase = []\n",
    "\n",
    "for e in s:\n",
    "    if e.isdigit():\n",
    "        if int(e)%2==0:\n",
    "            even.append(e)\n",
    "        else:\n",
    "            odd.append(e)\n",
    "    elif e.islower():\n",
    "        lowercase.append(e)\n",
    "    else:\n",
    "        uppercase.append(e)\n",
    "\n",
    "\n",
    "print(''.join(sorted(lowercase) + sorted(uppercase) + sorted(odd) + sorted(even)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Functionals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Map and Lambda Function\n",
    "\n",
    "cube = lambda x: x**3\n",
    "\n",
    "def fibonacci(n):\n",
    "    def fib(n):\n",
    "        if n == 0:\n",
    "            return 0\n",
    "        elif n == 1: \n",
    "            return 1\n",
    "        else:\n",
    "            return (fib(n-1) + fib(n-2))\n",
    "    \n",
    "    return [fib(m) for m in range(n)]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regex and Parsing challenges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Detect Floating Point Number\n",
    "import re\n",
    "\n",
    "\n",
    "def refloat(f):\n",
    "    if re.search(r'.*[^0-9+\\-\\.]', f):    #if f contains any characters except \n",
    "                                          #the ones that create a float \n",
    "                                          #(<=> if float() raises an error\n",
    "        return False\n",
    "    elif re.search(r'.*[\\+-].*', f[1:]):   #+- can only be in 1st position (indexed by 0)\n",
    "        return False\n",
    "    elif not re.search(r'.*\\.+[0-9]', f):  #at least one decimal value\n",
    "        return False\n",
    "    elif len(re.findall(r'\\.', f ))!=1: #exactly one point\n",
    "        return False\n",
    "    else:\n",
    "        return True\n",
    "\n",
    "\n",
    "T = int(input())      #number of test cases\n",
    "\n",
    "for _ in range(T):\n",
    "    f = input()\n",
    "    print(refloat(f))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Re.split()\n",
    "import re\n",
    "\n",
    "regex_pattern = r\"\\W\"\n",
    "\n",
    "print(\"\\n\".join(re.split(regex_pattern, input())))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Group(), Groups() & Groupdict()\n",
    "import re\n",
    "\n",
    "s = input()\n",
    "pattern = r'([a-zA-Z0-9])\\1'\n",
    "found = re.search(pattern, s)\n",
    "if found:\n",
    "    print(re.search(pattern, s).group(1))\n",
    "else: \n",
    "    print(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Re.findall() & Re.finditer()\n",
    "import re\n",
    "\n",
    "s = input()\n",
    "pattern = r'([qwrtypsdfghjklzxcvbnmQWRTYPSDFGHJKLZXCVBNM]{1})([aeiouAEIOU]{2,})'\n",
    "found = re.finditer(pattern, s)\n",
    "\n",
    "\n",
    "if re.findall(pattern, s)!=[]:\n",
    "   for x in found:\n",
    "      if x.end()!=len(s) and s[x.end()] in 'qwrtypsdfghjklzxcvbnmQWRTYPSDFGHJKLZXCVBNM':\n",
    "       print(x.group(2))\n",
    "\n",
    "else:\n",
    "    print(-1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Re.start() & Re.end()\n",
    "import re\n",
    "\n",
    "s = input()    \n",
    "k = input()\n",
    "\n",
    "k_pattern = re.compile('(?<='+k[0]+')' + k[1:])  #regex pattern for the string to search\n",
    "\n",
    "if re.search(k_pattern, s):\n",
    "    for x in re.finditer(k_pattern, s):\n",
    "        print((x.start() -1 , x.end()-1))\n",
    "else:\n",
    "    print((-1, -1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Re.sub()\n",
    "import re\n",
    "\n",
    "N = int(input())    #numero di righe di testo\n",
    "\n",
    "pattern1 = r'(?<= )&&(?= )'\n",
    "pattern2 = r'(?<= )\\|\\|(?= )'\n",
    "\n",
    "\n",
    "for _ in range(N):\n",
    "    s = input()\n",
    "    s = re.sub(pattern1, 'and', s)\n",
    "    print(re.sub(pattern2, 'or', s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Validating roman numerals \n",
    "\n",
    "regex_pattern = r\"M{0,3}(CM)??D{0,3}(CD)??C{0,3}(XC)??L?(XL)??X{0,3}(IX)??V{0,3}(IV)??(I){0,3}\"\t\n",
    "#EXPLAINATION:\n",
    "#accedpted characters: M, D, C, L, X, V, I\n",
    "#these characters must appear in order and with max 3 repetion each except for L, which can appear 0-1 times (50+50=100 == C)\n",
    "#besides, (CM), (CD), (XC), (XL), (IX) and (IV) are accepted combinations;\n",
    "#each of these can appear only one time and must be after the second character in the combination\n",
    "\n",
    "import re\n",
    "print(str(bool(re.match(regex_pattern, input()))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Validating phone numbers\n",
    "import re\n",
    "\n",
    "N = int(input())  #number of lines/test cases\n",
    "\n",
    "pattern = r'^[789][0-9]{9}$'\n",
    "\n",
    "for _ in range(N):\n",
    "    s = input()\n",
    "    if re.match(pattern, s):\n",
    "        print('YES')\n",
    "    else:\n",
    "        print('NO')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Validating and Parsing Email Addresses\n",
    "import re\n",
    "import email.utils\n",
    "\n",
    "n = int(input())    #number of test cases/lines\n",
    "\n",
    "pattern = r'^[a-zA-Z][a-zA-Z0-9\\-\\._]*@[a-zA-Z]+\\.[a-zA-Z]{1,3}$'\n",
    "\n",
    "for _ in range(n):\n",
    "    name_email = email.utils.parseaddr(input())\n",
    "    if re.match(pattern, name_email[1] ):\n",
    "        print(email.utils.formataddr(name_email))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Hex Color Code\n",
    "import re\n",
    "\n",
    "n = int(input())   #lines of CSS Codes\n",
    "code = ''\n",
    "for _ in range(n):\n",
    "    code += ' ' + input()\n",
    "\n",
    "splitpattern = r'(\\{.[^\\{\\}]*\\})'\n",
    "split = re.split(splitpattern, code)   #split[even] = Selector; split[odd] = Properties and values\n",
    "\n",
    "hexcolorpattern = r'#([0-9A-Fa-f]{6}|[0-9A-Fa-f]{3})'\n",
    "\n",
    "for i in range(1, len(split), 2):    #odd numbers - proprerties and values\n",
    "    for x in re.findall(hexcolorpattern, split[i]):\n",
    "        print('#'+x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#HTML Parser - Part 1\n",
    "from html.parser import HTMLParser\n",
    "\n",
    "class MyHTMLParser(HTMLParser):\n",
    "    def handle_starttag(self, tag, attrs):\n",
    "        print(\"Start :\", tag)\n",
    "        for attribute in attrs:\n",
    "            print('->', attribute[0], '>', attribute[1])\n",
    "    def handle_endtag(self, tag):\n",
    "        print(\"End   :\", tag)\n",
    "    def handle_startendtag(self, tag, attrs):\n",
    "        print(\"Empty :\", tag)\n",
    "        for attribute in attrs:\n",
    "            print('->', attribute[0], '>', attribute[1])\n",
    "    def handle_comment(self, data):\n",
    "        pass\n",
    "\n",
    "\n",
    "parser = MyHTMLParser()\n",
    "\n",
    "\n",
    "N = int(input())   #lines of code\n",
    "\n",
    "for _ in range(N):\n",
    "    parser.feed(input())\n",
    "\n",
    "parser.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#HTML Parser - Part 2\n",
    "from html.parser import HTMLParser\n",
    "\n",
    "class MyHTMLParser(HTMLParser):\n",
    "    def handle_comment(self, data):\n",
    "        if '\\n' in data:\n",
    "            print('>>> Multi-line Comment', '\\n'+data)\n",
    "        else:\n",
    "            print('>>> Single-line Comment', '\\n'+data)\n",
    "    \n",
    "    def handle_data(self, data):\n",
    "        if data != '\\n':\n",
    "            print( '>>> Data                 ', '\\n'+data)\n",
    "        \n",
    "        \n",
    "html = \"\"\n",
    "for i in range(int(input())):\n",
    "    html += input().rstrip()\n",
    "    html += '\\n'\n",
    "    \n",
    "parser = MyHTMLParser()\n",
    "parser.feed(html)\n",
    "parser.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Detect HTML Tags, Attributes and Attribute Values\n",
    "\n",
    "from html.parser import HTMLParser\n",
    "\n",
    "class MyHTMLParser(HTMLParser):\n",
    "    def handle_starttag(self, tag, attrs):\n",
    "        print(tag)\n",
    "        for attribute in attrs:\n",
    "            print('->', attribute[0], '>', attribute[1])\n",
    "    \n",
    "    def handle_endtag(self, tag):\n",
    "        pass\n",
    "    \n",
    "    def handle_startendtag(self, tag, attrs):\n",
    "        print(tag)\n",
    "        for attribute in attrs:\n",
    "            print('->', attribute[0], '>', attribute[1])\n",
    "    \n",
    "    def handle_comment(self, data):\n",
    "        pass\n",
    "\n",
    "\n",
    "parser = MyHTMLParser()\n",
    "\n",
    "\n",
    "N = int(input())   #lines of code\n",
    "\n",
    "for _ in range(N):\n",
    "    parser.feed(input())\n",
    "\n",
    "parser.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Validating UID\n",
    "\n",
    "import re\n",
    "\n",
    "def repetition(l): \n",
    "    n = len(l)\n",
    "\n",
    "    if n > 1:\n",
    "        i = 1\n",
    "        while i < n:\n",
    "            if l[i] in l[:i]:\n",
    "                return True\n",
    "            i+=1\n",
    "    \n",
    "    return False\n",
    "\n",
    "N = int(input())   #number of test cases\n",
    "\n",
    "for _ in range(N):\n",
    "    s = input()\n",
    "\n",
    "    digits = re.findall(r'[0-9]{1}', s)\n",
    "    upper = re.findall(r'[A-Z]{1}', s)\n",
    "    lower = re.findall(r'[a-z]{1}', s)\n",
    "\n",
    "    notalphanum = re.search( r'.*[^0-9a-zA-Z]', s)\n",
    "\n",
    "    if len(s) != 10:\n",
    "        print('Invalid')\n",
    "    elif len(digits) < 3 or repetition(digits):\n",
    "        print('Invalid')\n",
    "    elif len(upper) < 2 or repetition(upper) or repetition(lower):\n",
    "        print('Invalid')\n",
    "    elif notalphanum:\n",
    "        print(notalphanum)\n",
    "        print('Invalid')\n",
    "    else:\n",
    "        print('Valid')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Validating Credit Card Numbers \n",
    "\n",
    "import re\n",
    "\n",
    "pattern1 = r'(^[456])([0-9]{15}$)'\n",
    "pattern2 = r'(^[456])([0-9]{3}\\-[0-9]{4}\\-[0-9]{4}\\-[0-9]{4}$)'\n",
    "pattern_rep = r'.*(1111|2222|3333|4444|5555|6666|7777|8888|9999|0000).*' \n",
    "\n",
    "N = int(input())    #number of test cases\n",
    "\n",
    "for _ in range(N):\n",
    "    card_number = input()\n",
    "\n",
    "    if (re.match(pattern1, card_number) or re.match(pattern2, card_number)) and not re.match(pattern_rep, card_number.replace(\"-\",\"\") ):\n",
    "            print('Valid')\n",
    "    else: \n",
    "        print('Invalid')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Validating Postal Codes\n",
    "\n",
    "regex_integer_in_range = r\"^([1-9])([0-9]{5})$\"\t\n",
    "regex_alternating_repetitive_digit_pair = r'((?<=1)[0-9]{1}(?=1)|(?<=2)[0-9]{1}(?=2)|(?<=3)[0-9]{1}(?=3)|(?<=4)[0-9]{1}(?=4)|(?<=5)[0-9]{1}(?=5)|(?<=6)[0-9]{1}(?=6)|(?<=7)[0-9]{1}(?=7)|(?<=8)[0-9]{1}(?=8)|(?<=9)[0-9]{1}(?=9)|(?<=0)[0-9]{1}(?=0))'\n",
    "\n",
    "import re\n",
    "P = input()\n",
    "\n",
    "print (bool(re.match(regex_integer_in_range, P)) \n",
    "and len(re.findall(regex_alternating_repetitive_digit_pair, P)) < 2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Matrix Script\n",
    "\n",
    "import re\n",
    "\n",
    "N, M = list(map(int, input().split()))    #number of rows, number of columns\n",
    "\n",
    "flat_matrix = ''\n",
    "for _ in range(N):\n",
    "    flat_matrix += input() \n",
    "\n",
    "ordered_indexes = []\n",
    "NM = N*M\n",
    "for j in range(M):\n",
    "    ordered_indexes += [i for i in range(j, NM, M)]\n",
    "\n",
    "message = ''\n",
    "for i in ordered_indexes:\n",
    "    message += flat_matrix[i]\n",
    "\n",
    "pattern = r'(?<=[a-zA-Z0-9])([!@#$%&]+| {2,}|[!@#$%& ]{2,})(?=[a-zA-Z0-9])'\n",
    "\n",
    "print(re.sub(pattern, ' ', message))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# XML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#XML 1 - Find the Score\n",
    "\n",
    "import xml.etree.ElementTree as etree\n",
    "\n",
    "def get_attr_number(node):\n",
    "    attr_number = 0\n",
    "    for child in node.iter():\n",
    "        attr_number += len(child.attrib)\n",
    "    return attr_number\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    sys.stdin.readline()\n",
    "    xml = sys.stdin.read()\n",
    "    tree = etree.ElementTree(etree.fromstring(xml))\n",
    "    root = tree.getroot()\n",
    "    print(get_attr_number(root))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#XML2 - Find the Maximum Depth\n",
    "\n",
    "import xml.etree.ElementTree as etree\n",
    "\n",
    "maxdepth = 0\n",
    "def depth(elem, level):\n",
    "    global maxdepth\n",
    "    if maxdepth == level:\n",
    "        maxdepth += 1  \n",
    "    for child in elem:\n",
    "        maxdepth = depth(child, level +1)\n",
    "    return maxdepth\n",
    "    \n",
    "\n",
    "if __name__ == '__main__':\n",
    "    n = int(input())\n",
    "    xml = \"\"\n",
    "    for i in range(n):\n",
    "        xml =  xml + input() + \"\\n\"\n",
    "    tree = etree.ElementTree(etree.fromstring(xml))\n",
    "    depth(tree.getroot(), -1)\n",
    "    print(maxdepth)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Closures and Decorations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Standardize Mobile Number Using Decorators\n",
    "\n",
    "def wrapper(f):\n",
    "    def fun(l):\n",
    "        for i in range(len(l)):\n",
    "            ln = len(l[i])\n",
    "            if ln > 10:\n",
    "                pref = ln-10\n",
    "                l[i] = l[i][pref:]\n",
    "            \n",
    "            l[i] = '+91 ' + l[i][:5] + ' ' + l[i][5:]\n",
    "\n",
    "        return f(l)\n",
    "    \n",
    "    return fun"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Decorators 2 - Name Directory\n",
    "\n",
    "def person_lister(f):\n",
    "    def inner(people):\n",
    "        for person in people:\n",
    "            person[2]=int(person[2])\n",
    "        \n",
    "        people = sorted(people, key=operator.itemgetter(2))\n",
    "        return (f(person) for person in people)\n",
    "        \n",
    "    return inner\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Arrays\n",
    "import numpy \n",
    "\n",
    "def arrays(arr):\n",
    "    return numpy.flip(numpy.array(arr, float))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Shape and Reshape\n",
    "import numpy\n",
    "\n",
    "l = input().split()\n",
    "arr = numpy.array(l, int)\n",
    "print(numpy.reshape(arr, (3,3)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Transpose and Flatten\n",
    "import numpy\n",
    "\n",
    "dim = tuple(map(int, input().split()))    #matrix dimensions\n",
    "values = [input().split() for _ in range(max(dim)) ]\n",
    "arr = numpy.array(values, int)\n",
    "dim = numpy.shape(arr)\n",
    "\n",
    "print (numpy.transpose(arr))\n",
    "print (arr.flatten())\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Concatenate\n",
    "import numpy\n",
    "\n",
    "n, m, p = list(map(int, input().split()))\n",
    "\n",
    "values_1 = [input().split() for _ in range(n)]\n",
    "values_2 = [input().split() for _ in range(m)]\n",
    "\n",
    "arr1 = numpy.array(values_1, int)\n",
    "arr2 = numpy.array(values_2, int)\n",
    "\n",
    "print(numpy.concatenate((arr1, arr2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Zeros and Ones\n",
    "import numpy\n",
    "\n",
    "dim = tuple(map(int, input().split()))\n",
    "print(numpy.zeros(dim, int))\n",
    "print(numpy.ones(dim, int))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Eye and Identity\n",
    "import numpy\n",
    "numpy.set_printoptions(legacy='1.13')\n",
    "\n",
    "n, m = list(map(int, input().split()))\n",
    "print(numpy.eye(n,m))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Array Mathematics\n",
    "import numpy\n",
    "\n",
    "n, m = list(map(int, input().split()))\n",
    "A = numpy.array([input().split() for _ in range(n)], int)\n",
    "B = numpy.array([input().split() for _ in range(n)], int)\n",
    "\n",
    "print(A + B)\n",
    "print(A- B)\n",
    "print(A * B)\n",
    "print(A//B)\n",
    "print(A%B)\n",
    "print(A**B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Floor, Ceil and Rint\n",
    "import numpy \n",
    "\n",
    "numpy.set_printoptions(legacy='1.13')\n",
    "\n",
    "arr = numpy.array(input().split(), float)\n",
    "print(numpy.floor(arr))\n",
    "print(numpy.ceil(arr))\n",
    "print(numpy.rint(arr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Sum and Prod\n",
    "import numpy \n",
    "\n",
    "n, m = list(map(int, input().split()))\n",
    "arr = numpy.array([ input().split() for _ in range(n)], int)\n",
    "(n, m) = numpy.shape(arr)\n",
    "print(numpy.prod(numpy.sum(arr, axis=0)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Min e Max\n",
    "import numpy\n",
    "n, m = list(map(int, input().split()))\n",
    "arr = numpy.array([input().split()for _ in range(n)], int)\n",
    "(n, m) = numpy.shape(arr)\n",
    "\n",
    "print(numpy.max(numpy.min(arr, axis=1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Mean, Var, and Std\n",
    "import numpy\n",
    "\n",
    "dim = tuple(map(int, input().split()))\n",
    "arr = numpy.array([input().split() for _ in range(dim[0])], int)\n",
    "dim = numpy.shape(arr)\n",
    "\n",
    "print(numpy.mean(arr, axis=1))\n",
    "print(numpy.var(arr, axis = 0))\n",
    "print(round(numpy.std(arr),11))   #round due to \"wrong answer\" error on hackerrank"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Dot and Cross\n",
    "import numpy\n",
    "\n",
    "n= int(input())\n",
    "\n",
    "A = numpy.array([input().split() for _ in range(n)], int)\n",
    "(n, n) = numpy.shape(A)\n",
    "\n",
    "B=numpy.array([input().split() for _ in range(n)], int)\n",
    "(n, n) = numpy.shape(B)\n",
    "\n",
    "prod = numpy.dot(A,B)\n",
    "print(prod)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Inner and Outer\n",
    "import numpy\n",
    "\n",
    "A=numpy.array(input().split(), int)\n",
    "B=numpy.array(input().split(), int)\n",
    "\n",
    "print(numpy.inner(A,B))\n",
    "print(numpy.outer(A,B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Polynomials\n",
    "import numpy\n",
    "\n",
    "P = numpy.array(input().split(), float)\n",
    "x = float(input())\n",
    "\n",
    "print(numpy.polyval(P, x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Linear Algebra\n",
    "import numpy\n",
    "\n",
    "N = int(input())\n",
    "\n",
    "array = []\n",
    "for _ in range(N):\n",
    "    array.append(input().split())\n",
    "\n",
    "array = numpy.array(array, float)\n",
    "\n",
    "print(round(numpy.linalg.det(array), 2))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}