new algorithms

new algorithms

Author: hmkcode

java-combinations/README.md

@@ -1,12 +1,8 @@
-Non-Recursive Algorithm for Finding Combination
-===============================================
+Algorithms for Finding all Possible Combinations of k Elements in an Array with Java Implementation
+===================================================================================================
 
-Here is a generic non-recursive algorithm for finding all possible combination for an array of objects. 
+Refer to the [http://hmkcode.github.io/calculate-find-all-possible-combinations-of-an-array-using-java/](http://hmkcode.github.io/calculate-find-all-possible-combinations-of-an-array-using-java/) for more info.
 
-For example, if we have an Array of elements=`{"A","B","C","D","E"}` and we want to find the combination of these elements taken 3 at a time.
-Using math we can find the number of possible combination using a known [formula](https://en.wikipedia.org/wiki/Combination).
+Given an array of size N e.g. `e={'A','B','C','D','E'}` **N=5**, we want to find all possible combinations of K elements in that array. For example, if K=3 then one possible combination is of array **e** is `{'A','B','C'}. Here we have three different algorithms for finding *k*-combinations of an array. 
 
-However, to find those combinations we need an algorithm to do so.
-Below image explains the steps taken by the algorithm to find the results.
-
-![combinations](http://hmkcode.github.io/images/java/combinations.png)
+![combinations](http://hmkcode.github.io/images/java/combinations_forwardbackward.png)

java-combinations/src/main/java/com/hmkcode/ForwardBackward.java

@@ -0,0 +1,94 @@
+package com.hmkcode;
+
+
+
+public class ForwardBackward {
+
+	
+	public static void main(String[] args){
+		Object[] elements = new Object[] {'A','B','C','D','E'};
+		combination(elements,3);
+	}
+	
+	
+	public static void combination(Object[]  elements, int K){
+
+		// get the length of the array
+		// e.g. for {'A','B','C','D'} => N = 4 
+		int N = elements.length;
+		
+		if(K > N){
+			System.out.println("Invalid input, K > N");
+			return;
+		}
+		
+		// calculate the possible combinations
+		c(N,K);
+		
+		// init combination index array
+		int pointers[] = new int[K];
+		
+
+		int r = 0; // index for combination array
+		int i = 0; // index for elements array
+		
+		while(r >= 0){
+		
+			// forward step if i < (N + (r-K))
+			if(i <= (N + (r - K))){
+				pointers[r] = i;
+					
+				// if combination array is full print and increment i;
+				if(r == K-1){
+					print(pointers, elements);
+					i++;				
+				}
+				else{
+					// if combination is not full yet, select next element
+					i = pointers[r]+1;
+					r++;										
+				}				
+			}
+			
+			// backward step
+			else{
+				r--;
+				if(r >= 0)
+					i = pointers[r]+1;
+				
+			}			
+		}
+	}
+	
+
+	
+	private static int c(int n, int r){
+		int nf=fact(n);
+		int rf=fact(r);
+		int nrf=fact(n-r);
+		int npr=nf/nrf;
+		int ncr=npr/rf; 
+		
+		System.out.println("C("+n+","+r+") = "+ ncr);
+
+		return ncr;
+	}
+	
+	private static int fact(int n)
+	{
+		if(n == 0)
+			return 1;
+		else
+			return n * fact(n-1);
+	}
+	
+
+	private static void print(int[] combination, Object[] elements){
+
+		String output = "";
+		for(int z = 0 ; z < combination.length;z++){
+			output += elements[combination[z]];
+		}
+		System.out.println(output);
+	}
+}

java-combinations/src/main/java/com/hmkcode/Recursive.java

@@ -0,0 +1,38 @@
+package com.hmkcode;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class Recursive {
+
+	public static void main(String[] args) {
+		
+		List<String> e = Arrays.asList("A", "B", "C", "D", "E");		
+		combination(e, 3, "");
+		
+	}
+	static int counter = 0;
+	public static void combination(List<String> e, int K, String c){
+	
+		if(e.size() < K)
+			return;
+				
+		if(K == 1)
+			for(String s:e)
+				print(c+s);
+		else if(e.size() == K){
+			for(String s:e)
+				c+=s;
+			print(c);
+		}
+		else if(e.size() > K)
+			for(int i = 0 ; i < e.size() ; i++)
+				combination(e.subList(i+1, e.size()), K-1, c+e.get(i));
+		
+	}
+		
+	public static void print(String c){
+		counter++;
+		System.out.println(counter+"\t"+c);
+	}
+}

java-combinations/src/main/java/com/hmkcode/Shifting.java

@@ -0,0 +1,59 @@
+package com.hmkcode;
+
+public class Shifting 
+{
+    public static void main( String[] args )
+    {
+    	String[] e = {"A","B","C","D","E"};	
+    	int K = 3;
+    }
+	public static void combination(Object[]  e, int K){
+	
+		int[] ignore = new int[e.length-K]; // --> [0][0]
+    	int[] combination = new int[K]; // --> [][][]
+    	
+    	for(int w = 0; w < ignore.length; w++){ // --> [3][4]
+    		ignore[w] = e.length - K +(w+1);
+    		//System.out.println(ignore[w]);
+    	}
+    	
+    	int i = 0;
+    	int r = 0;
+    	int g = 0;
+    	boolean terminate = false;
+    	while(!terminate){    		
+	    	while(i < e.length && r < K){
+	    			
+	    		if(i != ignore[g]){
+	    			combination[r] = i;
+	    			System.out.print(e[combination[r]]+" ");
+	    			r++;
+	    			i++;
+	    		}
+	    		else{
+	    			g++;
+	    			
+	    			if(g == ignore.length)
+	    				g--;
+	    			
+	    			i++;
+	    		}
+	    	}
+	    	i = 0; r=0; g =0;
+			System.out.println("");
+
+	    	terminate = true;
+	    	
+	    	for(int w = 0 ; w < ignore.length; w++){
+	    		if(ignore[w] > w){	    			
+	    			ignore[w]--;
+	    			
+	    			if(w > 0)
+	    				ignore[w-1] = ignore[w]-1;
+	    			terminate = false;
+	    			break;	    			
+	    		}
+	    	}
+    	}    		
+	}
+}