New Commits

Author: rahulcode22

Bit-Manipulation/Min-XOR-Value.py

@@ -0,0 +1,16 @@
+'''
+Given an array of N integers, find the pair of integers in the array which have minimum XOR value. Report the minimum XOR value.
+'''
+def minXOR(arr):
+    arr = sorted(arr)
+    n = len(arr)
+    minXor = float('inf')
+    val = 0
+    for i in range(n-1):
+        val = arr[i]^arr[i+1]
+        minXor = min(minXor,val)
+
+    return minXor
+
+arr = [0,4,7,9]
+print minXOR(arr)

Bit-Manipulation/divide-integers.py

@@ -0,0 +1,16 @@
+class Solution:
+# @return an integer
+    def divide(self, dividend, divisor):
+        positive = (dividend < 0) ^ (divisor < 0)
+        dividend, divisor = abs(dividend), abs(divisor)
+        res = 0
+        while dividend >= divisor:
+            temp, i = divisor, 1
+            while dividend >= temp:
+                dividend -= temp
+                res += i
+                i <<= 1
+                temp <<= 1
+        if not positive:
+            res = -res
+        return min(max(-2147483648, res), 2147483647)

Bit-Manipulation/number-of-1-bits.py

@@ -0,0 +1,19 @@
+#Approach 1
+def setbits(n):
+    a = bin(n)
+    a = a[2:]
+    return a.count('1')
+
+n = 4
+print setbits(n)
+
+#Approach 2
+def num1bits(n):
+    res = 0
+    while n != 0:
+        if n&1:
+            res += 1
+
+        #Shifting by one bit to the right
+        n = n >> 1
+    return res

Bit-Manipulation/reverseBit.py

@@ -0,0 +1,7 @@
+def reversebit(num):
+    n = '{0:032b}'.format(num)
+    rev = n[::-1]
+    return int(rev,2)
+
+num = 4294967295
+print reversebit(num)

Bit-Manipulation/single-number.py

@@ -0,0 +1,17 @@
+'''
+Given an array of integers, every element appears twice except for one. Find that single one.
+
+Note: Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?
+
+Example :
+
+Input : [1 2 2 3 1]
+Output : 3
+'''
+def singlenum(arr):
+    res = 0
+    for i in arr:
+        res ^= i
+        print res
+arr= [1,2,2,3,1]
+singlenum(arr)

LinkedList/List-Cycle.py

@@ -0,0 +1,22 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    # @param A : head node of linked list
+    # @return the first node in the cycle in the linked list
+    def detectCycle(self, head):
+        slow = fast = head
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+            if slow == fast:
+                break
+        else:
+            return None
+        while head != slow:
+            slow = slow.next
+            head = head.next
+        return head

LinkedList/Merge-Lists.py

@@ -0,0 +1,28 @@
+'''
+Merge two sorted linked lists and return it as a new list.
+The new list should be made by splicing together the nodes of the first two lists, and should also be sorted.
+
+For example, given following linked lists :
+
+  5 -> 8 -> 20
+  4 -> 11 -> 15
+The merged list should be :
+
+4 -> 5 -> 8 -> 11 -> 15 -> 20
+'''
+def merge(h1,h2):
+    if None in (h1,h2):
+        return h1 or h2
+    dummy = head = ListNode(0)
+    while h1 and h2:
+        if h1.val < h2.val:
+            head.next = h1
+            head = h1
+            h1 = h1.next
+        else:
+            head.next = h2
+            head = h2
+            h2 = h2.next
+
+    head.next = h1 or h2
+    return dummy.next

LinkedList/Palindrome-List.py

@@ -0,0 +1,28 @@
+'''
+Given a singly linked list, determine if its a palindrome. Return 1 or 0 denoting if its a palindrome or not, respectively.
+
+Notes:
+
+Expected solution is linear in time and constant in space.
+For example,
+
+List 1-->2-->1 is a palindrome.
+List 1-->2-->3 is not a palindrome.
+'''
+def isPalindrome(self,head):
+    slow = fast = head
+    while fast and fast.next:
+        slow = slow.next
+        fast = fast.next.next
+    prev = None
+    while slow:
+        next = slow.next
+        slow.next = prev
+        prev = slow
+        slow = next
+    while prev:
+        if prev.val != head.val:
+            return 0
+        prev = prev.next
+        head = head.next
+    return 1

