Added tasks 381, 382, 383, 384.

Author: ThanhNIT

README.md

@@ -1081,6 +1081,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.6'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0383 |[Ransom Note](src/main/kotlin/g0301_0400/s0383_ransom_note/Solution.kt)| Easy | String, Hash_Table, Counting | 333 | 79.58
 | 0242 |[Valid Anagram](src.save/main/kotlin/g0201_0300/s0242_valid_anagram/Solution.kt)| Easy | Top_Interview_Questions, String, Hash_Table, Sorting | 251 | 87.65
 
 #### Day 7 Linked List
@@ -1512,6 +1513,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.6'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0384 |[Shuffle an Array](src/main/kotlin/g0301_0400/s0384_shuffle_an_array/Solution.kt)| Medium | Top_Interview_Questions, Array, Math, Randomized | 940 | 72.09
 
 #### Day 21 Others
 
@@ -1610,6 +1612,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.6'
 | 0437 |[Path Sum III](src/main/kotlin/g0401_0500/s0437_path_sum_iii/Solution.kt)| Medium | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Level_2_Day_7_Tree | 403 | 54.12
 | 0416 |[Partition Equal Subset Sum](src/main/kotlin/g0401_0500/s0416_partition_equal_subset_sum/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Level_2_Day_13_Dynamic_Programming | 509 | 57.56
 | 0394 |[Decode String](src/main/kotlin/g0301_0400/s0394_decode_string/Solution.kt)| Medium | Top_100_Liked_Questions, String, Stack, Recursion, Level_1_Day_14_Stack, Udemy_Strings | 224 | 64.86
+| 0384 |[Shuffle an Array](src/main/kotlin/g0301_0400/s0384_shuffle_an_array/Solution.kt)| Medium | Top_Interview_Questions, Array, Math, Randomized, Algorithm_II_Day_20_Others | 940 | 72.09
+| 0383 |[Ransom Note](src/main/kotlin/g0301_0400/s0383_ransom_note/Solution.kt)| Easy | String, Hash_Table, Counting, Data_Structure_I_Day_6_String | 333 | 79.58
+| 0382 |[Linked List Random Node](src/main/kotlin/g0301_0400/s0382_linked_list_random_node/Solution.kt)| Medium | Math, Linked_List, Randomized, Reservoir_Sampling | 283 | 100.00
+| 0381 |[Insert Delete GetRandom O(1) - Duplicates allowed](src/main/kotlin/g0301_0400/s0381_insert_delete_getrandom_o1_duplicates_allowed/RandomizedCollection.kt)| Hard | Array, Hash_Table, Math, Design, Randomized | 1313 | 50.00
 | 0380 |[Insert Delete GetRandom O(1)](src/main/kotlin/g0301_0400/s0380_insert_delete_getrandom_o1/RandomizedSet.kt)| Medium | Top_Interview_Questions, Array, Hash_Table, Math, Design, Randomized, Programming_Skills_II_Day_20 | 1326 | 68.23
 | 0378 |[Kth Smallest Element in a Sorted Matrix](src/main/kotlin/g0301_0400/s0378_kth_smallest_element_in_a_sorted_matrix/Solution.kt)| Medium | Top_Interview_Questions, Array, Sorting, Binary_Search, Matrix, Heap_Priority_Queue | 522 | 59.78
 | 0377 |[Combination Sum IV](src/main/kotlin/g0301_0400/s0377_combination_sum_iv/Solution.kt)| Medium | Array, Dynamic_Programming, Dynamic_Programming_I_Day_21 | 217 | 72.41

src/main/kotlin/g0301_0400/s0381_insert_delete_getrandom_o1_duplicates_allowed/RandomizedCollection.kt

@@ -0,0 +1,57 @@
+package g0301_0400.s0381_insert_delete_getrandom_o1_duplicates_allowed
+
+// #Hard #Array #Hash_Table #Math #Design #Randomized
+// #2022_11_24_Time_1313_ms_(50.00%)_Space_148_MB_(25.00%)
+
+@Suppress("kotlin:S2245")
+class RandomizedCollection() {
+    val m2a = HashMap<Int, HashSet<Int>>()
+    val a2m = ArrayList<Int>()
+    /** Initialize your data structure here. */
+
+    /** Inserts a value to the collection. Returns true if the collection did not already contain the specified element. */
+    fun insert(x: Int): Boolean {
+        a2m.add(x)
+        val pos = a2m.size - 1
+        if (x in m2a) {
+            m2a[x]!!.add(pos)
+            return false
+        } else {
+            m2a[x] = HashSet<Int>()
+            m2a[x]!!.add(pos)
+            return true
+        }
+    }
+
+    /** Removes a value from the collection. Returns true if the collection contained the specified element. */
+    fun remove(x: Int): Boolean {
+        if (x !in m2a)
+            return false
+        val pos = m2a[x]!!.iterator().next()
+        if (m2a[x]!!.size == 1)
+            m2a.remove(x)
+        else
+            m2a[x]!!.remove(pos)
+        if (pos != a2m.size - 1) {
+            m2a[a2m[a2m.size - 1]]!!.remove(a2m.size - 1)
+            m2a[a2m[a2m.size - 1]]!!.add(pos)
+            a2m[pos] = a2m[a2m.size - 1]
+        }
+        a2m.removeAt(a2m.size - 1)
+        return true
+    }
+
+    /** Get a random element from the collection. */
+    fun getRandom(): Int {
+        val pos = Math.floor(Math.random() * a2m.size).toInt()
+        return a2m[pos]
+    }
+}
+
+/*
+ * Your RandomizedCollection object will be instantiated and called as such:
+ * var obj = RandomizedCollection()
+ * var param_1 = obj.insert(`val`)
+ * var param_2 = obj.remove(`val`)
+ * var param_3 = obj.getRandom()
+ */

src/main/kotlin/g0301_0400/s0381_insert_delete_getrandom_o1_duplicates_allowed/readme.md

@@ -0,0 +1,47 @@
+381\. Insert Delete GetRandom O(1) - Duplicates allowed
+
+Hard
+
+`RandomizedCollection` is a data structure that contains a collection of numbers, possibly duplicates (i.e., a multiset). It should support inserting and removing specific elements and also removing a random element.
+
+Implement the `RandomizedCollection` class:
+
+*   `RandomizedCollection()` Initializes the empty `RandomizedCollection` object.
+*   `bool insert(int val)` Inserts an item `val` into the multiset, even if the item is already present. Returns `true` if the item is not present, `false` otherwise.
+*   `bool remove(int val)` Removes an item `val` from the multiset if present. Returns `true` if the item is present, `false` otherwise. Note that if `val` has multiple occurrences in the multiset, we only remove one of them.
+*   `int getRandom()` Returns a random element from the current multiset of elements. The probability of each element being returned is **linearly related** to the number of same values the multiset contains.
+
+You must implement the functions of the class such that each function works on **average** `O(1)` time complexity.
+
+**Note:** The test cases are generated such that `getRandom` will only be called if there is **at least one** item in the `RandomizedCollection`.
+
+**Example 1:**
+
+**Input**
+
+    ["RandomizedCollection", "insert", "insert", "insert", "getRandom", "remove", "getRandom"]
+    [[], [1], [1], [2], [], [1], []]
+
+**Output:** [null, true, false, true, 2, true, 1]
+
+**Explanation:**
+
+    RandomizedCollection randomizedCollection = new RandomizedCollection(); 
+    randomizedCollection.insert(1);     // return true since the collection does not contain 1. 
+                                        // Inserts 1 into the collection. 
+    randomizedCollection.insert(1);     // return false since the collection contains 1. 
+                                        // Inserts another 1 into the collection. Collection now contains [1,1]. 
+    randomizedCollection.insert(2);     // return true since the collection does not contain 2. 
+                                        // Inserts 2 into the collection. Collection now contains [1,1,2]. 
+    randomizedCollection.getRandom();   // getRandom should: 
+                                        // - return 1 with probability 2/3, or 
+                                        // - return 2 with probability 1/3. 
+    randomizedCollection.remove(1);     // return true since the collection contains 1. 
+                                        // Removes 1 from the collection. Collection now contains [1,2]. 
+    randomizedCollection.getRandom();   // getRandom should return 1 or 2, both equally likely.
+
+**Constraints:**
+
+*   <code>-2<sup>31</sup> <= val <= 2<sup>31</sup> - 1</code>
+*   At most <code>2 * 10<sup>5</sup></code> calls **in total** will be made to `insert`, `remove`, and `getRandom`.
+*   There will be **at least one** element in the data structure when `getRandom` is called.

src/main/kotlin/g0301_0400/s0382_linked_list_random_node/Solution.kt

@@ -0,0 +1,49 @@
+package g0301_0400.s0382_linked_list_random_node
+
+// #Medium #Math #Linked_List #Randomized #Reservoir_Sampling
+// #2022_11_24_Time_283_ms_(100.00%)_Space_38.6_MB_(100.00%)
+
+import com_github_leetcode.ListNode
+import java.util.Random
+
+/*
+ * Example:
+ * var li = ListNode(5)
+ * var v = li.`val`
+ * Definition for singly-linked list.
+ * class ListNode(var `val`: Int) {
+ *     var next: ListNode? = null
+ * }
+ */
+@Suppress("kotlin:S2245")
+class Solution(head: ListNode?) {
+    private val al: MutableList<Int>
+    private val rand: Random
+
+    init {
+        var head = head
+        al = ArrayList()
+        rand = Random()
+        while (head != null) {
+            al.add(head.`val`)
+            head = head.next
+        }
+    }
+
+    fun getRandom(): Int {
+        /*
+        Math.random() will generate a random number b/w 0 & 1.
+        then multiply it with the array size.
+        take only the integer part which is a random index.
+        return the element at that random index.
+         */
+        val ind = rand.nextInt(al.size)
+        return al[ind]
+    }
+}
+
+/*
+ * Your Solution object will be instantiated and called as such:
+ * var obj = Solution(head)
+ * var param_1 = obj.getRandom()
+ */

src/main/kotlin/g0301_0400/s0382_linked_list_random_node/readme.md

@@ -0,0 +1,44 @@
+382\. Linked List Random Node
+
+Medium
+
+Given a singly linked list, return a random node's value from the linked list. Each node must have the **same probability** of being chosen.
+
+Implement the `Solution` class:
+
+*   `Solution(ListNode head)` Initializes the object with the integer array nums.
+*   `int getRandom()` Chooses a node randomly from the list and returns its value. All the nodes of the list should be equally likely to be choosen.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/03/16/getrand-linked-list.jpg)
+
+**Input**
+
+    ["Solution", "getRandom", "getRandom", "getRandom", "getRandom", "getRandom"] 
+    [[[1, 2, 3]], [], [], [], [], []]
+
+**Output:**
+
+    [null, 1, 3, 2, 2, 3]
+
+**Explanation:**
+
+    Solution solution = new Solution([1, 2, 3]); 
+    solution.getRandom(); // return 1 
+    solution.getRandom(); // return 3 
+    solution.getRandom(); // return 2 
+    solution.getRandom(); // return 2 
+    solution.getRandom(); // return 3 
+    // getRandom() should return either 1, 2, or 3 randomly. Each element should have equal probability of returning.
+
+**Constraints:**
+
+*   The number of nodes in the linked list will be in the range <code>[1, 10<sup>4</sup>]</code>.
+*   <code>-10<sup>4</sup> <= Node.val <= 10<sup>4</sup></code>
+*   At most <code>10<sup>4</sup></code> calls will be made to `getRandom`.
+
+**Follow up:**
+
+*   What if the linked list is extremely large and its length is unknown to you?
+*   Could you solve this efficiently without using extra space?

