30 Days of Code Hackerrank.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 0: Hello, World."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to 30 Days of Code!\n",
      "Hello, World.\n",
      "Welcome to 30 Days of Code!\n"
     ]
    }
   ],
   "source": [
    "inp_string=input() #taking string input the input functions always returns str by default\n",
    "print(\"Hello, World.\")\n",
    "print(inp_string) #another print function is used for new line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 1: Data Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "4.0\n",
      "is the best place to learn and practice coding!\n",
      "16\n",
      "8.0\n",
      "HackerRank is the best place to learn and practice coding!\n"
     ]
    }
   ],
   "source": [
    "i = 4\n",
    "d = 4.0\n",
    "s = 'HackerRank '\n",
    "a = int(input())\n",
    "b = float(input())\n",
    "c = str(input()) #here the data type convert operator is used\n",
    "print(a + i)\n",
    "print(d + b)\n",
    "print(s + c) #a string can be appended by a + sign"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 2: Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.00\n",
      "20\n",
      "8\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "MealCost = float(input())\n",
    "TipPercent = int(input())\n",
    "TaxPercent = int(input())\n",
    "tip = MealCost * (TipPercent/100)\n",
    "tax = MealCost * (TaxPercent/100)\n",
    "totalCost = MealCost + tip + tax\n",
    "print(round(totalCost)) #use the round function instead of int because int (1.99=1) but in round (1.6=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 3: Intro to conditional Statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "Weird\n"
     ]
    }
   ],
   "source": [
    "num = int(input())\n",
    "if(num%2!=0): #first checking not equal to beacause it's much easier\n",
    "    print(\"Weird\") #no is odd\n",
    "elif(num>=2 and num<=5): #elif means if the previous statement is not true try this\n",
    "    print(\"Not Weird\")\n",
    "elif(num>=6 and num<=20):\n",
    "    print(\"Weird\")\n",
    "else:\n",
    "    print(\"Not Weird\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 4: Class Vs. Instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "-1\n",
      "Age is not valid, setting age to 0.\n",
      "You are young.\n",
      "You are young.\n",
      "\n",
      "10\n",
      "You are young.\n",
      "You are a teenager.\n",
      "\n",
      "16\n",
      "You are a teenager.\n",
      "You are old.\n",
      "\n",
      "18\n",
      "You are old.\n",
      "You are old.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self,initialAge): #__init__() function is used to assign values to object properties or other operations to do when the object is created.\n",
    "        if initialAge > 0:\n",
    "            self.age = initialAge #self parameter is a reference to current instance of the class and used to access class variables\n",
    "        else:\n",
    "            print(\"Age is not valid, setting age to 0.\")\n",
    "            self.age = 0\n",
    "    def amIOld(self): #This is method of the class Person. Method is nothing but function within a class\n",
    "        if self.age < 13:\n",
    "            print(\"You are young.\")\n",
    "        elif self.age < 18:\n",
    "            print(\"You are a teenager.\")\n",
    "        else:\n",
    "            print(\"You are old.\")\n",
    "    def yearPasses(self):\n",
    "        self.age = self.age + 1\n",
    "    \n",
    "    t = int(input()) #hackerrank has this driver code preloaded\n",
    "    for i in range(0,t):\n",
    "        age=int(input())\n",
    "        p=Person(age)\n",
    "        p.amIOld()\n",
    "        for j in range(0,3):\n",
    "            p.yearPasses()\n",
    "        p.amIOld()\n",
    "        print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 5: Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2 x 1 = 2\n",
      "2 x 2 = 4\n",
      "2 x 3 = 6\n",
      "2 x 4 = 8\n",
      "2 x 5 = 10\n",
      "2 x 6 = 12\n",
      "2 x 7 = 14\n",
      "2 x 8 = 16\n",
      "2 x 9 = 18\n",
      "2 x 10 = 20\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "for i in range (1,11): # the last no is ignored so it goes from 1 to 10\n",
    "    print(n,'x',i,'=',n*i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 6: Let's Review"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "Hacker\n",
      "Hce akr\n",
      "Rank\n",
      "Rn ak\n"
     ]
    }
   ],
   "source": [
    "t = int(input())\n",
    "for word in range(0,t):\n",
    "    s = str(input())\n",
    "    print(s[0::2] +\" \"+s[1::2]) #::2 is the jump step in the particular string start:end:jump is the syntax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 7: Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "1 4 3 2\n",
      "2 3 4 1\n"
     ]
    }
   ],
   "source": [
    "n = int(input())\n",
    "arr = list(map(int,input().rstrip().split())) #map(function, iterable) executes function for each item in the iterable\n",
    "            #rstrip() removes the blank spaces at the end\n",
    "            #split() splits the string into a list\n",
    "m = map(str,arr[::-1])\n",
    "print(\" \".join(m))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 8: Dictionaries and Maps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "sam 99912222\n",
      "tom 11122222\n",
      "harry 12299933\n",
      "sam\n",
      "sam=99912222\n",
      "harry\n",
      "harry=12299933\n",
      "edward\n",
      "Not found\n"
     ]
    }
   ],
   "source": [
    "phonebook = {} #creating an empty dictonary\n",
    "entries = int(input()) # no of elements in the phonebook\n",
    "\n",
    "for n in range(entries):\n",
    "    name, num = input().strip().split(' ') #getting name and no\n",
    "    name, num = [str(name), int(num)] #converting into appropriate data type\n",
    "    phonebook[name] = num\n",
    "\n",
    "while True:\n",
    "    try:  # try and except is used to avoid errors\n",
    "        search = str(input()) \n",
    "\n",
    "        if search in phonebook.keys():\n",
    "            output = ''.join('%s=%r' % (search, phonebook[search])) #%s is add string data and %r is raw data\n",
    "            print(output)\n",
    "        else:\n",
    "            print(\"Not found\")\n",
    "    except EOFError: #end of file error \n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 9: Recursion 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "def factorial(n):\n",
    "    if n == 1:\n",
    "        return n\n",
    "    else:\n",
    "        return n * factorial (n - 1) #it calls it's own function here\n",
    "num = int(input())\n",
    "print(factorial(num))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 10: Binary Numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "n = int(input().strip())\n",
    "binary = list(bin(n)[2:]) #bin function is used for binary conversion and [2:] to eliminate the suffix \"0 b\"\n",
    "count = 0\n",
    "maxcount = 0\n",
    "for i in binary:\n",
    "    if (i == '1'):\n",
    "        count += 1 #counting the 1 and adding it to the count\n",
    "    else:\n",
    "        if count > maxcount:\n",
    "            maxcount = count\n",
    "        count = 0\n",
    "if count > maxcount:\n",
    "    maxcount = count\n",
    "print(maxcount)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 11: 2D Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 1 0 0 0\n",
      "0 1 0 0 0 0\n",
      "1 1 1 0 0 0\n",
      "0 0 2 4 4 0\n",
      "0 0 0 2 0 0\n",
      "0 0 1 2 4 0\n",
      "19\n"
     ]
    }
   ],
   "source": [
    "arr = []\n",
    "for _ in range(6):\n",
    "    tmp = [int(x) for x in str(input()).split(\" \")]\n",
    "    arr.append(tmp)\n",
    "maximum = -9 * 7\n",
    "for i in range(6):\n",
    "    for j in range(6):\n",
    "        if j + 2 < 6 and i + 2 < 6:\n",
    "            result = arr[i][j] + arr[i][j + 1] + arr[i][j + 2] + arr[i + 1][j + 1] + arr[i + 2][j] + arr[i + 2][j + 1] + arr[i + 2][j + 2] #calculating the hour glass sum\n",
    "            if result > maximum:\n",
    "                maximum = result\n",
    "print(maximum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 12: Inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Heraldo Memelli 8135627\n",
      "2\n",
      "100 80\n",
      "Name: Memelli, Heraldo\n",
      "ID: 8135627\n",
      "Grade: O\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, firstName, lastName, idNumber):#initializing attributes\n",
    "        self.firstName = firstName\n",
    "        self.lastName = lastName\n",
    "        self.idNumber = idNumber\n",
    "    def printPerson(self):\n",
    "        print(\"Name:\", self.lastName + \",\", self.firstName)\n",
    "        print(\"ID:\", self.idNumber)\n",
    "        \n",
    "        #The main submission code\n",
    "class Student(Person):\n",
    "    def __init__(self, firstName, lastName, idNumber, testScores):\n",
    "        super().__init__(firstName, lastName, idNumber)\n",
    "        self.testScores = testScores\n",
    "\n",
    "    def calculate(self):\n",
    "        total = 0\n",
    "        for testScore in self.testScores:\n",
    "            total += testScore\n",
    "        avg = total / len(self.testScores)\n",
    "        if 90 <= avg <= 100:\n",
    "            return 'O'\n",
    "        if 80 <= avg < 90:\n",
    "            return 'E'\n",
    "        if 70 <= avg < 80:\n",
    "            return 'A'\n",
    "        if 55 <= avg < 70:\n",
    "            return 'P'\n",
    "        if 40 <= avg < 55:\n",
    "            return 'D'\n",
    "        return 'T'\n",
    "    \n",
    "    \n",
    "line = input().split()\n",
    "firstName = line[0]\n",
    "lastName = line[1]\n",
    "idNum = line[2]\n",
    "numScores = int(input()) # not needed for Python\n",
    "scores = list( map(int, input().split()) )\n",
    "s = Student(firstName, lastName, idNum, scores)\n",
    "s.printPerson()\n",
    "print(\"Grade:\", s.calculate())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 13: Abstract Classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Alchemist\n",
      "Paulo Coelho\n",
      "248\n",
      "Title: The Alchemist\n",
      "Author: Paulo Coelho\n",
      "Price: 248\n"
     ]
    }
   ],
   "source": [
    "from abc import ABCMeta, abstractmethod\n",
    "class Book(object, metaclass=ABCMeta):\n",
    "    def __init__(self,title,author):\n",
    "        self.title=title\n",
    "        self.author=author   \n",
    "    @abstractmethod\n",
    "    def display(): pass\n",
    "    \n",
    "    \n",
    "class MyBook(Book):\n",
    "    def __init__(self, title, author, price):\n",
    "        super().__init__(title, author)\n",
    "        self.price = price\n",
    "\n",
    "    def display(self):\n",
    "        print(\"Title: \" + self.title + \"\\nAuthor: \" + self.author + \"\\nPrice: \" + str(self.price))\n",
    "        \n",
    "        \n",
    "title=input()\n",
    "author=input()\n",
    "price=int(input())\n",
    "new_novel=MyBook(title,author,price)\n",
    "new_novel.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 14: Scope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1 2 5\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "class Difference:\n",
    "    def __init__(self, a):\n",
    "        self.__elements = a\n",
    "     \n",
    "    \n",
    "    def computeDifference(self):\n",
    "        maximum = 0\n",
    "\n",
    "        for i in range(len(self.__elements)):\n",
    "            for j in range(len(self.__elements)):\n",
    "                absolute = abs(self.__elements[i] - self.__elements[j])\n",
    "                if absolute > maximum:\n",
    "                    maximum = absolute\n",
    "        self.maximumDifference = maximum\n",
    "        \n",
    "        \n",
    "_= input()\n",
    "a = [int(e) for e in input().split(' ')]\n",
    "\n",
    "d = Difference(a)\n",
    "d.computeDifference()\n",
    "\n",
    "print(d.maximumDifference)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 15: Linked List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "    def __init__(self,data):\n",
    "        self.data = data\n",
    "        self.next = None \n",
    "class Solution: \n",
    "    def display(self,head):\n",
    "        current = head\n",
    "        while current:\n",
    "            print(current.data,end=' ')\n",
    "            current = current.next\n",
    "\n",
    "    def insert(self,head,data):\n",
    "        if head is None:\n",
    "            head = Node(data)\n",
    "        else:\n",
    "            curr = head\n",
    "            while curr.next:\n",
    "                curr = curr.next\n",
    "            curr.next = Node(data)\n",
    "        return head\n",
    "\n",
    "mylist= Solution()\n",
    "T=int(input())\n",
    "head=None\n",
    "for i in range(T):\n",
    "    data=int(input())\n",
    "    head=mylist.insert(head,data)    \n",
    "mylist.display(head);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 16: Exceptions - String to Integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    print(int(input()))\n",
    "except ValueError:\n",
    "    print(\"Bad String\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 17: More Exceptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Calculator:\n",
    "    def power(self, n, p):\n",
    "        if n < 0 or p < 0:\n",
    "            raise Exception(\"n and p should be non-negative\")\n",
    "        return pow(n, p)\n",
    "myCalculator=Calculator()\n",
    "T=int(input())\n",
    "for i in range(T):\n",
    "    n,p = map(int, input().split())\n",
    "    try:\n",
    "        ans=myCalculator.power(n,p)\n",
    "        print(ans)\n",
    "    except Exception as e:\n",
    "        print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 18: Queues and Stacks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "class Solution:\n",
    "    def __init__(self):\n",
    "        self.stack = []\n",
    "        self.queue = []\n",
    "    def popCharacter(self):\n",
    "        return self.stack.pop()\n",
    "    def pushCharacter(self, char):\n",
    "        self.stack.append(char)\n",
    "    def dequeueCharacter(self):\n",
    "        char = self.queue[0]\n",
    "        self.queue = self.queue[1:]\n",
    "        return char\n",
    "    def enqueueCharacter(self, char):\n",
    "        self.queue.append(char)\n",
    "# read the string s\n",
    "s=input()\n",
    "#Create the Solution class object\n",
    "obj=Solution()   \n",
    "\n",
    "l=len(s)\n",
    "# push/enqueue all the characters of string s to stack\n",
    "for i in range(l):\n",
    "    obj.pushCharacter(s[i])\n",
    "    obj.enqueueCharacter(s[i])\n",
    "    \n",
    "isPalindrome=True\n",
    "'''\n",
    "pop the top character from stack\n",
    "dequeue the first character from queue\n",
    "compare both the characters\n",
    "''' \n",
    "for i in range(l // 2):\n",
    "    if obj.popCharacter()!=obj.dequeueCharacter():\n",
    "        isPalindrome=False\n",
    "        break\n",
    "#finally print whether string s is palindrome or not.\n",
    "if isPalindrome:\n",
    "    print(\"The word, \"+s+\", is a palindrome.\")\n",
    "else:\n",
    "    print(\"The word, \"+s+\", is not a palindrome.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 19: Interfaces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AdvancedArithmetic(object):\n",
    "    def divisorSum(n):\n",
    "        raise NotImplementedError\n",
    "\n",
    "class Calculator(AdvancedArithmetic):\n",
    "    def divisorSum(self, n):\n",
    "        val = 0\n",
    "        for i in range(1,n+1):\n",
    "            if(n % i == 0):\n",
    "                val += i\n",
    "        return val\n",
    "\n",
    "n = int(input())\n",
    "my_calculator = Calculator()\n",
    "s = my_calculator.divisorSum(n)\n",
    "print(\"I implemented: \" + type(my_calculator).__bases__[0].__name__)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Day 20: Sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "n = int(input().strip())\n",
    "a = list(map(int, input().strip().split(' ')))\n",
    "numSwaps = 0\n",
    "for i in range(n):\n",
    "    for j in range(n-1):\n",
    "        if(a[j] > a[j+1]):\n",
    "            numSwaps+=1\n",
    "            a[j], a[j+1] = a[j+1], a[j]\n",
    "    if(numSwaps is 0):\n",
    "        break\n",
    "print(\"Array is sorted in \" + str(numSwaps) + \" swaps.\")\n",
    "print(\"First Element: \" + str(a[0]))\n",
    "print(\"Last Element: \" + str(a[n-1]))"
   ]
  }
 ],
 "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
}