LinkedList/Remove-Duplicates.py

@@ -0,0 +1,7 @@
+def removeDuplicates(head):
+    curr = head
+    while curr:
+        while curr.next and curr.next.val == curr.val:
+            curr.next = curr.next.next
+        curr = curr.next
+    return head

LinkedList/Remove-Nth-Node.py

@@ -0,0 +1,18 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def removeNthFromEnd(self, head, n):
+        fast = slow = head
+        for _ in range(n):
+            fast = fast.next
+        if not fast:
+            return head.next
+        while fast.next:
+            fast = fast.next
+            slow = slow.next
+        slow.next = slow.next.next
+        return head

LinkedList/Reverse-LinkedList-ii.py

@@ -0,0 +1,22 @@
+'''Sort a linked list in O(n log n) time using constant space complexity.'''
+def merge(self,h1,h2):
+    dummy = tail = ListNode(0)
+    while h1 and h2:
+        if h1.val < h2.val:
+            tail.next = h1
+            tail = h1
+            h1 = h1.next
+        else:
+            tail.next = h2
+            tail = h2
+            h2 = h2.next
+    tail.next = h1 or h2
+    return dummy.next
+def sortList(head):
+    if head or head.next:
+        return head
+    prev, slow, fast = None, head, head
+    while fast and fast.next:
+        prev, slow, fast = slow, slow.next, fast.next.next
+    prev.next = None
+    return self.merge(self.sort(head),self.sort(slow))

LinkedList/Sort-List.py

@@ -4,7 +4,11 @@
 
 # InterviewBit Solutions
 