src/main/kotlin/g0301_0400/s0383_ransom_note/Solution.kt

@@ -0,0 +1,23 @@
+package g0301_0400.s0383_ransom_note
+
+// #Easy #String #Hash_Table #Counting #Data_Structure_I_Day_6_String
+// #2022_11_24_Time_333_ms_(79.58%)_Space_45.2_MB_(75.39%)
+
+class Solution {
+    fun canConstruct(ransomNote: String, magazine: String): Boolean {
+        val a = IntArray(26)
+        var n = ransomNote.length
+        for (i in 0 until n) {
+            a[ransomNote[i].code - 97]++
+        }
+        var i = 0
+        while (i < magazine.length && n != 0) {
+            if (a[magazine[i].code - 97] > 0) {
+                n--
+                a[magazine[i].code - 97]--
+            }
+            i++
+        }
+        return n == 0
+    }
+}

src/main/kotlin/g0301_0400/s0383_ransom_note/readme.md

@@ -0,0 +1,30 @@
+383\. Ransom Note
+
+Easy
+
+Given two strings `ransomNote` and `magazine`, return `true` _if_ `ransomNote` _can be constructed by using the letters from_ `magazine` _and_ `false` _otherwise_.
+
+Each letter in `magazine` can only be used once in `ransomNote`.
+
+**Example 1:**
+
+**Input:** ransomNote = "a", magazine = "b"
+
+**Output:** false
+
+**Example 2:**
+
+**Input:** ransomNote = "aa", magazine = "ab"
+
+**Output:** false
+
+**Example 3:**
+
+**Input:** ransomNote = "aa", magazine = "aab"
+
+**Output:** true
+
+**Constraints:**
+
+*   <code>1 <= ransomNote.length, magazine.length <= 10<sup>5</sup></code>
+*   `ransomNote` and `magazine` consist of lowercase English letters.

