hackerrank_examples.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 6 7\n",
      "3 6 10\n",
      "1   1\n"
     ]
    }
   ],
   "source": [
    "# Compare the Triplets\n",
    "\n",
    "\"\"\"    If a[i] > b[i], then Alice is awarded 1 point.\n",
    "    If a[i] < b[i], then Bob is awarded 1 point.\n",
    "    If a[i] = b[i], then neither person receives a point.\n",
    "\"\"\"\n",
    "def compareTriplets(a, b):\n",
    "    aPoint=0\n",
    "    bPoint=0\n",
    "#     it can be len(b) also\n",
    "    for i in range(len(a)):\n",
    "        if a[i]>b[i]:\n",
    "            aPoint+=1\n",
    "        elif a[i]<b[i]:\n",
    "            bPoint+=1\n",
    "    return aPoint,bPoint      \n",
    "a=[int(x) for x in input().split()]\n",
    "b=[int(x) for x in input().split()]\n",
    "pointa,pointb=compareTriplets(a,b)\n",
    "print(pointa,\"\",pointb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1 2 3\n",
      "4 5 6\n",
      "9 8 9\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# Diagonal Difference\n",
    "def diagonalDifference(arr):\n",
    "    lsum=0\n",
    "    rsum=0\n",
    "    for i in range(len(arr)):\n",
    "        for j in range(len(arr[i])):\n",
    "            if i+j==n-1:\n",
    "                rsum+=arr[i][j]\n",
    "    for i in range(len(arr)):\n",
    "        for j in range(len(arr[i])):\n",
    "            if i==j:\n",
    "                lsum+=arr[i][j]\n",
    "                \n",
    "    return abs(lsum-rsum)           \n",
    "                \n",
    "n=int(input())\n",
    "arr = [[int(j) for j in input().split()]for i in range(n)]\n",
    "print(diagonalDifference(arr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 -1 1 1\n",
      "0.4\n",
      "0.2\n",
      "0.4\n"
     ]
    }
   ],
   "source": [
    "# Plus Minus\n",
    "\n",
    "def plusMinus(arr):\n",
    "    pos=0\n",
    "    n=len(arr)\n",
    "    neg=0\n",
    "    zero=0\n",
    "    for i in range(n):\n",
    "        if arr[i]>0:\n",
    "            pos+=1\n",
    "        elif arr[i]<0:\n",
    "            neg+=1\n",
    "        else:\n",
    "            zero+=1\n",
    "    print(round(pos/n,6))\n",
    "    print(round(neg/n,6))\n",
    "    print(round(zero/n,6))\n",
    "arr = list(map(int, input().rstrip().split()))\n",
    "plusMinus(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5\n",
      "10 14\n"
     ]
    }
   ],
   "source": [
    "# Mini-Max Sum\n",
    "def miniMaxSum(arr):\n",
    "    c=0\n",
    "    sm=[]\n",
    "    for i in range(len(arr)):\n",
    "#         1 2 3 4 5 \n",
    "        temp=0\n",
    "        for j in range(i,len(arr)-1):\n",
    "            temp+=arr[j]\n",
    "        sm.append(temp)\n",
    "        arr.append(arr[i])    \n",
    "            \n",
    "    print(min(sm),end=\" \")\n",
    "    print(max(sm))\n",
    "\n",
    "arr = [int(x) for x in input().split()]\n",
    "miniMaxSum(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "3 2 1 3\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# Birthday Cake Candles\n",
    "\n",
    "def birthdayCakeCandles(candles):\n",
    "    occurence={}\n",
    "    for i in candles:\n",
    "        if i in occurence:\n",
    "            occurence[i]=occurence[i]+1\n",
    "        else:            \n",
    "            occurence[i]=1\n",
    "    mx=-111\n",
    "    for i in occurence:\n",
    "        if occurence[i]>mx:\n",
    "            mx=occurence[i]\n",
    "    return mx        \n",
    "n=int(input())\n",
    "candles=[int(x) for x in input().split()]\n",
    "print(birthdayCakeCandles(candles))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "     #\n",
      "    ##\n",
      "   ###\n",
      "  ####\n",
      " #####\n",
      "######\n"
     ]
    }
   ],
   "source": [
    "#### Staircase\n",
    "def staircase(n):\n",
    "    i=0\n",
    "    j=0\n",
    "    s=0\n",
    "    while i<n:\n",
    "        j=0\n",
    "        s=0\n",
    "        while s<n-i-1:\n",
    "            print(' ',end=\"\")\n",
    "            s+=1\n",
    "        while j<=i:\n",
    "            print('#',end=\"\")\n",
    "            j+=1\n",
    "        print()    \n",
    "        i+=1\n",
    "        \n",
    "            \n",
    "n=int(input())\n",
    "staircase(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "07:05:45PM\n",
      "19:05:45\n"
     ]
    }
   ],
   "source": [
    "# Time Conversion\n",
    "def timeConversion(s):\n",
    "    hours=['13','14','15','16','17','18','19','20','21','22','23','24']\n",
    "    indexes={'01':1,'02':2,'03':3,'04':4,'05':5,'06':6,'07':7,'08':8,'09':9,'10':10,'11':11,'12':12}\n",
    "    if 'PM' in s or 'pm' in s:\n",
    "        sm=indexes[s[:2]]\n",
    "        change=hours[sm-1]\n",
    "        res=s[:len(s)-2]\n",
    "        res.replace(s[:2],change) \n",
    "        return res\n",
    "    else:\n",
    "        return s[:len(s)-2]\n",
    "s=input()\n",
    "print(timeConversion(s))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "73 67 38 33\n",
      "75 67 40 33\n"
     ]
    }
   ],
   "source": [
    "#### Grading Students\n",
    "\n",
    "def gradingStudents(grades):\n",
    "    check=3\n",
    "    start=1\n",
    "    result=[]\n",
    "    for i in grades:\n",
    "        start=1\n",
    "        flag=False\n",
    "        while start<check:\n",
    "            if (i+start)%5==0 and i+start >=40:\n",
    "                result.append(i+start)\n",
    "                flag=True\n",
    "            start+=1    \n",
    "        if flag is False:\n",
    "            result.append(i)\n",
    "    return result       \n",
    "n=int(input())\n",
    "grades=[int(x) for x in input().split()]\n",
    "result =gradingStudents(grades)\n",
    "print(*result)\n",
    "# 4\n",
    "# 73 67 38 33"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def countApplesAndOranges(s, t, a, b, apples, oranges):\n",
    "    one=0\n",
    "    two=0\n",
    "    for i in range(len(apples)):\n",
    "        apples[i]=a+apples[i]\n",
    "    for i in range((len(oranges))):\n",
    "        oranges[i]=b+oranges[i]\n",
    "    for i in apples:\n",
    "        if i <=t and i>=s:\n",
    "            one+=1\n",
    "    for i in oranges:\n",
    "        if i <=t and i>=s:\n",
    "            two+=1        \n",
    "    print(one)        \n",
    "    print(two)\n",
    "#     return one,two        \n",
    "st=[int(x) for x in input().split()]\n",
    "s=st[0]\n",
    "t=st[1]\n",
    "ab=[int(x) for x in input().split()]\n",
    "a=ab[0]\n",
    "b=ab[0]\n",
    "mn=[int(x) for x in input().split()]\n",
    "m=mn[0]\n",
    "n=mn[1]\n",
    "apples = list(map(int, input().rstrip().split()))\n",
    "oranges = list(map(int, input().rstrip().split()))\n",
    "one,two=countApplesAndOranges(s, t, a, b, apples, oranges)\n",
    "print(one,''two)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 3 4 2\n",
      "YES\n"
     ]
    }
   ],
   "source": [
    "# Number Line Jumps\n",
    "def kangaroo(x1, v1, x2, v2):\n",
    "    limit=10000\n",
    "    i=0\n",
    "    x=x1\n",
    "    y=x2\n",
    "    while i<limit:\n",
    "        x+=v1\n",
    "        y+=v2\n",
    "        if x==y:\n",
    "            return 'YES'\n",
    "        i+=1\n",
    "    return 'NO'\n",
    "x1,v1,x2,v2=[int(x) for x in input().split()]\n",
    "print(kangaroo(x1, v1, x2, v2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def divisibleSumPairs(n, k, ar):\n",
    "    res=0\n",
    "    for i in range(len(ar)):\n",
    "        for j in range(i+1,len(ar)):\n",
    "            if (int(ar[i]+ar[j])%k==0):\n",
    "                res+=1\n",
    "    return res       \n",
    "ar=[1,3,2,6,1,2]        \n",
    "n=6\n",
    "k=3\n",
    "print(divisibleSumPairs(n, k, ar))\n",
    "#     print(i%3,'and',i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "07:05:45PM\n",
      "19:05:45\n"
     ]
    }
   ],
   "source": [
    "# https://www.hackerrank.com/challenges/time-conversion/problem\n",
    "tMap = {'01':'13','02':'14','03':'15','04':'16','05':'17','06':'18','07':'19' ,'08':'20','09':'21','10':'22','11':'23','12':'24'}\n",
    "\n",
    "def timeConversion(s):\n",
    "    if 'PM' in s:\n",
    "        s=s.replace('PM','')\n",
    "        string = s.split(':')\n",
    "        string[0]=tMap[string[0]]    \n",
    "        return ':'.join(string)        \n",
    "    else:\n",
    "        s.replace('AM',' ')\n",
    "        return s;\n",
    "    # Write your code here\n",
    "s = input()\n",
    "print(timeConversion(s))\n",
    "# 07:05:45PM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'07:05:45'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'07:05:45PM'.replace('PM','')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Maximum Element\n",
    "\n",
    "You have an empty sequence, and you will be given\n",
    "\n",
    "queries. Each query is one of these three types:\n",
    "\n",
    "1 x  -Push the element x into the stack.\n",
    "2    -Delete the element present at the top of the stack.\n",
    "3    -Print the maximum element in the stack.\n",
    "\n",
    "Function Description\n",
    "\n",
    "Complete the getMax function in the editor below.\n",
    "\n",
    "getMax has the following parameters:\n",
    "- string operations[n]: operations as strings\n",
    "\n",
    "Returns\n",
    "- int[]: the answers to each type 3 query\n",
    "\n",
    "Input Format\n",
    "\n",
    "The first line of input contains an integer,\n",
    ". The next\n",
    "\n",
    "lines each contain an above mentioned query.\n",
    "\n",
    "Constraints\n",
    "\n",
    "Constraints\n",
    "\n",
    "\n",
    "\n",
    "All queries are valid.\n",
    "\n",
    "Sample Input\n",
    "\n",
    "STDIN   Function\n",
    "-----   --------\n",
    "10      operations[] size n = 10\n",
    "1 97    operations = ['1 97', '2', '1 20', ....]\n",
    "2\n",
    "1 20\n",
    "2\n",
    "1 26\n",
    "1 20\n",
    "2\n",
    "3\n",
    "1 91\n",
    "3\n",
    "\n",
    "Sample Output\n",
    "\n",
    "26\n",
    "91\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getMax():    \n",
    "    stack = []\n",
    "    max_stack = []\n",
    "    for i in range(int(input())):\n",
    "        try:\n",
    "            cmd = input()\n",
    "        except: \n",
    "            cmd = '3'        \n",
    "        if cmd[0] == '1':\n",
    "            n = int(cmd.split()[1])\n",
    "            stack.append(n)\n",
    "            if len(max_stack) == 0 or max_stack[-1] < n:\n",
    "                max_stack.append(n)\n",
    "            else: \n",
    "                max_stack.append(max_stack[-1])\n",
    "        elif cmd == '2':\n",
    "            stack.pop()\n",
    "            max_stack.pop()\n",
    "        else: \n",
    "            print(max_stack[-1])\n",
    "getMax()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Balanced Brackets'\n",
    "\n",
    "A bracket is considered to be any one of the following characters: (, ), {, }, [, or ].\n",
    "\n",
    "Two brackets are considered to be a matched pair if the an opening bracket (i.e., (, [, or {) occurs to the left of a closing bracket (i.e., ), ], or }) of the exact same type. There are three types of matched pairs of brackets: [], {}, and ().\n",
    "\n",
    "A matching pair of brackets is not balanced if the set of brackets it encloses are not matched. For example, {[(])} is not balanced because the contents in between { and } are not balanced. The pair of square brackets encloses a single, unbalanced opening bracket, (, and the pair of parentheses encloses a single, unbalanced closing square bracket, ].\n",
    "\n",
    "By this logic, we say a sequence of brackets is balanced if the following conditions are met:\n",
    "\n",
    "    It contains no unmatched brackets.\n",
    "    The subset of brackets enclosed within the confines of a matched pair of brackets is also a matched pair of brackets.\n",
    "\n",
    "Given\n",
    "\n",
    "strings of brackets, determine whether each sequence of brackets is balanced. If a string is balanced, return YES. Otherwise, return NO.\n",
    "\n",
    "Function Description\n",
    "\n",
    "Complete the function isBalanced in the editor below.\n",
    "\n",
    "isBalanced has the following parameter(s):\n",
    "\n",
    "    string s: a string of brackets\n",
    "\n",
    "Returns\n",
    "\n",
    "    string: either YES or NO\n",
    "\n",
    "Input Format\n",
    "\n",
    "The first line contains a single integer\n",
    ", the number of strings.\n",
    "Each of the next lines contains a single string\n",
    "\n",
    ", a sequence of brackets.\n",
    "\n",
    "Constraints\n",
    "\n",
    ", where\n",
    "\n",
    "    is the length of the sequence.\n",
    "    All chracters in the sequences ∈ { {, }, (, ), [, ] }.\n",
    "\n",
    "Output Format\n",
    "\n",
    "For each string, return YES or NO.\n",
    "\n",
    "Sample Input\n",
    "\n",
    "STDIN Function ----- -------- 3 n = 3 {[()]} first s = '{[()]}' {[(])} second s = '{[(])}' {{[[(())]]}} third s ='{{[[(())]]}}'\n",
    "\n",
    "Sample Output\n",
    "\n",
    "YES\n",
    "NO\n",
    "YES\n",
    "\n",
    "Explanation\n",
    "\n",
    "    The string {[()]} meets both criteria for being a balanced string.\n",
    "    The string {[(])} is not balanced because the brackets enclosed by the matched pair { and } are not balanced: [(]).\n",
    "    The string {{[[(())]]}} meets both criteria for being a balanced string.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def isBalanced(s):\n",
    "    s=list(s)\n",
    "    stack=[]\n",
    "    for i in s:\n",
    "        if i =='{' or i== '[' or i=='(':\n",
    "            stack.append(i)\n",
    "        elif i =='}' or i ==']' or i ==')':\n",
    "            if len(stack) == 0:\n",
    "                return False\n",
    "            stack.pop()\n",
    "    return len(stack) ==0\n",
    "    # Write your code here\n",
    "# isBalanced('{{[[(())]]}}')\n",
    "isBalanced('{[(])}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Largest Rectangle\n",
    "\n",
    "Skyline Real Estate Developers is planning to demolish a number of old, unoccupied buildings and construct a shopping mall in their place. Your task is to find the largest solid area in which the mall can be constructed.\n",
    "\n",
    "There are a number of buildings in a certain two-dimensional landscape. Each building has a height, given by\n",
    ". If you join adjacent buildings, they will form a solid rectangle of area\n",
    "\n",
    ".\n",
    "\n",
    "Example\n",
    "A rectangle of height and length can be constructed within the boundaries. The area formed is\n",
    "\n",
    ".\n",
    "\n",
    "Function Description\n",
    "\n",
    "Complete the function largestRectangle int the editor below. It should return an integer representing the largest rectangle that can be formed within the bounds of consecutive buildings.\n",
    "\n",
    "largestRectangle has the following parameter(s):\n",
    "\n",
    "    int h[n]: the building heights\n",
    "\n",
    "Returns\n",
    "- long: the area of the largest rectangle that can be formed within the bounds of consecutive buildings\n",
    "\n",
    "Input Format\n",
    "\n",
    "The first line contains\n",
    ", the number of buildings.\n",
    "The second line contains\n",
    "\n",
    "space-separated integers, each the height of a building.\n",
    "\n",
    "Constraints\n",
    "\n",
    "Sample Input\n",
    "\n",
    "STDIN       Function\n",
    "-----       --------\n",
    "5           h[] size n = 5\n",
    "1 2 3 4 5   h = [1, 2, 3, 4, 5]\n",
    "\n",
    "Sample Output\n",
    "\n",
    "9\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "18\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "def largestRectangle(h):\n",
    "    res = 0\n",
    "    \n",
    "    for i in range(len(h)):\n",
    "        length = 0\n",
    "        for j in range(i, -1, -1):\n",
    "            if h[j] >= h[i]:\n",
    "                length += 1\n",
    "            else:\n",
    "                break\n",
    "                \n",
    "        for j in range(i+1, len(h)):\n",
    "            if h[j] >= h[i]:\n",
    "                length += 1\n",
    "            else:\n",
    "                break\n",
    "        res = max(res, length*h[i]) \n",
    "    return res    \n",
    "print(largestRectangle([1,2,3,4,5])) # 8\n",
    "print(largestRectangle([1,3,5,9,11]))# 18\n",
    "print(largestRectangle([11,11,10,10,10])) # 50"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Waiter\n",
    "\n",
    "You are a waiter at a party. There is a pile of numbered plates. Create an empty array. At each iteration, , remove each plate from the top of the stack in order. Determine if the number on the plate is evenly divisible by the prime number. If it is, stack it in pile . Otherwise, stack it in stack . Store the values in from top to bottom in . In the next iteration, do the same with the values in stack . Once the required number of iterations is complete, store the remaining values in in , again from top to bottom. Return the\n",
    "\n",
    "array.\n",
    "\n",
    "Example\n",
    "\n",
    "\n",
    "An abbreviated list of primes is\n",
    "\n",
    ". Stack the plates in reverse order.\n",
    "\n",
    "\n",
    "Begin iterations. On the first iteration, check if items are divisible by .\n",
    "\n",
    "Move elements to\n",
    "\n",
    ".\n",
    "\n",
    "On the second iteration, test if elements are divisible by .\n",
    "\n",
    "Move elmements to\n",
    "\n",
    ".\n",
    "\n",
    "And on the third iteration, test if elements are divisible by .\n",
    "\n",
    "Move elmements to\n",
    "\n",
    ".\n",
    "\n",
    "All iterations are complete, so move the remaining elements in , from top to bottom, to\n",
    "\n",
    ".\n",
    "\n",
    ". Return this list.\n",
    "\n",
    "Function Description\n",
    "\n",
    "Complete the waiter function in the editor below.\n",
    "\n",
    "waiter has the following parameters:\n",
    "\n",
    "    int number[n]: the numbers on the plates\n",
    "    int q: the number of iterations\n",
    "\n",
    "Returns\n",
    "\n",
    "    int[n]: the numbers on the plates after processing\n",
    "\n",
    "Input Format\n",
    "\n",
    "The first line contains two space separated integers,\n",
    "and .\n",
    "The next line contains space separated integers representing the initial pile of plates, i.e.,\n",
    "\n",
    ".\n",
    "\n",
    "Constraints\n",
    "\n",
    "\n",
    "\n",
    "Sample Input 0\n",
    "\n",
    "5 1\n",
    "3 4 7 6 5\n",
    "\n",
    "Sample Output 0\n",
    "\n",
    "4\n",
    "6\n",
    "3\n",
    "7\n",
    "5\n",
    "\n",
    "Explanation 0\n",
    "\n",
    "Initially:\n",
    "\n",
    "= [3, 4, 7, 6, 5]<-TOP\n",
    "\n",
    "After 1 iteration (divide by 2, the 1st prime number):\n",
    "\n",
    "= [5, 7, 3]<-TOP\n",
    "\n",
    "= [6, 4]<-TOP\n",
    "\n",
    "Move\n",
    "elements to\n",
    "\n",
    ".\n",
    "\n",
    "All iterations are complete, so move elements to\n",
    "\n",
    ".\n",
    "\n",
    ".\n",
    "\n",
    "Sample Input 1\n",
    "\n",
    "5 2\n",
    "3 3 4 4 9\n",
    "\n",
    "Sample Output 1\n",
    "\n",
    "4\n",
    "4\n",
    "9\n",
    "3\n",
    "3\n",
    "\n",
    "Explanation 1\n",
    "\n",
    "Initially:\n",
    "\n",
    "= [3, 3, 4, 4, 9]<-TOP\n",
    "\n",
    "After\n",
    "\n",
    "iteration (divide by 2):\n",
    "\n",
    "= [9, 3, 3]<-TOP\n",
    "\n",
    "= [4, 4]<-TOP\n",
    "\n",
    "Move\n",
    "to\n",
    "\n",
    ".\n",
    "\n",
    "After\n",
    "\n",
    "iteration (divide by 3):\n",
    "\n",
    "= []<- TOP\n",
    "\n",
    "= [3, 3, 9]<-TOP\n",
    "\n",
    "Move\n",
    "elements to\n",
    "\n",
    ".\n",
    "\n",
    "There are no values remaining in . "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 4, 9, 3, 3]\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "def waiter(number, q):\n",
    "    lower = 2\n",
    "    upper = 10000\n",
    "    prime = [i for i in range(lower, upper + 1) if all(i % j != 0 for j in range(2, i))]\n",
    "    A = [[] for i in range(q + 1)] \n",
    "    B = [[] for i in range(q + 1)] \n",
    "    A[0] = number\n",
    "    result=[]\n",
    "    for i in range(q):\n",
    "        for j in range(len(A[i])):\n",
    "            n = A[i].pop()\n",
    "            if n % prime[i] == 0:\n",
    "                B[i].append(n)\n",
    "            else :\n",
    "                A[i+1].append(n)\n",
    "    for i in range(len(B)):\n",
    "        while B[i] != []:\n",
    "            result.append(B[i].pop())\n",
    "    for i in range(len(A)):\n",
    "        while A[i] != []:\n",
    "            result.append(A[i].pop())\n",
    "    return  result\n",
    "# print(waiter([3,4,7,6,5],1)) # [4, 6, 3, 7, 5]\n",
    "print(waiter([3,3,4,4,9],2)) # [4, 4, 9, 3, 3]"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}