Assignment_6.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://communications.univie.ac.at/fileadmin/_processed_/csm_Uni_Logo_2016_2f47aacf37.jpg\" \n",
    "     alt=\"Logo Universität Wien\" \n",
    "     width=\"200\"/>\n",
    "\n",
    "# Practical Machine Learning for Natural Language Processing - 2023 SS  \n",
    "\n",
    "### Assigment 2 - Generators and Classes   \n",
    "\n",
    "In this assigment we are going to play with generators and instances/classes - structures that retain state.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Alea Iacta Est  \n",
    "\n",
    "(a) Using [generator functions](https://github.com/rsouza/Python_Course/blob/master/Notebooks/Python_Basic/03_Functions.ipynb), create an object that emulates an eight-sided dice (1-8) that is biased, such that the probability of this generator function returning a certain value is proportional to the value itself (i.e. the face \"6\" is 3 times more likely to come out than face \"2\");  \n",
    "\n",
    " <img src=\"https://cdn11.bigcommerce.com/s-70184/images/stencil/608x608/products/532/7428/d8-dice-blue__64321.1664335674.jpg\" alt=\"8-Dice\" style=\"width:250px;height:300px;\"> \n",
    "\n",
    "(b) Using [Matplotlib](https://matplotlib.org/) plt.plot or plt.hist commands, show graphically the result of 10000 casts of the die;  \n",
    "\n",
    "(c) Modify this generator function so that it terminates automatically when all possible values (1,2,3,4,5,6,7,8) have been cast at least once. In this case, it will return the total absolute time that has elapsed since the first iteration.  (hint: a function can have both **return** and **yield** commands)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a) \n",
    "import random\n",
    "    \n",
    "def dice_rolling(casts):\n",
    "    dice = ([i, i*(1/sum(range(1, 9)))] for i in range(1, 9))\n",
    "    values = []\n",
    "    p = []\n",
    "    for m,n in dice:\n",
    "        values.append(m)\n",
    "        p.append(n)\n",
    "    return(random.choices(values, weights=p, k=casts))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# b)\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "x = np.array(dice_rolling(10000))\n",
    "\n",
    "# plot:\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "ax.hist(x, bins=8, linewidth=0.5, edgecolor=\"white\")\n",
    "\n",
    "ax.set(xlim=(0, 9), xticks=np.arange(0, 8),\n",
    "       ylim=(0, 3000), yticks=np.linspace(0, 3000, 12))\n",
    "plt.xlabel('Dice Side')\n",
    "plt.ylabel('Casts Number')\n",
    "plt.title('Histogram Dice Casts')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "48\n"
     ]
    }
   ],
   "source": [
    "# c)\n",
    "def dice_rolling_modify():\n",
    "    dice = ([i, i*(1/sum(range(1, 9)))] for i in range(1, 9))\n",
    "    values = []\n",
    "    p = []\n",
    "    for m,n in dice:\n",
    "        values.append(m)\n",
    "        p.append(n)\n",
    "    dice_rolls = []\n",
    "    counter = 0\n",
    "    for i in range(1, 9):\n",
    "        while i not in dice_rolls:\n",
    "            dice_rolls.append(random.choices(values, weights=p)[0])\n",
    "            counter += 1\n",
    "    return counter\n",
    "print(dice_rolling_modify())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. A ticket to the first Class    \n",
    "\n",
    "+ Create a Class called \"Elevator\". Each instance of this class receives as parameters the number of floors in the building and starts the elevator on the lowest floor.  \n",
    "+ This Class should have methods and properties to allow the elevator to:\n",
    "<br></br>\n",
    "    + Receive a call - user(s) press a button to go to specific floor(s);  \n",
    "    + Receive a floor as a destination - when users enter the elevator, each one may press a button to choose destination floor;  \n",
    "    + Store and inform which floor the elevator is at each moment(consider that trips for consecutive floors takes 5 seconds, and stopping takes 10 seconds);  \n",
    "    + Store and inform which users are in the elevator;  \n",
    "    + Store and inform the sequence of floors yet to be visited;  \n",
    "    + Store the number of times the elevator stopped in each floor (passing through the floor without \"stopping\" on the floor does not count);  \n",
    "    + Refuses commands to go to inexistent floors.  \n",
    "<br></br>\n",
    "+ Simulate the behavior of the elevator serving ten users, each one calling from a random floor, and chosing a random destination floor.   \n",
    "+ Graphically illustrate the current elevator position for the requested simulation.   \n",
    "+ (BONUS) Create a smart building simulator, controlling calls made to n > 1 elevators and routing elevator properly.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Elevator:\n",
    "    def __init__(self, floor_num, pickup, dropoff):\n",
    "        self.cur_floor = 0\n",
    "        self.floors = floor_num\n",
    "        self.visited_floors = []\n",
    "        self.pickup = pickup\n",
    "        self.dropoff = dropoff\n",
    "        self.users = {}\n",
    "        self.users_present = []\n",
    "        self.timetable = []\n",
    "        self.time = 0\n",
    "         \n",
    "        \n",
    "        if self.correct(pickup) == True and self.correct(dropoff)== True:\n",
    "            self.order(pickup, dropoff)\n",
    "            \n",
    "    \n",
    "    def correct(self,nums):\n",
    "        if len(nums) > 1:\n",
    "            for i in nums:\n",
    "                if i > self.floors or i < 0:\n",
    "                    print(\"The requested floor does not exist, please request a different floor.\")\n",
    "                    quit()\n",
    "                elif len(self.pickup) != len(self.dropoff):\n",
    "                    print(\"There is no equal number of pickup and dropoff. Please, try again\")\n",
    "                    quit()\n",
    "            return True\n",
    "        if i > self.floors or i < 0:\n",
    "            print(\"The requested floor does not exist, please request a different number.\")\n",
    "            quit()\n",
    "        else:\n",
    "            print(\"Got it\")\n",
    "            return True\n",
    "    \n",
    "    #a function to go up\n",
    "    def go_up(self, floor_now, floor_goal):\n",
    "        f = floor_now\n",
    "        for i in range(floor_now, floor_goal-1):\n",
    "            f = f + 1\n",
    "            self.time += 5\n",
    "            print(\"*MOVING*\\n Floor: \", f)\n",
    "        floor_now = f + 1\n",
    "        self.time += 10\n",
    "        self.timetable.append([floor_now, self.time])\n",
    "        print( \"*MOVING*\\n*STOPPING*\\nYou arrived to the floor: \", floor_now)\n",
    "        return floor_now\n",
    "    \n",
    "    #a function to go down   \n",
    "    def go_down(self, floor_now, floor_goal):\n",
    "        now_floor = floor_now\n",
    "        for i in range(now_floor, floor_goal+1, -1):\n",
    "            floor_now = floor_now - 1\n",
    "            self.time += 5\n",
    "            print( \"*MOVING* Floor: \", floor_now)\n",
    "        floor_now = floor_now - 1\n",
    "        self.time += 10\n",
    "        self.timetable.append([floor_now, self.time])\n",
    "        print( \"*MOVING\\n*STOPPING*\\n You arrived to the floor: \", floor_now)\n",
    "        return floor_now\n",
    "\n",
    "    #a function to display current users            \n",
    "    def user_funct(self):\n",
    "        print(\"There are \", len(self.users_present), \"users in the elevator:\" )\n",
    "        for l,k in self.users_present:\n",
    "            print(\"Entered floor: \",l , \"Leaving floor: \", k)\n",
    "            \n",
    "   \n",
    "    #a function to display visited floors                   \n",
    "    def visited(self):\n",
    "        sorted_visited = {}\n",
    "        for i in self.visited_floors:\n",
    "            if i in sorted_visited.keys():\n",
    "                sorted_visited[i] += 1\n",
    "            else:\n",
    "                sorted_visited[i] = 1\n",
    "                \n",
    "        print(\"Visited floors: \", sorted_visited)\n",
    "    \n",
    "    def time_traveling(self):\n",
    "        return(self.timetable)\n",
    "    \n",
    "    def remaining(self):\n",
    "        floors_left = [l for k,l in self.users_present]\n",
    "        if len(floors_left) > 0:\n",
    "            print(\"Remaining floors to travel to: \", set(floors_left))\n",
    "        return floors_left\n",
    "\n",
    "    #a function to pick up a user\n",
    "    def pick(self, pickup_floor, dropoff_floor):\n",
    "        if self.cur_floor == pickup_floor:\n",
    "            print(\"User(s) entered at the floor\", self.cur_floor)\n",
    "        elif pickup_floor < dropoff_floor:\n",
    "            print(\"*** Elevator called at the floor\", pickup_floor,\"***\")\n",
    "            self.cur_floor = self.go_up(self.cur_floor, pickup_floor)\n",
    "        else:\n",
    "            print(\"*** Elevator called at the floor\", pickup_floor,\"***\")\n",
    "            self.cur_floor = self.go_down(self.cur_floor, pickup_floor)\n",
    "        self.users_present.append([pickup_floor, dropoff_floor])\n",
    "        [self.users_present.remove([m,n]) for m, n in self.users_present if self.cur_floor == n]\n",
    "        self.user_funct()\n",
    "        self.remaining()\n",
    "        self.visited_floors.append(pickup_floor)\n",
    "        \n",
    "        \n",
    "    #a function to drop off a user    \n",
    "    def drop(self, pickup_floor, dropoff_floor):  \n",
    "        if self.cur_floor == dropoff_floor:\n",
    "            pass\n",
    "        elif pickup_floor < dropoff_floor:\n",
    "            self.cur_floor = self.go_up(self.cur_floor, dropoff_floor)\n",
    "        elif pickup_floor > dropoff_floor:\n",
    "            self.cur_floor = self.go_down(self.cur_floor, dropoff_floor)\n",
    "            \n",
    "        print(\"User(s) left at the floor\", self.cur_floor)\n",
    "        self.users_present.remove([pickup_floor, dropoff_floor])\n",
    "        self.user_funct()\n",
    "        self.remaining()\n",
    "        self.visited_floors.append(dropoff_floor)\n",
    "        \n",
    "        \n",
    "    #a function to order the floors to visit\n",
    "    def order(self, p, d):\n",
    "        going_up = []\n",
    "        going_down = []\n",
    "        up_floors_list = []\n",
    "        down_floors_list = []\n",
    "                              \n",
    "        if len(p)>1 or len(d)>1:\n",
    "            for i in range(len(p)):\n",
    "                self.users[p[i]]= d[i]\n",
    "                if p[i] < d[i]:\n",
    "                    going_up.append([p[i],d[i]])\n",
    "                    going_up.sort(key=lambda x: x[0]) \n",
    "                    up_floors_list.append(p[i])\n",
    "                    up_floors_list.append(d[i])\n",
    "                    \n",
    "                else:\n",
    "                    going_down.append([p[i],d[i]])\n",
    "                    going_down.sort(key=lambda x: x[0], reverse = True)\n",
    "                    down_floors_list.append(p[i])\n",
    "                    down_floors_list.append(d[i])\n",
    "        up_floors_list_sorted = sorted(set(up_floors_list))\n",
    "        down_floors_list_sorted = sorted(set(down_floors_list), reverse = True)\n",
    "        \n",
    "        turn_up = 0\n",
    "        for i in up_floors_list_sorted:\n",
    "            if [True for n, m in going_up if n == i]:\n",
    "                for n, m in [[n,m] for n, m in going_up if n == i]:\n",
    "                    self.pick(n, m)\n",
    "                    turn_up = 1\n",
    "            elif turn_up == 1 and [True for n, m in going_up if m == i]:\n",
    "                for n, m in [[n,m] for n, m in going_up if m == i]:\n",
    "                    self.drop(n, m)\n",
    "                \n",
    "        turn_down = 0\n",
    "        \n",
    "        for i in down_floors_list_sorted:\n",
    "            if [True for n, m in going_down if n == i]:\n",
    "                for n, m in [[n,m] for n, m in going_down if n == i]:\n",
    "                    self.pick(n, m)\n",
    "                    turn_down = 1\n",
    "            elif turn_down == 1 and [True for n, m in going_down if m == i]:\n",
    "                for n, m in [[n,m] for n, m in going_down if m == i]:\n",
    "                    self.drop(n,m)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "going up: [[0, 17], [2, 18], [3, 5], [5, 7], [10, 15], [14, 15]]\n",
      "up sorted [0, 2, 3, 5, 7, 10, 14, 15, 17, 18]\n",
      "going down [[14, 3], [12, 9], [9, 1], [5, 0]]\n",
      "down sorted [14, 12, 9, 5, 3, 1, 0]\n",
      "User(s) entered at the floor 0\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  0 Leaving floor:  17\n",
      "Remaining floors to travel to:  {17}\n",
      "*** Elevator called at the floor 2 ***\n",
      "*MOVING*\n",
      " Floor:  1\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  2\n",
      "There are  2 users in the elevator:\n",
      "Entered floor:  0 Leaving floor:  17\n",
      "Entered floor:  2 Leaving floor:  18\n",
      "Remaining floors to travel to:  {17, 18}\n",
      "*** Elevator called at the floor 3 ***\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  3\n",
      "There are  3 users in the elevator:\n",
      "Entered floor:  0 Leaving floor:  17\n",
      "Entered floor:  2 Leaving floor:  18\n",
      "Entered floor:  3 Leaving floor:  5\n",
      "Remaining floors to travel to:  {17, 18, 5}\n",
      "*** Elevator called at the floor 5 ***\n",
      "*MOVING*\n",
      " Floor:  4\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  5\n",
      "There are  3 users in the elevator:\n",
      "Entered floor:  0 Leaving floor:  17\n",
      "Entered floor:  2 Leaving floor:  18\n",
      "Entered floor:  5 Leaving floor:  7\n",
      "Remaining floors to travel to:  {17, 18, 7}\n",
      "*MOVING*\n",
      " Floor:  6\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  7\n",
      "User(s) left at the floor 7\n",
      "There are  2 users in the elevator:\n",
      "Entered floor:  0 Leaving floor:  17\n",
      "Entered floor:  2 Leaving floor:  18\n",
      "Remaining floors to travel to:  {17, 18}\n",
      "*** Elevator called at the floor 10 ***\n",
      "*MOVING*\n",
      " Floor:  8\n",
      "*MOVING*\n",
      " Floor:  9\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  10\n",
      "There are  3 users in the elevator:\n",
      "Entered floor:  0 Leaving floor:  17\n",
      "Entered floor:  2 Leaving floor:  18\n",
      "Entered floor:  10 Leaving floor:  15\n",
      "Remaining floors to travel to:  {17, 18, 15}\n",
      "*** Elevator called at the floor 14 ***\n",
      "*MOVING*\n",
      " Floor:  11\n",
      "*MOVING*\n",
      " Floor:  12\n",
      "*MOVING*\n",
      " Floor:  13\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  14\n",
      "There are  4 users in the elevator:\n",
      "Entered floor:  0 Leaving floor:  17\n",
      "Entered floor:  2 Leaving floor:  18\n",
      "Entered floor:  10 Leaving floor:  15\n",
      "Entered floor:  14 Leaving floor:  15\n",
      "Remaining floors to travel to:  {17, 18, 15}\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  15\n",
      "User(s) left at the floor 15\n",
      "There are  3 users in the elevator:\n",
      "Entered floor:  0 Leaving floor:  17\n",
      "Entered floor:  2 Leaving floor:  18\n",
      "Entered floor:  14 Leaving floor:  15\n",
      "Remaining floors to travel to:  {17, 18, 15}\n",
      "User(s) left at the floor 15\n",
      "There are  2 users in the elevator:\n",
      "Entered floor:  0 Leaving floor:  17\n",
      "Entered floor:  2 Leaving floor:  18\n",
      "Remaining floors to travel to:  {17, 18}\n",
      "*MOVING*\n",
      " Floor:  16\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  17\n",
      "User(s) left at the floor 17\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  2 Leaving floor:  18\n",
      "Remaining floors to travel to:  {18}\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  18\n",
      "User(s) left at the floor 18\n",
      "There are  0 users in the elevator:\n",
      "*** Elevator called at the floor 14 ***\n",
      "*MOVING* Floor:  17\n",
      "*MOVING* Floor:  16\n",
      "*MOVING* Floor:  15\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  14\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  14 Leaving floor:  3\n",
      "Remaining floors to travel to:  {3}\n",
      "*** Elevator called at the floor 12 ***\n",
      "*MOVING* Floor:  13\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  12\n",
      "There are  2 users in the elevator:\n",
      "Entered floor:  14 Leaving floor:  3\n",
      "Entered floor:  12 Leaving floor:  9\n",
      "Remaining floors to travel to:  {9, 3}\n",
      "*** Elevator called at the floor 9 ***\n",
      "*MOVING* Floor:  11\n",
      "*MOVING* Floor:  10\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  9\n",
      "There are  2 users in the elevator:\n",
      "Entered floor:  14 Leaving floor:  3\n",
      "Entered floor:  9 Leaving floor:  1\n",
      "Remaining floors to travel to:  {1, 3}\n",
      "*** Elevator called at the floor 5 ***\n",
      "*MOVING* Floor:  8\n",
      "*MOVING* Floor:  7\n",
      "*MOVING* Floor:  6\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  5\n",
      "There are  3 users in the elevator:\n",
      "Entered floor:  14 Leaving floor:  3\n",
      "Entered floor:  9 Leaving floor:  1\n",
      "Entered floor:  5 Leaving floor:  0\n",
      "Remaining floors to travel to:  {0, 1, 3}\n",
      "*MOVING* Floor:  4\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  3\n",
      "User(s) left at the floor 3\n",
      "There are  2 users in the elevator:\n",
      "Entered floor:  9 Leaving floor:  1\n",
      "Entered floor:  5 Leaving floor:  0\n",
      "Remaining floors to travel to:  {0, 1}\n",
      "*MOVING* Floor:  2\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  1\n",
      "User(s) left at the floor 1\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  5 Leaving floor:  0\n",
      "Remaining floors to travel to:  {0}\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  0\n",
      "User(s) left at the floor 0\n",
      "There are  0 users in the elevator:\n"
     ]
    }
   ],
   "source": [
    "#Simulate the behavior of the elevator serving ten users, \n",
    "#each one calling from a random floor, and chosing a random destination floor.\n",
    "import random\n",
    "\n",
    "in_floors = [random.randint(0,19) for i in range(10)]\n",
    "out_floors = [random.randint(0,19) for i in range(10)]\n",
    "\n",
    "elevator1 = Elevator(19, in_floors, out_floors) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Traveling time plot')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 500x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Graphically illustrate the current elevator position for the requested simulation.\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "time_elevator1 = elevator1.time_traveling()\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(5, 7))\n",
    "ax.plot([i[0] for i in time_elevator1], [i[1] for i in time_elevator1])\n",
    "ax.set_xlabel('Floors')  # Add an x-label to the axes.\n",
    "ax.set_ylabel('Seconds')  # Add a y-label to the axes.\n",
    "ax.set_title(\"Traveling time plot\")  # Add a title to the axes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#a new version but unsure how to implement time\n",
    "#Work in progress\n",
    "import random\n",
    "\n",
    "class Elevator1:\n",
    "    def __init__(self, floor_num):\n",
    "        self.cur_floor = 0\n",
    "        self.floors = floor_num\n",
    "        self.visited_floors = []\n",
    "        self.users_present = []\n",
    "        self.users = {}\n",
    "        self.timetable = []\n",
    "        self.time = 0\n",
    "        \n",
    "        self.going_up = []\n",
    "        self.going_down = []\n",
    "        self.up_floors_list = []\n",
    "        self.down_floors_list = []\n",
    "        \n",
    "        self.begin()\n",
    "             \n",
    "    def begin(self):\n",
    "        #the number of passengers can be changed\n",
    "        #passenger = self.entering_and_leaving(1)\n",
    "        \n",
    "        for i in range(10):\n",
    "            cur_passenger = self.entering_and_leaving(1)\n",
    "            x, y = cur_passenger\n",
    "            self.order(int(x[0]), int(y[0]))\n",
    "            \n",
    "           \n",
    "    def entering_and_leaving(self, passengers):\n",
    "        \n",
    "        in_floor = [random.randint(0,self.floors) for i in range(passengers)]\n",
    "        out_floor = [random.randint(0,self.floors)]\n",
    "        return in_floor, out_floor\n",
    "        \n",
    "    def correct(self, in_floor, out_floor):\n",
    "        if in_floor == out_floor:\n",
    "            print (\"It is not possible to request and leave at the same floor\")\n",
    "            return False\n",
    "    \n",
    "\n",
    "    #a function to go up\n",
    "    def go_up(self, floor_now, floor_goal):\n",
    "        f = floor_now\n",
    "        for i in range(floor_now, floor_goal-1):\n",
    "            f = f + 1\n",
    "            self.time += 5\n",
    "            print(\"*MOVING*\\n Floor: \", f)\n",
    "        floor_now = f + 1\n",
    "        self.time += 10\n",
    "        self.timetable.append([floor_now, self.time])\n",
    "        print( \"*MOVING*\\n*STOPPING*\\nYou arrived to the floor: \", floor_now)\n",
    "        return floor_now\n",
    "    \n",
    "    #a function to go down   \n",
    "    def go_down(self, floor_now, floor_goal):\n",
    "        now_floor = floor_now\n",
    "        for i in range(now_floor, floor_goal+1, -1):\n",
    "            floor_now = floor_now - 1\n",
    "            self.time += 5\n",
    "            print( \"*MOVING* Floor: \", floor_now)\n",
    "        floor_now = floor_now - 1\n",
    "        self.time += 10\n",
    "        self.timetable.append([floor_now, self.time])\n",
    "        print( \"*MOVING\\n*STOPPING*\\n You arrived to the floor: \", floor_now)\n",
    "        return floor_now\n",
    "    \n",
    "    #a function to display current users            \n",
    "    def user_funct(self):\n",
    "        print(\"There are \", len(self.users_present), \"users in the elevator:\" )\n",
    "        for l,k in self.users_present:\n",
    "            print(\"Entered floor: \",l , \"Leaving floor: \", k)\n",
    "            \n",
    "    #a function to display visited floors                   \n",
    "    def visited(self):\n",
    "        sorted_visited = {}\n",
    "        for i in self.visited_floors:\n",
    "            if i in sorted_visited.keys():\n",
    "                sorted_visited[i] += 1\n",
    "            else:\n",
    "                sorted_visited[i] = 1      \n",
    "        print(\"Visited floors: \", sorted_visited)\n",
    "    \n",
    "    #a function to create a time table for traveling across floors\n",
    "    def time_traveling(self):\n",
    "        return(self.timetable)\n",
    "    \n",
    "    #a function to display how many floors are left to travel to \n",
    "    def remaining(self):\n",
    "        floors_left = [l for k,l in self.users_present]\n",
    "        if len(floors_left) > 0:\n",
    "            print(\"Remaining floors to travel to: \", set(floors_left))\n",
    "        return floors_left\n",
    "\n",
    "    #a function to pick up a user\n",
    "    def pick(self, pickup_floor, dropoff_floor):\n",
    "        if self.cur_floor == pickup_floor:\n",
    "            print(\"User(s) entered at the floor\", self.cur_floor)\n",
    "        elif pickup_floor < dropoff_floor:\n",
    "            print(\"*** Elevator called at the floor\", pickup_floor,\"***\")\n",
    "            self.cur_floor = self.go_up(self.cur_floor, pickup_floor)\n",
    "        else:\n",
    "            print(\"*** Elevator called at the floor\", pickup_floor,\"***\")\n",
    "            self.cur_floor = self.go_down(self.cur_floor, pickup_floor)\n",
    "        self.users_present.append([pickup_floor, dropoff_floor])\n",
    "        [self.users_present.remove([m,n]) for m, n in self.users_present if self.cur_floor == n]\n",
    "        self.user_funct()\n",
    "        self.remaining()\n",
    "        self.visited_floors.append(pickup_floor)\n",
    "        \n",
    "        \n",
    "    #a function to drop off a user    \n",
    "    def drop(self, pickup_floor, dropoff_floor):  \n",
    "        if self.cur_floor == dropoff_floor:\n",
    "            pass\n",
    "        elif pickup_floor < dropoff_floor:\n",
    "            self.cur_floor = self.go_up(self.cur_floor, dropoff_floor)\n",
    "        elif pickup_floor > dropoff_floor:\n",
    "            self.cur_floor = self.go_down(self.cur_floor, dropoff_floor)\n",
    "            \n",
    "        print(\"User(s) left at the floor\", self.cur_floor)\n",
    "        self.users_present.remove([pickup_floor, dropoff_floor])\n",
    "        self.user_funct()\n",
    "        self.remaining()\n",
    "        self.visited_floors.append(dropoff_floor)\n",
    "        \n",
    "    \n",
    "    \n",
    "    #a function to order the floors to visit\n",
    "    def order(self, p, d):                  \n",
    "        self.users[p]= d\n",
    "        if p < d:\n",
    "            self.going_up.append([p,d])\n",
    "            self.going_up.sort(key=lambda x: x[0]) \n",
    "            self.up_floors_list.append(p)\n",
    "            self.up_floors_list.append(d)\n",
    "                    \n",
    "        else:\n",
    "            self.going_down.append([p,d])\n",
    "            self.going_down.sort(key=lambda x: x[0], reverse = True)\n",
    "            self.down_floors_list.append(p)\n",
    "            self.down_floors_list.append(d)\n",
    "                    \n",
    "        up_floors_list_sorted = sorted(set(self.up_floors_list))\n",
    "        down_floors_list_sorted = sorted(set(self.down_floors_list), reverse = True)\n",
    "        \n",
    "        #turn_up = 0\n",
    "        \n",
    "        for n,m in self.going_up:\n",
    "            print(self.cur_floor)\n",
    "            self.pick(n,m)\n",
    "            self.drop(n,m)\n",
    "            \n",
    "        for n,m in self.going_down:\n",
    "            print(self.cur_floor)\n",
    "            self.pick(n,m)\n",
    "            self.drop(n,m)\n",
    "        \n",
    "            \n",
    "            \n",
    "        \n",
    "#         for i in up_floors_list_sorted:\n",
    "#             if [True for n, m in self.going_up if n == i]:\n",
    "#                 for n, m in [[n,m] for n, m in self.going_up if n == i]:\n",
    "#                     self.pick(n, m)\n",
    "#                     turn_up = 1\n",
    "#             elif turn_up == 1 and [True for n, m in self.going_up if m == i]:\n",
    "#                 for n, m in [[n,m] for n, m in self.going_up if m == i]:\n",
    "#                     self.drop(n, m)\n",
    "                \n",
    "#         turn_down = 0\n",
    "#         for i in down_floors_list_sorted:\n",
    "#             if [True for n, m in self.going_down if n == i]:\n",
    "#                 for n, m in [[n,m] for n, m in self.going_down if n == i]:\n",
    "#                     self.pick(n, m)\n",
    "#                     turn_down = 1\n",
    "#             elif turn_down == 1 and [True for n, m in self.going_down if m == i]:\n",
    "#                 for n, m in [[n,m] for n, m in self.going_down if m == i]:\n",
    "#                     self.drop(n,m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "*** Elevator called at the floor 9 ***\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  -1\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  9 Leaving floor:  6\n",
      "Remaining floors to travel to:  {6}\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  -2\n",
      "User(s) left at the floor -2\n",
      "There are  0 users in the elevator:\n",
      "-2\n",
      "*** Elevator called at the floor 9 ***\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  -3\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  9 Leaving floor:  6\n",
      "Remaining floors to travel to:  {6}\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  -4\n",
      "User(s) left at the floor -4\n",
      "There are  0 users in the elevator:\n",
      "-4\n",
      "*** Elevator called at the floor 6 ***\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  -5\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  6 Leaving floor:  0\n",
      "Remaining floors to travel to:  {0}\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  -6\n",
      "User(s) left at the floor -6\n",
      "There are  0 users in the elevator:\n",
      "-6\n",
      "*** Elevator called at the floor 1 ***\n",
      "*MOVING*\n",
      " Floor:  -5\n",
      "*MOVING*\n",
      " Floor:  -4\n",
      "*MOVING*\n",
      " Floor:  -3\n",
      "*MOVING*\n",
      " Floor:  -2\n",
      "*MOVING*\n",
      " Floor:  -1\n",
      "*MOVING*\n",
      " Floor:  0\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  1\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  1 Leaving floor:  18\n",
      "Remaining floors to travel to:  {18}\n",
      "*MOVING*\n",
      " Floor:  2\n",
      "*MOVING*\n",
      " Floor:  3\n",
      "*MOVING*\n",
      " Floor:  4\n",
      "*MOVING*\n",
      " Floor:  5\n",
      "*MOVING*\n",
      " Floor:  6\n",
      "*MOVING*\n",
      " Floor:  7\n",
      "*MOVING*\n",
      " Floor:  8\n",
      "*MOVING*\n",
      " Floor:  9\n",
      "*MOVING*\n",
      " Floor:  10\n",
      "*MOVING*\n",
      " Floor:  11\n",
      "*MOVING*\n",
      " Floor:  12\n",
      "*MOVING*\n",
      " Floor:  13\n",
      "*MOVING*\n",
      " Floor:  14\n",
      "*MOVING*\n",
      " Floor:  15\n",
      "*MOVING*\n",
      " Floor:  16\n",
      "*MOVING*\n",
      " Floor:  17\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  18\n",
      "User(s) left at the floor 18\n",
      "There are  0 users in the elevator:\n",
      "18\n",
      "*** Elevator called at the floor 9 ***\n",
      "*MOVING* Floor:  17\n",
      "*MOVING* Floor:  16\n",
      "*MOVING* Floor:  15\n",
      "*MOVING* Floor:  14\n",
      "*MOVING* Floor:  13\n",
      "*MOVING* Floor:  12\n",
      "*MOVING* Floor:  11\n",
      "*MOVING* Floor:  10\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  9\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  9 Leaving floor:  6\n",
      "Remaining floors to travel to:  {6}\n",
      "*MOVING* Floor:  8\n",
      "*MOVING* Floor:  7\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  6\n",
      "User(s) left at the floor 6\n",
      "There are  0 users in the elevator:\n",
      "6\n",
      "User(s) entered at the floor 6\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  6 Leaving floor:  0\n",
      "Remaining floors to travel to:  {0}\n",
      "*MOVING* Floor:  5\n",
      "*MOVING* Floor:  4\n",
      "*MOVING* Floor:  3\n",
      "*MOVING* Floor:  2\n",
      "*MOVING* Floor:  1\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  0\n",
      "User(s) left at the floor 0\n",
      "There are  0 users in the elevator:\n",
      "0\n",
      "*** Elevator called at the floor 1 ***\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  1\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  1 Leaving floor:  18\n",
      "Remaining floors to travel to:  {18}\n",
      "*MOVING*\n",
      " Floor:  2\n",
      "*MOVING*\n",
      " Floor:  3\n",
      "*MOVING*\n",
      " Floor:  4\n",
      "*MOVING*\n",
      " Floor:  5\n",
      "*MOVING*\n",
      " Floor:  6\n",
      "*MOVING*\n",
      " Floor:  7\n",
      "*MOVING*\n",
      " Floor:  8\n",
      "*MOVING*\n",
      " Floor:  9\n",
      "*MOVING*\n",
      " Floor:  10\n",
      "*MOVING*\n",
      " Floor:  11\n",
      "*MOVING*\n",
      " Floor:  12\n",
      "*MOVING*\n",
      " Floor:  13\n",
      "*MOVING*\n",
      " Floor:  14\n",
      "*MOVING*\n",
      " Floor:  15\n",
      "*MOVING*\n",
      " Floor:  16\n",
      "*MOVING*\n",
      " Floor:  17\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  18\n",
      "User(s) left at the floor 18\n",
      "There are  0 users in the elevator:\n",
      "18\n",
      "*** Elevator called at the floor 2 ***\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  19\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  2 Leaving floor:  4\n",
      "Remaining floors to travel to:  {4}\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  20\n",
      "User(s) left at the floor 20\n",
      "There are  0 users in the elevator:\n",
      "20\n",
      "*** Elevator called at the floor 9 ***\n",
      "*MOVING* Floor:  19\n",
      "*MOVING* Floor:  18\n",
      "*MOVING* Floor:  17\n",
      "*MOVING* Floor:  16\n",
      "*MOVING* Floor:  15\n",
      "*MOVING* Floor:  14\n",
      "*MOVING* Floor:  13\n",
      "*MOVING* Floor:  12\n",
      "*MOVING* Floor:  11\n",
      "*MOVING* Floor:  10\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  9\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  9 Leaving floor:  6\n",
      "Remaining floors to travel to:  {6}\n",
      "*MOVING* Floor:  8\n",
      "*MOVING* Floor:  7\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  6\n",
      "User(s) left at the floor 6\n",
      "There are  0 users in the elevator:\n",
      "6\n",
      "User(s) entered at the floor 6\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  6 Leaving floor:  0\n",
      "Remaining floors to travel to:  {0}\n",
      "*MOVING* Floor:  5\n",
      "*MOVING* Floor:  4\n",
      "*MOVING* Floor:  3\n",
      "*MOVING* Floor:  2\n",
      "*MOVING* Floor:  1\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  0\n",
      "User(s) left at the floor 0\n",
      "There are  0 users in the elevator:\n",
      "0\n",
      "*** Elevator called at the floor 1 ***\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  1\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  1 Leaving floor:  18\n",
      "Remaining floors to travel to:  {18}\n",
      "*MOVING*\n",
      " Floor:  2\n",
      "*MOVING*\n",
      " Floor:  3\n",
      "*MOVING*\n",
      " Floor:  4\n",
      "*MOVING*\n",
      " Floor:  5\n",
      "*MOVING*\n",
      " Floor:  6\n",
      "*MOVING*\n",
      " Floor:  7\n",
      "*MOVING*\n",
      " Floor:  8\n",
      "*MOVING*\n",
      " Floor:  9\n",
      "*MOVING*\n",
      " Floor:  10\n",
      "*MOVING*\n",
      " Floor:  11\n",
      "*MOVING*\n",
      " Floor:  12\n",
      "*MOVING*\n",
      " Floor:  13\n",
      "*MOVING*\n",
      " Floor:  14\n",
      "*MOVING*\n",
      " Floor:  15\n",
      "*MOVING*\n",
      " Floor:  16\n",
      "*MOVING*\n",
      " Floor:  17\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  18\n",
      "User(s) left at the floor 18\n",
      "There are  0 users in the elevator:\n",
      "18\n",
      "*** Elevator called at the floor 2 ***\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  19\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  2 Leaving floor:  4\n",
      "Remaining floors to travel to:  {4}\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  20\n",
      "User(s) left at the floor 20\n",
      "There are  0 users in the elevator:\n",
      "20\n",
      "*** Elevator called at the floor 12 ***\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  21\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  12 Leaving floor:  15\n",
      "Remaining floors to travel to:  {15}\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  22\n",
      "User(s) left at the floor 22\n",
      "There are  0 users in the elevator:\n",
      "22\n",
      "*** Elevator called at the floor 9 ***\n",
      "*MOVING* Floor:  21\n",
      "*MOVING* Floor:  20\n",
      "*MOVING* Floor:  19\n",
      "*MOVING* Floor:  18\n",
      "*MOVING* Floor:  17\n",
      "*MOVING* Floor:  16\n",
      "*MOVING* Floor:  15\n",
      "*MOVING* Floor:  14\n",
      "*MOVING* Floor:  13\n",
      "*MOVING* Floor:  12\n",
      "*MOVING* Floor:  11\n",
      "*MOVING* Floor:  10\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  9\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  9 Leaving floor:  6\n",
      "Remaining floors to travel to:  {6}\n",
      "*MOVING* Floor:  8\n",
      "*MOVING* Floor:  7\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  6\n",
      "User(s) left at the floor 6\n",
      "There are  0 users in the elevator:\n",
      "6\n",
      "User(s) entered at the floor 6\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  6 Leaving floor:  0\n",
      "Remaining floors to travel to:  {0}\n",
      "*MOVING* Floor:  5\n",
      "*MOVING* Floor:  4\n",
      "*MOVING* Floor:  3\n",
      "*MOVING* Floor:  2\n",
      "*MOVING* Floor:  1\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  0\n",
      "User(s) left at the floor 0\n",
      "There are  0 users in the elevator:\n",
      "0\n",
      "*** Elevator called at the floor 1 ***\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  1\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  1 Leaving floor:  18\n",
      "Remaining floors to travel to:  {18}\n",
      "*MOVING*\n",
      " Floor:  2\n",
      "*MOVING*\n",
      " Floor:  3\n",
      "*MOVING*\n",
      " Floor:  4\n",
      "*MOVING*\n",
      " Floor:  5\n",
      "*MOVING*\n",
      " Floor:  6\n",
      "*MOVING*\n",
      " Floor:  7\n",
      "*MOVING*\n",
      " Floor:  8\n",
      "*MOVING*\n",
      " Floor:  9\n",
      "*MOVING*\n",
      " Floor:  10\n",
      "*MOVING*\n",
      " Floor:  11\n",
      "*MOVING*\n",
      " Floor:  12\n",
      "*MOVING*\n",
      " Floor:  13\n",
      "*MOVING*\n",
      " Floor:  14\n",
      "*MOVING*\n",
      " Floor:  15\n",
      "*MOVING*\n",
      " Floor:  16\n",
      "*MOVING*\n",
      " Floor:  17\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  18\n",
      "User(s) left at the floor 18\n",
      "There are  0 users in the elevator:\n",
      "18\n",
      "*** Elevator called at the floor 2 ***\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  19\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  2 Leaving floor:  4\n",
      "Remaining floors to travel to:  {4}\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  20\n",
      "User(s) left at the floor 20\n",
      "There are  0 users in the elevator:\n",
      "20\n",
      "*** Elevator called at the floor 7 ***\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  21\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  7 Leaving floor:  19\n",
      "Remaining floors to travel to:  {19}\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  22\n",
      "User(s) left at the floor 22\n",
      "There are  0 users in the elevator:\n",
      "22\n",
      "*** Elevator called at the floor 12 ***\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  23\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  12 Leaving floor:  15\n",
      "Remaining floors to travel to:  {15}\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  24\n",
      "User(s) left at the floor 24\n",
      "There are  0 users in the elevator:\n",
      "24\n",
      "*** Elevator called at the floor 9 ***\n",
      "*MOVING* Floor:  23\n",
      "*MOVING* Floor:  22\n",
      "*MOVING* Floor:  21\n",
      "*MOVING* Floor:  20\n",
      "*MOVING* Floor:  19\n",
      "*MOVING* Floor:  18\n",
      "*MOVING* Floor:  17\n",
      "*MOVING* Floor:  16\n",
      "*MOVING* Floor:  15\n",
      "*MOVING* Floor:  14\n",
      "*MOVING* Floor:  13\n",
      "*MOVING* Floor:  12\n",
      "*MOVING* Floor:  11\n",
      "*MOVING* Floor:  10\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  9\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  9 Leaving floor:  6\n",
      "Remaining floors to travel to:  {6}\n",
      "*MOVING* Floor:  8\n",
      "*MOVING* Floor:  7\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  6\n",
      "User(s) left at the floor 6\n",
      "There are  0 users in the elevator:\n",
      "6\n",
      "User(s) entered at the floor 6\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  6 Leaving floor:  0\n",
      "Remaining floors to travel to:  {0}\n",
      "*MOVING* Floor:  5\n",
      "*MOVING* Floor:  4\n",
      "*MOVING* Floor:  3\n",
      "*MOVING* Floor:  2\n",
      "*MOVING* Floor:  1\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  0\n",
      "User(s) left at the floor 0\n",
      "There are  0 users in the elevator:\n",
      "0\n",
      "*** Elevator called at the floor 1 ***\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  1\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  1 Leaving floor:  18\n",
      "Remaining floors to travel to:  {18}\n",
      "*MOVING*\n",
      " Floor:  2\n",
      "*MOVING*\n",
      " Floor:  3\n",
      "*MOVING*\n",
      " Floor:  4\n",
      "*MOVING*\n",
      " Floor:  5\n",
      "*MOVING*\n",
      " Floor:  6\n",
      "*MOVING*\n",
      " Floor:  7\n",
      "*MOVING*\n",
      " Floor:  8\n",
      "*MOVING*\n",
      " Floor:  9\n",
      "*MOVING*\n",
      " Floor:  10\n",
      "*MOVING*\n",
      " Floor:  11\n",
      "*MOVING*\n",
      " Floor:  12\n",
      "*MOVING*\n",
      " Floor:  13\n",
      "*MOVING*\n",
      " Floor:  14\n",
      "*MOVING*\n",
      " Floor:  15\n",
      "*MOVING*\n",
      " Floor:  16\n",
      "*MOVING*\n",
      " Floor:  17\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  18\n",
      "User(s) left at the floor 18\n",
      "There are  0 users in the elevator:\n",
      "18\n",
      "*** Elevator called at the floor 2 ***\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  19\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  2 Leaving floor:  4\n",
      "Remaining floors to travel to:  {4}\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  20\n",
      "User(s) left at the floor 20\n",
      "There are  0 users in the elevator:\n",
      "20\n",
      "*** Elevator called at the floor 7 ***\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  21\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  7 Leaving floor:  19\n",
      "Remaining floors to travel to:  {19}\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  22\n",
      "User(s) left at the floor 22\n",
      "There are  0 users in the elevator:\n",
      "22\n",
      "*** Elevator called at the floor 12 ***\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  23\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  12 Leaving floor:  15\n",
      "Remaining floors to travel to:  {15}\n",
      "*MOVING*\n",
      "*STOPPING*\n",
      "You arrived to the floor:  24\n",
      "User(s) left at the floor 24\n",
      "There are  0 users in the elevator:\n",
      "24\n",
      "*** Elevator called at the floor 13 ***\n",
      "*MOVING* Floor:  23\n",
      "*MOVING* Floor:  22\n",
      "*MOVING* Floor:  21\n",
      "*MOVING* Floor:  20\n",
      "*MOVING* Floor:  19\n",
      "*MOVING* Floor:  18\n",
      "*MOVING* Floor:  17\n",
      "*MOVING* Floor:  16\n",
      "*MOVING* Floor:  15\n",
      "*MOVING* Floor:  14\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  13\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  13 Leaving floor:  3\n",
      "Remaining floors to travel to:  {3}\n",
      "*MOVING* Floor:  12\n",
      "*MOVING* Floor:  11\n",
      "*MOVING* Floor:  10\n",
      "*MOVING* Floor:  9\n",
      "*MOVING* Floor:  8\n",
      "*MOVING* Floor:  7\n",
      "*MOVING* Floor:  6\n",
      "*MOVING* Floor:  5\n",
      "*MOVING* Floor:  4\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  3\n",
      "User(s) left at the floor 3\n",
      "There are  0 users in the elevator:\n",
      "3\n",
      "*** Elevator called at the floor 9 ***\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  2\n",
      "There are  1 users in the elevator:\n",
      "Entered floor:  9 Leaving floor:  6\n",
      "Remaining floors to travel to:  {6}\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  1\n",
      "User(s) left at the floor 1\n",
      "There are  0 users in the elevator:\n",
      "1\n",
      "*** Elevator called at the floor 6 ***\n",
      "*MOVING\n",
      "*STOPPING*\n",
      " You arrived to the floor:  0\n",
      "There are  0 users in the elevator:\n",
      "User(s) left at the floor 0\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "list.remove(x): x not in list",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[26], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m elevator2 \u001b[38;5;241m=\u001b[39m \u001b[43mElevator1\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m20\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[0;32mIn[25], line 20\u001b[0m, in \u001b[0;36mElevator1.__init__\u001b[0;34m(self, floor_num)\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mup_floors_list \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m     18\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdown_floors_list \u001b[38;5;241m=\u001b[39m []\n\u001b[0;32m---> 20\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbegin\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[0;32mIn[25], line 29\u001b[0m, in \u001b[0;36mElevator1.begin\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     27\u001b[0m cur_passenger \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mentering_and_leaving(\u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m     28\u001b[0m x, y \u001b[38;5;241m=\u001b[39m cur_passenger\n\u001b[0;32m---> 29\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43morder\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43my\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[0;32mIn[25], line 159\u001b[0m, in \u001b[0;36mElevator1.order\u001b[0;34m(self, p, d)\u001b[0m\n\u001b[1;32m    157\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcur_floor)\n\u001b[1;32m    158\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpick(n,m)\n\u001b[0;32m--> 159\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdrop\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn\u001b[49m\u001b[43m,\u001b[49m\u001b[43mm\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[0;32mIn[25], line 124\u001b[0m, in \u001b[0;36mElevator1.drop\u001b[0;34m(self, pickup_floor, dropoff_floor)\u001b[0m\n\u001b[1;32m    121\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcur_floor \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgo_down(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcur_floor, dropoff_floor)\n\u001b[1;32m    123\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mUser(s) left at the floor\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcur_floor)\n\u001b[0;32m--> 124\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43musers_present\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mremove\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[43mpickup_floor\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdropoff_floor\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    125\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39muser_funct()\n\u001b[1;32m    126\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mremaining()\n",
      "\u001b[0;31mValueError\u001b[0m: list.remove(x): x not in list"
     ]
    }
   ],
   "source": [
    "elevator2 = Elevator1(20) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}