Merge pull request #86 from andrewkshim/master

Spiral Java solution

Author: blakeembrey

problems/anagram-detection/AnagramDetection.java

@@ -0,0 +1,68 @@
+import java.util.HashMap;
+import java.util.Map;
+
+
+public class AnagramDetection {
+	
+	private Map<Character, Integer> charToPrimeMap;
+	
+	public AnagramDetection() {
+		charToPrimeMap = new HashMap<Character, Integer>();
+		populateCharToPrimeMap();
+	}
+	
+	private boolean isPrime(int n) {
+		for (int i = 2; i < Math.ceil(Math.sqrt(n)); ++i) {
+			if (n % i == 0) {
+				return false;
+			}
+		}
+		return true;
+	}
+	
+	private int getNthPrime(int n) {
+		int nthPrime = 2;
+		while(n > 0) {
+			if (isPrime(nthPrime)) {
+				--n;
+			}
+			++nthPrime;
+		}
+		return nthPrime;
+	}
+	
+	private void populateCharToPrimeMap() {
+		for (int i = 0; i < 52; i += 2) {
+			charToPrimeMap.put((char)('a'+i/2), getNthPrime(i/2));
+			charToPrimeMap.put(Character.toUpperCase((char)('a'+i/2)), getNthPrime(i/2+1));
+		}
+	}
+	
+	private int hashString(String input) {
+		int hash = 1;
+		for (char c: input.toCharArray()) {
+			hash *= charToPrimeMap.get(c);
+		}
+		return hash;
+	}
+	
+	public int detectAnagrams(String original, String anagram) {
+		char[] originalChars = original.toCharArray();
+		int anagramCount = 0;
+		for (int i = 0; i < original.length() - anagram.length(); ++i) {
+			String currentSubstring = String.copyValueOf(originalChars, i, anagram.length());
+			if (hashString(currentSubstring) == hashString(anagram)) {
+				++anagramCount;
+			}
+		}
+		return anagramCount;
+	}
+	
+	public static void main(String[] args) {
+		AnagramDetection a = new AnagramDetection();
+		System.out.println(a.detectAnagrams("AdnBndAndBdaBn", "dAn"));
+		System.out.println(a.detectAnagrams("AbrAcadAbRa", "cAda"));
+	}
+	
+
+}

problems/array-pair-sum/ArrayPairSum.java

@@ -0,0 +1,43 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+
+
+public class ArrayPairSum {
+	
+	public ArrayList<int[]> getAllSumPairs(int k, int[] input) {
+		ArrayList<int[]> allSumPairs = new ArrayList<int[]>();
+		HashMap<Integer, Boolean> usedNumbers = new HashMap<Integer, Boolean>();
+		for (int i = 0; i < input.length; ++i) {
+			int difference = k - input[i];
+			if (usedNumbers.containsKey(difference) && !usedNumbers.get(difference)) {
+				int[] sumPair = new int[2];
+				sumPair[0] = input[i];
+				sumPair[1] = difference;
+				allSumPairs.add(sumPair);
+				usedNumbers.put(input[i], true);
+			} else {
+				usedNumbers.put(input[i], false);
+			}
+		}
+		return allSumPairs;
+	}
+	
+	public static void printAllPairSums(ArrayList<int[]> allPairSums) {
+		String output = "[ ";
+		for (int[] pairSum: allPairSums) {
+			output += Arrays.toString(pairSum);
+			output += " ";
+		}
+		output += " ]";
+		System.out.println(output);
+	}	
+	
+	public static void main(String[] arg) {
+		ArrayPairSum a = new ArrayPairSum();
+		int[] input1 = { 3, 4, 5, 6, 7 };
+		printAllPairSums(a.getAllSumPairs(10, input1));
+		int[] input2 = { 3, 4, 5, 4, 4 };
+		printAllPairSums(a.getAllSumPairs(8, input2));
+	}
+}

problems/balanced-brackets/BalancedBrackets.java

@@ -0,0 +1,32 @@
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Stack;
+
+
+public class BalancedBrackets {
+		
+	public boolean isBalanced(String s) {
+		HashMap<Character, Character> bracketMap = new HashMap<Character, Character>();
+		bracketMap.put('{', '}');
+		bracketMap.put('[', ']');
+		bracketMap.put('(', ')');
+		Stack<Character> bracketStack = new Stack<Character>();
+		for (char c: s.toCharArray()) {
+			if (!bracketStack.isEmpty() && bracketMap.get(bracketStack.peek()) == c) {
+				bracketStack.pop();
+			} else if (bracketMap.containsKey(c)) {
+				bracketStack.push(c);
+			} else {
+				return false;
+			}
+		}
+		return bracketStack.isEmpty();
+	}
+	
+	public static void main(String[] args) {
+		BalancedBrackets b = new BalancedBrackets();
+		System.out.println(b.isBalanced("()[]{}(([])){[()][]}"));
+		System.out.println(b.isBalanced("())[]{}"));
+		System.out.println(b.isBalanced("[(])"));
+	}
+}

