Data Structure Exercise- Cracking the coding Interview.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Array and Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.1 Is Unique: Implement an algorithm to determine if a string has all unique characters. What if you\n",
    "cannot use additional data structures?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def IsUnique(s):\n",
    "    sorted_s=sorted(s)\n",
    "    for i in range(len(sorted_s)):\n",
    "        if sorted_s[i]==sorted_s[i+1]:\n",
    "            return False\n",
    "        else:\n",
    "            return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IsUnique(\"gdjfhsdjha\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.2 Check Permutation: Given two strings, write a method to decide if one is a permutation of the\n",
    "other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def chk_perm(s,t):\n",
    "    sorted_s=sorted(s)\n",
    "    sorted_t=sorted(t)\n",
    "    if sorted_s==sorted_t:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chk_perm('god','dog')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chk_perm('god','hot')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.3 URLify: Write a method to replace all spaces in a string with '%20: You may assume that the string\n",
    "has sufficient space at the end to hold the additional characters, and that you are given the \"true\"\n",
    "length of the string. (Note: If implementing in Java, please use a character array so that you can\n",
    "perform this operation in place.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def urlifyString(str):\n",
    "    res = []\n",
    "    start = False\n",
    "    str = str.strip() # Removes white space from the beginning and end of the string\n",
    "    for char in reversed(str):\n",
    "        if(char == ' '):\n",
    "            res += '02%'\n",
    "        else: res += char\n",
    "    res = ''.join(res[::-1])\n",
    "    return res\n",
    " \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Mr%20John%20Smith'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "urlifyString(\"       Mr John Smith           \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.4 Palindrome Permutation: Given a string, write a function to check if it is a permutation of\n",
    "a palindrome. A palindrome is a word or phrase that is the same forwards and backwards. A\n",
    "permutation is a rearrangement of letters. The palindrome does not need to be limited to just\n",
    "dictionary words. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def permofpal(s):\n",
    "    s=s.replace(\" \",\"\")\n",
    "    s=s.lower()\n",
    "    \n",
    "    dic={}\n",
    "    \n",
    "    for i in s:\n",
    "        if i in dic:\n",
    "            dic[i] +=1\n",
    "        else:\n",
    "            dic[i] = 1\n",
    "    \n",
    "    odd_count=0\n",
    "    for k,v in dic.items():\n",
    "        if v % 2 != 0 and odd_count == 0:\n",
    "            odd_count +=1\n",
    "        elif v % 2 != 0 and odd_count != 0:\n",
    "            return False\n",
    "    return True\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "permofpal('Tact Coa')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.5 One Away: There are three types of edits that can be performed on strings: insert a character,\n",
    "remove a character, or replace a character. Given two strings, write a function to check if they are\n",
    "one edit (or zero edits) away."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Returns true if edit distance between s1 and s2 is\n",
    "# one, else false\n",
    "def isEditDistanceOne(s1, s2):\n",
    " \n",
    "    # Find lengths of given strings\n",
    "    m = len(s1)\n",
    "    n = len(s2)\n",
    " \n",
    "    # If difference between lengths is more than 1,\n",
    "    # then strings can't be at one distance\n",
    "    if abs(m - n) > 1:\n",
    "        return false\n",
    " \n",
    "    count = 0    # Count of isEditDistanceOne\n",
    " \n",
    "    i = 0\n",
    "    j = 0\n",
    "    while i < m and j < n:\n",
    "        # If current characters dont match\n",
    "        if s1[i] != s2[j]:\n",
    "            if count == 1:\n",
    "                return false\n",
    " \n",
    "            # If length of one string is\n",
    "            # more, then only possible edit\n",
    "            # is to remove a character\n",
    "            if m > n:\n",
    "                i+=1\n",
    "            elif m < n:\n",
    "                j+=1\n",
    "            else:    # If lengths of both strings is same\n",
    "                i+=1\n",
    "                j+=1\n",
    " \n",
    "            # Increment count of edits\n",
    "            count+=1\n",
    " \n",
    "        else:    # if current characters match\n",
    "            i+=1\n",
    "            j+=1\n",
    " \n",
    "    # if last character is extra in any string\n",
    "    if i < m or j < n:\n",
    "        count+=1\n",
    " \n",
    "    return count == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isEditDistanceOne(\"abde\", \"abcde\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.6 String Compression: Implement a method to perform basic string compression using the counts\n",
    "of repeated characters. For example, the string aabcccccaaa would become a2b1c5a3. If the\n",
    "\"compressed\" string would not become smaller than the original string, your method should return\n",
    "the original string. You can assume the string has only uppercase and lowercase letters (a - z)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def str_comp(s):\n",
    "    s=s.lower()\n",
    "    a=\"\"\n",
    "    count = 1\n",
    "    a+=s[0]\n",
    "    \n",
    "    for i in range(len(s)-1):\n",
    "        if s[i] == s[i+1]:\n",
    "            count+=1\n",
    "        else:\n",
    "            if count>1:\n",
    "                a+=str(count)\n",
    "            a+=s[i+1]\n",
    "            count = 1\n",
    "    if count>1:\n",
    "        a +=str(count)\n",
    "    if len(s)<len(a):\n",
    "        return s\n",
    "    else:\n",
    "        return a\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a2bc5a3'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str_comp('aabcccccaaa')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.7 Rotate Matrix: Given an image represented by an NxN matrix, where each pixel in the image is 4\n",
    "bytes, write a method to rotate the image by 90 degrees. (an you do this in place?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rotate(mat):\n",
    "    if(len(mat)==0 or len(mat) != len(mat[0])):\n",
    "        return False \n",
    "    n=len(mat)\n",
    "    \n",
    "    for layer in range(n//2,1):\n",
    "        first=layer\n",
    "        last=n-1-layer\n",
    "        \n",
    "        for i in range(first,last,1):\n",
    "            offset=i-first\n",
    "            top=mat[first][i]\n",
    "            mat[first][i]=mat[last-offset][first]\n",
    "            mat[last-offset][first]=mat[last][last-offset]\n",
    "            mat[i][last]=top\n",
    "    return True\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rotate([[1,2,3,4],[13,14,15,16],[5,6,7,8],[9,10,11,12]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.8 Zero Matrix: Write an algorithm such that if an element in an MxN matrix is 0, its entire row and\n",
    "column are set to 0. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nullifyRow(mat,row):\n",
    "    for j in range(len(mat[0]),1):\n",
    "        mat[row][j] = 0\n",
    "        return\n",
    "\n",
    "def nullifyColumn(mat,col):\n",
    "    for i in range(len(mat),1):\n",
    "        mat[i][col] = 0\n",
    "        return\n",
    "\n",
    "def setZero(mat):\n",
    "    rowhaszero=False\n",
    "    colhaszero=False\n",
    "    \n",
    "    for j in range(len(mat[0]),1):             # check if first row has a zero\n",
    "        if(mat[0][j]==0):\n",
    "            rowhaszero=True\n",
    "            break\n",
    "    \n",
    "    for i in range(len(mat),1):                # check if first column has a zero\n",
    "        if(mat[i][0]==0):\n",
    "            colhaszero=True\n",
    "            break\n",
    "    \n",
    "    for i in range(len(mat),1):                # Check for zeros in the rest of the array\n",
    "        for j in range(len(mat[0]),1):\n",
    "            if(mat[i][j]==0):\n",
    "                mat[i][0] = 0\n",
    "                mat[0][j] = 0\n",
    "    \n",
    "    for i in range(len(mat),1):                # Nullify rows based on values in first column\n",
    "        if(mat[i][0]==0):\n",
    "            nullifyRow(mat,i)\n",
    "    \n",
    "    for j in range(len(mat[0]),1):             # Nullify columns based on values in first row \n",
    "        if(mat[0][j]==0):\n",
    "            nullifyColumn(mat,j)\n",
    "            \n",
    "    if(rowhaszero):                            # Nullify first row \n",
    "        nullifyRow(mat,0)\n",
    "        \n",
    "    if(colhaszero):                           # Nullify first column \n",
    "        nullifyColumn(mat,0)\n",
    "    \n",
    "    return\n",
    "                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "setZero([[1,2,3,4],[13,14,15,16],[5,6,7,8],[9,10,11,12]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.9 String Rotation: Assume you have a method i5Substring which checks ifone word is a substring\n",
    "of another. Given two strings, 51 and 52, write code to check if 52 is a rotation of 51 using only one\n",
    "call to isSubstring (e.g., Uwaterbottleuis a rotation ofuerbottlewatU). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def isRotation(s1,s2):\n",
    "    l=len(s1)\n",
    "    #check that s1 and s2 are equal length and not empty\n",
    "    if l == len(s2) and l > 0:\n",
    "        # Concatenate 51 and sl within new buffer \n",
    "        s1s1 = s1+s1\n",
    "        return isSubtring(s1s1,s2)\n",
    "    return False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linked Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#create a linkedlist:\n",
    "class Node:\n",
    "    def __init__(self, data=None):\n",
    "        self.data = data\n",
    "        self.next = None\n",
    "\n",
    "#Linkedlist class with basic functions:\n",
    "class SLinkedList:\n",
    "    def __init__(self):\n",
    "        self.head = None\n",
    "        \n",
    "    def append(self, newdata):\n",
    "        NewNode = Node(newdata)\n",
    "        if self.head is None:\n",
    "            self.head = NewNode\n",
    "            return\n",
    "        \n",
    "        current = self.head\n",
    "        while(current.next is not None):\n",
    "            current = current.next\n",
    "        current.next=NewNode\n",
    "        \n",
    "    def prepend(self, newdata):\n",
    "        newHead = Node(newdata)\n",
    "        newHead.next = head\n",
    "        head = newHead\n",
    "        \n",
    "    def deleteWithValue(data):\n",
    "        if head is None:\n",
    "            return\n",
    "        if head.data == data:\n",
    "            head = head.next\n",
    "            return\n",
    "        \n",
    "        current = head\n",
    "        while current.next is not None:\n",
    "            if current.next.data == data:\n",
    "                current.next = current.next.next\n",
    "                return\n",
    "            \n",
    "            current = current.next\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2.1 Remove Dups: Write code to remove duplicates from an unsorted linked list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def deletedups(n):\n",
    "    set = {}\n",
    "    while (n is not None):\n",
    "        if(set.contains(n.data)):\n",
    "            pre"
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}