new algorithms

Author: melmedany

src/main/java/BinaryNumbers.java

@@ -0,0 +1,21 @@
+/**
+ * @author medany
+ */
+
+/*
+ * Given a base-10 integer, n, convert it to binary (base-2). Then find and
+ * print the base-10 integer denoting the maximum number of consecutive 1's in
+ * n's binary representation.
+ */
+public class BinaryNumbers {
+
+	public int solve(int decimal) {
+		int max = 0, consecutive = 0;
+		while (decimal != 0) {
+			consecutive = decimal % 2 == 1 ? consecutive + 1 : 0;
+			max = consecutive > max ? consecutive : max;
+			decimal /= 2;
+		}
+		return max;
+	}
+}

src/main/java/BirthdayChocolate.java

@@ -0,0 +1,34 @@
+/**
+ * @author medany
+ */
+
+/*
+ * Lily has a chocolate bar consisting of a row of n squares where each square
+ * has an integer written on it. She wants to share it with Ron for his
+ * birthday, which falls on month m and day d. Lily wants to give Ron a piece of
+ * chocolate only if it contains consecutive squares whose integers sum to d.
+ * 
+ * Given m, d, and the sequence of integers written on each square of Lily's
+ * chocolate bar, how many different ways can Lily break off a piece of
+ * chocolate to give to Ron?
+ */
+public class BirthdayChocolate {
+
+	public int solve(int d, int m, int[] sequence) {
+		int max = 0, count = 0;
+		for (int i = 0; i < sequence.length; i++) {
+			count = 0;
+			for (int j = i; i + m > sequence.length ? j < sequence.length : j < i + m; j++) {
+				count += sequence[j];
+				if (count > d) {
+					break;
+				} else if (count == d && j == i + m - 1) {
+					count = 0;
+					max++;
+					break;
+				}
+			}
+		}
+		return max;
+	}
+}

src/main/java/BitwiseAND.java

@@ -0,0 +1,10 @@
+/**
+ * @author medany
+ */
+
+public class BitwiseAND {
+	public int solve(int n, int k) {
+		return ((k - 1) | k) > n && k % 2 == 0 ? k - 2 : k - 1;
+	}
+
+}

src/main/java/EqualizetheArray.java

@@ -0,0 +1,36 @@
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author medany
+ */
+
+/*
+ * Karl has an array n of integers defined as A = a0, a1, ..., an-1. In one
+ * operation, he can delete any element from the array.
+ * 
+ * Karl wants all the elements of the array to be equal to one another. To do
+ * this, he must delete zero or more elements from the array. Find and print the
+ * minimum number of deletion operations Karl must perform so that all the
+ * array's elements are equal.
+ */
+
+public class EqualizetheArray {
+
+	public int solve(int[] arr) {
+		Map<Integer, Integer> allOccurs = new HashMap<>();
+		int maxOccurs = 0;
+		for (int i = 0; i < arr.length; i++) {
+			if (allOccurs.containsKey(arr[i])) {
+				allOccurs.put(arr[i], allOccurs.get(arr[i]) + 1);
+				if (allOccurs.get(arr[i]) > maxOccurs) {
+					maxOccurs = allOccurs.get(arr[i]);
+				}
+			} else {
+				allOccurs.put(arr[i], 1);
+			}
+		}
+		return maxOccurs == 0 ? arr.length - 1 : arr.length - maxOccurs;
+	}
+
+}

src/main/java/FindAnagrams.java

@@ -0,0 +1,51 @@
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @author mohamed
+ */
+
+/*
+ * Find if a String A contains anagrams of a String B
+ */
+
+public class FindAnagrams {
+
+	private static int primes[] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79,
+			83, 89, 97, 101 };
+
+	public String[] solve(String haystack, String needle) {
+		final String word = haystack.toLowerCase().trim();
+		final String anagram = needle.toLowerCase().trim();
+		final Set<String> anagrams = new HashSet<>();
+
+		long anagramProduct = 1;
+
+		// 01. calculate product of given String B
+		for (int i = 0; i < anagram.length(); i++) {
+			anagramProduct *= primes[anagram.charAt(i) - 'a'];
+		}
+
+		final Map<Long, Integer> cumprods = new LinkedHashMap<>();
+
+		long cumprod = 1;
+		for (int i = 0; i < word.length(); i++) {
+			String current = "";
+			// 02. calculate cumulative product of String A
+			cumprod *= primes[word.charAt(i) - 'a'];
+			// 03. add cumulative product to a Set
+			cumprods.put(cumprod, i);
+
+			if (cumprod % anagramProduct == 0) {
+				if (cumprod == anagramProduct || cumprods.containsKey(cumprod / anagramProduct)) {
+					current = word.substring(i - anagram.length() + 1, i + 1);
+					if (!anagram.equals(current))
+						anagrams.add((word.substring(i - anagram.length() + 1, i + 1)));
+				}
+			}
+		}
+		return anagrams.toArray(new String[] {});
+	}
+}

