Untitled1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def allowed(p):\n",
    "    s = set([tuple(p) for p in P])\n",
    "    if len(s) < len(p):\n",
    "        return False\n",
    "    for p1, p2 in zip(p, p[1:]):\n",
    "        if p1[0] == p2[0] or p1[1] == p2[1] or p1[0] - p1[1] == p2[0] - p2[1] or  p1[0] + p1[1] == p2[0] + p2[1]:\n",
    "            return False\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "R, C = 2,5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2], [0, 0]]\n"
     ]
    }
   ],
   "source": [
    "P = []\n",
    "p1 = [0, 0]\n",
    "p2 = [1, 2]\n",
    "P.append(p2.copy())\n",
    "P.append(p1.copy())\n",
    "print(P)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1] [1, 3]\n",
      "[0, 2] [1, 4]\n",
      "[0, 3] [1, 0]\n",
      "[0, 4] [1, 1]\n"
     ]
    }
   ],
   "source": [
    "for R in range(0, R, 2):\n",
    "    for i in range(C-1):\n",
    "        p1[1] = (p1[1] + 1) % C\n",
    "        p2[1] = (p2[1] + 1) % C\n",
    "        print(p1, p2)\n",
    "        P.append(p2.copy())\n",
    "        P.append(p1.copy())\n",
    "    p1[0] = p1[0] + 2\n",
    "    p2[0] = p2[0] + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2],\n",
       " [0, 0],\n",
       " [1, 3],\n",
       " [0, 1],\n",
       " [1, 4],\n",
       " [0, 2],\n",
       " [1, 0],\n",
       " [0, 3],\n",
       " [1, 1],\n",
       " [0, 4]]"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "allowed(P)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0\n",
      "1 2\n",
      "0 1\n",
      "1 3\n",
      "0 2\n",
      "1 0\n",
      "0 3\n",
      "1 1\n",
      "2 0\n",
      "3 2\n",
      "2 1\n",
      "3 3\n",
      "2 2\n",
      "3 0\n"
     ]
    }
   ],
   "source": [
    "for p in P:\n",
    "    print(p[0], p[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "w1 = 'TARPOL'\n",
    "w2 = 'PROL'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "def longest_common(w1,w2):\n",
    "    longest = 0\n",
    "    i = -1\n",
    "    while True:\n",
    "        if w1[i] == w2[i]:\n",
    "            longest += 1\n",
    "            i -= 1\n",
    "        else:\n",
    "            break\n",
    "    return longest\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "longest_common(w1,w2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_rows, n_columns = 3, 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_all_neighbours(n_rows, n_columns):\n",
    "    import itertools\n",
    "\n",
    "    neighbours = dict()\n",
    "    for row in range(n_rows):\n",
    "        for col in range(n_columns):\n",
    "            diagonals = [(r, c) for r, c in itertools.chain(\n",
    "                zip(range(row + 1, n_rows), range(col + 1, n_columns)),\n",
    "                zip(range(row - 1, -1, -1), range(col - 1, -1, -1)),\n",
    "                zip(range(row + 1, n_rows), range(col - 1, -1, -1)),\n",
    "                zip(range(row - 1, -1, -1), range(col + 1, n_columns))\n",
    "            )]\n",
    "            vert_hor = [(i, col) for i in range(n_rows)] + \\\n",
    "                       [(row, i) for i in range(n_columns)]\n",
    "            neighbours[(row, col)] = set(diagonals + vert_hor)\n",
    "    return neighbours"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(0, 0): {(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (2, 0), (2, 2)},\n",
       " (0, 1): {(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 1)},\n",
       " (0, 2): {(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (2, 0), (2, 2)},\n",
       " (1, 0): {(0, 0), (0, 1), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1)},\n",
       " (1, 1): {(0, 0),\n",
       "  (0, 1),\n",
       "  (0, 2),\n",
       "  (1, 0),\n",
       "  (1, 1),\n",
       "  (1, 2),\n",
       "  (2, 0),\n",
       "  (2, 1),\n",
       "  (2, 2)},\n",
       " (1, 2): {(0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 1), (2, 2)},\n",
       " (2, 0): {(0, 0), (0, 2), (1, 0), (1, 1), (2, 0), (2, 1), (2, 2)},\n",
       " (2, 1): {(0, 1), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)},\n",
       " (2, 2): {(0, 0), (0, 2), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)}}"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = find_all_neighbours(3, 3)\n",
    "n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 1)"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(n, key=lambda k: len(n[k]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [],
   "source": [
    "del n[(1,1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(0, 0): {(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (2, 0), (2, 2)},\n",
       " (0, 1): {(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 1)},\n",
       " (0, 2): {(0, 0), (0, 1), (0, 2), (1, 1), (1, 2), (2, 0), (2, 2)},\n",
       " (1, 0): {(0, 0), (0, 1), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1)},\n",
       " (1, 2): {(0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 1), (2, 2)},\n",
       " (2, 0): {(0, 0), (0, 2), (1, 0), (1, 1), (2, 0), (2, 1), (2, 2)},\n",
       " (2, 1): {(0, 1), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)},\n",
       " (2, 2): {(0, 0), (0, 2), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)}}"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [(i, col) for i in range(n_rows)] + [(row, i) for i in range(n_columns)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = [(r, c) for r, c in itertools.chain(\n",
    "    zip(range(row + 1, n_rows), range(col + 1, n_columns)),\n",
    "    zip(range(row - 1, -1, -1), range(col - 1, -1, -1)),\n",
    "    zip(range(row + 1, n_rows), range(col -1, -1, -1)),\n",
    "    zip(range(row - 1, -1, -1),range(col + 1, n_columns))\n",
    ")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 0), (1, 0), (2, 0), (0, 0), (0, 1), (0, 2), (1, 1), (2, 2)]"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 if False else 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In else\n",
      "After loop\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 2:\n",
    "    i += 1\n",
    "    if i > 10:\n",
    "        break\n",
    "else:\n",
    "    print(\"In else\")\n",
    "    \n",
    "print(\"After loop\")"
   ]
  },
  {
   "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.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}