Linked List(61, 86, 146)

Author: remy727

README.md

@@ -45,6 +45,7 @@
 | 55 | Jump Game | [Ruby](./algorithms/ruby/0055-jump-game.rb) | Medium |
 | 58 | Length of Last Word | [Ruby](./algorithms/ruby/0058-length-of-last-word.rb) | Easy |
 | 59 | Spiral Matrix II | [Ruby](./algorithms/ruby/0059-spiral-matrix-ii.rb) | Medium |
+| 61 | Rotate List | [Ruby](./algorithms/ruby/0061-rotate-list.rb) | Medium |
 | 62 | Unique Paths | [Ruby](./algorithms/ruby/0062-unique-paths.rb) | Medium |
 | 63 | Unique Paths II | [Ruby](./algorithms/ruby/0063-unique-paths-ii.rb) | Medium |
 | 64 | Minimum Path Sum | [Ruby](./algorithms/ruby/0064-minimum-path-sum.rb) | Medium |
@@ -60,6 +61,7 @@
 | 76 | Minimum Window Substring | [Ruby](./algorithms/ruby/0076-minimum-window-substring.rb) | Hard |
 | 80 | Remove Duplicates from Sorted Array II | [Ruby](./algorithms/ruby/0080-remove-duplicates-from-sorted-array-ii.rb) | Medium |
 | 82 | Remove Duplicates from Sorted List II | [Ruby](./algorithms/ruby/0082-remove-duplicates-from-sorted-list-ii.rb) | Medium |
+| 86 | Partition List | [Ruby](./algorithms/ruby/0086-partition-list.rb) | Medium |
 | 87 | Scramble String | [Ruby](./algorithms/ruby/0087-scramble-string.rb) | Hard |
 | 88 | Merge Sorted Array | [Ruby](./algorithms/ruby/0088-merge-sorted-array.rb) | Easy |
 | 91 | Decode Ways | [Ruby](./algorithms/ruby/0091-decode-ways.rb) | Medium |
@@ -92,6 +94,7 @@
 | 139 | Word Break | [Ruby](./algorithms/ruby/0139-word-break.rb) | Medium |
 | 141 | Linked List Cycle | [Ruby](./algorithms/ruby/0141-linked-list-cycle.rb) | Easy |
 | 142 | Linked List Cycle II | [Ruby](./algorithms/ruby/0142-linked-list-cycle-ii.rb) | Medium |
+| 146 | LRU Cache | [Ruby](./algorithms/ruby/0146-lru-cache.rb) | Medium |
 | 148 | Sort List | [Ruby](./algorithms/ruby/0148-sort-list.rb) | Medium |
 | 149 | Max Points on a Line | [Ruby](./algorithms/ruby/0149-max-points-on-a-line.rb) | Hard |
 | 150 | Evaluate Reverse Polish Notation | [Ruby](./algorithms/ruby/0150-evaluate-reverse-polish-notation.rb) | Medium |

algorithms/ruby/0061-rotate-list.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# 61. Rotate List
+# https://leetcode.com/problems/rotate-list
+# Medium
+
+=begin
+Given the head of a linked list, rotate the list to the right by k places.
+
+Example 1:
+Input: head = [1,2,3,4,5], k = 2
+Output: [4,5,1,2,3]
+
+Example 2:
+Input: head = [0,1,2], k = 4
+Output: [2,0,1]
+
+Constraints:
+* The number of nodes in the list is in the range [0, 500].
+* -100 <= Node.val <= 100
+* 0 <= k <= 2 * 109
+=end
+
+# 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
+# @param {Integer} k
+# @return {ListNode}
+def rotate_right(head, k)
+  return head if head.nil? || head.next.nil? || k == 0
+
+  # Calculate the length of the linked list
+  length = 1
+  old_tail = head
+  while old_tail.next
+    old_tail = old_tail.next
+    length += 1
+  end
+
+  # Update k to be the effective number of rotations needed
+  k %= length
+  return head if k == 0
+
+  # Find the new tail node (length - k - 1) and the new head node (length - k)
+  new_tail = head
+  (length - k - 1).times { new_tail = new_tail.next }
+  new_head = new_tail.next
+
+  # Update the next pointers of the new tail and the old tail
+  new_tail.next = nil
+  old_tail.next = head
+
+  new_head
+end

algorithms/ruby/0086-partition-list.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# 86. Partition List
+# https://leetcode.com/problems/partition-list
+# Medium
+
+=begin
+Given the head of a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.
+
+You should preserve the original relative order of the nodes in each of the two partitions.
+
+Example 1:
+Input: head = [1,4,3,2,5,2], x = 3
+Output: [1,2,2,4,3,5]
+
+Example 2:
+Input: head = [2,1], x = 2
+Output: [1,2]
+
+Constraints:
+* The number of nodes in the list is in the range [0, 200].
+* -100 <= Node.val <= 100
+* -200 <= x <= 200
+=end
+
+# 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
+# @param {Integer} x
+# @return {ListNode}
+def partition(head, x)
+  # Create dummy nodes for before and after lists
+  before = ListNode.new(0)
+  after = ListNode.new(0)
+
+  # Initialize pointers for before and after lists
+  before_ptr = before
+  after_ptr = after
+
+  # Iterate through the linked list
+  while head
+    if head.val < x
+      # Append the node to the before list
+      before_ptr.next = head
+      before_ptr = before_ptr.next
+    else
+      # Append the node to the after list
+      after_ptr.next = head
+      after_ptr = after_ptr.next
+    end
+
+    # Move to the next node in the original list
+    head = head.next
+  end
+
+  # Connect the before list with the after list
+  before_ptr.next = after.next
+
+  # Set the last node of the after list to nil
+  after_ptr.next = nil
+
+  # Return the new head of the partitioned list
+  before.next
+end

algorithms/ruby/0146-lru-cache.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# 146. LRU Cache
+# https://leetcode.com/problems/lru-cache
+# Medium
+
+=begin
+Design a data structure that follows the constraints of a Least Recently Used (LRU) cache.
+
+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
+0 <= key <= 104
+0 <= value <= 105
+At most 2 * 105 calls will be made to get and put.
+=end
+
+class LRUCache
+  # Initialize your data structure here
+  # @param {Integer} capacity
+  def initialize(capacity)
+    @capacity = capacity
+    @elems = {}
+  end
+
+  # @param {Integer} key
+  # @return {Integer}
+  def get(key)
+    val = @elems.delete key
+    if val
+      @elems[key] = val
+    else
+      -1
+    end
+  end
+
+  # @param {Integer} key
+  # @param {Integer} value
+  # @return {Void}
+  def put(key, value)
+    @elems.delete key
+    @elems[key] = value
+    @elems.delete @elems.first.first if @elems.size > @capacity
+  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)