add 3237

Author: fishercoder1534

Diff for: paginated_contents/algorithms/4th_thousand/README.md

@@ -1,5 +1,6 @@
 | #    | Title                                                                                                                                                               | Solutions                                                                                                                         | Video                                                                         | Difficulty | Tag                                                                  
 |------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------|------------|----------------------------------------------------------------------
+| 3237 | [Alt and Tab Simulation](https://leetcode.com/problems/alt-and-tab-simulation/)                                                                 | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/fourththousand/_3237.java) |                                                                               | Medium     | 
 | 3234 | [Count the Number of Substrings With Dominant Ones](https://leetcode.com/problems/count-the-number-of-substrings-with-dominant-ones/)                                                                 | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/fourththousand/_3234.java) |                                                                               | Medium     | Sliding Window
 | 3233 | [Find the Count of Numbers Which Are Not Special](https://leetcode.com/problems/find-the-count-of-numbers-which-are-not-special/)                                                                 | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/fourththousand/_3233.java) |                                                                               | Medium     | Math
 | 3232 | [Find if Digit Game Can Be Won](https://leetcode.com/problems/find-if-digit-game-can-be-won/)                                                                 | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/fourththousand/_3232.java) |                                                                               | Easy       |

Diff for: src/main/java/com/fishercoder/solutions/fourththousand/_3237.java

@@ -0,0 +1,74 @@
+package com.fishercoder.solutions.fourththousand;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class _3237 {
+    public static class Solution1 {
+        /**
+         * My completely original solution, very natural to think of doubly linked list + hashmap.
+         */
+        public int[] simulationResult(int[] windows, int[] queries) {
+            Map<Integer, DoublyLinkedListNode> map = new HashMap<>();
+            DoublyLinkedListNode pre = buildList(windows, map);
+            for (int q : queries) {
+                moveToHead(q, pre, map);
+            }
+            return backToArray(pre, windows.length);
+        }
+
+        private int[] backToArray(DoublyLinkedListNode pre, int length) {
+            DoublyLinkedListNode tmp = pre;
+            int[] ans = new int[length];
+            for (int i = 0; i < length; i++) {
+                ans[i] = tmp.next.val;
+                tmp = tmp.next;
+            }
+            return ans;
+        }
+
+        private void moveToHead(int q, DoublyLinkedListNode headPrev, Map<Integer, DoublyLinkedListNode> map) {
+            DoublyLinkedListNode node = map.get(q);
+            //if this window is already at the head, then we don't need to do anything
+            if (headPrev.next == node) {
+                return;
+            }
+            //get this node's next and prev pointers
+            DoublyLinkedListNode next = node.next;
+            DoublyLinkedListNode prev = node.prev;
+            //connect it's next to its previous' next, essentially cutting the current node out of the chain
+            prev.next = next;
+            //in case this is tail, we don't need to re-assign its next pointer
+            if (next != null) {
+                next.prev = prev;
+            }
+            DoublyLinkedListNode oldHead = headPrev.next;
+            headPrev.next = node;
+            node.next = oldHead;
+            oldHead.prev = node;
+        }
+
+        private DoublyLinkedListNode buildList(int[] windows, Map<Integer, DoublyLinkedListNode> map) {
+            DoublyLinkedListNode pre = new DoublyLinkedListNode(-1);
+            DoublyLinkedListNode tmp = pre;
+            for (int i = 0; i < windows.length; i++) {
+                DoublyLinkedListNode next = new DoublyLinkedListNode(windows[i]);
+                next.prev = tmp;
+                tmp.next = next;
+                map.put(windows[i], next);
+                tmp = tmp.next;
+            }
+            return pre;
+        }
+
+        public static class DoublyLinkedListNode {
+            DoublyLinkedListNode prev;
+            DoublyLinkedListNode next;
+            int val;
+
+            public DoublyLinkedListNode(int val) {
+                this.val = val;
+            }
+        }
+    }
+}

Diff for: src/test/java/com/fishercoder/fourththousand/_3237Test.java

@@ -0,0 +1,26 @@
+package com.fishercoder.fourththousand;
+
+import com.fishercoder.solutions.fourththousand._3237;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+public class _3237Test {
+    private static _3237.Solution1 solution1;
+
+    @BeforeEach
+    public void setup() {
+        solution1 = new _3237.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        assertArrayEquals(new int[]{2, 3, 1}, solution1.simulationResult(new int[]{1, 2, 3}, new int[]{3, 3, 2}));
+    }
+
+    @Test
+    public void test2() {
+        assertArrayEquals(new int[]{3, 1, 4, 2}, solution1.simulationResult(new int[]{1, 4, 2, 3}, new int[]{4, 1, 3}));
+    }
+}