chapter 13 done

Author: gardncl

arrays/src/test/java/GenerateNonuniformRandomNumbersTest.java

@@ -1,6 +1,7 @@
 import org.junit.Test;
 
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
@@ -41,8 +42,11 @@ public void nonUniformRandomNumberGeneration3() {
     }
 
     private void test(List<Integer> values, List<Double> probabilities) {
-        final Map<Integer, AtomicInteger> results = values.stream().map(integer -> new AbstractMap.SimpleImmutableEntry<>(integer, new AtomicInteger(0)))
-                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+        final Map<Integer, AtomicInteger> results = new ConcurrentHashMap<>(
+                values.stream()
+                        .map(integer -> new AbstractMap.SimpleImmutableEntry<>(integer, new AtomicInteger(0)))
+                        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue))
+        );
 
         IntStream.range(0, N)
                 .parallel()

datastructures/src/main/java/DuplicateAndMissing.java

@@ -0,0 +1,25 @@
+public class Tuple {
+
+    public Integer first;
+    public Integer second;
+
+    public Tuple() {
+    }
+
+    public Tuple(Integer first, Integer second) {
+        this.first = first;
+        this.second = second;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Tuple that = (Tuple) o;
+
+        if (first != null ? !first.equals(that.first) : that.first != null) return false;
+        return second != null ? second.equals(that.second) : that.second == null;
+    }
+
+}

datastructures/src/main/java/Tuple.java

@@ -0,0 +1,16 @@
+# Chapter 13: Hash Tables
+
+* 13.1 PalindromicPermutations
+* 13.2 IsLetterConstructable
+* 13.3 LRUCache
+* 13.4 ComputeLCA
+* 13.5 ComputeKMostFrequent
+* 13.6 NearestRepeated
+* 13.7 SmallestSubarray
+* 13.8 SmallestSequentialSubarray
+* 13.9 LongestSubarray
+* 13.10 LongestContainedInterval
+* 13.11 ComputeAverageTopThree
+* 13.12 ComputeStringDecompositions
+* 13.13 CollatzConjecture
+* 13.14 HashFunctionChess

hashtables/README.md

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>elements-of-programming-interviews</artifactId>
+        <groupId>gardncl</groupId>
+        <version>1.5</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>hashtables</artifactId>
+    <name>Chapter 13: Hash Tables</name>
+    <dependencies>
+        <dependency>
+            <groupId>gardncl</groupId>
+            <artifactId>datastructures</artifactId>
+            <version>1.4</version>
+        </dependency>
+        <dependency>
+            <groupId>gardncl</groupId>
+            <artifactId>utils</artifactId>
+            <version>1.4</version>
+        </dependency>
+    </dependencies>
+
+
+</project>

hashtables/pom.xml

@@ -0,0 +1,13 @@
+public class CollatzConjecture {
+
+    /*
+    13.13
+
+    Test the Collatz conjecture for the first n positive integers.
+     */
+
+    public static boolean testCollatzConjecture(int n) {
+
+        return false;
+    }
+}

hashtables/src/main/java/CollatzConjecture.java

@@ -0,0 +1,28 @@
+import java.util.Iterator;
+
+public class ComputeAverageTopThree {
+
+    /*
+    13.11
+
+    Write a program which takes as input a file containing test
+    scores and returns the student who has the maximum score
+    averaged across his or her top three tests. If the student
+    has fewer that three test scores, ignore that student.
+     */
+
+    public static class NameScore {
+        public String name;
+        public Integer score;
+
+        public NameScore(String name, Integer score) {
+            this.name = name;
+            this.score = score;
+        }
+    }
+
+    public static String findStudent(Iterator<NameScore> iterator) {
+
+        return "";
+    }
+}

hashtables/src/main/java/ComputeAverageTopThree.java

@@ -0,0 +1,17 @@
+import java.util.Collections;
+import java.util.List;
+
+public class ComputeKMostFrequent {
+
+    /*
+    13.5
+
+    You are given an array of strings. Compute the
+    k strings that appear most frequently in the array.
+     */
+
+    public static List<String> mostFrequent(List<String> list, int k) {
+
+        return Collections.emptyList();
+    }
+}

hashtables/src/main/java/ComputeKMostFrequent.java

@@ -0,0 +1,15 @@
+public class ComputeLCA {
+
+    /*
+    13.4
+
+    Design an algorithm for computing the LCA of two nodes
+    in a binary tree. The algorithm's time complexity
+    should depend only on the distance from the nodes to the LCA.
+     */
+
+    public static BinaryTreeParent<Integer> LCA(BinaryTreeParent<Integer> node0, BinaryTreeParent<Integer> node1) {
+
+        return new BinaryTreeParent<>(0);
+    }
+}

hashtables/src/main/java/ComputeLCA.java

@@ -0,0 +1,19 @@
+import java.util.Collections;
+import java.util.List;
+
+public class ComputeStringDecompositions {
+
+    /*
+    13.12
+
+    Write a program which takes as input a string (the "sentence")
+    and an array of strings (the "words"), and returns the starting
+    indices of substrings of the sentence string which are the
+    concatenation of all the strings in the words array.
+     */
+
+    public static List<String> findAllSubstring(String s, List<String> words) {
+
+        return Collections.emptyList();
+    }
+}