Added tasks 142-338

Author: javadev

README.md

@@ -77,7 +77,6 @@ def traverse(board, word, idx, i, j)
 
   board[i][j] = '#'
 
-  # res = false
   res = (traverse(board, word, idx + 1, i, j + 1) ||
       traverse(board, word, idx + 1, i, j - 1) ||
       traverse(board, word, idx + 1, i + 1, j) ||

src/main/ruby/g0001_0100/s0079_word_search/readme.md

@@ -0,0 +1,72 @@
+[![](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)
+
+## 141\. Linked List Cycle
+
+Easy
+
+Given `head`, the head of a linked list, determine if the linked list has a cycle in it.
+
+There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the `next` pointer. Internally, `pos` is used to denote the index of the node that tail's `next` pointer is connected to. **Note that `pos` is not passed as a parameter**.
+
+Return `true` _if there is a cycle in the linked list_. Otherwise, return `false`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist.png)
+
+**Input:** head = [3,2,0,-4], pos = 1
+
+**Output:** true
+
+**Explanation:** There is a cycle in the linked list, where the tail connects to the 1st node (0-indexed). 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test2.png)
+
+**Input:** head = [1,2], pos = 0
+
+**Output:** true
+
+**Explanation:** There is a cycle in the linked list, where the tail connects to the 0th node. 
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test3.png)
+
+**Input:** head = [1], pos = -1
+
+**Output:** false
+
+**Explanation:** There is no cycle in the linked list. 
+
+**Constraints:**
+
+*   The number of the nodes in the list is in the range <code>[0, 10<sup>4</sup>]</code>.
+*   <code>-10<sup>5</sup> <= Node.val <= 10<sup>5</sup></code>
+*   `pos` is `-1` or a **valid index** in the linked-list.
+
+**Follow up:** Can you solve it using `O(1)` (i.e. constant) memory?
+
+## Solution
+
+```ruby
+# @param {ListNode} head
+# @return {Boolean}
+def hasCycle(head)
+  return false if head.nil?
+
+  fast = head.next
+  slow = head
+
+  while fast && fast.next
+    return true if fast == slow
+
+    fast = fast.next.next
+    slow = slow.next
+  end
+
+  false
+end
+```

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

@@ -0,0 +1,90 @@
+[![](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)
+
+## 142\. Linked List Cycle II
+
+Medium
+
+Given the `head` of a linked list, return _the node where the cycle begins. If there is no cycle, return_ `null`.
+
+There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the `next` pointer. Internally, `pos` is used to denote the index of the node that tail's `next` pointer is connected to (**0-indexed**). It is `-1` if there is no cycle. **Note that** `pos` **is not passed as a parameter**.
+
+**Do not modify** the linked list.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist.png)
+
+**Input:** head = [3,2,0,-4], pos = 1
+
+**Output:** tail connects to node index 1
+
+**Explanation:** There is a cycle in the linked list, where tail connects to the second node. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test2.png)
+
+**Input:** head = [1,2], pos = 0
+
+**Output:** tail connects to node index 0
+
+**Explanation:** There is a cycle in the linked list, where tail connects to the first node. 
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist_test3.png)
+
+**Input:** head = [1], pos = -1
+
+**Output:** no cycle
+
+**Explanation:** There is no cycle in the linked list. 
+
+**Constraints:**
+
+*   The number of the nodes in the list is in the range <code>[0, 10<sup>4</sup>]</code>.
+*   <code>-10<sup>5</sup> <= Node.val <= 10<sup>5</sup></code>
+*   `pos` is `-1` or a **valid index** in the linked-list.
+
+**Follow up:** Can you solve it using `O(1)` (i.e. constant) memory?
+
+## Solution
+
+```ruby
+# Definition for singly-linked list.
+# class ListNode
+#     attr_accessor :val, :next
+#     def initialize(val)
+#         @val = val
+#         @next = nil
+#     end
+# end
+
+# @param {ListNode} head
+# @return {ListNode}
+def detectCycle(head)
+  return nil if head.nil? || head.next.nil?
+
+  slow = head
+  fast = head
+
+  while fast && fast.next
+    fast = fast.next.next
+    slow = slow.next
+
+    # Intersected inside the loop.
+    break if slow == fast
+  end
+
+  return nil if fast.nil? || fast.next.nil?
+
+  slow = head
+  while slow != fast
+    slow = slow.next
+    fast = fast.next
+  end
+
+  slow
+end
+```

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

