Added tasks 1052, 1053, 1054.

Author: javadev

src/main/java/g1001_1100/s1052_grumpy_bookstore_owner/Solution.java

@@ -0,0 +1,37 @@
+package g1001_1100.s1052_grumpy_bookstore_owner;
+
+// #Medium #Array #Sliding_Window #2022_02_28_Time_4_ms_(70.26%)_Space_54.4_MB_(27.35%)
+
+public class Solution {
+    public int maxSatisfied(int[] customers, int[] grumpy, int minutes) {
+        // storing numbers of customers who faced grumpy owner till ith minute.
+        int[] grumpySum = new int[grumpy.length];
+        int ans = 0;
+        if (grumpy[0] == 1) {
+            grumpySum[0] = customers[0];
+        } else {
+            ans += customers[0];
+        }
+        for (int i = 1; i < grumpy.length; i++) {
+            if (grumpy[i] == 1) {
+                grumpySum[i] = grumpySum[i - 1] + customers[i];
+            } else {
+                grumpySum[i] = grumpySum[i - 1];
+                ans += customers[i];
+            }
+        }
+        // calculating max number of customers who faced grumpy owner in a window of size 'minutes'.
+        int max = 0;
+        for (int i = 0; i <= customers.length - minutes; i++) {
+            if (i == 0) {
+                max = Math.max(max, grumpySum[i + minutes - 1]);
+            } else {
+                max = Math.max(max, grumpySum[i + minutes - 1] - grumpySum[i - 1]);
+            }
+        }
+        // making the owner non-grumpy in that max window and adding the number of customers who do
+        // not face the grumpy customers.
+        ans += max;
+        return ans;
+    }
+}

src/main/java/g1001_1100/s1052_grumpy_bookstore_owner/readme.md

@@ -0,0 +1,36 @@
+1052\. Grumpy Bookstore Owner
+
+Medium
+
+There is a bookstore owner that has a store open for `n` minutes. Every minute, some number of customers enter the store. You are given an integer array `customers` of length `n` where `customers[i]` is the number of the customer that enters the store at the start of the <code>i<sup>th</sup></code> minute and all those customers leave after the end of that minute.
+
+On some minutes, the bookstore owner is grumpy. You are given a binary array grumpy where `grumpy[i]` is `1` if the bookstore owner is grumpy during the <code>i<sup>th</sup></code> minute, and is `0` otherwise.
+
+When the bookstore owner is grumpy, the customers of that minute are not satisfied, otherwise, they are satisfied.
+
+The bookstore owner knows a secret technique to keep themselves not grumpy for `minutes` consecutive minutes, but can only use it once.
+
+Return _the maximum number of customers that can be satisfied throughout the day_.
+
+**Example 1:**
+
+**Input:** customers = [1,0,1,2,1,1,7,5], grumpy = [0,1,0,1,0,1,0,1], minutes = 3
+
+**Output:** 16
+
+**Explanation:** The bookstore owner keeps themselves not grumpy for the last 3 minutes.
+
+The maximum number of customers that can be satisfied = 1 + 1 + 1 + 1 + 7 + 5 = 16.
+
+**Example 2:**
+
+**Input:** customers = [1], grumpy = [0], minutes = 1
+
+**Output:** 1
+
+**Constraints:**
+
+*   `n == customers.length == grumpy.length`
+*   <code>1 <= minutes <= n <= 2 * 10<sup>4</sup></code>
+*   `0 <= customers[i] <= 1000`
+*   `grumpy[i]` is either `0` or `1`.

src/main/java/g1001_1100/s1053_previous_permutation_with_one_swap/Solution.java

@@ -0,0 +1,25 @@
+package g1001_1100.s1053_previous_permutation_with_one_swap;
+
+// #Medium #Array #Greedy #2022_02_28_Time_0_ms_(100.00%)_Space_56.1_MB_(27.21%)
+
+public class Solution {
+    public int[] prevPermOpt1(int[] arr) {
+        for (int i = arr.length - 1; i >= 0; i--) {
+            int diff = Integer.MAX_VALUE;
+            int index = i;
+            for (int j = i + 1; j < arr.length; j++) {
+                if (arr[i] - arr[j] > 0 && diff > arr[i] - arr[j]) {
+                    diff = arr[i] - arr[j];
+                    index = j;
+                }
+            }
+            if (diff != Integer.MAX_VALUE) {
+                int temp = arr[i];
+                arr[i] = arr[index];
+                arr[index] = temp;
+                break;
+            }
+        }
+        return arr;
+    }
+}

src/main/java/g1001_1100/s1053_previous_permutation_with_one_swap/readme.md

