Simplified the code

Author: rampatra

src/main/java/com/rampatra/linkedlists/CloneWithRandPointers.java

@@ -25,8 +25,7 @@ public static <E extends Comparable<E>> DoubleLinkedList<E> clone(DoubleLinkedLi
 
         // copy each node and insert after it
         while (curr != null) {
-            DoubleLinkedNode<E> newNode = new DoubleLinkedNode<>(null, curr.item, curr.next);
-            curr.next = newNode;
+            curr.next = new DoubleLinkedNode<>(null, curr.item, curr.next);
             curr = curr.next.next;
         }
 
@@ -53,10 +52,10 @@ public static <E extends Comparable<E>> DoubleLinkedList<E> clone(DoubleLinkedLi
 
     public static void main(String[] args) {
         DoubleLinkedList<Integer> linkedList = new DoubleLinkedList<>();
-        linkedList.add(00);
-        linkedList.add(11);
-        linkedList.add(22);
-        linkedList.add(33);
+        linkedList.add(0);
+        linkedList.add(1);
+        linkedList.add(2);
+        linkedList.add(3);
         linkedList.getNode(0).prev = null;
         linkedList.getNode(1).prev = linkedList.getNode(2);
         linkedList.getNode(2).prev = linkedList.getNode(0);

src/main/java/com/rampatra/strings/AnagramsTogether.java

@@ -11,7 +11,6 @@
  *
  * @author rampatra
  * @since 9/23/15
- * @time: 8:11 PM
  */
 public class AnagramsTogether {
 
@@ -24,7 +23,7 @@ public class AnagramsTogether {
      *
      * @param s
      */
-    public static void printAnagramsTogether(String[] s) {
+    private static void printAnagramsTogether(String[] s) {
 
         // each key holds all the indexes of a anagram
         HashMap<String, List<Integer>> hashMap = new HashMap<>();

src/main/java/com/rampatra/strings/AnagramsTogetherLexicographically.java

@@ -12,28 +12,25 @@
 public class AnagramsTogetherLexicographically {
 
     /**
-     * Takes an array of String {@param s} and prints anagrams in groups where the groups
+     * Takes an array of String {@code strings} and prints anagrams in groups where the groups
      * are arranged lexicographically and the strings within each group are also arranged
      * lexicographically.
      *
-     * @param s
+     * @param strings
      */
-    public static void printAnagramsTogether(String[] s) {
+    public static void printAnagramsTogether(String[] strings) {
 
         HashMap<String, List<Integer>> hashMap = new HashMap<>();
-        TreeSet<List<String>> treeSet = new TreeSet<>(new Comparator() {
-            @Override
-            public int compare(Object o1, Object o2) {
-                if (o1 instanceof List<?> && o2 instanceof List<?>) {
-                    return ((List<String>) o1).get(0).compareTo(((List<String>) o2).get(0));
-                } else {
-                    return 0;
-                }
+        TreeSet<List<String>> treeSet = new TreeSet<>((Comparator) (o1, o2) -> {
+            if (o1 instanceof List<?> && o2 instanceof List<?>) {
+                return ((List<String>) o1).get(0).compareTo(((List<String>) o2).get(0));
+            } else {
+                return 0;
             }
         });
 
-        for (int i = 0; i < s.length; i++) {
-            String removeSpaces = s[i].replaceAll("\\s+", "");
+        for (int i = 0; i < strings.length; i++) {
+            String removeSpaces = strings[i].replaceAll("\\s+", "");
             char[] chars = removeSpaces.toCharArray();
             Arrays.sort(chars);
 
@@ -50,17 +47,14 @@ public int compare(Object o1, Object o2) {
             List<String> anagrams = new ArrayList<>();
 
             for (int i = 0; i < entry.getValue().size(); i++) {
-                anagrams.add(s[entry.getValue().get(i)]);
+                anagrams.add(strings[entry.getValue().get(i)]);
             }
 
             Collections.sort(anagrams); // arrange anagrams lexicographically within a single line
             treeSet.add(anagrams); // sort the entire output lexicographically
         }
 
-        Iterator iterator = treeSet.iterator();
-        while (iterator.hasNext()) {
-            System.out.println(iterator.next());
-        }
+        treeSet.stream().flatMap(Collection::stream).forEach(System.out::println);
     }
 
     /**
@@ -72,6 +66,7 @@ public static void main(String[] args) {
         Scanner in = new Scanner(System.in);
         List<String> strings = new ArrayList<>();
         String s;
+        System.out.println("Input string in separate lines (blank string to stop):");
         // you should use in.hasNextLine()
         while (!(s = in.nextLine()).trim().equals("")) {
             strings.add(s);

src/main/java/com/rampatra/strings/KeepOnlyKConsecutiveLetters.java

@@ -18,27 +18,22 @@ public class KeepOnlyKConsecutiveLetters {
      *
      * @param str input string
      * @param k
-     * @return
+     * @return a string with at most {@code k} consecutive characters
      */
     private static String keepOnlyKConsecutiveLetters(String str, int k) {
         StringBuilder sb = new StringBuilder();
+        int count = 0;
 
         for (int i = 0; i < str.length(); i++) {
-            char ch = str.charAt(i);
-
-            for (int j = 0; i + j < str.length() && j < k; j++) {
-                char ch2 = str.charAt(i + j);
-                if (ch2 == ch) {
-                    sb.append(ch2);
-                } else {
-                    break;
-                }
+            if (i != 0 && str.charAt(i) != str.charAt(i - 1)) {
+                count = 0;
             }
-
-            while (i + 1 < str.length() && str.charAt(i + 1) == str.charAt(i)) {
-                i++;
+            if (count < k) {
+                sb.append(str.charAt(i));
+                count++;
             }
         }
+
         return sb.toString();
     }