Merge remote-tracking branch 'origin/master'

Author: longluo

Java/src/com/longluo/contest/biweekly_contest_108/Problem1.java

@@ -0,0 +1,40 @@
+package com.longluo.contest.biweekly_contest_108;
+
+/**
+ * https://leetcode.cn/contest/biweekly-contest-108
+ */
+public class Problem1 {
+
+    public static int alternatingSubarray(int[] nums) {
+        int n = nums.length;
+
+        int ans = 0;
+
+        for (int i = 0; i < n; i++) {
+            int prev = nums[i];
+            int cnt = 0;
+            int step = 1;
+
+            for (int j = i + 1; j < n; j++) {
+                if (nums[j] != prev + step) {
+                    break;
+                }
+
+                prev = nums[j];
+                cnt++;
+                step *= -1;
+            }
+
+            if (cnt > 0) {
+                ans = Math.max(ans, cnt + 1);
+            }
+        }
+
+        return ans == 0 ? -1 : ans;
+    }
+
+    public static void main(String[] args) {
+        System.out.println("2 ?= " + alternatingSubarray(new int[]{4, 5, 6}));
+        System.out.println("4 ?= " + alternatingSubarray(new int[]{2, 3, 4, 3, 4}));
+    }
+}

Java/src/com/longluo/contest/biweekly_contest_108/Problem2.java

@@ -0,0 +1,46 @@
+package com.longluo.contest.biweekly_contest_108;
+
+import java.util.*;
+
+/**
+ * https://leetcode.cn/contest/biweekly-contest-108
+ */
+public class Problem2 {
+
+    public static List<Integer> relocateMarbles(int[] nums, int[] moveFrom, int[] moveTo) {
+        Map<Integer, Integer> posMap = new HashMap<>();
+
+        for (int x : nums) {
+            posMap.put(x, posMap.getOrDefault(x, 0) + 1);
+        }
+
+        for (int i = 0; i < moveFrom.length; i++) {
+            int from = moveFrom[i];
+            int to = moveTo[i];
+
+            if (from == to) {
+                continue;
+            }
+
+            posMap.put(to, posMap.getOrDefault(to, 0) + posMap.get(from));
+            posMap.remove(from);
+        }
+
+        List<Integer> ans = new ArrayList<>();
+
+        for (int key : posMap.keySet()) {
+            ans.add(key);
+        }
+
+        Collections.sort(ans);
+
+        return ans;
+    }
+
+    public static void main(String[] args) {
+        System.out.println("[1] ?= " + relocateMarbles(new int[]{3, 4}, new int[]{4, 3, 1, 2, 2, 3, 2, 4, 1}, new int[]{3, 1, 2, 2, 3, 2, 4, 1, 1}));
+        System.out.println("[11, 20, 23] ?= " + relocateMarbles(new int[]{4, 6, 6, 9, 18}, new int[]{18, 6, 17, 4, 9, 19, 2}, new int[]{23, 17, 20, 19, 11, 2, 20}));
+        System.out.println("[5, 6, 8, 9] ?= " + relocateMarbles(new int[]{1, 6, 7, 8}, new int[]{1, 7, 2}, new int[]{2, 9, 5}));
+        System.out.println("[2] ?= " + relocateMarbles(new int[]{1, 1, 3, 3}, new int[]{1, 3}, new int[]{2, 2}));
+    }
+}

Java/src/com/longluo/contest/biweekly_contest_109/Problem1.java

