Add solution to Task #1

anverbogatov · anverbogatov · commit 2991d8faefc5 · 2022-03-11T11:46:09.000+04:00
diff --git a/src/main/java/com/anverbogatov/algorithms/tasks/README.md b/src/main/java/com/anverbogatov/algorithms/tasks/README.md
@@ -0,0 +1,17 @@
+# 📍 Coding Problems
+
+## 🦅 Overview
+
+In this section (in current java package), I have added a list of coding problems that I have found on the Internet, and
+I have found them quite interesting and useful in learning algorithms.
+
+If you want to get even more value from this section, please try to solve these tasks by yourself before looking onto my
+implementations.
+
+## 📙 Task #1
+
+Given a list of numbers and a number k, return whether any two numbers from the list add up to k.
+
+For example, given [10, 15, 3, 7] and k of 17, return true since 10 + 7 is 17.
+
+**Bonus:** Can you do this in one pass?
diff --git a/src/main/java/com/anverbogatov/algorithms/tasks/Task1.java b/src/main/java/com/anverbogatov/algorithms/tasks/Task1.java
@@ -0,0 +1,62 @@
+package com.anverbogatov.algorithms.tasks;
+
+import java.util.HashSet;
+
+public final class Task1 {
+
+    /**
+     * Find if any of two numbers in the given array add up to given `sum`.
+     * Time complexity of the algorithm used here is O(n^2).
+     *
+     * @param numbers - given array of numbers
+     * @param sum     - given sum
+     * @return `true` if two numbers in the given array add up to `sum`
+     */
+    public static boolean isSumExist(int[] numbers, int sum) {
+        for (int i = 0; i < numbers.length; i++) {
+            int firstNum = numbers[i];
+            for (int j = 0; j < numbers.length; j++) {
+                int secondNum = numbers[j];
+                if (i == j) {
+                    continue;
+                }
+                if (firstNum + secondNum == sum) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Find if any of two numbers in the given array add up to given `sum`.
+     * Time complexity of the algorithm used here is O(n) and that is better than another version in the class.
+     *
+     * @param numbers - given array of numbers
+     * @param sum     - given sum
+     * @return `true` if two numbers in the given array add up to `sum`
+     */
+    public static boolean isSumExistBonus(int[] numbers, int sum) {
+        // todo: re-check
+        if (numbers.length <= 1) {
+            return false;
+        }
+        /*
+         I'm using memoization here to store temporary data.
+         Since both operations - add & contains on HashSets have O(1) complexity,
+         we can do all calculations we need in one iteration on a given array.
+         */
+        var temp = new HashSet<Integer>(numbers.length);
+        for (var num : numbers) {
+            temp.add(num);
+            if (temp.contains(sum - num)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+
+}
diff --git a/src/test/java/com/anverbogatov/algorithms/tasks/Task1Test.java b/src/test/java/com/anverbogatov/algorithms/tasks/Task1Test.java
@@ -0,0 +1,114 @@
+package com.anverbogatov.algorithms.tasks;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.stream.IntStream;
+
+public class Task1Test {
+
+    @Test
+    public void isSumExistOnEmptyArray() {
+        // given
+        var numbers = new int[]{};
+        var sum = 17;
+        // when
+        var result = Task1.isSumExist(numbers, sum);
+        // then
+        Assert.assertFalse(result);
+    }
+
+    @Test
+    public void isSumExistOnSingleElementArray() {
+        // given
+        var numbers = new int[]{17};
+        var sum = 17;
+        // when
+        var result = Task1.isSumExist(numbers, sum);
+        // then
+        Assert.assertFalse(result);
+    }
+
+    @Test
+    public void isSumExist() {
+        // given
+        var numbers = new int[]{10, 15, 3, 7};
+        var sum = 17;
+        // when
+        var result = Task1.isSumExist(numbers, sum);
+        // then
+        Assert.assertTrue(result);
+    }
+
+    @Test
+    public void isSumExistNegative() {
+        // given
+        var numbers = new int[]{10, 15, 3, 7};
+        var sum = 19;
+        // when
+        var result = Task1.isSumExist(numbers, sum);
+        // then
+        Assert.assertFalse(result);
+    }
+
+
+    @Test
+    public void isSumExistOnEmptyArrayBonus() {
+        // given
+        var numbers = new int[]{};
+        var sum = 17;
+        // when
+        var result = Task1.isSumExistBonus(numbers, sum);
+        // then
+        Assert.assertFalse(result);
+    }
+
+    @Test
+    public void isSumExistOnSingleElementArrayBonus() {
+        // given
+        var numbers = new int[]{17};
+        var sum = 17;
+        // when
+        var result = Task1.isSumExistBonus(numbers, sum);
+        // then
+        Assert.assertFalse(result);
+    }
+
+    @Test
+    public void isSumExistBonus() {
+        // given
+        var numbers = new int[]{10, 15, 3, 7};
+        var sum = 17;
+        // when
+        var result = Task1.isSumExistBonus(numbers, sum);
+        // then
+        Assert.assertTrue(result);
+    }
+
+    @Test
+    public void isSumExistNegativeBonus() {
+        // given
+        var numbers = new int[]{10, 15, 3, 7};
+        var sum = 19;
+        // when
+        var result = Task1.isSumExistBonus(numbers, sum);
+        // then
+        Assert.assertFalse(result);
+    }
+
+    @Test
+    public void isSumExistPerformanceLog() {
+        // given
+        var numbers = IntStream.range(0, 10000).toArray();
+        var sum = 9451;
+        // when
+        var _start = System.nanoTime();
+        var result1 = Task1.isSumExist(numbers, sum);
+        System.out.println("Original: " + (System.nanoTime() - _start));
+        _start = System.nanoTime();
+        var result2 = Task1.isSumExistBonus(numbers, sum);
+        System.out.println("Bonus: " + (System.nanoTime() - _start));
+        // then
+        Assert.assertEquals(result1, result2);
+    }
+}