problems/convert-array/ConvertArray.java

@@ -0,0 +1,29 @@
+import java.util.Arrays;
+
+
+public class ConvertArray {
+	
+	public int getOriginalIndex(int currentIndex, int length) {
+		return (currentIndex % 3) * length + currentIndex/3;
+	}
+	
+	public int[] convert(int[] input) {
+		for (int i = 0; i < input.length; ++i) {
+			int originalIndex = getOriginalIndex(i, input.length/3);
+			while (originalIndex < i) {
+				originalIndex = getOriginalIndex(originalIndex, input.length/3);
+			}
+			int temp = input[i];
+			input[i] = input[originalIndex];
+			input[originalIndex] = temp;
+		}
+		return input;
+	}
+
+	public static void main(String[] args) {
+		ConvertArray c = new ConvertArray();
+		int[] test1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+		System.out.println(Arrays.toString(c.convert(test1)));
+		
+	}
+}

problems/spiral/Spiral.java

@@ -0,0 +1,85 @@
+import java.util.Arrays;
+
+public class Spiral {
+	
+	  private enum Direction { 
+	      UP, DOWN, LEFT, RIGHT 
+	  }
+
+	  private boolean isCoordinateValid(int height, int width, int row, int column) {
+	      return (row > 0 && row <= height) && (column > 0 && column <= width);
+	  }
+
+	  private int getNumberAtCoordinate(int width, int row, int column) {
+	      return column + (row - 1) * width; 
+	  }
+
+	  private int[] getNextCoordinate(int row, int column, Direction currentDirection) {
+	      int[] nextCoordinate = new int[2];
+	      nextCoordinate[0] = row;
+	      nextCoordinate[1] = column;
+	      switch (currentDirection) {
+	          case UP: 
+	              nextCoordinate[0] -= 1; 
+	              break;
+	          case LEFT: 
+	              nextCoordinate[1] -= 1;
+	              break;
+	          case DOWN: 
+	              nextCoordinate[0] += 1;
+	              break;
+	          case RIGHT:
+	              nextCoordinate[1] += 1;
+	              break;
+	      }
+	      return nextCoordinate;
+	  } 
+
+	  private Direction getNextDirection(Direction currentDirection) {
+	      switch (currentDirection) {
+	        case UP:
+	            return Direction.LEFT;
+	        case LEFT:
+	            return Direction.DOWN;
+	        case DOWN:
+	            return Direction.RIGHT;
+	        case RIGHT:
+	            return Direction.UP;
+	        default:
+	            return currentDirection;
+	      }
+	  }
+
+	  public int[] spiral(int height, int width, int row, int column) {
+	      int numberOfElements = height * width;
+	      int[] output = new int[numberOfElements]; 
+	      int outputIndex = 0;
+	      Direction currentDirection = Direction.UP;
+	      int stepsTaken = 0;
+	      int stepsNeeded = 1;
+	      while (outputIndex < numberOfElements) {
+	          if (isCoordinateValid(height, width, row, column)) {
+	              output[outputIndex++] = getNumberAtCoordinate(width, row, column);
+	          }
+	          int[] nextCoordinate = getNextCoordinate(row, column, currentDirection);
+	          row = nextCoordinate[0];
+	          column = nextCoordinate[1];
+	          ++stepsTaken;
+	          if (stepsTaken == stepsNeeded) {
+	              if (currentDirection == Direction.LEFT || currentDirection == Direction.RIGHT) {
+	                  ++stepsNeeded;
+	              }
+	              stepsTaken = 0;
+	        	  currentDirection = getNextDirection(currentDirection);
+	          }
+	      } 
+	      return output;
+	  }	
+	  
+	  public static void main(String[] args) {
+		  Spiral s = new Spiral();
+		  System.out.println(Arrays.toString(s.spiral(5, 5, 3, 3)));
+		  System.out.println(Arrays.toString(s.spiral(2, 4, 1, 2)));
+		  
+	  }
+}