Java mergesort exercise

package exercises;
public class MergeSort {
  private static void merge(int[] values, int leftStart, int midPoint,
      int rightEnd) {
    int intervalSize = rightEnd - leftStart;
    int[] mergeSpace = new int[intervalSize];
    int nowMerging = 0;
    int pointLeft = leftStart;
    int pointRight = midPoint;
    do {
      if (values[pointLeft] <= values[pointRight]) {
        mergeSpace[nowMerging] = values[pointLeft];
        pointLeft++;
      } else {
        mergeSpace[nowMerging] = values[pointRight];
        pointRight++;
      }
      nowMerging++;
    } while (pointLeft < midPoint && pointRight < rightEnd);
    int fillFromPoint = pointLeft < midPoint ? pointLeft : pointRight;
    System.arraycopy(values, fillFromPoint, mergeSpace, nowMerging,
        intervalSize - nowMerging);
    System.arraycopy(mergeSpace, 0, values, leftStart, intervalSize);
  }
  public static void mergeSort(int[] values) {
    mergeSort(values, 0, values.length);
  }
  private static void mergeSort(int[] values, int start, int end) {
    int intervalSize = end - start;
    if (intervalSize < 2) {
      return;
    }
    boolean isIntervalSizeEven = intervalSize % 2 == 0;
    int splittingAdjustment = isIntervalSizeEven ? 0 : 1;
    int halfSize = intervalSize / 2;
    int leftStart = start;
    int rightEnd = end;
    int midPoint = start + halfSize + splittingAdjustment;
    mergeSort(values, leftStart, midPoint);
    mergeSort(values, midPoint, rightEnd);
    merge(values, leftStart, midPoint, rightEnd);
  }
}

Show that a × b can be less than min(a, b)

Show that a × b can be less than min(a, b) (a, b) = (-2, 3) -2 (3) < min(-2, 3) -6 < -2

Show that a + b can be less than min(a, b)

Show that a + b can be less than min(a, b). (a, b) = (-1, -1) -1 + (-1) < min(-1, -1) 2 < -1

Write a method to decide if two strings are anagrams or not

Write a method to decide if two strings are anagrams or not.

import java.util.HashMap;
import java.util.Map;
import junit.framework.TestCase;
/**
 * Write a method to decide if two strings are anagrams or not.
 */
public class StringAnagrams extends TestCase {
  public static boolean areAnagrams(String s1, String s2) {
    if (s1 == null) {
      throw new NullPointerException("Argument 's1' can not be null.");
    }
    if (s2 == null) {
      throw new NullPointerException("Argument 's2' can not be null.");
    }
    Map<Character, Integer> charMap = new HashMap<Character, Integer>();
    stringIntoCharMapWithValues(s1, charMap, 1);
    stringIntoCharMapWithValues(s2, charMap, -1);
    return isMapOfNumbersAllZeroes(charMap);
  }
  public static <K, V extends Number> boolean isMapOfNumbersAllZeroes(
      Map<K, V> map) {
    for (Number i : map.values()) {
      if (!i.equals(0)) {
        return false;
      }
    }
    return true;
  }
  public static void stringIntoCharMapWithValues(String string,
      Map<Character, Integer> map, int value) {
    int length = string.length();
    for (int i = 0; i < length; i++) {
      char c = string.charAt(i);
      if (Character.isWhitespace(c)
          || (!Character.isLetter(c) && !Character.isDigit(c))) {
        continue;
      }
      if (map.containsKey(c)) {
        map.put(c, map.get(c) + value);
      } else {
        map.put(c, value);
      }
    }
  }
  public static void testAreAnagrams() {
    try {
      areAnagrams(null, "a");
    } catch (NullPointerException e) {
    }
    try {
      areAnagrams("a", null);
    } catch (NullPointerException e) {
    }
    try {
      areAnagrams(null, null);
    } catch (NullPointerException e) {
    }
    assertTrue(areAnagrams("", ""));
    assertTrue(areAnagrams("a", "a"));
    assertFalse(areAnagrams("a", ""));
    assertFalse(areAnagrams("", "a"));
    assertTrue(areAnagrams("ab", "ab"));
    assertTrue(areAnagrams("ab", "ba"));
    assertFalse(areAnagrams("ab", "bc"));
    assertFalse(areAnagrams("ab", "b c"));
    assertTrue(areAnagrams("ab", "b a"));
    assertTrue(areAnagrams(" ab", "ba "));
    assertTrue(areAnagrams("a4 b", "4b a"));
    assertFalse(areAnagrams("a4 b", "5b a"));
    assertFalse(areAnagrams("aa", "a"));
    assertTrue(areAnagrams("a,b,c.", "- 'c b a'"));
  }
}

Write code to reverse a C-Style String. (C-String means that “abcd” is represented as five characters, including the null character.)