@@ -0,0 +1,34 @@
+package com.longluo.contest.biweekly_contest_109;
+
+import java.util.Arrays;
+
+/**
+ * https://leetcode.cn/contest/biweekly-contest-109
+ */
+public class Problem1 {
+
+    public static boolean isGood(int[] nums) {
+        Arrays.sort(nums);
+
+        int len = nums.length;
+
+        int n = nums[len - 1];
+        if (n != len - 1) {
+            return false;
+        }
+
+        for (int i = 0; i < n; i++) {
+            if (nums[i] != (i + 1)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public static void main(String[] args) {
+        System.out.println("true ?= " + isGood(new int[]{1, 1}));
+        System.out.println("false ?= " + isGood(new int[]{2, 1, 3}));
+        System.out.println("true ?= " + isGood(new int[]{1, 3, 3, 2}));
+    }
+}

Java/src/com/longluo/contest/biweekly_contest_109/Problem2.java

@@ -0,0 +1,51 @@
+package com.longluo.contest.biweekly_contest_109;
+
+import java.util.*;
+
+/**
+ * https://leetcode.cn/contest/biweekly-contest-109
+ */
+public class Problem2 {
+
+    public static String sortVowels(String s) {
+        Set<Character> vowels = new HashSet<>();
+
+        for (char ch : "AEIOUaeiou".toCharArray()) {
+            vowels.add(ch);
+        }
+
+        List<Character> list = new ArrayList<>();
+
+        for (char ch : s.toCharArray()) {
+            if (vowels.contains(ch)) {
+                list.add(ch);
+            }
+        }
+
+        if (list.size() == 0) {
+            return s;
+        }
+
+        Collections.sort(list);
+
+        StringBuilder sb = new StringBuilder();
+
+        int idx = 0;
+
+        for (char ch : s.toCharArray()) {
+            if (vowels.contains(ch)) {
+                sb.append(list.get(idx));
+                idx++;
+            } else {
+                sb.append(ch);
+            }
+        }
+
+        return sb.toString();
+    }
+
+    public static void main(String[] args) {
+        System.out.println("lEOtcede ?= " + sortVowels("lEetcOde"));
+        System.out.println("lYmpH ?= " + sortVowels("lYmpH"));
+    }
+}

Java/src/com/longluo/contest/biweekly_contest_110/Problem1.java

@@ -0,0 +1,23 @@
+package com.longluo.contest.biweekly_contest_110;
+
+/**
+ * https://leetcode.cn/contest/biweekly-contest-110
+ */
+public class Problem1 {
+
+    public static int accountBalanceAfterPurchase(int purchaseAmount) {
+        int shiwei = purchaseAmount / 10;
+        int gewei = purchaseAmount % 10;
+
+        if (gewei >= 5) {
+            shiwei++;
+        }
+
+        return 100 - 10 * shiwei;
+    }
+
+    public static void main(String[] args) {
+        System.out.println("90 ?= " + accountBalanceAfterPurchase(9));
+        System.out.println("80 ?= " + accountBalanceAfterPurchase(15));
+    }
+}

Java/src/com/longluo/contest/biweekly_contest_110/Problem2.java

@@ -0,0 +1,49 @@
+package com.longluo.contest.biweekly_contest_110;
+
+import com.longluo.datastructure.ListNode;
+import com.longluo.datastructure.Node;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * https://leetcode.cn/contest/biweekly-contest-110
+ */
+public class Problem2 {
+
+    public static ListNode insertGreatestCommonDivisors(ListNode head) {
+        List<Integer> nums = new ArrayList<>();
+
+        ListNode pNode = head;
+
+        while (pNode != null) {
+            nums.add(pNode.val);
+            pNode = pNode.next;
+        }
+
+        for (int i = nums.size() - 1; i > 0; i--) {
+            int first = nums.get(i);
+            int second = nums.get(i - 1);
+
+            int result = gcd(first, second);
+            nums.add(i, result);
+        }
+
+        pNode = head;
+
+        for (int i = 1; i < nums.size(); i++) {
+            pNode.next = new ListNode(nums.get(i));
+            pNode = pNode.next;
+        }
+
+        return head;
+    }
+
+    private static int gcd(int a, int b) {
+        return b == 0 ? a : gcd(b, a % b);
+    }
+
+    public static void main(String[] args) {
+
+    }
+}

Java/src/com/longluo/contest/biweekly_contest_111/Problem1.java

@@ -0,0 +1,37 @@
+package com.longluo.contest.biweekly_contest_111;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * https://leetcode.cn/contest/biweekly-contest-111
+ */
+public class Problem1 {
+
+    public static int countPairs(List<Integer> nums, int target) {
+        int n = nums.size();
+
+        int ans = 0;
+
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                if (nums.get(i) + nums.get(j) < target) {
+                    ans++;
+                }
+            }
+        }
+
+        return ans;
+    }
+
+    public static void main(String[] args) {
+        List<Integer> tst1 = new ArrayList<>();
+        tst1.add(-1);
+        tst1.add(1);
+        tst1.add(2);
+        tst1.add(3);
+        tst1.add(1);
+
+        System.out.println("3 ?= " + countPairs(tst1, 2));
+    }
+}

Java/src/com/longluo/contest/biweekly_contest_112/Problem1.java

@@ -0,0 +1,87 @@
+package com.longluo.contest.biweekly_contest_112;
+
+/**
+ * https://leetcode.cn/contest/biweekly-contest-112
+ */
+public class Problem1 {
+
+    public static boolean canBeEqual(String s1, String s2) {
+        if (s1.equals(s2)) {
+            return true;
+        }
+
+        int[] cnt1 = new int[26];
+
+        int[] cnt2 = new int[26];
+
+        for (int i = 0; i < 4; i++) {
+            cnt1[s1.charAt(i) - 'a']++;
+            cnt2[s2.charAt(i) - 'a']++;
+        }
+
+        for (int i = 0; i < 26; i++) {
+            if (cnt1[i] != cnt2[i]) {
+                return false;
+            }
+        }
+
+        for (int i = 0; i < 4; i++) {
+            char a1 = s1.charAt(i);
+            char a2 = s2.charAt(i);
+
+            if (a1 == a2) {
+                continue;
+            }
+
+            boolean flag = false;
+
+            for (int j = 0; j < 4; j++) {
+                if (s2.charAt(j) == a1 && Math.abs(i - j) == 2) {
+                    flag = true;
+                    break;
+                }
+            }
+
+            if (!flag) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public static boolean canBeEqual_bf(String s1, String s2) {
+        boolean[] masks = new boolean[4];
+
+        for (int i = 0; i < 4; i++) {
+            char ch = s1.charAt(i);
+
+            boolean flag = false;
+
+            for (int j = 0; j < 4; j += 2) {
+                int loc = (i + j) % 4;
+
+                if (!masks[loc] && s2.charAt(loc) == ch) {
+                    flag = true;
+                    masks[loc] = true;
+                    break;
+                }
+            }
+
+            if (!flag) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public static void main(String[] args) {
+        System.out.println("true ?= " + canBeEqual("abcd", "cdab"));
+        System.out.println("false ?= " + canBeEqual("abcd", "dacb"));
+
+        System.out.println("true ?= " + canBeEqual_bf("abcd", "abcd"));
+        System.out.println("true ?= " + canBeEqual_bf("abcd", "cdab"));
+        System.out.println("false ?= " + canBeEqual_bf("abcd", "dacb"));
+    }
+}