src/main/kotlin/g0301_0400/s0384_shuffle_an_array/Solution.kt

@@ -0,0 +1,39 @@
+package g0301_0400.s0384_shuffle_an_array
+
+// #Medium #Top_Interview_Questions #Array #Math #Randomized #Algorithm_II_Day_20_Others
+// #2022_11_24_Time_940_ms_(72.09%)_Space_81.5_MB_(51.16%)
+
+import java.util.Random
+
+@Suppress("kotlin:S2245")
+class Solution(private val nums: IntArray) {
+    private val random: Random = Random()
+
+    // Resets the array to its original configuration and return it.
+    fun reset(): IntArray {
+        return nums
+    }
+
+    // Returns a random shuffling of the array.
+    fun shuffle(): IntArray {
+        val shuffled = nums.clone()
+        for (i in nums.size - 1 downTo 1) {
+            val j: Int = random.nextInt(i + 1)
+            swap(shuffled, i, j)
+        }
+        return shuffled
+    }
+
+    private fun swap(shuffled: IntArray, i: Int, j: Int) {
+        val tmp = shuffled[i]
+        shuffled[i] = shuffled[j]
+        shuffled[j] = tmp
+    }
+}
+
+/*
+ * Your Solution object will be instantiated and called as such:
+ * var obj = Solution(nums)
+ * var param_1 = obj.reset()
+ * var param_2 = obj.shuffle()
+ */

