Various array algorithms

Author: kumar91gopi

ChekPairWithGivenSum.rb

@@ -1,5 +1,7 @@
-#Given an array A[] and a number x, check for pair in A[] with sum as x(Using Hash Map)
-#Time-complexity: O(n), Space-complexity: O(n)
+#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
@@ -14,10 +16,33 @@ def check_pair(arr,x)
     	map[arr[i]]=1
     end
     if flag
-        print "Array has two elements with sum:#{x}"
+        return "Array has two elements with sum:#{x}"
     else
-        print "Array doesn't have two elements with sum:#{x}"
+        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)

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

LeadersInArray.rb

@@ -0,0 +1,22 @@
+=begin
+Algorithm to print all the LEADERS in the array.
+An element is leader if it is greater than all the elements to its right side,the rightmost element is always a leader. 
+Time-complexity: O(n)
+Auxiliary-space: O(1)
+=end
+
+def find_leaders(a)
+    n = a.length
+    max_from_right = a[n-1]
+    print "#{max_from_right}"+" "
+    
+    for i in (n-2).downto(0)
+        if a[i]>max_from_right
+            max_from_right=a[i]
+            print "#{max_from_right}"+" "
+        end
+    end
+end
+
+find_leaders([16, 17, 4, 3, 5, 2]) # => 2 5 17
+    

MaxSliceSumAlgorithm.rb

@@ -1,8 +1,8 @@
 # Algorithm to find the largest possible continuos sum in an array.
 #Time-complexity: O(n), Auxiliary space: O(1)
+# Algorithm-paradigm: Dynamic-programming
 
-
-
+# This algorithm doesn't work for negative numbers,it simply returns zero if all numbers are negative.
 def max_continuos_sum(a)
    max_ending_sum = max_slice_sum =0 
    n=a.length
@@ -13,4 +13,18 @@ def max_continuos_sum(a)
     return  max_slice_sum
 end
 
-max_continuos_sum([1,1,-1,2,3,4,-9,3,4,5,-6])
+max_continuos_sum([1,1,-1,2,3,4,-9,3,4,5,-6]) # => 13
+
+
+# Algorithm to handle negative numbers as well
+def max_continuos_sum(a)
+   max_ending_sum = max_slice_sum =a[0]
+   n=a.length
+   for i in 0...n
+    max_ending_sum = [a[i],(max_ending_sum+a[i])].max
+    max_slice_sum = [max_slice_sum,max_ending_sum].max
+   end
+    return  max_slice_sum
+end
+
+max_continuos_sum([-5,-4,-10,-2,-3,-2,-1,-9]) #=> -1

README.md

@@ -22,28 +22,34 @@ The solutions are easy to understand and complete.
 6. [Merge Sort](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/sorting/MergeSort.rb)
 7. [Quick Sort](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/sorting/QuickSort.rb)
 8. [3 way Quick Sort](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/sorting/3wayQuickSort.rb)
-9. [Counting Sort](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/sorting/3wayQuickSort.rb)
+9. [Counting Sort](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/sorting/CountingSort.rb)
+10. [Sort array in wave form](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/sorting/SortInWaveForm.rb)
 
 
 ### Others ###
 
-1. Algorithms for array rotation
+1. [Swapping two numbers](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/SwappingTwoNumbers.rb)
+2. [Algorithm for reversing an array]((https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/ReverseAnArray.rb))
+3. Algorithms for array rotation
     * [Juggling Algorithm for array rotation](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/JugglingAlgorithm.rb)
     * [Reversal Algorithm for array rotation](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/ReversalAlgorithm.rb)
     * Block Swap Algorithm for array rotation
         * [Recursive](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/BlockSwapAlgorithmRecursive.rb)
         * [Iterative](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/BlockSwapAlgorithmIterative.rb)
