Added tasks 347-1143

Author: javadev

README.md

@@ -0,0 +1,110 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Ruby/LeetCode-in-Ruby?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Ruby/LeetCode-in-Ruby)
+[![](https://img.shields.io/github/forks/LeetCode-in-Ruby/LeetCode-in-Ruby?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Ruby/LeetCode-in-Ruby/fork)
+
+## 138\. Copy List with Random Pointer
+
+Medium
+
+A linked list of length `n` is given such that each node contains an additional random pointer, which could point to any node in the list, or `null`.
+
+Construct a [**deep copy**](https://en.wikipedia.org/wiki/Object_copying#Deep_copy) of the list. The deep copy should consist of exactly `n` **brand new** nodes, where each new node has its value set to the value of its corresponding original node. Both the `next` and `random` pointer of the new nodes should point to new nodes in the copied list such that the pointers in the original list and copied list represent the same list state. **None of the pointers in the new list should point to nodes in the original list**.
+
+For example, if there are two nodes `X` and `Y` in the original list, where `X.random --> Y`, then for the corresponding two nodes `x` and `y` in the copied list, `x.random --> y`.
+
+Return _the head of the copied linked list_.
+
+The linked list is represented in the input/output as a list of `n` nodes. Each node is represented as a pair of `[val, random_index]` where:
+
+*   `val`: an integer representing `Node.val`
+*   `random_index`: the index of the node (range from `0` to `n-1`) that the `random` pointer points to, or `null` if it does not point to any node.
+
+Your code will **only** be given the `head` of the original linked list.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2019/12/18/e1.png)
+
+**Input:** head = \[\[7,null],[13,0],[11,4],[10,2],[1,0]]
+
+**Output:** [[7,null],[13,0],[11,4],[10,2],[1,0]] 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2019/12/18/e2.png)
+
+**Input:** head = \[\[1,1],[2,1]]
+
+**Output:** [[1,1],[2,1]] 
+
+**Example 3:**
+
+**![](https://assets.leetcode.com/uploads/2019/12/18/e3.png)**
+
+**Input:** head = \[\[3,null],[3,0],[3,null]]
+
+**Output:** [[3,null],[3,0],[3,null]] 
+
+**Example 4:**
+
+**Input:** head = []
+
+**Output:** []
+
+**Explanation:** The given linked list is empty (null pointer), so return null. 
+
+**Constraints:**
+
+*   `0 <= n <= 1000`
+*   `-10000 <= Node.val <= 10000`
+*   `Node.random` is `null` or is pointing to some node in the linked list.
+
+## Solution
+
+```ruby
+require_relative '../../com_github_leetcode/random/node'
+
+# Definition for Node.
+# class Node
+#     attr_accessor :val, :next, :random
+#     def initialize(val = 0)
+#         @val = val
+#		  @next = nil
+#		  @random = nil
+#     end
+# end
+
+# @param {Node} node
+# @return {Node}
+def copy_random_list(head)
+  return nil if head.nil?
+
+  # First pass to create cloned nodes and insert them after the original nodes
+  curr = head
+  while curr
+    cloned_node = Node.new(curr.val)
+    cloned_node.next = curr.next
+    curr.next = cloned_node
+    curr = cloned_node.next
+  end
+
+  # Second pass to set the random pointers of the cloned nodes
+  curr = head
+  while curr
+    curr.next.random = curr.random.next if curr.random
+    curr = curr.next.next
+  end
+
+  # Third pass to separate the original and cloned nodes
+  curr = head
+  new_head = nil
+  while curr
+    cloned_node = curr.next
+    new_head ||= cloned_node
+    curr.next = cloned_node.next
+    cloned_node.next = curr.next.next if curr.next
+    curr = curr.next
+  end
+
+  new_head
+end
+```

src/main/ruby/g0101_0200/s0138_copy_list_with_random_pointer/readme.md

@@ -0,0 +1,60 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Ruby/LeetCode-in-Ruby?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Ruby/LeetCode-in-Ruby)
+[![](https://img.shields.io/github/forks/LeetCode-in-Ruby/LeetCode-in-Ruby?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Ruby/LeetCode-in-Ruby/fork)
+
+## 139\. Word Break
+
+Medium
+
+Given a string `s` and a dictionary of strings `wordDict`, return `true` if `s` can be segmented into a space-separated sequence of one or more dictionary words.
+
+**Note** that the same word in the dictionary may be reused multiple times in the segmentation.
+
+**Example 1:**
+
+**Input:** s = "leetcode", wordDict = ["leet","code"]
+
+**Output:** true
+
+**Explanation:** Return true because "leetcode" can be segmented as "leet code". 
+
+**Example 2:**
+
+**Input:** s = "applepenapple", wordDict = ["apple","pen"]
+
+**Output:** true
+
+**Explanation:** Return true because "applepenapple" can be segmented as "apple pen apple". Note that you are allowed to reuse a dictionary word. 
+
+**Example 3:**
+
+**Input:** s = "catsandog", wordDict = ["cats","dog","sand","and","cat"]
+
+**Output:** false 
+
+**Constraints:**
+
+*   `1 <= s.length <= 300`
+*   `1 <= wordDict.length <= 1000`
+*   `1 <= wordDict[i].length <= 20`
+*   `s` and `wordDict[i]` consist of only lowercase English letters.
+*   All the strings of `wordDict` are **unique**.
+
+## Solution
+
+```ruby
+# @param {String} s
+# @param {String[]} word_dict
+# @return {Boolean}
+def word_break(s, word_dict)
+  memo = Array.new(s.size - 1, nil)
+  dp = lambda do |i|
+    return true if i < 0
+    return memo[i] unless memo[i].nil?
+
+    memo[i] = word_dict.any? do |word|
+      s[i - word.size + 1..i] == word && dp[i - word.size]
+    end
+  end
+  dp[s.size - 1]
+end
+```

src/main/ruby/g0101_0200/s0139_word_break/readme.md

@@ -0,0 +1,46 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Ruby/LeetCode-in-Ruby?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Ruby/LeetCode-in-Ruby)
+[![](https://img.shields.io/github/forks/LeetCode-in-Ruby/LeetCode-in-Ruby?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Ruby/LeetCode-in-Ruby/fork)
+
+## 347\. Top K Frequent Elements
+
+Medium
+
+Given an integer array `nums` and an integer `k`, return _the_ `k` _most frequent elements_. You may return the answer in **any order**.
+
+**Example 1:**
+
+**Input:** nums = [1,1,1,2,2,3], k = 2
+
+**Output:** [1,2]
+
+**Example 2:**
+
+**Input:** nums = [1], k = 1
+
+**Output:** [1]
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   `k` is in the range `[1, the number of unique elements in the array]`.
+*   It is **guaranteed** that the answer is **unique**.
+
+**Follow up:** Your algorithm's time complexity must be better than `O(n log n)`, where n is the array's size.
+
+## Solution
+
+```ruby
+# @param {Integer[]} nums
+# @param {Integer} k
+# @return {Integer[]}
+def top_k_frequent(nums, k)
+  numhash = Hash.new(0)
+  nums.each {|num| numhash[num] += 1}
+  newhash = numhash.sort_by {|k, v| -v}
+  ret_array = []
+  for i in 0...k
+    ret_array << newhash[i][0]
+  end
+  return ret_array
+end
+```

src/main/ruby/g0301_0400/s0347_top_k_frequent_elements/readme.md

@@ -0,0 +1,91 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Ruby/LeetCode-in-Ruby?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Ruby/LeetCode-in-Ruby)
+[![](https://img.shields.io/github/forks/LeetCode-in-Ruby/LeetCode-in-Ruby?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Ruby/LeetCode-in-Ruby/fork)
+
+## 394\. Decode String
+
+Medium
+
+Given an encoded string, return its decoded string.
+
+The encoding rule is: `k[encoded_string]`, where the `encoded_string` inside the square brackets is being repeated exactly `k` times. Note that `k` is guaranteed to be a positive integer.
+
+You may assume that the input string is always valid; No extra white spaces, square brackets are well-formed, etc.
+
+Furthermore, you may assume that the original data does not contain any digits and that digits are only for those repeat numbers, `k`. For example, there won't be input like `3a` or `2[4]`.
+
+**Example 1:**
+
+**Input:** s = "3[a]2[bc]"
+
+**Output:** "aaabcbc" 
+
+**Example 2:**
+
+**Input:** s = "3[a2[c]]"
+
+**Output:** "accaccacc" 
+
+**Example 3:**
+
+**Input:** s = "2[abc]3[cd]ef"
+
+**Output:** "abcabccdcdcdef" 
+
+**Example 4:**
+
+**Input:** s = "abc3[cd]xyz"
+
+**Output:** "abccdcdcdxyz" 
+
+**Constraints:**
+
+*   `1 <= s.length <= 30`
+*   `s` consists of lowercase English letters, digits, and square brackets `'[]'`.
+*   `s` is guaranteed to be **a valid** input.
+*   All the integers in `s` are in the range `[1, 300]`.
+
+## Solution
+
+```ruby
+# @param {String} s
+# @return {String}
+def decode_string(s)
+  @i = 0
+  decode_helper(s)
+end
+
+private
+
+def decode_helper(s)
+  count = 0
+  result = ""
+
+  while @i < s.length
+    c = s[@i]
+    @i += 1
+
+    if letter?(c)
+      result += c
+    elsif digit?(c)
+      count = count * 10 + c.to_i
+    elsif c == ']'
+      break
+    elsif c == '['
+      # sub problem
+      repeat = decode_helper(s)
+      result += repeat * count
+      count = 0
+    end
+  end
+
+  result
+end
+
+def letter?(c)
+  c =~ /[a-zA-Z]/
+end
+
+def digit?(c)
+  c =~ /\d/
+end
+```

src/main/ruby/g0301_0400/s0394_decode_string/readme.md

@@ -0,0 +1,52 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Ruby/LeetCode-in-Ruby?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Ruby/LeetCode-in-Ruby)
+[![](https://img.shields.io/github/forks/LeetCode-in-Ruby/LeetCode-in-Ruby?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Ruby/LeetCode-in-Ruby/fork)
+
+## 416\. Partition Equal Subset Sum
+
+Medium
+
+Given a **non-empty** array `nums` containing **only positive integers**, find if the array can be partitioned into two subsets such that the sum of elements in both subsets is equal.
+
+**Example 1:**
+
+**Input:** nums = [1,5,11,5]
+
+**Output:** true
+
+**Explanation:** The array can be partitioned as [1, 5, 5] and [11]. 
+
+**Example 2:**
+
+**Input:** nums = [1,2,3,5]
+
+**Output:** false
+
+**Explanation:** The array cannot be partitioned into equal sum subsets. 
+
+**Constraints:**
+
+*   `1 <= nums.length <= 200`
+*   `1 <= nums[i] <= 100`
+
+## Solution
+
+```ruby
+# @param {Integer[]} nums
+# @return {Boolean}
+def can_partition(nums)
+  sums = nums.sum
+  return false if sums.odd?
+
+  sums /= 2
+  dp = Array.new(sums + 1, false)
+  dp[0] = true
+
+  nums.each do |num|
+    sums.downto(num) do |sum|
+      dp[sum] = dp[sum] || dp[sum - num]
+    end
+  end
+
+  dp[sums]
+end
+```