@@ -0,0 +1,34 @@
+1053\. Previous Permutation With One Swap
+
+Medium
+
+Given an array of positive integers `arr` (not necessarily distinct), return _the lexicographically largest permutation that is smaller than_ `arr`, that can be **made with exactly one swap** (A _swap_ exchanges the positions of two numbers `arr[i]` and `arr[j]`). If it cannot be done, then return the same array.
+
+**Example 1:**
+
+**Input:** arr = [3,2,1]
+
+**Output:** [3,1,2]
+
+**Explanation:** Swapping 2 and 1.
+
+**Example 2:**
+
+**Input:** arr = [1,1,5]
+
+**Output:** [1,1,5]
+
+**Explanation:** This is already the smallest permutation.
+
+**Example 3:**
+
+**Input:** arr = [1,9,4,6,7]
+
+**Output:** [1,7,4,6,9]
+
+**Explanation:** Swapping 9 and 7.
+
+**Constraints:**
+
+*   <code>1 <= arr.length <= 10<sup>4</sup></code>
+*   <code>1 <= arr[i] <= 10<sup>4</sup></code>

src/main/java/g1001_1100/s1054_distant_barcodes/Solution.java

@@ -0,0 +1,34 @@
+package g1001_1100.s1054_distant_barcodes;
+
+// #Medium #Array #Hash_Table #Sorting #Greedy #Heap_Priority_Queue #Counting
+// #2022_02_28_Time_45_ms_(64.21%)_Space_69.1_MB_(71.24%)
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution {
+    public int[] rearrangeBarcodes(int[] barcodes) {
+        Map<Integer, Integer> cnt = new HashMap<>();
+        for (int i : barcodes) {
+            cnt.put(i, cnt.getOrDefault(i, 0) + 1);
+        }
+        List<Map.Entry<Integer, Integer>> list = new ArrayList<>(cnt.entrySet());
+        list.sort(Map.Entry.<Integer, Integer>comparingByValue().reversed());
+        int l = barcodes.length;
+        int i = 0;
+        int[] res = new int[l];
+        for (Map.Entry<Integer, Integer> e : list) {
+            int time = e.getValue();
+            while (time-- > 0) {
+                res[i] = e.getKey();
+                i += 2;
+                if (i >= barcodes.length) {
+                    i = 1;
+                }
+            }
+        }
+        return res;
+    }
+}

src/main/java/g1001_1100/s1054_distant_barcodes/readme.md

@@ -0,0 +1,24 @@
+1054\. Distant Barcodes
+
+Medium
+
+In a warehouse, there is a row of barcodes, where the <code>i<sup>th</sup></code> barcode is `barcodes[i]`.
+
+Rearrange the barcodes so that no two adjacent barcodes are equal. You may return any answer, and it is guaranteed an answer exists.
+
+**Example 1:**
+
+**Input:** barcodes = [1,1,1,2,2,2]
+
+**Output:** [2,1,2,1,2,1]
+
+**Example 2:**
+
+**Input:** barcodes = [1,1,1,1,2,2,3,3]
+
+**Output:** [1,3,1,3,1,2,1,2]
+
+**Constraints:**
+
+*   `1 <= barcodes.length <= 10000`
+*   `1 <= barcodes[i] <= 10000`

src/test/java/g1001_1100/s1052_grumpy_bookstore_owner/SolutionTest.java

@@ -0,0 +1,24 @@
+package g1001_1100.s1052_grumpy_bookstore_owner;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void maxSatisfied() {
+        assertThat(
+                new Solution()
+                        .maxSatisfied(
+                                new int[] {1, 0, 1, 2, 1, 1, 7, 5},
+                                new int[] {0, 1, 0, 1, 0, 1, 0, 1},
+                                3),
+                equalTo(16));
+    }
+
+    @Test
+    void maxSatisfied2() {
+        assertThat(new Solution().maxSatisfied(new int[] {1}, new int[] {0}, 3), equalTo(1));
+    }
+}

src/test/java/g1001_1100/s1053_previous_permutation_with_one_swap/SolutionTest.java

@@ -0,0 +1,25 @@
+package g1001_1100.s1053_previous_permutation_with_one_swap;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void prevPermOpt1() {
+        assertThat(new Solution().prevPermOpt1(new int[] {3, 2, 1}), equalTo(new int[] {3, 1, 2}));
+    }
+
+    @Test
+    void prevPermOpt2() {
+        assertThat(new Solution().prevPermOpt1(new int[] {1, 1, 5}), equalTo(new int[] {1, 1, 5}));
+    }
+
+    @Test
+    void prevPermOpt3() {
+        assertThat(
+                new Solution().prevPermOpt1(new int[] {1, 9, 4, 6, 7}),
+                equalTo(new int[] {1, 7, 4, 6, 9}));
+    }
+}

src/test/java/g1001_1100/s1054_distant_barcodes/SolutionTest.java

@@ -0,0 +1,22 @@
+package g1001_1100.s1054_distant_barcodes;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void rearrangeBarcodes() {
+        assertThat(
+                new Solution().rearrangeBarcodes(new int[] {1, 1, 1, 2, 2, 2}),
+                equalTo(new int[] {1, 2, 1, 2, 1, 2}));
+    }
+
+    @Test
+    void rearrangeBarcodes2() {
+        assertThat(
+                new Solution().rearrangeBarcodes(new int[] {1, 1, 1, 1, 2, 2, 3, 3}),
+                equalTo(new int[] {1, 2, 1, 2, 1, 3, 1, 3}));
+    }
+}