Rearrange String K Distance Apart

Author: manastalukdar

.vscode/markdown.code-snippets

@@ -26,9 +26,17 @@
 			"",
 			"## Discussion",
 			"",
-			"### Time Complexity",
+			"### Approach",
 			"",
-			"### Space Complexity",
+			"#### Time Complexity",
+			"",
+			"#### Space Complexity",
+			"",
+			"### Alternate Approach 1",
+			"",
+			"#### Time Complexity - Alternate Approach 1",
+			"",
+			"#### Space Complexity - Alternate Approach 1",
 			"",
 			"## Notes",
 			"",

src/EducativeIo/Courses/GrokkingTheCodingInterview/Ch13_TopKElements/PC1_RearrangeStringKDistanceApart/Java/Solution.java

@@ -0,0 +1,51 @@
+package EducativeIo.Courses.GrokkingTheCodingInterview.Ch13_TopKElements.PC1_RearrangeStringKDistanceApart.Java;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+public class Solution {
+    public static void main(String[] args) {
+        System.out.println("Reorganized string: " + reorganizeString("mmpp", 2));
+        System.out.println("Reorganized string: " + reorganizeString("Programming", 3));
+        System.out.println("Reorganized string: " + reorganizeString("aab", 2));
+        System.out.println("Reorganized string: " + reorganizeString("aappa", 3));
+    }
+
+    public static String reorganizeString(String str, int k) {
+        if (k <= 1) {
+            return str;
+        }
+
+        Map<Character, Integer> charFrequencyMap = new HashMap<>();
+        for (char chr : str.toCharArray())
+            charFrequencyMap.put(chr, charFrequencyMap.getOrDefault(chr, 0) + 1);
+
+        PriorityQueue<Map.Entry<Character, Integer>> maxHeap =
+                new PriorityQueue<Map.Entry<Character, Integer>>(
+                        (e1, e2) -> e2.getValue() - e1.getValue());
+
+        // add all characters to the max heap
+        maxHeap.addAll(charFrequencyMap.entrySet());
+
+        Queue<Map.Entry<Character, Integer>> queue = new LinkedList<>();
+        StringBuilder resultString = new StringBuilder(str.length());
+        while (!maxHeap.isEmpty()) {
+            Map.Entry<Character, Integer> currentEntry = maxHeap.poll();
+            // append the current character to the result string and decrement its count
+            resultString.append(currentEntry.getKey());
+            currentEntry.setValue(currentEntry.getValue() - 1);
+            queue.offer(currentEntry);
+            if (queue.size() == k) {
+                Map.Entry<Character, Integer> entry = queue.poll();
+                if (entry.getValue() > 0)
+                    maxHeap.add(entry);
+            }
+        }
+
+        // if we were successful in appending all the characters to the result string, return it
+        return resultString.length() == str.length() ? resultString.toString() : "";
+    }
+}

src/EducativeIo/Courses/GrokkingTheCodingInterview/Ch13_TopKElements/PC1_RearrangeStringKDistanceApart/Java/SolutionTest.java

@@ -0,0 +1,75 @@
+package EducativeIo.Courses.GrokkingTheCodingInterview.Ch13_TopKElements.PC1_RearrangeStringKDistanceApart.Java;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.time.Duration;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+
+public class SolutionTest {
+
+    Solution solution;
+
+    @BeforeEach
+    public void setUp() throws Exception {
+        solution = new Solution();
+    }
+
+    @AfterEach
+    public void tearDown() throws Exception {
+        solution = null;
+    }
+
+    @Test
+    public void MainFunction() {
+        assertTimeout(Duration.ofMillis(500), () -> {
+            String[] args = new String[0];
+            assertAll(() -> Solution.main(args));
+        });
+    }
+
+    @Test
+    public void TrivialCase1() {
+        String str = "mmpp";
+        int k = 2;
+        assertTimeout(Duration.ofMillis(500), () -> {
+            String expected = "pmpm";
+            String actual = Solution.reorganizeString(str, k);
+            assertEquals(expected, actual);
+        });
+    }
+
+    @Test
+    public void TrivialCase2() {
+        String str = "Programming";
+        int k = 3;
+        assertTimeout(Duration.ofMillis(500), () -> {
+            String expected = "rgmPrgmiano";
+            String actual = Solution.reorganizeString(str, k);
+            assertEquals(expected, actual);
+        });
+    }
+
+    @Test
+    public void TrivialCase3() {
+        String str = "aab";
+        int k = 2;
+        assertTimeout(Duration.ofMillis(500), () -> {
+            String expected = "aba";
+            String actual = Solution.reorganizeString(str, k);
+            assertEquals(expected, actual);
+        });
+    }
+
+    @Test
+    public void TrivialCase4() {
+        String str = "aappa";
+        int k = 3;
+        assertTimeout(Duration.ofMillis(500), () -> {
+            String expected = "";
+            String actual = Solution.reorganizeString(str, k);
+            assertEquals(expected, actual);
+        });
+    }
+}

