Searching algos in array

Author: kumar91gopi

Diff for: arrays/BlockSwapAlgorithmIterative.rb

@@ -0,0 +1,67 @@
+# Block swap algorithm for array rotation(Iterative)
+
+#Initialize A=[0..d-1], B=[d..size-1]
+#until size of A is equal to size of B
+
+#  a)  If A is shorter
+#           1. Divide B into Bl and Br such that Br is of same length as A.
+#           2. Swap A and Br to change ABlBr into BrBlA.
+#           3. Now A is at its final place, so recur on pieces of B.  
+
+#   b)  If A is longer
+#          1. Divide A into Al and Ar such that Al is of same length as B.
+#          2. Swap Al and B to change AlArB into BArAl.
+#          3. Now B is at its final place, so recur on pieces of A.
+
+#Finally when A and B are of equal size, block swap them.
+
+# Iterative approach
+
+def block_swap(a,d)
+    n=a.length
+  if n>0
+    
+      if d>=n
+        d%=n
+      end
+    
+      if d==0
+          return a
+      end
+
+      if d==n-d
+          swap(a,0,d,d)
+      end
+
+      i= d
+      j= n-d
+
+      while(i!=j)
+          if i<j
+              swap(a,d-i,d+j-i,i)
+              j-=i
+          else
+              swap(a,d-i,d,j)
+              i-=j
+          end
+      end
+    
+    swap(a,d-i,d,i)
+  end
+  
+    return a
+  
+end
+    
+
+def swap(a,start1,start2,d)
+    if (start1 != start2)
+        for i in 0...d
+            temp = a[start1+i]
+            a[start1+i] = a[start2+i]
+            a[start2+i] = temp
+        end
+    end
+end
+
+block_swap([1,2,3,4,5,6,7,8,9],5)

Diff for: arrays/BlockSwapAlgorithmRecursive.rb

@@ -0,0 +1,68 @@
+# Block swap algorithm for array rotation(Recursive)
+
+#Initialize A=[0..d-1], B=[d..size-1]
+#until size of A is equal to size of B
+
+#  a)  If A is shorter
+#           1. Divide B into Bl and Br such that Br is of same length as A.
+#           2. Swap A and Br to change ABlBr into BrBlA.
+#           3. Now A is at its final place, so recur on pieces of B.  
+
+#   b)  If A is longer
+#          1. Divide A into Al and Ar such that Al is of same length as B.
+#          2. Swap Al and B to change AlArB into BArAl.
+#          3. Now B is at its final place, so recur on pieces of A.
+
+#Finally when A and B are of equal size, block swap them.
+
+
+
+# Recursive Approach
+
+ #Driver function
+def rotate_array(a, d) #Input array "a" and rotation by "d" elemets
+  	finish =a.length-1
+    block_swap(a,0,finish,d)
+end
+
+def block_swap(a,start,finish,d)
+    
+    n=finish-start+1
+    
+  	if n>0
+      
+      if d>n
+        d%=n
+      end
+      
+      if d==0
+          return a
+      end
+      
+      if d==n-d
+          swap(a,start,start+d,d)
+          return a
+      elsif d<n-d
+          swap(a,start,finish-d+1,d)
+        block_swap(a,start,finish-d,d)
+      else
+          swap(a,start,d,n-d)
+          block_swap(a,n-d,n-1,(2*d)-n)
+      end
+      
+    end
+    
+    return a
+    
+end
+
+
+    #Utility function for swapping
+def swap(a,start1,start2,d)
+        for i in 0...d
+            temp = a[start1+i]
+            a[start1+i] = a[start2+i]
+            a[start2+i] = temp
+        end
+end
+rotate_array([1,2,3,4,5,6,7,8,9,10],6)

Diff for: arrays/ChekPairWithGivenSum.rb

@@ -0,0 +1,48 @@
+#Given an array A[] and a number x, check for pair in A[] with sum as x
+
+#Approach 1: Using Hash Map
+#Time-complexity: O(n), Space-complexity: O(n) {extra space required for hashmap}
+
+def check_pair(arr,x)
+    len=arr.length
+    flag=false
+    map=Hash.new()
+    for i in 0...len
+        t=x-arr[i]
+		if map[t]
+			flag=true
+			break
+		end
+    	map[arr[i]]=1
+    end
+    if flag
+        return "Array has two elements with sum:#{x}"
+    else
+        return "Array doesn't have two elements with sum:#{x}"
+    end
+end
+
+check_pair([5,4,10,-2,3,2,-1,9],9)
+
+
+##Approach 2: Sorting and then searching using left and right indexes.
+#Time-complexity: O(nlogn) //O(nlogn)+O(n), Space-complexity: O(1)
+
+def check_pair(arr,x)
+    len=arr.length
+    arr.sort!           # You can choose your own sorting algorithm
+    left=0
+    right=len-1
+    while left<right
+        if (arr[left]+arr[right]==x)
+            return "Array has two elements with sum:#{x}"
+        elsif (arr[left]+arr[right]>x)
+            right-=1
+        else
+            left+=1
+        end
+    end
+    return "Array doesn't have two elements with sum:#{x}"
+end
+
+check_pair([5,4,10,-2,3,2,-1,9],9)

Diff for: arrays/ClosestSum.rb