+<<<<<<< HEAD
 ![languages-Python%20&%20C++-orange.svg](https://img.shields.io/badge/languages-Python%20&%20C++-orange.svg) [![License-GNU-red.svg](https://img.shields.io/badge/License-GNU-red.svg)](https://img.shields.io/badge/License-GNU-red.svg) [![codebeat-A-brightgreen.svg](https://img.shields.io/badge/codebeat-A-brightgreen.svg)](https://codebeat.co/projects/github-com-alex-keyes-interviewbit)
+=======
+![languages-Python%20&%20C++-orange.svg](https://img.shields.io/badge/languages-Python%20&%20C++-orange.svg) [![License-GNU-red.svg](https://img.shields.io/badge/License-GNU-red.svg)](https://img.shields.io/badge/License-GNU-red.svg) [![codebeat-A-brightgreen.svg](https://img.shields.io/badge/codebeat-A-brightgreen.svg)](https://codebeat.co/projects/github-com-alex-keyes-interviewbit) 
+>>>>>>> f25736fcc5701ad2c7c6fe7a9ef9ce691d7acab1
 
 This is a repository of solutions to all problems I've solved on InterviewBit. I am not quite sure exactly how many problems there are on the website, but I'll be updating this with every problem I solve. Please issue a pull request if you think you have a better solution or something I could improve upon.
 
@@ -16,3 +20,8 @@ This is a repository of solutions to all problems I've solved on InterviewBit. I
 *   [Binary Search](https://github.com/rahulcode22/Data-structures/tree/master/Binary-Search)
 *   [String](https://github.com/rahulcode22/Data-structures/tree/master/String)
 *   [Stack and Queue](#)
+<<<<<<< HEAD
+=======
+
+
+>>>>>>> f25736fcc5701ad2c7c6fe7a9ef9ce691d7acab1

README.md

@@ -0,0 +1,33 @@
+def findword(matrix,row,col,word):
+    x = [-1,-1,-1,0,0,1,1,1]
+    y = [-1,0,1,-1,1,-1,0,1]
+    #if first vhar of word doesn't match with given starting point in grid
+    if matrix[row][col] != word[0]:
+        return False
+    len_ = len(word)
+    #searching words in all directions
+    for dir_ in range(8):
+        #intialize starting point for curr direction
+        rd = row + x[dir_]
+        cd = col + y[dir_]
+        #first character is already matched,check remaining char
+        for k in range(1,len_):
+            if rd >= len(matrix) or rd <0 or cd >= len(matrix[0]) or cd < 0:
+                break
+            #if not matched break
+            if matrix[rd][cd] != word[k]:
+                break
+            rd += x[dir_]
+            cd += y[dir_]
+        if k == len_:
+            return True
+    return False
+
+def patternSearch(matrix,word):
+    for row in range(len(matrix)):
+        for col in range(len(matrix[0])):
+            if findword(matrix,row,col,word):
+                return row,col
+
+matrix = [['G','E','E','K','S','F'],['Q','U','I','Z','Q','A'],['A','B','C','D','E','F']]
+print patternSearch(matrix,"GEEKS")

String/Searching-word-in-2D-matrix.py

@@ -0,0 +1,25 @@
+'''Given a string containing only digits, restore it by returning all possible valid IP address combinations.
+
+A valid IP address must be in the form of A.B.C.D, where A,B,C and D are numbers from 0-255. The numbers cannot be 0 prefixed unless they are 0.
+
+Example:
+
+Given “25525511135”,
+
+return [“255.255.11.135”, “255.255.111.35”]. (Make sure the returned strings are sorted in order)'''
+def validIpAddress(st):
+    temp = []
+    def is_valid(x):
+        return x and int(x) < 256 and not (s.startwith('0') and len(x) > 1)
+    for i in range(1,4):
+        if not is_valid(st[:i]):
+            continue
+        for j in range(i,i+4):
+            if not is_valid(st[i:j]):
+                continue
+            for l in range(j,j+4):
+                if not (is_valid(st[j:l]) and is_valid(st[l:])):
+                    continue
+                ip = st[:i], st[i:j], st[j:l], st[l:]
+                temp.append('.'.join(ip))
+    return sorted(temp)

String/Valid-ip-address.py

@@ -0,0 +1,40 @@
+'''
+
+Given an array S of n integers, find three integers in S such that the sum is closest to a given number, target.
+Return the sum of the three integers.
+
+Assume that there will only be one solution
+
+Example:
+given array S = {-1 2 1 -4},
+and target = 1.
+
+The sum that is closest to the target is 2. (-1 + 2 + 1 = 2)
+'''
+def closestSum(arr,target):
+    i = 0
+    arr = sorted(arr)
+    min_ = float('inf')
+    n = len(arr)
+    res= 0
+    while (i < n):
+        j = i+1
+        k = n-1
+        while (j<k):
+            sum_ = arr[i]+arr[j]+arr[k]
+            diff = abs(sum_ - target)
+            if diff == 0:
+                return sum_
+            if diff < min_:
+                min_ = diff
+                res = sum_
+            if sum_ <= target:
+                j += 1
+            else:
+                k -= 1
+        i += 1
+    return res
+
+arr = [-1,2,1,-4]
+target = 1
+print closestSum(arr,target)

Two Pointers/3Sum.py

@@ -0,0 +1,25 @@
+'''
+Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0?
+Find all unique triplets in the array which gives the sum of zero.
+'''
+def check(arr):
+    i = 0
+    arr =  sorted(arr)
+    n = len(arr)
+    lis = []
+    while i < n:
+        j = i + 1
+        k = n - 1
+        while j < k:
+            sum_ = arr[i] + arr[j] + arr[k]
+            if sum_ == 0:
+                lis.append((arr[i],arr[j],arr[k]))
+            if sum_ <= 0:
+                j += 1
+            else:
+                k -= 1
+        i += 1
+    lis = list(set(lis))
+    return lis
+arr = [-1,0,1,2,-1,-4]
+print check(arr)

Two Pointers/3SumZero.py

@@ -0,0 +1,26 @@
+'''
+You are given an array of N non-negative integers, A0, A1 ,…, AN-1.
+Considering each array element Ai as the edge length of some line segment, count the number of triangles which you can form using these array values.
+
+Notes:
+
+You can use any value only once while forming each triangle. Order of choosing the edge lengths doesn’t matter. Any triangle formed should have a positive area.
+
+Return answer modulo 109 + 7.
+'''
+class Solution:
+    # @param A : list of integers
+    # @return an integer
+    def nTriang(self, arr):
+        arr = sorted(arr)
+        count = 0
+        n = len(arr)
+        if len(arr) < 3:
+            return 0
+        for i in range(0,n-2):
+            k = i+2
+            for j in range(i+1,n):
+                while (k < n and arr[i] + arr[j] > arr[k]):
+                    k += 1
+                count += k - j - 1
+        return count%(10**9 + 7)