-2. [Algorithm to find maximum continuos sum in an array(Kadane's Algorithm)](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/MaxSliceSumAlgorithm.rb)
-3. [Find missing number in array](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/FindMissingNumber.rb)
-4. [Swapping two numbers](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/SwappingTwoNumbers.rb)
-5. Shuffling an Array
+4. [Algorithm to find maximum continuos sum in an array(Kadane's Algorithm)](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/MaxSliceSumAlgorithm.rb)
+5. [Find missing number in array](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/FindMissingNumber.rb)
+6. Shuffling an Array
     * [Knuth shuffling Algorithm](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/KnuthShufflingAlgorithm.rb)
     * [Fitcher-Yates shuffling Algorithm](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/FitcherYatesShufflingAlgorithm.rb)
-6. [Find pair in array with sum equal to given sum](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/ChekPairWithGivenSum.rb)
-7. [Find equilibrium index in an array](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/EquilibriumIndexofArray.rb)
-8. Find fixed point in an array
+7. [Find pair in array with sum equal to given sum](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/ChekPairWithGivenSum.rb)
+8. [Find pair in array with sum closest to given sum](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/ClosestSum.rb)
+9. [Find equilibrium index in an array](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/EquilibriumIndexofArray.rb)
+10. Find fixed point in an array
     * [fixed point in unsorted array](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/FixedPointInUnsorted.rb)
     * [fixed point in sorted array](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/FixedPointInSorted.rb)
+11. Dutch National Flag Problem
+    * [Segregate Os and 1s in a given array](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/Segregate0and1.rb)
+12. [Find all Leaders in an array](https://github.com/kumar91gopi/Algorithms-and-Data-Structures-in-Ruby/blob/master/LeadersInArray.rb)
 
 
 

ReverseAnArray.rb

@@ -0,0 +1,41 @@
+#Given an array reverse it without using extra-space
+#Time-complexity: O(n), Auxiliary-space: O(1)
+
+# Iterative
+def reverse_array(a)
+    right=a.length-1
+    left=0
+    while(left<right)
+     #swap the elements
+        temp=a[left]        #Swapping can be like done like this a[left],a[right]=a[right],a[left]
+        a[left]=a[right]
+        a[right]=temp
+        
+        left+=1
+        right-=1
+    end
+    print a
+end
+
+reverse_array([1,2,3,4,5]) # => [5,4,3,2,1]
+
+# Recursive
+
+        #driver program
+def driver_program(a)
+    right=a.length-1
+    left=0 
+    reverse_array(a,left,right)
+    print a
+end
+def reverse_array(a,left,right)
+    
+    return  if left>=right 
+     #swap the elements
+        temp=a[left]        
+        a[left]=a[right]
+        a[right]=temp
+        reverse_array(a,left+1,right-1)
+end
+
+driver_program([1,2,3,4,5]) # => [5,4,3,2,1]

Segregate0and1.rb

@@ -0,0 +1,30 @@
+#Given an array of 0s and 1s in random order.Segregate 0s on left side and 1s on right side of the array.
+##Brute-force: Count 0s and rewrite array first with counted zeros then by 1
+#Time-complexity:O(n),Auxiliary-space:O(1)
+
+
+##Algorithm: Dutch National Flag Algorithm
+#Time-complexity:O(n),Auxiliary-space:O(1)
+
+def segregate(a)
+   left=0
+   right=a.length-1
+   while left<right
+        #Increment left index while we see 0 at left
+        while a[left]== 0
+            left+=1
+        end
+        #Decrement right index while we see 1 at right
+        while a[right]==1
+            right-=1
+        end
+        #Exchange arr[left] and arr[right]
+        if left<right
+            a[left],a[right]=a[right],a[left]
+            left+=1
+            right-=1
+        end
+   end
+    return a
+end
+segregate([1,0,1,1,0,0]) # => [0, 0, 0, 1, 1, 1]

sorting/SortInWaveForm.rb

@@ -0,0 +1,27 @@
+=begin
+Given an unsorted array of integers, sort the array into a wave like array. 
+An array ‘arr[0..n-1]’ is sorted in wave form if arr[0] >= arr[1] <= arr[2] >= arr[3] <= arr[4] >= …..
+=end
+#Time-complexity: O(n)
+#Auxiliary-space: O(1)
+
+def sort_in_wave(a)
+    n= a.length
+   (0...n).step(2) do |i|
+        if ((i>0) && (a[i]<a[i-1]))
+            swap(a,i,i-1)
+        end
+        
+        if ((i<n-1) && (a[i]<a[i+1]))
+            swap(a,i,i+1)
+        end
+    end
+    return a
+end
+
+def swap(a,i,j)
+    a[i],a[j]=a[j],a[i]
+end
+
+sort_in_wave([10,90,49,2,1,5,23]) # => [90,10,49,1,5,2,23]
+