@@ -0,0 +1,27 @@
+#Given array of integers(both +ve and -ve) find the two elements such that their sum is closest to given number x.
+#Time-complexity: O(nlogn) // O(nlogn){for sorting}+O(n), Auxiliary-space:O(1)
+
+#Algorithm: Sort the array and using two indexes left and right update the closest sum
+
+def closest_sum(a,x)
+  a.sort!               #You can choose any sorting algorithm of your choice with
+  left=min_l=0
+  right=min_r=a.length-1
+  min_sum = 1.0/0.0     #Initializing min_sum with infinity
+  while(left<right)
+    sum=(a[left]+a[right])-x
+    if sum.abs<min_sum
+        min_sum=sum.abs
+        min_l=left
+        min_r=right
+    end
+    if sum<0
+        left+=1
+    else
+        right-=1
+    end
+  end
+    print " The two elements whose sum is minimum are #{a[min_l]} and #{a[min_r]}"   
+end
+
+closest_sum([1,3,2,4,5],9) # => The two elements whose sum is minimum are 4 and 5

Diff for: arrays/EquilibriumIndexofArray.rb

@@ -0,0 +1,28 @@
+=begin
+Equilibrium index of an array is an index such that the sum of elements at lower indexes is equal to the sum of elements at higher indexes.
+For example, in an arrya A:
+A[]=[-7,1,5,2,-4,3,0]
+3 is an equilibrium index, because:
+A[0] + A[1] + A[2] = A[4] + A[5] + A[6]
+Time-complexity: O(n)
+Auxiliary-space: O(1)
+=end
+
+def find_equilibrium(a)
+  len = a.length
+  leftsum=0
+  rightsum=0
+  for x in a
+    rightsum+=x
+  end
+  for i in 0...len
+    rightsum-=a[i]
+    if (leftsum == rightsum)
+      return i
+    end
+    leftsum+=a[i]
+  end
+  
+  return -1
+      
+end

Diff for: arrays/FindMissingNumber.rb

@@ -0,0 +1,51 @@
+# Problem:
+=begin
+Given an array of size N ,taht has elements in range 1 to N ,all elements in the arrayb are unique, 
+Find the missing number.
+e.g.
+array = [1,5,2,4,6]
+answer = 3
+=end
+
+#Approach 1 - Find the sum of all elements of array and substract it from sum of the range , the difference will be missing number.
+# Time-complexity = O(n)
+#Caveats: If the numbers are very large the sum can lead to integer overflow.
+
+def find_missing_number(a)
+    n = a.length+1
+    range_sum = (n * (n+1))/2  # Sum of numbers from 1 to n is (n* n+1 )/2
+    arr_sum = 0
+    for x in a
+        arr_sum+=x
+    end
+    
+    return missing_element = range_sum - arr_sum
+    
+end
+
+
+#Approach 2 (No integer overflow)- Take bitwise XOR of all elements of the array with the numbers in given range, 
+#As( a XOR a == 0 ) all numbers present in array will xor out and become zero except the missing number. 
+# Time-complexity = O(n)
+
+def find_missing_number(a)
+    n = a.length+1
+    missing_element = 0
+    (1..n).each {|num| missing_element^= num}
+    for x in a
+        missing_element^=x
+    end
+  return missing_element
+end
+
+
+
+#Ruby magic
+#One line code but it uses O(n) auxiliary-space, it returns an array containing only the missing_element
+# Array1-Array2 in ruby returns an array containing all the elements that are in Array1 but not in Array2
+
+def find_missing_number(a)
+    n = a.length+1
+    range = Array (1..n)
+    missing_element = range-a
+end

Diff for: arrays/FitcherYatesShufflingAlgorithm.rb

@@ -0,0 +1,20 @@
+#Fitcher-Yates shuffling algorithm
+#(start from last element,swap with random element from the array,decrement array size by one and repeat until array size is 1)
+#Time-complexity: O(n)
+
+def shuffle(arr)
+   n=arr.length
+   for i in (n-1).downto(1)
+    j=Random.rand(i+1)
+    swap(arr,i,j)
+   end
+   print arr
+end
+
+def swap(arr,i,j)
+  temp = arr[i]
+  arr[i] = arr[j]
+  arr[j] = temp
+end
+
+shuffle([1,2,3,4,5,6])

Diff for: arrays/FixedPointInSorted.rb

@@ -0,0 +1,28 @@
+=begin
+Given an array of n distinct integers sorted in ascending order, find a fixed point in the array.
+Fixed Point in an array is an index i such that arr[i] is equal to i, i.e. a[i]==i
+Time-complexity: O(logn)
+Space-complexity: O(1)
+Algorithm: Binary Search
+=end
+
+def fixed_point(a)
+    n=a.length
+    hi=n-1
+    lo=0
+    while(hi>=lo)
+        mid=lo+(hi-lo)/2
+        
+        if a[mid]==mid
+            return mid
+        elsif a[mid]<mid
+            lo=mid+1
+        else
+            hi=mid-1
+        end
+    end
+    
+    #if no fixed point exists
+    return -1
+
+end

Diff for: arrays/FixedPointInUnsorted.rb

@@ -0,0 +1,17 @@
+=begin
+Given an array, find a fixed point in the array.
+Fixed Point in an array is an index i such that arr[i] is equal to i, i.e. a[i]==i
+Time-complexity: O(n)
+Space-complexity: O(1)
+Algorithm: Linear Search
+=end
+def fixed_point(a)
+    n=a.length
+    for i in 0...n
+        if a[i]==i
+            return i
+        end
+    end
+    #if no fixed point exists
+    return -1
+end