Hacker Rank.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#HackerRank Problems"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0000000this is string example....wow!!!0000000\n",
      "Not Pangram\n",
      "['!', '.', '0', 'a', 'e', 'g', 'h', 'i', 'l', 'm', 'n', 'o', 'p', 'r', 's', 't', 'w', 'x']\n",
      "['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n"
     ]
    }
   ],
   "source": [
    "#Pangrams\n",
    "import string\n",
    "st1=raw_input().replace(' ','')\n",
    "if sorted(set(st1.lower())) == sorted(set(list(string.ascii_lowercase))):\n",
    "    print 'Pangram'\n",
    "    \n",
    "else:\n",
    "    print \"Not Pangram\"\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "str=\"a.b.c\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a.b.c'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a.b.c\n"
     ]
    }
   ],
   "source": [
    "print str.strip( '.' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0000000this is string example....wow!!!0000000\n",
      "0000000thisisstringexample....wow!!!0000000\n"
     ]
    }
   ],
   "source": [
    "str = \"0000000this is string example....wow!!!0000000\"\n",
    "print str.strip( '!' )\n",
    "print str.replace(' ','')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "454\n",
      "431359146674410236714672241392314090778194310760649159697657763987455\n",
      "32\n",
      "131071\n"
     ]
    }
   ],
   "source": [
    "#Utopian Tree\n",
    "import sys\n",
    "\n",
    "\n",
    "t = int(raw_input().strip())\n",
    "for a0 in xrange(t):\n",
    "    n = int(raw_input().strip())\n",
    "    if n==0:\n",
    "        print'1'\n",
    "    elif n==1:\n",
    "        print '2'\n",
    "    elif n%2==0:\n",
    "        q=n//2\n",
    "        print 2**(q+1)-1\n",
    "    else:\n",
    "        q=n//2\n",
    "        print 2**(q+2)-2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 \n",
      "12 \n",
      "72\n"
     ]
    }
   ],
   "source": [
    "lst=[1,2,3,4,5,3,4,5,66]\n",
    "a=b=c=0\n",
    "for i in range(0,len(lst),3):\n",
    "    a+=lst[i]\n",
    "for i in range(1,len(lst),3):\n",
    "    b+=lst[i]\n",
    "for i in range(2,len(lst),3):\n",
    "    c+=lst[i]\n",
    "            \n",
    "    \n",
    "print a,\"\\n\",b,\"\\n\",c\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "lst=[1,2,3,4,5,3,4,5]\n",
    "a=0\n",
    "for i in range(2,len(lst),3):\n",
    "    a+=i\n",
    "    print i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5\n",
      "[1, 2, 3, 4, 5]\n",
      "5 7 3\n"
     ]
    }
   ],
   "source": [
    "lst=map(int,raw_input().strip().split())\n",
    "print lst\n",
    "a= sum(lst[i] for i in range(0,len(lst),3))\n",
    "b= sum(lst[i] for i in range(1,len(lst),3))\n",
    "c= sum(lst[i] for i in range(2,len(lst),3))\n",
    "print \"%s %s %s\" %(a,b,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 0 9 1\n",
      "5 61 53 6 7 72 75 42 5 79 91 5 16\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "\n",
    "lst=map(int,raw_input().split())\n",
    "min1=min([i for i in lst if i>=1])\n",
    "index1=lst.index(max1)        \n",
    "lst2=map(int,raw_input().split())\n",
    "max1=lst2[index1]\n",
    "print max1+min1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1 2 3\n",
      "1 2 3 \n",
      "2\n"
     ]
    }
   ],
   "source": [
    "a=raw_input().split()\n",
    "lst=map(int,raw_input().split())\n",
    "min1=min([i for i in lst if i>=1])\n",
    "index1=lst.index(min1)        \n",
    "lst2=map(int,raw_input().split())\n",
    "max1=lst2[index1]\n",
    "print max1+min1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "10000\n",
      "4321\n"
     ]
    }
   ],
   "source": [
    "for i in range(int(raw_input())):\n",
    "    l=int(raw_input())\n",
    "    f=0\n",
    "    for x in range(l):\n",
    "        a=map(int,(j for j in str(x)))\n",
    "        set1=set(a)\n",
    "        if sorted(set1) == sorted(set(i for i in range(1,len(a)+1))):\n",
    "            f=a\n",
    "if f!=0:\n",
    "    print reduce(lambda x,y:x*10+y,f)\n",
    "else:\n",
    "    print '-1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b=100\n",
    "b=[i for i in str(b)]\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', '0', '0']"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'0', '1'}"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(''.join(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def is_prime(n):\n",
    "    if n == 2 or n == 3: \n",
    "            return True\n",
    "    if n<2 or n%2 == 0: return False\n",
    "    if n < 9: return True\n",
    "    if n%3 == 0: return False\n",
    "    r = int(n**0.5)\n",
    "    f = 5\n",
    "    while f <= r:\n",
    "        \n",
    "        if n%f == 0: return False\n",
    "        if n%(f+2) == 0: return False\n",
    "        f +=6\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_prime(4231)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "100\n",
      "-1\n",
      "10000\n",
      "4231\n"
     ]
    }
   ],
   "source": [
    "# Enter your code here. Read input from STDIN. Print output to STDOUT\n",
    "def is_prime(n):\n",
    "    if n == 2 or n == 3: \n",
    "            return True\n",
    "    if n<2 or n%2 == 0: \n",
    "        return False\n",
    "    if n < 9: \n",
    "        return True\n",
    "    if n%3 == 0: \n",
    "        return False\n",
    "    r = int(n**0.5)\n",
    "    f = 5\n",
    "    while f <= r:\n",
    "        \n",
    "        if n%f == 0: return False\n",
    "        if n%(f+2) == 0: return False\n",
    "        f +=6\n",
    "    return True \n",
    "for i in range(int(raw_input())):\n",
    "    l=int(raw_input())\n",
    "    f=0\n",
    "    for x in range(l):\n",
    "        if is_prime(x):\n",
    "            \n",
    "            a=map(int,(j for j in str(x)))\n",
    "            set1=set(a)\n",
    "            if sorted(set1) == sorted(set(i for i in range(1,len(a)+1))):\n",
    "                f=a\n",
    "                f=reduce(lambda x,y:x*10+y,f)\n",
    "                \n",
    "    \n",
    "    \n",
    "    if f!=0:\n",
    "        print f\n",
    "    else:\n",
    "        print '-1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "abdcdeedcba\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "#PalindromeIndex\n",
    "for i in range(int(raw_input())):\n",
    "    str1=list(i for i in raw_input().strip())\n",
    "    if str1==str1[::-1]:\n",
    "        print '-1'\n",
    "    else:\n",
    "        for i in range(len(str1)):\n",
    "            temp=str1.pop(i)\n",
    "            if str1==str1[::-1]:\n",
    "                print i\n",
    "                break\n",
    "            else:\n",
    "                str1.insert(i,temp)\n",
    "               "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wcwwc\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "s=str(raw_input().strip())\n",
    "l = 0\n",
    "r = len(s) - 1\n",
    "\n",
    "while (l < r):\n",
    "    if (s[l] == s[r]):\n",
    "        l+=1\n",
    "        r-=1\n",
    "\n",
    "    else:\n",
    "        break\n",
    "\n",
    "\n",
    "\n",
    "if (l >= r):\n",
    "    print \"-1\\n\"\n",
    "    \n",
    "\n",
    "\n",
    "saveLeft = l;\n",
    "saveRight = r;\n",
    "\n",
    "l+=1;\n",
    "leftFault = 1;\n",
    "while (l < r):\n",
    "    if (s[l] == s[r]):\n",
    "        l+=1\n",
    "        r-=1\n",
    "\n",
    "    else:\n",
    "        leftFault = 0\n",
    "        break\n",
    "\n",
    "\n",
    "\n",
    "if leftFault==0:\n",
    "    print saveRight\n",
    "else:\n",
    "    print saveLeft\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "87878\n",
      "Louise\n"
     ]
    }
   ],
   "source": [
    "#CounterGame\n",
    "def is_power2(num):\n",
    "    \n",
    "                            #states if a number is a power of two\n",
    "\n",
    "    return num != 0 and ((num & (num - 1)) == 0)\n",
    "\n",
    "def wincheck(n):\n",
    "                            #'checks who has won the game'\n",
    "    if n==1:\n",
    "        return 'Richard'\n",
    "    move=0\n",
    "    while n>1:\n",
    "        if is_power2(n):\n",
    "                            #'if n is power of 2 then reduce by half of n'\n",
    "            n-=(n/2)\n",
    "            move+=1\n",
    "        else:\n",
    "                            #'if n is not power of 2 then find nearest pow of 2 and reduce by it'\n",
    "            n-=(2**int(math.floor(math.log(n)/math.log(2))))\n",
    "            move+=1\n",
    "            \n",
    "    if move%2==1 and n==1:\n",
    "        return 'Louise'\n",
    "    elif move%2==0 and n==1:\n",
    "        return 'Richard'\n",
    "    else:\n",
    "        return 'Failed'\n",
    "    \n",
    "for i in range(int(raw_input().strip())):\n",
    "    n=int(raw_input().strip())\n",
    "    print wincheck(n)\n",
    "    \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12 31 45 99\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#Any or All\n",
    "#https://www.hackerrank.com/challenges/any-or-all\n",
    "lst=raw_input().split()\n",
    "if all(i>=0 for i in lst):\n",
    "    print any(str(i)==str(i)[::-1] for i in lst)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "1 2 3 4 5 -9\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "raw_input()\n",
    "lst=map(int,raw_input().split())\n",
    "print all(i>=0 for i in lst) and any(str(i)==str(i)[::-1] for i in lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 3\n",
      "1 1 1\n",
      "1 3 1\n",
      "1 2 1\n",
      "1\n",
      "1 1 1\n",
      "\n",
      "1 2 1\n",
      "\n",
      "1 3 1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Sort Data\n",
    "#https://www.hackerrank.com/challenges/python-sort-sort\n",
    "i,j=map(int,raw_input().split())\n",
    "lst=[]\n",
    "for x in range(i):\n",
    "    lst.append(map(int,raw_input().split()))\n",
    "k=int(raw_input().strip())\n",
    "lst.sort(key=lambda x: x[k])\n",
    "for x in range(i):\n",
    "    print ' '.join(str(l) for l in lst[x])+'\\n'\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11 19\n",
      "-11 -19\n",
      "0.00+0.00i\n",
      "22.00+38.00i\n",
      "240.00-418.00i\n",
      "-1.00+0.00i\n",
      "21.95+0.00i\n",
      "21.95+0.00i\n"
     ]
    }
   ],
   "source": [
    "#Classes Complex number\n",
    "#https://www.hackerrank.com/challenges/class-1-dealing-with-complex-numbers\n",
    "class complexnum(object):\n",
    "    import cmath\n",
    "    def __init__(self,a,b,c,d):\n",
    "        self.a=complex(a,b)\n",
    "        self.c=complex(c,d)\n",
    "        \n",
    "    def __add__(self):\n",
    "        self.s1=self.a+self.c\n",
    "        \n",
    "        print \"%.2f%s%.2fi\" %(self.s1.real,('+' if self.s1.imag>=0 else '-'),abs(self.s1.imag))\n",
    "    def __sub__(self):\n",
    "        self.s1=self.a-self.c\n",
    "        print \"%.2f%s%.2fi\" %(self.s1.real,('+' if self.s1.imag>=0 else '-'),abs(self.s1.imag))\n",
    "    def __div__(self):\n",
    "        self.s1=self.a/self.c\n",
    "        print \"%.2f%s%.2fi\" %(self.s1.real,('+' if self.s1.imag>=0 else '-'),abs(self.s1.imag))\n",
    "    def __mul__(self):\n",
    "        self.s1=self.a*self.c\n",
    "        print \"%.2f%s%.2fi\" %(self.s1.real,('+' if self.s1.imag>=0 else '-'),abs(self.s1.imag))\n",
    "    def __mod__(self):\n",
    "        print \"%.2f%s%.2fi\" %(abs(self.a).real,('+' if abs(self.a).imag>=0 else '-'),abs(self.a).imag)\n",
    "        print \"%.2f%s%.2fi\" %(abs(self.c).real,('+' if abs(self.c).imag>=0 else '-'),abs(self.c).imag)\n",
    "    def operate(self):\n",
    "        self.__add__()\n",
    "        self.__sub__()\n",
    "        self.__mul__()\n",
    "        self.__div__()\n",
    "        self.__mod__()\n",
    "\n",
    "a,b=map(float,raw_input().split())\n",
    "c,d=map(float,raw_input().split())\n",
    "obj1=complexnum(a,b,c,d)\n",
    "obj1.operate()\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 84\n",
      "1 765952241\n",
      "3 289380515 265118103 309882974\n",
      "2 747649220 587740446\n",
      "2 682866882 596381508\n",
      "1 342723101\n",
      "70\n"
     ]
    }
   ],
   "source": [
    "#Itertools\n",
    "#https://www.hackerrank.com/challenges/maximize-it/\n",
    "k,m=map(int,raw_input().split())\n",
    "main=[]\n",
    "for i in range(k):\n",
    "    lst=map(int,raw_input().split())\n",
    "    \n",
    "    main.append(max(lst))\n",
    "print max(map(sum(pow(int(i),2) for i in main)%m    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[765952241, 309882974, 747649220, 682866882, 342723101]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#CorrectLogic\n",
    "k, m = map(int, raw_input().split())\n",
    "import itertools\n",
    "ls = []\n",
    "for _ in xrange(k):\n",
    "    ls.append(map(lambda x:x**2, map(int, raw_input().split()[1:])))\n",
    "print max(map(lambda x:x%m, map(sum, itertools.product(*ls))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hack 2\n",
      "ac\n",
      "ah\n",
      "ak\n",
      "ca\n",
      "ch\n",
      "ck\n",
      "ha\n",
      "hc\n",
      "hk\n",
      "ka\n",
      "kc\n",
      "kh\n"
     ]
    }
   ],
   "source": [
    "#ItertoolsPermutations\n",
    "\n",
    "from itertools import permutations\n",
    "a,b=raw_input().split()\n",
    "print \"\\n\".join( [''.join(i) for i in sorted(permutations(a,int(b)))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 4 5\n",
      "5 6 7\n",
      "1 6 7\n",
      "5 3 2 1\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "#https://www.hackerrank.com/challenges/no-idea\n",
    "#Sets\n",
    "raw_input()\n",
    "arr=map(int,raw_input().strip().split())\n",
    "a=set(map(int,raw_input().strip().split()))\n",
    "b=set(map(int,raw_input().strip().split()))\n",
    "print sum([0 + 1 if i in a else 0 - 1 if i in b else 0+0 for i in arr ])\n",
    "#converted to set as lookup in sets is faster than a list    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Collections\n",
    "#https://www.hackerrank.com/challenges/word-order/\n",
    "\n",
    "from collections import Counter\n",
    "n=int(raw_input().strip())\n",
    "lst=[]\n",
    "for i in range(n):\n",
    "    lst.append(raw_input().strip())\n",
    "\n",
    "\n",
    "set1=Counter(lst)\n",
    "a=[]\n",
    "for i in lst:\n",
    "    try:\n",
    "        a.append(set1.pop(i))\n",
    "    except:\n",
    "        continue\n",
    "print len(set(lst))        \n",
    "print ' '.join(str(i) for i in a) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#https://www.hackerrank.com/challenges/the-minion-game\n",
    "#minion game\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Regex\n",
    "\n",
    "import re\n",
    "\n",
    "for i in range(int(raw_input().strip())):\n",
    "    str1=str(raw_input().strip())\n",
    "    print bool(re.search(r\"+\",r\".\",str1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "its@hack.com1\n",
      "it@ha_c.com\n",
      "1\n",
      "4\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "1 is not in list",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-45-9e1efa6caeaf>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     24\u001b[0m     \u001b[1;32mexcept\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     25\u001b[0m         \u001b[1;32mprint\u001b[0m \u001b[1;36m4\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 26\u001b[1;33m         \u001b[1;32mdel\u001b[0m \u001b[0mstr1\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mstr1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     27\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     28\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: 1 is not in list"
     ]
    }
   ],
   "source": [
    "#https://www.hackerrank.com/challenges/validate-list-of-email-address-with-filter\n",
    "str1=[]\n",
    "for i in range(int(raw_input().strip())):\n",
    "    str1.append(str(raw_input().strip()))\n",
    "str1=sorted(str1)    \n",
    "for j in range(len(str1)):   \n",
    "    try:\n",
    "        \n",
    "        str2=str1[j].split('@')\n",
    "        if len(str2)==2:\n",
    "            str3=str2[1].split('.')\n",
    "            if len(str3)==2 and len(str3[1])==3:\n",
    "                if (\"_\" in str2[0] or \"-\" in str2[0] or str2[0].isalpha()) and (str3[0].isalnum() and str3[1].isalnum) :\n",
    "                    continue\n",
    "                else:\n",
    "                    print 1\n",
    "                    del str1[j\n",
    "            else:\n",
    "                print 2\n",
    "                del str1[j]\n",
    "        else:\n",
    "            print 3\n",
    "            del str1[j]\n",
    "    except:\n",
    "        print 4\n",
    "        del str1[j]\n",
    "    \n",
    "                \n",
    "print str1         "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}