AI-HackerRank-BOT_Clean-Stochastic.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# BOTClean Stochastic\n",
    "A deterministic environment is one where the next state is completely determined by the current state of the environment and the task executed by the agent. If there is any randomness involved in determining the next state, the environment is stochastic.\n",
    "\n",
    "The game [Bot Clean](https://www.hackerrank.com/challenges/botclean) took place in a deterministic environment. In this version, the bot is given 200 moves to clean as many dirty cells as possible. The grid initially has 1 dirty cell. When the bot cleans this cell, a new cell in the grid is made dirty. The new cell can be anywhere in the grid.\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 appropriate dirty cell and clean it.\n",
    "\n",
    "## Input Format\n",
    "The first line contains two single spaced integers which indicates the current position of the bot. The grid is indexed (x, y) 0<=x,y<=4 top to bottom and left to right respectively. Refer to to [board convention here.](https://www.hackerrank.com/scoring/board-convention)\n",
    "\n",
    "5 lines follow showing the grid rows. Each cell in the grid is represented by any of the following 3 characters:\n",
    "\n",
    "    'b' (ascii value 98) - the bot's current position (if on clean cell).\n",
    "\n",
    "    'd' (ascii value 100) - a dirty cell (even if the robot is present on top of it).\n",
    "\n",
    "    '-' (ascii value 45) - a clean cell in the grid.\n",
    "\n",
    "\n",
    "## Sample Input\n",
    "\n",
    "<p>0 0<br />\n",
    "b---d<br />\n",
    "-----<br />\n",
    "-----<br />\n",
    "-----<br />\n",
    "-----</p>\n",
    "\n",
    "## Output Format\n",
    "\n",
    "\n",
    "Output is the action that is taken by the bot in the current step and it can be any of the movements in 4 directions or cleaning the cell in which it is currently located. The output formats are LEFT, RIGHT, UP and DOWN or CLEAN. Output CLEAN to clean the dirty cell. Repeat this process until all the cells on the grid are cleaned.\n",
    "\n",
    "## Sample Output\n",
    "\n",
    "RIGHT\n",
    "## Resultant State\n",
    "\n",
    "<p>\n",
    "-b--d<br />\n",
    "-----<br />\n",
    "-----<br />\n",
    "-----<br />\n",
    "-----</p>\n",
    "\n",
    "The bot is positioned now at (0,1) and is 1 step closer to the dirty cell. The next input will be\n",
    "\n",
    "<p>\n",
    "0 1<br />\n",
    "-b--d<br />\n",
    "-----<br />\n",
    "-----<br />\n",
    "-----<br />\n",
    "-----<br />\n",
    "    </p>\n",
    "    \n",
    "## Task\n",
    "\n",
    "Complete the function nextMove that takes in 3 parameters posr, posc being the co-ordinates of the bot’s current position and board which indicates the board state, and print the bot’s next move.\n",
    "\n",
    "## Scoring\n",
    "\n",
    "At the end of 200 moves, your score will be equal to the number of dirty cell the bot has cleaned divided by 4.\n",
    "\n",
    "## Educational Links\n",
    "\n",
    "https://en.wikipedia.org/wiki/Stochastic_game"
   ]
  },
  {
   "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": [
    "### Function to set each target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def setTargets(n, target):\n",
    "    while target == [] and target != [0,0]:\n",
    "        target=[rd.randint(0,n-1), rd.randint(0,n-1)] if target == [0,0] else [rd.randint(0,n-1), rd.randint(0,n-1)]\n",
    "    return(target)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getTargets(board):\n",
    "    for r, row in enumerate(board):\n",
    "        for c, col in enumerate(row):\n",
    "            if board[r][c] == 'd':\n",
    "                target=[r,c]\n",
    "    return(target)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function to set and print the steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def setStep(posr, posc, nr, nc):\n",
    "    if posr != nr:\n",
    "        posr = posr + 1 if posr < nr else posr - 1 if posr > nr else posr\n",
    "    elif posc != nc:\n",
    "        posc = posc + 1 if posc < nc else posc - 1 if posc > nc else posc\n",
    "    return(posr, posc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def printStep(nr, nc, posr,posc):    \n",
    "    return('LEFT' if nc < posc else 'RIGHT' if nc > posc else 'UP' if nr < posr else 'DOWN' if nr > posr else \"CLEAN\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function to build the board and lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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",
    "    return(grid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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] == (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] == target:\n",
    "                s=dirty\n",
    "            else:\n",
    "                s=space\n",
    "        line = line+s\n",
    "    return(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function to manager the target and steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nextMove(posr, posc, board, target):\n",
    "    target = getTargets(board) if target == [] else target\n",
    "    nr, nc = setStep(posr, posc, target[0], target[1])\n",
    "    step = printStep(nr, nc, posr,posc)    \n",
    "    target = [] if [posr, posc] == target else target\n",
    "    return(step, posr, posc, nr, nc,target)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Start the BOT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b-d--\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "RIGHT\n",
      "-bd--\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "RIGHT\n",
      "--d--\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "CLEAN\n",
      "--b-d\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "RIGHT\n",
      "---bd\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "RIGHT\n",
      "----d\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "CLEAN\n",
      "----b\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "--d--\n",
      "DOWN\n",
      "-----\n",
      "----b\n",
      "-----\n",
      "-----\n",
      "--d--\n",
      "DOWN\n",
      "-----\n",
      "-----\n",
      "----b\n",
      "-----\n",
      "--d--\n",
      "DOWN\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "----b\n",
      "--d--\n",
      "DOWN\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "--d-b\n",
      "LEFT\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "--db-\n",
      "LEFT\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "--d--\n",
      "CLEAN\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "d-b--\n",
      "LEFT\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "db---\n",
      "LEFT\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "-----\n",
      "d----\n",
      "CLEAN\n"
     ]
    }
   ],
   "source": [
    "n, c = 5, 0\n",
    "target, board = [], []\n",
    "posr, posc = 0,0\n",
    "lr, lc = n,n\n",
    "while c <= 3:\n",
    "    target = setTargets(n, target) if  target == [] else target\n",
    "    board = buildBoard(n, lr, lc, posr, posc, board, target)\n",
    "    step, lr, lc, posr, posc,target = nextMove(posr, posc, board, target)\n",
    "    c:c = c + 1 if step == 'CLEAN' else c\n",
    "    print(*board,sep='\\n')\n",
    "    print(step,sep='\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}