MyProblems2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import deque\n",
    "l=[1,2,3,4,4,5,5,6]\n",
    "l.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l=deque(l)\n",
    "\n",
    "l.popleft()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "54\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Penny'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import deque\n",
    "import collections\n",
    "l=deque(['Sheldon', 'Leonard', 'Penny', 'Rajesh', 'Howard'])\n",
    "for i in xrange(int(raw_input())):\n",
    "    a=l.popleft()\n",
    "    l.append(a)\n",
    "    l.append(a)\n",
    "    \n",
    "a=list(collections.deque(l))   \n",
    "a.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def doublecola():\n",
    "    input1=int(raw_input())\n",
    "    i=1\n",
    "    while True:\n",
    "        sq=2**i\n",
    "        sq1=(sq*5)-10\n",
    "        if input1>=sq1 and input1<((2**(i+1))*5)-10:\n",
    "            for j in range(1,6):\n",
    "                sq2=sq1+(sq*j)\n",
    "                if input1<sq2:\n",
    "                    return j\n",
    "\n",
    "        else:\n",
    "            i+=1\n",
    "        \n",
    "            \n",
    "        \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "doublecola()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def doublecola(input1):\n",
    "    i=1\n",
    "    while True:\n",
    "        sq=2**i\n",
    "        sq1=(((2**i)-1)*5)+1\n",
    "        if input1>=sq1 and input1<((2**(i+1))*5)+1:\n",
    "            for j in range(1,6):\n",
    "                sq2=sq1+(sq*j)\n",
    "                if input1<sq2:\n",
    "                    return j\n",
    "\n",
    "        i+=1\n",
    "        \n",
    "def whoIsNext(names, r):\n",
    "    if r>10:\n",
    "        a=doublecola(r)\n",
    "        if a==1:\n",
    "            return 'Sheldon'\n",
    "        elif a==2:\n",
    "            return 'Leonard'\n",
    "        elif a==3:\n",
    "            return 'Penny'\n",
    "        elif a==4:\n",
    "            return 'Rajesh'\n",
    "        elif a==5:\n",
    "            return 'Howard'\n",
    "        else:\n",
    "            return False\n",
    "    else:\n",
    "        return names[r-6]\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Penny'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names = [\"Sheldon\", \"Leonard\", \"Penny\", \"Rajesh\", \"Howard\"]\n",
    "r = 54\n",
    "res = \"Sheldon\"\n",
    "whoIsNext(names, r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def doublecola(names,input1):\n",
    "    i=1\n",
    "    a=len(names)\n",
    "    while True:\n",
    "        sq=2**i\n",
    "        sq1=(((sq)-1)*a)+1\n",
    "        if input1>=sq1 and input1<((2**(i+1))*a)+1:\n",
    "            for j in range(1,a+1):\n",
    "                sq2=sq1+(sq*j)\n",
    "                if input1<sq2:\n",
    "                    return j\n",
    "\n",
    "        i+=1\n",
    "        \n",
    "def whoIsNext(names, r):\n",
    "    if r>len(names):\n",
    "        a=doublecola(names,r)\n",
    "        return names[a-1]\n",
    "    else:\n",
    "        return names[r-(len(names)+1)]\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sheldon'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names = [\"Sheldon\", \"Leonard\", \"Penny\", ]\n",
    "r = 4\n",
    "res = \"Sheldon\"\n",
    "whoIsNext(names, r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def whoIsNext(names, r):\n",
    "    while r > len(names):\n",
    "        r = (r - (len(names)-1)) / 2\n",
    "        print r\n",
    "    return names[r-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Leonard'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names = [\"Sheldon\", \"Leonard\"]\n",
    "r =5\n",
    "res = \"Sheldon\"\n",
    "whoIsNext(names, r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "First one works for all inputs\n",
    "second is way cleverer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "a=[[1,1,1],[0,1,2],[2,1,0]]\n",
    "b=[]\n",
    "for i in xrange(3):\n",
    "        if a[i].count(1)==3 or a[i].count(2)==3:\n",
    "            print a[0][0]\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def isSolved(board):\n",
    "    sumd=0\n",
    "    sumd2=0\n",
    "            \n",
    "    for i in xrange(3):\n",
    "        if sum(board[i])==3 or sum(board[i])==6:\n",
    "            print sum(board[i])\n",
    "            print 'ala'\n",
    "            return sum(board[i])/3\n",
    "        else:\n",
    "            for y in xrange(3):\n",
    "                    if sum(a[i] for a in zip(*board))==3 or sum(a[i] for a in zip(*board))==6:\n",
    "                        print 'a'\n",
    "                        return sum(a[i] for a in zip(*board))/3\n",
    "                    elif y==i:\n",
    "                        sumd+=board[i][y]\n",
    "                    elif y==i and (i==2 or y==2):\n",
    "                        sumd2+=board[i][y]\n",
    "                \n",
    "                    \n",
    "    if sumd==3 or sumd==6:\n",
    "        print 'b'\n",
    "        return sumd/3\n",
    "    elif sumd2==3 or sumd2==6:\n",
    "        print 'c'\n",
    "        return sumd/3\n",
    "    elif sum(x.count(0) for x in board)<=2 :\n",
    "        print 'd'\n",
    "        return 0\n",
    "    else:\n",
    "        return -1\n",
    "        \n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "ala\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isSolved([[0,0,1],[0,1,2],[2,1,0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ala\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isSolved([[0,0,1],[0,1,2],[2,1,0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3, 4)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [[1, 2,3], [2, 3,4], [3, 4,5]]\n",
    "a2 = zip(*a)\n",
    "a2[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-1-bf60da320f3a>, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-1-bf60da320f3a>\"\u001b[1;36m, line \u001b[1;32m3\u001b[0m\n\u001b[1;33m    print \"FizzBuzz\" if i%3 == 0 and i%5 == 0 else \"buzz\" for i in xrange(n+1)\u001b[0m\n\u001b[1;37m                                                            ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "n = int(raw_input())\n",
    "\n",
    "print \"FizzBuzz\" if i%3 == 0 and i%5 == 0 else \"buzz\" for i in xrange(n+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def f(lst):\n",
    "    return [type(x) for x in lst]\n",
    "\n",
    "l1 = [1,[1,1]]\n",
    "l2 = [2,[2,2]]\n",
    "l3 = [1,1,[1,1]]\n",
    "l4 = [2,2,[2,2,2]]\n",
    "\n",
    "print f(l1)==f(l2)\n",
    "print f(l3)==f(l4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "from itertools import izip_longest\n",
    "\n",
    "def compare_shape(list1, list2):\n",
    "    '''Compare the \"shape\" of two lists, ignoring the contents.'''\n",
    "\n",
    "    # Use generators to save memory\n",
    "    def shape(l):\n",
    "        '''Flatten list to a series of tokens, [, ], or 0.'''\n",
    "        if isinstance(l, list):\n",
    "            yield '['\n",
    "            for x in l:\n",
    "                for y in shape(x):\n",
    "                    yield y\n",
    "            yield ']'\n",
    "        else:\n",
    "            yield 0\n",
    "\n",
    "    # Use all() to save time.\n",
    "    # Use izip to save memory\n",
    "    # Use izip_longest to ensure correct answer if list1 is a prefix of list2\n",
    "    return all(a == b\n",
    "               for a,b in izip_longest(shape(list1), shape(list2), fillvalue=object()))\n",
    "\n",
    "l1 = [1,[1,1]]\n",
    "l2 = [2,[2,2]]\n",
    "l3 = [1,1,[1,1],1,[1,1]]\n",
    "l4 = [2,2,[2,2],1,[]]\n",
    "\n",
    "print compare_shape(l1, l2)\n",
    "print compare_shape(l3, l4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def same_structure_as(original,other):\n",
    "    if isinstance(original, list) and isinstance(other, list) and len(original) == len(other):\n",
    "        for o1, o2 in zip(original, other):\n",
    "            if not same_structure_as(o1, o2): return False\n",
    "        else: return True\n",
    "    else: return not isinstance(original, list) and not isinstance(other, list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def sierpinski(n):\n",
    "    \n",
    "    a=[1]\n",
    "    b=1\n",
    "    for i in range(1,2**n):\n",
    "        if i%2==0:\n",
    "            b=b+2\n",
    "            a.append(b) \n",
    "        else:\n",
    "            b=b*3\n",
    "            a.append(b)\n",
    "    print a        \n",
    "    b=['{0:0b}'.format(i) for i in a]\n",
    "  \n",
    "    for i in b:\n",
    "        \n",
    "        if '0' in i:\n",
    "            b[b.index(i)]=i.replace('0',' ') \n",
    "    for i in b:\n",
    "        \n",
    "        if '1' in i:\n",
    "            b[b.index(i)]=i.replace('1','L')\n",
    "    for i in b:\n",
    "        b[b.index(i)]=''.join(i)\n",
    "        \n",
    "            \n",
    "        \n",
    "    print '\\n'.join(map(str,(' '.join(i) for i in b)))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 15, 17, 51, 53, 159]\n",
      "L\n",
      "L L\n",
      "L   L\n",
      "L L L L\n",
      "L       L\n",
      "L L     L L\n",
      "L L   L   L\n",
      "L     L L L L L\n"
     ]
    }
   ],
   "source": [
    "sierpinski(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B I N G O\n"
     ]
    }
   ],
   "source": [
    "s = \"BINGO\"\n",
    "print(\" \".join(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B I N G O\n"
     ]
    }
   ],
   "source": [
    "s = \"BINGO\"\n",
    "print s.replace(\"\",\" \")[1:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                         1\n",
      "                                       1    1\n",
      "                                    1    2    1\n",
      "                                  1    3    3    1\n",
      "                               1    4    6    4    1\n",
      "                             1    5    a    a    5    1\n",
      "                          1    6    f   14    f    6    1\n",
      "                        1    7   15   23   23   15    7    1\n",
      "                     1    8   1c   38   46   38   1c    8    1\n",
      "                   1    9   24   54   7e   7e   54   24    9    1\n",
      "                1    a   2d   78   d2   fc   d2   78   2d    a    1\n",
      "              1    b   37   a5  14a  1ce  1ce  14a   a5   37    b    1\n"
     ]
    }
   ],
   "source": [
    "tri =[]\n",
    "\n",
    "for row in range(12):\n",
    "   for col in range(row+1):\n",
    "      if col == 0:\n",
    "         tri.append([1])\n",
    "      elif col == row:\n",
    "         tri[row].append(1)\n",
    "      else:\n",
    "         tri[row].append(tri[row-1][col]+tri[row-1][col-1])\n",
    "\n",
    "for row in tri:\n",
    "   nvals = len(row)\n",
    "   spaces = (80 - 5 * nvals)/2\n",
    "   paddington = \" \" * spaces\n",
    "   bear = \"\"\n",
    "   for val in row:\n",
    "      bear += \"%5x\" % val\n",
    "   print paddington + bear"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        L       \n",
      "       L  L      \n",
      "      L     L     \n",
      "     L  L  L  L    \n",
      "    L           L   \n",
      "   L  L        L  L  \n",
      "  L     L     L     L \n",
      " L  L  L  L  L  L  L  L\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "size = 3\n",
    "modulus = 2\n",
    "\n",
    "lines = modulus**size\n",
    "\n",
    "vector = [1]\n",
    "for i in range(1,lines+1):\n",
    "  vector.insert(0,0)\n",
    "  vector.append(0)\n",
    "\n",
    "for i in range(0,lines):\n",
    "  newvector = vector[:]\n",
    "  for j in range(0,len(vector)-1):\n",
    "    if (newvector[j] == 0):\n",
    "      print \"\",\n",
    "    else:\n",
    "      remainder = newvector[j] % modulus\n",
    "      if (remainder == 0):\n",
    "        print \" \",\n",
    "      else:\n",
    "        print \"L\",\n",
    "    newvector[j] = vector[j-1] + vector[j+1]\n",
    "  print\n",
    "  vector = newvector[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def pascal(n):\n",
    "    row = [1]\n",
    "    k = [0]\n",
    "    for x in range(max(n,0)):\n",
    "        print row\n",
    "        row=[l+r for l,r in zip(row+k,k+row)]\n",
    "    return n>=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n",
      "[1, 1]\n",
      "[1, 2, 1]\n",
      "[1, 3, 3, 1]\n",
      "[1, 4, 6, 4, 1]\n",
      "[1, 5, 10, 10, 5, 1]\n",
      "[1, 6, 15, 20, 15, 6, 1]\n",
      "[1, 7, 21, 35, 35, 21, 7, 1]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pascal(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}