src/EducativeIo/Courses/GrokkingTheCodingInterview/Ch13_TopKElements/PC1_RearrangeStringKDistanceApart/metadata.json

@@ -0,0 +1,33 @@
+{
+    "type": "Coding",
+    "name": "Rearrange String K Distance Apart",
+    "origin": {
+        "name": "Educative",
+        "link": "https://www.educative.io/courses/grokking-the-coding-interview/m2E4y26k3LE"
+    },
+    "companies": ["", ""],
+    "categories": [{
+            "name": "Courses",
+            "children": [{
+                "name": "Grokking the Coding Interview: Patterns for Coding Questions",
+                "children": []
+            }]
+        },
+        {
+            "name": "Difficulty",
+            "children": [{
+                "name": "Hard",
+                "children": []
+            }]
+        },
+        {
+            "name": "Pattern",
+            "children": [{
+                "name": "Top K Elements",
+                "children": []
+            }]
+        }
+    ],
+    "tags": ["Top K Elements"],
+    "buckets": []
+}

src/EducativeIo/Courses/GrokkingTheCodingInterview/Ch13_TopKElements/PC1_RearrangeStringKDistanceApart/readme.md

@@ -0,0 +1,57 @@
+# Problem Definition
+
+## Description
+
+Given a string and a number ‘K’, find if the string can be rearranged such that the same characters are at least ‘K’ distance apart from each other.
+
+Example 1:
+
+```plaintext
+Input: "mmpp", K=2
+Output: "mpmp" or "pmpm"
+Explanation: All same characters are 2 distance apart.
+```
+
+Example 2:
+
+```plaintext
+Input: "Programming", K=3
+Output: "rgmPrgmiano" or "gmringmrPoa"
+Explanation: All same characters are 3 distance apart.
+```
+
+Example 3:
+
+```plaintext
+Input: "aab", K=2
+Output: "aba"
+Explanation: All same characters are 2 distance apart.
+```
+
+Example 4:
+
+```plaintext
+Input: "aappa", K=3
+Output: ""
+Explanation: We cannot find an arrangement of the string where any two 'a' are 3 distance apart.
+```
+
+## Discussion
+
+### Approach
+
+This problem follows the **Top ‘K’ Numbers** pattern and is quite similar to **Rearrange String**. The only difference is that in the ‘Rearrange String’ the same characters need not be adjacent i.e., they should be at least ‘2’ distance apart (in other words, there should be at least one character between two same characters), while in the current problem, the same characters should be ‘K’ distance apart.
+
+Following a similar approach, since we were inserting a character back in the heap in the next iteration, in this problem, we will re-insert the character after ‘K’ iterations. We can keep track of previous characters in a queue to insert them back in the heap after ‘K’ iterations.
+
+#### Time Complexity
+
+The time complexity of the above algorithm is O(N*logN) where ‘N’ is the number of characters in the input string.
+
+#### Space Complexity
+
+The space complexity will be O(N), as in the worst case, we need to store all the ‘N’ characters in the HashMap.
+
+## Notes
+
+## References