add 970

fishercoder1534 · fishercoder1534 · commit 38d642e21fb5 · 2019-01-06T17:03:23.000-08:00
diff --git a/README.md b/README.md
@@ -29,6 +29,7 @@ Your ideas/fixes/algorithms are more than welcome!
 
 |  #  |      Title     |   Solutions   | Time          | Space         | Video  | Difficulty  | Tag                   
 |-----|----------------|---------------|---------------|---------------|--------|-------------|-------------
+|970|[Powerful Integers](https://leetcode.com/problems/powerful-integers/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_970.java) | O(?) | O(1) | |Easy| Math
 |966|[Vowel Spellchecker](https://leetcode.com/problems/vowel-spellchecker/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_966.java) | O(hlogn) | O(n) | |Medium| Hash Table, String
 |965|[Univalued Binary Tree](https://leetcode.com/problems/univalued-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_965.java) | O(n) | O(h) | |Easy| DFS, recursion|
 |961|[N-Repeated Element in Size 2N Array](https://leetcode.com/problems/n-repeated-element-in-size-2n-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_961.java) | O(n) | O(1) | |Easy|
diff --git a/src/main/java/com/fishercoder/solutions/_970.java b/src/main/java/com/fishercoder/solutions/_970.java
@@ -0,0 +1,81 @@
+package com.fishercoder.solutions;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * 970. Powerful Integers
+ *
+ * Given two non-negative integers x and y, an integer is powerful if it is equal to x^i + y^j for some integers i >= 0 and j >= 0.
+ *
+ * Return a list of all powerful integers that have value less than or equal to bound.
+ *
+ * You may return the answer in any order.  In your answer, each value should occur at most once.
+ *
+ * Example 1:
+ *
+ * Input: x = 2, y = 3, bound = 10
+ * Output: [2,3,4,5,7,9,10]
+ * Explanation:
+ * 2 = 2^0 + 3^0
+ * 3 = 2^1 + 3^0
+ * 4 = 2^0 + 3^1
+ * 5 = 2^1 + 3^1
+ * 7 = 2^2 + 3^1
+ * 9 = 2^3 + 3^0
+ * 10 = 2^0 + 3^2
+ *
+ * Example 2:
+ *
+ * Input: x = 3, y = 5, bound = 15
+ * Output: [2,4,6,8,10,14]
+ *
+ *
+ * Note:
+ * 1 <= x <= 100
+ * 1 <= y <= 100
+ * 0 <= bound <= 10^6
+ */
+public class _970 {
+  public static class Solution1 {
+    /**This approach results in Time Limit Exceeded since it's apparently doing
+     * redundant checks.*/
+    public List<Integer> powerfulIntegers(int x, int y, int bound) {
+      Set<Integer> result = new HashSet<>();
+      int small = x;
+      int big = y;
+      if (x > y) {
+        small = y;
+        big = x;
+      }
+      int maxPower = bound / small;
+      for (int i = 0; i <= maxPower+1; i++) {
+        for (int j = 0; j <= maxPower+1; j++) {
+          int sum = (int) (Math.pow(small, i) + Math.pow(big, j));
+          if (sum <= bound) {
+            result.add(sum);
+          }
+        }
+      }
+      List<Integer> list = new ArrayList<>(result);
+      Collections.sort(list);
+      return list;
+    }
+  }
+
+  public static class Solution2 {
+    /** credit: https://leetcode.com/problems/powerful-integers/discuss/214212/JavaC%2B%2BPython-Brute-Force */
+    public List<Integer> powerfulIntegers(int x, int y, int bound) {
+      Set<Integer> result = new HashSet<>();
+      for (int i = 1; i < bound; i *= x > 1 ? x : bound + 1) {
+        for (int j = 1; i + j <= bound; j *= y > 1 ? y : bound + 1) {
+          result.add(i + j);
+        }
+      }
+      return new ArrayList<>(result);
+    }
+  }
+}
diff --git a/src/test/java/com/fishercoder/_970Test.java b/src/test/java/com/fishercoder/_970Test.java
@@ -0,0 +1,55 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._970;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _970Test {
+  private static _970.Solution1 solution1;
+  private static _970.Solution2 solution2;
+
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _970.Solution1();
+    solution2 = new _970.Solution2();
+  }
+
+  @Test
+  public void test1() {
+    assertEquals(Arrays.asList(2, 3, 4, 5, 7, 9, 10), solution1.powerfulIntegers(2, 3, 10));
+    assertEquals(Arrays.asList(2, 3, 4, 5, 7, 9, 10), solution2.powerfulIntegers(2, 3, 10));
+  }
+
+  @Test
+  public void test2() {
+    assertEquals(Arrays.asList(2, 4, 6, 8, 10, 14), solution1.powerfulIntegers(3, 5, 15));
+    assertEquals(Arrays.asList(2, 4, 6, 8, 10, 14), solution2.powerfulIntegers(3, 5, 15));
+  }
+
+  @Test
+  public void test3() {
+    assertEquals(Arrays.asList(2, 3, 5, 7, 8, 9, 10), solution1.powerfulIntegers(2, 6, 12));
+    assertEquals(Arrays.asList(2, 3, 5, 7, 8, 9, 10), solution2.powerfulIntegers(2, 6, 12));
+  }
+
+  @Test
+  public void test4() {
+    assertEquals(Arrays.asList(2, 3, 5, 9, 10, 11), solution1.powerfulIntegers(2, 9, 12));
+    assertEquals(Arrays.asList(2, 3, 5, 9, 10, 11), solution2.powerfulIntegers(2, 9, 12));
+  }
+
+  @Test
+  public void test5() {
+    assertEquals(Arrays.asList(2, 91, 180, 8101, 8190, 16200, 729001, 729090,
+        737100), solution1.powerfulIntegers(90, 90, 1000000));
+    List<Integer> actual = solution2.powerfulIntegers(90, 90, 1000000);
+    Collections.sort(actual);
+    assertEquals(Arrays.asList(2, 91, 180, 8101, 8190, 16200, 729001, 729090,
+        737100), actual);
+  }
+}