/*
Write code to reverse a C-Style String. (C-String means that “abcd” is represented as five characters, including the null character.)
*/
#include <stdio.h>
void reverse(char* cStyleString) {
  char temp;
  char* leftSwap;
  char* rightSwap;
  leftSwap = cStyleString; // Position left swapping point at string's start
  rightSwap = cStyleString; // Position right swapping point at string's start
  while (*rightSwap) { // Repeat until terminating character (\0) is found
    rightSwap++; // Traverse string by advancing to the next character
  } // End of string now located
  rightSwap--; // Backtrack one step from terminating character
  while (leftSwap < rightSwap) {
    temp = *leftSwap; // Temporarily store character to swap
    *leftSwap = *rightSwap;
    *rightSwap = temp;
    leftSwap++; // Converge to centre of string
    rightSwap--; // Converge to centre of string
  }
}
int main() {
  char cStyleString[] = "Hello, world!";
  printf("%s\n", cStyleString);
  reverse(cStyleString);
  printf("%s\n", cStyleString);
  return 0;
}

Insert a spacer character into a given String every n characters from the right

import junit.framework.TestCase;
/**
 * Insert a spacer character into a given String every n characters from the
 * right.
 */
public class InsertCharacterAfterEveryNCharacters extends TestCase {
  public static String insertSpacerAfterNCharactersFromTheRight(char spacer,
      int spacing, String string) {
    final int length = string.length();
    final int newStringCapacity =
        length + (int) Math.ceil(length / (double) spacing);
    StringBuilder stringBuilder = new StringBuilder(newStringCapacity);
    for (int i = length - 1; i >= 0; i--) {
      stringBuilder.append(string.charAt(i));
      if (i % spacing == 0 && i > 0) {
        stringBuilder.append(spacer);
      }
    }
    return stringBuilder.toString();
  }
  public static void testInsertSpacerAfterNCharactersFromTheRight() {
    assertEquals("", insertSpacerAfterNCharactersFromTheRight('-', 8, ""));
    assertEquals("1", insertSpacerAfterNCharactersFromTheRight('-', 8, "1"));
    assertEquals("11", insertSpacerAfterNCharactersFromTheRight('-', 8, "11"));
    assertEquals("11111111",
        insertSpacerAfterNCharactersFromTheRight('-', 8, "11111111"));
    assertEquals("1-11111111",
        insertSpacerAfterNCharactersFromTheRight('-', 8, "111111111"));
    assertEquals("11111111-11111111",
        insertSpacerAfterNCharactersFromTheRight('-', 8, "1111111111111111"));
  }
}

Implement an algorithm to determine if a string has all unique characters. What if you can not use additional data structures? What if you have to use bit masking to track occurrences?

import java.util.BitSet;
import java.util.HashMap;
import java.util.Map;
import junit.framework.TestCase;
/**
 * Implement an algorithm to determine if a string has all unique characters.
 * What if you can not use additional data structures? What if you have to use
 * bit masking to track occurrences?
 */
public class StringHasAllUniqueCharacters extends TestCase {
  public static boolean hasAllUniqueCharacters(String string) {
    Map<Character, Boolean> charactersMap = new HashMap<Character, Boolean>();
    for (char c : string.toCharArray()) {
      if (charactersMap.containsKey(c)) {
        return false;
      }
      charactersMap.put(c, true);
    }
    return true;
  }
  public static boolean hasAllUniqueCharactersNoHelperDS(String string) {
    final int length = string.length();
    for (int i = 0; i < length; i++) {
      final char c = string.charAt(i);
      for (int j = i + 1; j < length; j++) {
        if (c == string.charAt(j)) {
          return false;
        }
      }
    }
    return true;
  }
  public static boolean hasAllUniqueCharactersUsingBitMasking(String string) {
    final int length = string.length();
    final int nBitsToStoreAllUnicodeCharacters =
        (int) Math.ceil(Math.log(Character.MAX_CODE_POINT) / Math.log(2d));
    BitSet bitSet = new BitSet(nBitsToStoreAllUnicodeCharacters);
    for (int i = 0; i < length; i++) {
      char c = string.charAt(i);
      if (bitSet.get(c)) {
        return false;
      }
      bitSet.set(c);
    }
    return true;
  }
  public static void testHasAllUniqueCharacters() {
    assertTrue(hasAllUniqueCharacters(""));
    assertTrue(hasAllUniqueCharacters("a"));
    assertFalse(hasAllUniqueCharacters("aa"));
    assertTrue(hasAllUniqueCharacters("as"));
    assertFalse(hasAllUniqueCharacters("abcde a"));
  }
  public static void testHasAllUniqueCharactersNoAdditionalDS() {
    assertTrue(hasAllUniqueCharacters(""));
    assertTrue(hasAllUniqueCharacters("a"));
    assertFalse(hasAllUniqueCharacters("aa"));
    assertTrue(hasAllUniqueCharacters("as"));
    assertFalse(hasAllUniqueCharacters("abcde a"));
  }
  public static void testHasAllUniqueCharactersUsingBitMasking() {
    assertTrue(hasAllUniqueCharactersUsingBitMasking(""));
    assertTrue(hasAllUniqueCharactersUsingBitMasking("a"));
    assertFalse(hasAllUniqueCharactersUsingBitMasking("aa"));
    assertTrue(hasAllUniqueCharactersUsingBitMasking("as"));
    assertFalse(hasAllUniqueCharacters("abcde a"));
  }
}