@@ -0,0 +1,140 @@
+[![](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)
+
+## 146\. LRU Cache
+
+Medium
+
+Design a data structure that follows the constraints of a **[Least Recently Used (LRU) cache](https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU)**.
+
+Implement the `LRUCache` class:
+
+*   `LRUCache(int capacity)` Initialize the LRU cache with **positive** size `capacity`.
+*   `int get(int key)` Return the value of the `key` if the key exists, otherwise return `-1`.
+*   `void put(int key, int value)` Update the value of the `key` if the `key` exists. Otherwise, add the `key-value` pair to the cache. If the number of keys exceeds the `capacity` from this operation, **evict** the least recently used key.
+
+The functions `get` and `put` must each run in `O(1)` average time complexity.
+
+**Example 1:**
+
+**Input** ["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"] [[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
+
+**Output:** [null, null, null, 1, null, -1, null, -1, 3, 4]
+
+**Explanation:**
+
+    LRUCache lRUCache = new LRUCache(2);
+    lRUCache.put(1, 1); // cache is {1=1}
+    lRUCache.put(2, 2); // cache is {1=1, 2=2}
+    lRUCache.get(1); // return 1
+    lRUCache.put(3, 3); // LRU key was 2, evicts key 2, cache is {1=1, 3=3}
+    lRUCache.get(2); // returns -1 (not found)
+    lRUCache.put(4, 4); // LRU key was 1, evicts key 1, cache is {4=4, 3=3}
+    lRUCache.get(1); // return -1 (not found)
+    lRUCache.get(3); // return 3
+    lRUCache.get(4); // return 4 
+
+**Constraints:**
+
+*   `1 <= capacity <= 3000`
+*   <code>0 <= key <= 10<sup>4</sup></code>
+*   <code>0 <= value <= 10<sup>5</sup></code>
+*   At most 2<code> * 10<sup>5</sup></code> calls will be made to `get` and `put`.
+
+## Solution
+
+```ruby
+class LRUCache
+  class LruCacheNode
+    attr_accessor :key, :value, :prev, :next
+
+    def initialize(k, v)
+      @key = k
+      @value = v
+    end
+  end
+
+=begin
+    :type capacity: Integer
+=end
+  def initialize(cap)
+    @capacity = cap
+    @cache_map = {}
+    # insert here
+    @head = nil
+    # remove here
+    @tail = nil
+  end
+
+=begin
+    :type key: Integer
+    :rtype: Integer
+=end
+  def get(key)
+    val_node = @cache_map[key]
+    return -1 if val_node.nil?
+
+    move_to_head(val_node)
+    val_node.value
+  end
+
+=begin
+    :type key: Integer
+    :type value: Integer
+    :rtype: Void
+=end
+  def put(key, value)
+    val_node = @cache_map[key]
+
+    if val_node
+      val_node.value = value
+      move_to_head(val_node)
+    else
+      if @cache_map.size < @capacity
+        if @cache_map.empty?
+          node = LruCacheNode.new(key, value)
+          @cache_map[key] = node
+          @head = node
+          @tail = node
+        else
+          node = LruCacheNode.new(key, value)
+          @cache_map[key] = node
+          node.next = @head
+          @head.prev = node
+          @head = node
+        end
+      else
+        # remove from tail
+        last = @tail
+        @tail = last.prev
+        @tail.next = nil unless @tail.nil?
+        @cache_map.delete(last.key)
+        @head = nil if @cache_map.empty?
+        # Call recursively
+        put(key, value)
+      end
+    end
+  end
+
+  private
+
+  def move_to_head(node)
+    return if node == @head
+
+    @tail = node.prev if node == @tail
+    prev = node.prev
+    nex = node.next
+    prev.next = nex
+    nex.prev = prev unless nex.nil?
+    node.prev = nil
+    node.next = @head
+    @head.prev = node
+    @head = node
+  end
+end
+
+# Your LRUCache object will be instantiated and called as such:
+# obj = LRUCache.new(capacity)
+# param_1 = obj.get(key)
+# obj.put(key, value)
+```

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

@@ -0,0 +1,71 @@
+[![](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)
+
+## 148\. Sort List
+
+Medium
+
+Given the `head` of a linked list, return _the list after sorting it in **ascending order**_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/14/sort_list_1.jpg)
+
+**Input:** head = [4,2,1,3]
+
+**Output:** [1,2,3,4] 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/09/14/sort_list_2.jpg)
+
+**Input:** head = [-1,5,3,4,0]
+
+**Output:** [-1,0,3,4,5] 
+
+**Example 3:**
+
+**Input:** head = []
+
+**Output:** [] 
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range <code>[0, 5 * 10<sup>4</sup>]</code>.
+*   <code>-10<sup>5</sup> <= Node.val <= 10<sup>5</sup></code>
+
+**Follow up:** Can you sort the linked list in `O(n logn)` time and `O(1)` memory (i.e. constant space)?
+
+## Solution
+
+```ruby
+require_relative '../../com_github_leetcode/list_node'
+
+# Definition for singly-linked list.
+# class ListNode
+#     attr_accessor :val, :next
+#     def initialize(val = 0, _next = nil)
+#         @val = val
+#         @next = _next
+#     end
+# end
+# @param {ListNode} head
+# @return {ListNode}
+def sort_list(head)
+  list = []
+  new_head = ListNode.new
+
+  while head
+    list << head.val
+    head = head.next
+  end
+
+  curr = new_head
+  list.sort.each do |v|
+    curr.next = ListNode.new(v)
+    curr = curr.next
+  end
+
+  new_head.next
+end
+```