src/main/java/LeapYear.java

@@ -0,0 +1,10 @@
+
+/**
+ * @author medany
+ */
+
+public class LeapYear {
+	public boolean solve(int year) {
+		return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0) ? true : false;
+	}
+}

src/main/java/RepeatedString.java

@@ -0,0 +1,39 @@
+/**
+ * @author medany
+ */
+
+/*
+ * Print a single integer denoting the number of letter a's in the first n
+ * letters of the infinite string created by repeating s infinitely many times.
+ */
+
+public class RepeatedString {
+
+	public long solve(String s, long n) {
+		long num = 0, repeats = 0, aCount = 0;
+		if (s.equals("a")) {
+			return n;
+		} else {
+			for (int i = 0; i < s.length(); i++) {
+				if (s.charAt(i) == 'a') {
+					aCount++;
+				}
+			}
+
+			repeats = n / s.length();
+
+			if (repeats * s.length() == n) {
+				return aCount * repeats;
+			} else {
+				num = aCount * repeats;
+				String remain = s.substring(0, (int) n - (int) (s.length() * repeats));
+				for (int i = 0; i < remain.length(); i++) {
+					if (remain.charAt(i) == 'a') {
+						num++;
+					}
+				}
+			}
+		}
+		return num;
+	}
+}

src/main/java/StringSimilarity.java

@@ -0,0 +1,35 @@
+
+/**
+ * @author medany
+ */
+
+/*
+ * For two strings A and B, we define the similarity of the strings to be the
+ * length of the longest prefix common to both strings. For example, the
+ * similarity of strings "abc" and "abd" is 2, while the similarity of strings
+ * "aaa" and "aaab" is 3.
+ * 
+ * Calculate the sum of similarities of a string S with each of it's suffixes.
+ */
+public class StringSimilarity {
+
+	public long solve(String a) {
+
+		long similarities = a.length();
+		String suffix = new String(a.substring(1));
+		int i;
+
+		while (!suffix.isEmpty()) {
+			for (i = 0; i < suffix.length(); i++) {
+				if (suffix.charAt(i) == a.charAt(i)) {
+					similarities += 1;
+				} else
+					break;
+			}
+			suffix = suffix.substring(1);
+		}
+
+		return similarities;
+	}
+
+}

test/main/java/BinaryNumbersTest.java

@@ -0,0 +1,39 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author medany
+ */
+public class BinaryNumbersTest {
+
+	private BinaryNumbers alg = new BinaryNumbers();
+	private int actual, expected;
+
+	@Test
+	public void Test_1() {
+
+		actual = alg.solve(5);
+		expected = 1;
+
+		Assert.assertEquals(expected, actual);
+	}
+
+	@Test
+	public void Test_2() {
+
+		actual = alg.solve(12);
+		expected = 2;
+
+		Assert.assertEquals(expected, actual);
+	}
+
+	@Test
+	public void Test_3() {
+
+		actual = alg.solve(524283);
+		expected = 16;
+
+		Assert.assertEquals(expected, actual);
+	}
+
+}

test/main/java/BirthdayChocolateTest.java

@@ -0,0 +1,40 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author medany
+ */
+public class BirthdayChocolateTest {
+
+	private BirthdayChocolate alg = new BirthdayChocolate();
+	private int actual, expected;
+
+	@Test
+	public void Test_1() {
+
+		actual = alg.solve(3, 2, new int[] { 1, 2, 1, 3, 2 });
+		expected = 2;
+
+		Assert.assertEquals(expected, actual);
+	}
+
+	@Test
+	public void Test_2() {
+
+		actual = alg.solve(3, 2, new int[] { 1, 1, 1, 1, 1, 1 });
+		expected = 0;
+
+		Assert.assertEquals(expected, actual);
+	}
+
+	@Test
+	public void Test_3() {
+
+		actual = alg.solve(18, 6, new int[] { 4, 5, 4, 5, 1, 2, 1, 4, 3, 2, 4, 4, 3, 5, 2, 2, 5, 4, 3, 2, 3, 5, 2, 1, 5,
+				2, 3, 1, 2, 3, 3, 1, 2, 5 });
+		expected = 6;
+
+		Assert.assertEquals(expected, actual);
+	}
+
+}

test/main/java/BitwiseANDTest.java

@@ -0,0 +1,39 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author medany
+ */
+public class BitwiseANDTest {
+
+	private BitwiseAND alg = new BitwiseAND();
+	private int actual, expected;
+
+	@Test
+	public void Test_1() {
+
+		actual = alg.solve(5, 2);
+		expected = 1;
+
+		Assert.assertEquals(expected, actual);
+	}
+
+	@Test
+	public void Test_2() {
+
+		actual = alg.solve(8, 5);
+		expected = 4;
+
+		Assert.assertEquals(expected, actual);
+	}
+
+	@Test
+	public void Test_3() {
+
+		actual = alg.solve(2, 2);
+		expected = 0;
+
+		Assert.assertEquals(expected, actual);
+	}
+
+}