release v1.8

Author: gardncl

datastructures/src/main/java/DuplicateAndMissing.java

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

datastructures/src/main/java/MinMax.java

@@ -0,0 +1,20 @@
+public class MinMax {
+    public Integer min;
+    public Integer max;
+
+    public MinMax(Integer min, Integer max) {
+        this.min = min;
+        this.max = max;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        MinMax minMax = (MinMax) o;
+
+        if (min != null ? !min.equals(minMax.min) : minMax.min != null) return false;
+        return max != null ? max.equals(minMax.max) : minMax.max == null;
+    }
+}

pom.xml

@@ -16,6 +16,7 @@
         <module>stacksandqueues</module>
         <module>binarytrees</module>
         <module>heaps</module>
+        <module>searching</module>
     </modules>
     <packaging>pom</packaging>
 

searching/README.md

@@ -0,0 +1,12 @@
+# Chapter 12: Searching
+
+* 12.1 SearchSorted
+* 12.2 SearchSortedIndex
+* 12.3 SearchSortedCyclic
+* 12.4 IntegerSquareRoot
+* 12.5 RealSquareRoot
+* 12.6 SearchSorted2D
+* 12.7 FindMinAndMax
+* 12.8 FindKthLargest
+* 12.9 FindMissingIP
+* 12.10 FindDuplicateAndMissing

searching/pom.xml

@@ -0,0 +1,29 @@
+<?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>searching</artifactId>
+    <name>Chapter 12: Searching</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>

searching/src/main/java/FindDuplicateAndMissing.java

@@ -0,0 +1,18 @@
+import java.util.List;
+
+public class FindDuplicateAndMissing {
+
+    /*
+    12.10
+
+    You are given an array of n integers, each between 0 and n - 1,
+    inclusive. Exactly one element appears twice, implying exactly
+    one number between 0 and n - 1 is missing from the array. How
+    would you compute the duplicate and missing numbers?
+     */
+
+    public static DuplicateAndMissing search(List<Integer> list) {
+
+        return new DuplicateAndMissing(0,0);
+    }
+}

searching/src/main/java/FindKthLargest.java

@@ -0,0 +1,16 @@
+import java.util.List;
+
+public class FindKthLargest {
+
+    /*
+    12.8
+
+    Design an algorithm for computing the kth largest
+    element in an array. Assume entries are distinct.
+     */
+
+    public static int findKth(List<Integer> list, int k) {
+
+        return 0;
+    }
+}

searching/src/main/java/FindMinAndMax.java

@@ -0,0 +1,16 @@
+import java.util.List;
+
+public class FindMinAndMax {
+
+    /*
+    12.7
+
+    Design an algorithm to find the min and max elements in an array.
+     */
+
+    public static MinMax findMinMax(List<Integer> list) {
+
+        return new MinMax(0,0);
+    }
+
+}

searching/src/main/java/FindMissingIP.java

@@ -0,0 +1,17 @@
+public class FindMissingIP {
+
+    /*
+    12.9
+
+    Suppose you were given a file containing roughly one billion
+    IP addresses, each of which is a 32-bit quantity. How would
+    you programmatically find an IP address that is not in the file?
+    Assume you have unlimited drive space but only a few megabytes
+    of RAM at your disposal.
+     */
+
+    private static int search(Iterable<Integer> sequence) {
+
+        return 0;
+    }
+}

searching/src/main/java/IntegerSquareRoot.java

@@ -0,0 +1,15 @@
+public class IntegerSquareRoot {
+
+    /*
+    12.4
+
+    Write a program which takes a non-negative integer and
+    returns the largest integer whose square is less that
+    or equal to the given integer.
+     */
+
+    public static int squareRoot(int n) {
+
+        return 0;
+    }
+}