add a solution for 179

fishercoder1534 · fishercoder1534 · commit b362c921b95c · 2021-11-29T11:22:17.000-08:00
diff --git a/src/main/java/com/fishercoder/solutions/_179.java b/src/main/java/com/fishercoder/solutions/_179.java
@@ -1,89 +1,90 @@
 package com.fishercoder.solutions;
 
-import java.util.Arrays;
-import java.util.Comparator;
+import java.util.*;
 
-/**
- * 179. Largest Number
-
- Given a list of non negative integers, arrange them such that they form the largest number.
-
- Example 1:
-
- Input: [10,2]
- Output: "210"
-
- Example 2:
-
- Input: [3,30,34,5,9]
- Output: "9534330"
-
- Note: The result may be very large, so you need to return a string instead of an integer.
- */
 public class _179 {
 
-  public static class Solution1 {
-    public String largestNumber(int[] num) {
-      if (num.length == 0) {
-        return "";
-      }
-      if (num.length == 1) {
-        return Integer.toString(num[0]);
-      }
-      String[] str = new String[num.length];
-      for (int i = 0; i < num.length; i++) {
-        str[i] = Integer.toString(num[i]);
-      }
-      Arrays.sort(str, new StringComparator());
-      StringBuilder sb = new StringBuilder("");
-      for (int i = num.length - 1; i >= 0; i--) {
-        sb.append(str[i]);
-      }
-      if (sb.charAt(0) == '0') {
-        return "0";
-      }
-      return sb.toString();
-    }
-
-    class StringComparator implements Comparator<String> {
-      public int compare(String s1, String s2) {
-        if (s1.length() == 0 && s2.length() == 0) {
-          return 0;
-        }
-        if (s2.length() == 0) {
-          return 1;
-        }
-        if (s1.length() == 0) {
-          return -1;
-        }
-        for (int i = 0; i < s1.length() && i < s2.length(); i++) {
-          if (s1.charAt(i) > s2.charAt(i)) {
-            return 1;
-          } else if (s1.charAt(i) < s2.charAt(i)) {
-            return -1;
-          }
+    public static class Solution1 {
+        public String largestNumber(int[] num) {
+            if (num.length == 0) {
+                return "";
+            }
+            if (num.length == 1) {
+                return Integer.toString(num[0]);
+            }
+            String[] str = new String[num.length];
+            for (int i = 0; i < num.length; i++) {
+                str[i] = Integer.toString(num[i]);
+            }
+            Arrays.sort(str, new StringComparator());
+            StringBuilder sb = new StringBuilder("");
+            for (int i = num.length - 1; i >= 0; i--) {
+                sb.append(str[i]);
+            }
+            if (sb.charAt(0) == '0') {
+                return "0";
+            }
+            return sb.toString();
         }
-        if (s1.length() == s2.length()) {
-          return 0;
+
+        class StringComparator implements Comparator<String> {
+            public int compare(String s1, String s2) {
+                if (s1.length() == 0 && s2.length() == 0) {
+                    return 0;
+                }
+                if (s2.length() == 0) {
+                    return 1;
+                }
+                if (s1.length() == 0) {
+                    return -1;
+                }
+                for (int i = 0; i < s1.length() && i < s2.length(); i++) {
+                    if (s1.charAt(i) > s2.charAt(i)) {
+                        return 1;
+                    } else if (s1.charAt(i) < s2.charAt(i)) {
+                        return -1;
+                    }
+                }
+                if (s1.length() == s2.length()) {
+                    return 0;
+                }
+                if (s1.length() > s2.length()) {
+                    if (s1.charAt(0) < s1.charAt(s2.length())) {
+                        return 1;
+                    } else if (s1.charAt(0) > s1.charAt(s2.length())) {
+                        return -1;
+                    } else {
+                        return compare(s1.substring(s2.length()), s2);
+                    }
+                } else {
+                    if (s2.charAt(0) < s2.charAt(s1.length())) {
+                        return -1;
+                    } else if (s2.charAt(0) > s2.charAt(s1.length())) {
+                        return 1;
+                    } else {
+                        return compare(s1, s2.substring(s1.length()));
+                    }
+                }
+            }
         }
-        if (s1.length() > s2.length()) {
-          if (s1.charAt(0) < s1.charAt(s2.length())) {
-            return 1;
-          } else if (s1.charAt(0) > s1.charAt(s2.length())) {
-            return -1;
-          } else {
-            return compare(s1.substring(s2.length()), s2);
-          }
-        } else {
-          if (s2.charAt(0) < s2.charAt(s1.length())) {
-            return -1;
-          } else if (s2.charAt(0) > s2.charAt(s1.length())) {
-            return 1;
-          } else {
-            return compare(s1, s2.substring(s1.length()));
-          }
+    }
+
+    public static class Solution2 {
+        /**
+         * My completely original solution on 11/29/2021:
+         * we'll just sort these numbers as if they are strings.
+         */
+        public String largestNumber(int[] nums) {
+            List<String> strings = new ArrayList<>();
+            for (int num : nums) {
+                strings.add(Integer.toString(num));
+            }
+            Collections.sort(strings, (a, b) -> (b + a).compareToIgnoreCase(a + b));
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < strings.size(); i++) {
+                sb.append(strings.get(i));
+            }
+            return sb.charAt(0) == '0' ? "0" : sb.toString();
         }
-      }
     }
-  }
 }
diff --git a/src/test/java/com/fishercoder/_179Test.java b/src/test/java/com/fishercoder/_179Test.java
@@ -0,0 +1,53 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._179;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _179Test {
+    private static _179.Solution1 solution1;
+    private static _179.Solution2 solution2;
+    private static int[] nums;
+    private static String expected;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _179.Solution1();
+        solution2 = new _179.Solution2();
+    }
+
+    @Test
+    public void test1() {
+        nums = new int[]{34323, 3432};
+        expected = "343234323";
+        assertEquals(expected, solution1.largestNumber(nums));
+        assertEquals(expected, solution2.largestNumber(nums));
+    }
+
+    @Test
+    public void test2() {
+        nums = new int[]{111311, 1113};
+        expected = "1113111311";
+        assertEquals(expected, solution1.largestNumber(nums));
+        assertEquals(expected, solution2.largestNumber(nums));
+    }
+
+    @Test
+    public void test3() {
+        nums = new int[]{3, 30, 34, 5, 9};
+        expected = "9534330";
+        assertEquals(expected, solution1.largestNumber(nums));
+        assertEquals(expected, solution2.largestNumber(nums));
+    }
+
+    @Test
+    public void test4() {
+        nums = new int[]{0, 0};
+        expected = "0";
+        assertEquals(expected, solution1.largestNumber(nums));
+        assertEquals(expected, solution2.largestNumber(nums));
+    }
+
+}
