AI-HackerRank-BOT_Clean.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# BotClean\n",
    "The goal of Artificial Intelligence is to create a rational agent [Artificial Intelligence 1.1.4](https://www.hackerrank.com/external_redirect?to=http://www.amazon.com/Artificial-Intelligence-Modern-Approach-3rd/dp/0136042597#reader_B004O4BZ16). An agent gets input from the environment through sensors and acts on the environment with actuators. In this challenge, you will program a simple bot to perform the correct actions based on environmental input.\n",
    "\n",
    "Meet the bot MarkZoid. It's a cleaning bot whose sensor is a head mounted camera and whose actuators are the wheels beneath it. It's used to clean the floor.\n",
    "\n",
    "The bot here is positioned at the top left corner of a 5*5 grid. Your task is to move the bot to clean all the dirty cells.\n",
    "## Input Format\n",
    "The first line contains two space separated integers which indicate the current position of the bot.\n",
    "The board is indexed using [Matrix Convention](https://www.hackerrank.com/scoring/board-convention)\n",
    "5 lines follow representing the grid. Each cell in the grid is represented by any of the following 3 characters: 'b' (ascii value 98) indicates the bot's current position, 'd' (ascii value 100) indicates a dirty cell and '-' (ascii value 45) indicates a clean cell in the grid.\n",
    "\n",
    "Note If the bot is on a dirty cell, the cell will still have 'd' on it.\n",
    "## Output Format\n",
    "The output is the action that is taken by the bot in the current step, and it can be either one of the movements in 4 directions or cleaning up the cell in which it is currently located. The valid output strings are LEFT, RIGHT, UP and DOWN or CLEAN. If the bot ever reaches a dirty cell, output CLEAN to clean the dirty cell. Repeat this process until all the cells on the grid are cleaned."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sample Input #00\n",
    "0 0 <br />\n",
    "b---d<br />\n",
    "-d--d<br />\n",
    "--dd-<br />\n",
    "--d--<br />\n",
    "----d\n",
    "### Sample Output #00\n",
    "RIGHT\n",
    "### Resultant state\n",
    "-b--d<br />\n",
    "-d--d<br />\n",
    "--dd-<br />\n",
    "--d--<br />\n",
    "----d<br />\n",
    "### Sample Input #01\n",
    "0 1<br />\n",
    "-b--d<br />\n",
    "-d--d<br />\n",
    "--dd-<br />\n",
    "--d--<br />\n",
    "----d\n",
    "### Sample Output #01\n",
    "DOWN\n",
    "### Resultant state\n",
    "----d<br />\n",
    "-d--d<br />\n",
    "--dd-<br />\n",
    "--d--<br />\n",
    "----d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task\n",
    "\n",
    "Complete the function next_move that takes in 3 parameters posr, posc being the co-ordinates of the bot's current position and board which indicates the board state to print the bot's next move.\n",
    "\n",
    "The codechecker will keep calling the function next_move till the game is over or you make an invalid move.\n",
    "\n",
    "## Scoring\n",
    "\n",
    "Your score is (200 - number of moves the bot makes)/40. CLEAN is considered a move as well.\n",
    "\n",
    "Once you submit, your bot will be played on four grids with three of the grid configurations unknown to you. The final score will be the sum of the scores obtained in each of the four grids.\n",
    "\n",
    "## Education Links\n",
    "Introduction to AI by Stuart Russell and Peter Norvig<br/>\n",
    "[Motor cognition](https://www.hackerrank.com/external_redirect?to=https://en.wikipedia.org/wiki/Motor_cognition)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import the library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random as rd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define the functions to set, get and remove targets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def setTargets(n, target):\n",
    "    for r in range(rd.randint(0,n*n//2)):\n",
    "            t=[rd.randint(0,n-1), rd.randint(0,n-1)]\n",
    "            t='' if t in list(target) or t == [0,0] else target.append(t)\n",
    "    return(sorted(target))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getTargets(n, grid, target):\n",
    "    for r in range(n):\n",
    "        for c in range(n):\n",
    "            if grid[r][c] == 'd':\n",
    "                target.append([r,c])\n",
    "    return(target)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def removeTarget(lr,lc, target):\n",
    "    target.remove([lr,lc])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define the functions to set, get and print steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def setStep(lr, lc, posr, posc, nr, nc):\n",
    "    posr = lr + 1 if lr < nr else lr - 1 if lr > nr else posr\n",
    "    posc = lc + 1 if lc < nc and posr == lr else lc - 1 if lc > nc and posr == lr else posc\n",
    "    step = printStep(posr,posc,lr, lc)\n",
    "    return(step, posr, posc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getStep(posr, posc, target):\n",
    "    lr,lc = posr,posc\n",
    "    if target != []:\n",
    "        [nr,nc] = min(target)\n",
    "        i = 1\n",
    "        while i < len(target) and i <= 2:\n",
    "            x = target[i]\n",
    "            nr,nc = x if (nr + nc) > (x[0] + x[1]) and (nr-posr) + (nc-posc) > (x[0] - posr) + (x[1] - posc) else [nr,nc]\n",
    "            i+=1\n",
    "        return(lr,lc,nr,nc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def printStep(posr,posc,lr, lc):    \n",
    "    return('LEFT' if lc > posc else 'RIGHT' if lc < posc else 'UP' if lr > posr else 'DOWN' if lr < posr else \"CLEAN\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define de function to build the the board"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def buildBoard(n, lr, lc, posr, posc, grid, target):\n",
    "    for r in range(n):\n",
    "        line = buildLine(n, lr, lc, posr, posc, grid, r, target)\n",
    "        if len(grid) == r:\n",
    "            grid.append(line)\n",
    "        else:\n",
    "            grid[r]=line\n",
    "    if [lr,lc] in list(target):\n",
    "        removeTarget(lr, lc, target)\n",
    "    return(grid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def buildLine(n, lr, lc, posr, posc, grid, r, target):\n",
    "    line,space,bot,dirty='','-','b','d'\n",
    "    for c in range(n):\n",
    "        if len(grid)==r:\n",
    "            d = [r,c] if [r,c] in list(target) else [n,n]\n",
    "            s:s=bot if [posr,posc] == [r,c] else dirty if d[0] == r and d[1]==c else space\n",
    "        else:\n",
    "            if [posr,posc] == [r,c] and grid[r][c] != dirty or [posr,posc] == [r,c] and [lr,lc] == [posr,posc]:\n",
    "                s=bot\n",
    "            elif [r,c] in target:\n",
    "                s=dirty\n",
    "            else:\n",
    "                s=space\n",
    "        line = line+s\n",
    "    return(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Start the BOT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b----\n",
      "dd-d-\n",
      "--d-d\n",
      "---d-\n",
      "d--d-\n",
      "DOWN\n",
      "\n",
      "-----\n",
      "dd-d-\n",
      "--d-d\n",
      "---d-\n",
      "d--d-\n",
      "CLEAN\n",
      "\n",
      "-----\n",
      "bd-d-\n",
      "--d-d\n",
      "---d-\n",
      "d--d-\n",
      "RIGHT\n",
      "\n",
      "-----\n",
      "-d-d-\n",
      "--d-d\n",
      "---d-\n",
      "d--d-\n",
      "CLEAN\n",
      "\n",
      "-----\n",
      "-b-d-\n",
      "--d-d\n",
      "---d-\n",
      "d--d-\n",
      "RIGHT\n",
      "\n",
      "-----\n",
      "--bd-\n",
      "--d-d\n",
      "---d-\n",
      "d--d-\n",
      "RIGHT\n",
      "\n",
      "-----\n",
      "---d-\n",
      "--d-d\n",
      "---d-\n",
      "d--d-\n",
      "CLEAN\n",
      "\n",
      "-----\n",
      "---b-\n",
      "--d-d\n",
      "---d-\n",
      "d--d-\n",
      "DOWN\n",
      "\n",
      "-----\n",
      "-----\n",
      "--dbd\n",
      "---d-\n",
      "d--d-\n",
      "LEFT\n",
      "\n",
      "-----\n",
      "-----\n",
      "--d-d\n",
      "---d-\n",
      "d--d-\n",
      "CLEAN\n",
      "\n",
      "-----\n",
      "-----\n",
      "--b-d\n",
      "---d-\n",
      "d--d-\n",
      "DOWN\n",
      "\n",
      "-----\n",
      "-----\n",
      "----d\n",
      "--bd-\n",
      "d--d-\n",
      "DOWN\n",
      "\n",
      "-----\n",
      "-----\n",
      "----d\n",
      "---d-\n",
      "d-bd-\n",
      "LEFT\n",
      "\n",
      "-----\n",
      "-----\n",
      "----d\n",
      "---d-\n",
      "db-d-\n",
      "LEFT\n",
      "\n",
      "-----\n",
      "-----\n",
      "----d\n",
      "---d-\n",
      "d--d-\n",
      "CLEAN\n",
      "\n",
      "-----\n",
      "-----\n",
      "----d\n",
      "---d-\n",
      "b--d-\n",
      "UP\n",
      "\n",
      "-----\n",
      "-----\n",
      "----d\n",
      "b--d-\n",
      "---d-\n",
      "UP\n",
      "\n",
      "-----\n",
      "-----\n",
      "b---d\n",
      "---d-\n",
      "---d-\n",
      "RIGHT\n",
      "\n",
      "-----\n",
      "-----\n",
      "-b--d\n",
      "---d-\n",
      "---d-\n",
      "RIGHT\n",
      "\n",
      "-----\n",
      "-----\n",
      "--b-d\n",
      "---d-\n",
      "---d-\n",
      "RIGHT\n",
      "\n",
      "-----\n",
      "-----\n",
      "---bd\n",
      "---d-\n",
      "---d-\n",
      "RIGHT\n",
      "\n",
      "-----\n",
      "-----\n",
      "----d\n",
      "---d-\n",
      "---d-\n",
      "CLEAN\n",
      "\n",
      "-----\n",
      "-----\n",
      "----b\n",
      "---d-\n",
      "---d-\n",
      "DOWN\n",
      "\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "---db\n",
      "---d-\n",
      "LEFT\n",
      "\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "---d-\n",
      "---d-\n",
      "CLEAN\n",
      "\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "---b-\n",
      "---d-\n",
      "DOWN\n",
      "\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "---d-\n",
      "CLEAN\n",
      "\n",
      "Done!\n",
      "Board's clean!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "n = rd.randrange(5,7,2)\n",
    "posr,posc = 0,0\n",
    "lr,lc = [n,n]\n",
    "grid = []\n",
    "target = []\n",
    "target = setTargets(n, target)\n",
    "while len(target) > 0:\n",
    "    grid = buildBoard(n, lr, lc, posr, posc, grid, target)    \n",
    "    target = getTargets(n, grid, target) if target == [] else target\n",
    "    lr, lc, nr, nc = getStep(posr, posc, target) if target != [] else [lr, lc, nr, nc]    \n",
    "    step, posr, posc = setStep(lr, lc, posr, posc, nr, nc) if target != [] else [\"Board's clean!\", posr, posc]    \n",
    "    print(*grid,sep='\\n') if target != [] else print('Done!')\n",
    "    print(step+'\\n')"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}