src/main/kotlin/g0301_0400/s0384_shuffle_an_array/readme.md

@@ -0,0 +1,26 @@
+384\. Shuffle an Array
+
+Medium
+
+Given an integer array `nums`, design an algorithm to randomly shuffle the array. All permutations of the array should be **equally likely** as a result of the shuffling.
+
+Implement the `Solution` class:
+
+*   `Solution(int[] nums)` Initializes the object with the integer array `nums`.
+*   `int[] reset()` Resets the array to its original configuration and returns it.
+*   `int[] shuffle()` Returns a random shuffling of the array.
+
+**Example 1:**
+
+**Input** ["Solution", "shuffle", "reset", "shuffle"] [[[1, 2, 3]], [], [], []]
+
+**Output:** [null, [3, 1, 2], [1, 2, 3], [1, 3, 2]]
+
+**Explanation:** Solution solution = new Solution([1, 2, 3]); solution.shuffle(); // Shuffle the array [1,2,3] and return its result. // Any permutation of [1,2,3] must be equally likely to be returned. // Example: return [3, 1, 2] solution.reset(); // Resets the array back to its original configuration [1,2,3]. Return [1, 2, 3] solution.shuffle(); // Returns the random shuffling of array [1,2,3]. Example: return [1, 3, 2]
+
+**Constraints:**
+
+*   `1 <= nums.length <= 50`
+*   <code>-10<sup>6</sup> <= nums[i] <= 10<sup>6</sup></code>
+*   All the elements of `nums` are **unique**.
+*   At most <code>10<sup>4</sup></code> calls **in total** will be made to `reset` and `shuffle`.

src/test/kotlin/g0301_0400/s0381_insert_delete_getrandom_o1_duplicates_allowed/RandomizedCollectionTest.kt

@@ -0,0 +1,36 @@
+package g0301_0400.s0381_insert_delete_getrandom_o1_duplicates_allowed
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+import java.util.Arrays
+
+internal class RandomizedCollectionTest {
+    @Test
+    fun randomizedCollectionTest() {
+        val result: MutableList<String> = ArrayList()
+        var randomizedCollection: RandomizedCollection? = null
+        result.add(randomizedCollection.toString() + "")
+        randomizedCollection = RandomizedCollection()
+        result.add(randomizedCollection.insert(1).toString() + "")
+        result.add(randomizedCollection.insert(1).toString() + "")
+        result.add(randomizedCollection.insert(2).toString() + "")
+        val random = randomizedCollection.getRandom()
+        result.add(random.toString() + "")
+        result.add(randomizedCollection.remove(1).toString() + "")
+        val random2 = randomizedCollection.getRandom()
+        result.add(random2.toString() + "")
+        val expected: List<String> = ArrayList(
+            Arrays.asList(
+                "null",
+                "true",
+                "false",
+                "true",
+                random.toString() + "",
+                "true",
+                random2.toString() + ""
+            )
+        )
+        assertThat(result, equalTo(expected))
+    }
+}