add 1056

fishercoder1534 · fishercoder1534 · commit 3ee64c39c2e1 · 2019-06-02T08:54:59.000-07:00
diff --git a/README.md b/README.md
@@ -28,6 +28,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |  #  |      Title     |   Solutions   | Time          | Space         | Video  | Difficulty  | Tag                   
 |-----|----------------|---------------|---------------|---------------|--------|-------------|-------------
 |1065|[Index Pairs of a String](https://leetcode.com/problems/index-pairs-of-a-string/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1065.java) | O(nlogn) | O(1) | |Medium||
+|1056|[Confusing Number](https://leetcode.com/problems/confusing-number/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1056.java) | O(n) | O(1) | |Easy||
 |1055|[Fixed Point](https://leetcode.com/problems/fixed-point/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1055.java) | O(n) | O(1) | |Easy||
 |1051|[Height Checker](https://leetcode.com/problems/height-checker/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1051.java) | O(nlogn) | O(1) | |Easy||
 |1047|[Remove All Adjacent Duplicates In String](https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1047.java) | O(n) | O(1) | |Easy||
diff --git a/src/main/java/com/fishercoder/solutions/_1056.java b/src/main/java/com/fishercoder/solutions/_1056.java
@@ -0,0 +1,73 @@
+package com.fishercoder.solutions;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 1056. Confusing Number
+ *
+ * Given a number N, return true if and only if it is a confusing number, which satisfies the following condition:
+ * We can rotate digits by 180 degrees to form new digits. When 0, 1, 6, 8, 9 are rotated 180 degrees,
+ * they become 0, 1, 9, 8, 6 respectively. When 2, 3, 4, 5 and 7 are rotated 180 degrees,
+ * they become invalid. A confusing number is a number that when rotated 180 degrees becomes a different number with each digit valid.
+ *
+ * Example 1:
+ * Input: 6
+ * Output: true
+ * Explanation:
+ * We get 9 after rotating 6, 9 is a valid number and 9!=6.
+ *
+ *
+ * Example 2:
+ * Input: 89
+ * Output: true
+ * Explanation:
+ * We get 68 after rotating 89, 86 is a valid number and 86!=89.
+ *
+ *
+ * Example 3:
+ * Input: 11
+ * Output: false
+ * Explanation:
+ * We get 11 after rotating 11, 11 is a valid number but the value remains the same, thus 11 is not a confusing number.
+ *
+ * Example 4:
+ * Input: 25
+ * Output: false
+ * Explanation:
+ * We get an invalid number after rotating 25.
+ *
+ *  Note:
+ *
+ * 0 <= N <= 10^9
+ * After the rotation we can ignore leading zeros, for example if after rotation we have 0008 then this number is considered as just 8.*/
+public class _1056 {
+    public static class Solution1 {
+        Map<Integer, Integer> map = new HashMap<Integer, Integer>() {{
+            put(0, 0);
+            put(1, 1);
+            put(8, 8);
+            put(6, 9);
+            put(9, 6);
+        }};
+
+        public boolean confusingNumber(int N) {
+            if (N == 0) {
+                return false;
+            }
+            int newNumber = 0;
+            int originalN = N;
+            while (N != 0) {
+                newNumber *= 10;
+                int digit = N % 10;
+                if (!map.containsKey(digit)) {
+                    return false;
+                }
+                digit = map.get(digit);
+                newNumber += digit;
+                N /= 10;
+            }
+            return newNumber != originalN;
+        }
+    }
+}
diff --git a/src/test/java/com/fishercoder/_1056Test.java b/src/test/java/com/fishercoder/_1056Test.java
@@ -0,0 +1,37 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._1056;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _1056Test {
+    private static _1056.Solution1 solution1;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _1056.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        assertEquals(true, solution1.confusingNumber(6));
+    }
+
+    @Test
+    public void test2() {
+        assertEquals(true, solution1.confusingNumber(89));
+    }
+
+    @Test
+    public void test3() {
+        assertEquals(false, solution1.confusingNumber(11));
+    }
+
+    @Test
+    public void test4() {
+        assertEquals(false, solution1.confusingNumber(25));
+    }
+
+}
