feat: add solutions for a week

Author: remy727

README.md

@@ -283,6 +283,7 @@
 | 847 | Shortest Path Visiting All Nodes | [Ruby](./algorithms/ruby/0847-shortest-path-visiting-all-nodes.rb) | Hard |
 | 852 | Peak Index in a Mountain Array | [Ruby](./algorithms/ruby/0852-peak-index-in-a-mountain-array.rb) | Medium |
 | 859 | Buddy Strings | [Ruby](./algorithms/ruby/0859-buddy-strings.rb) | Easy |
+| 862 | Shortest Subarray with Sum at Least K | [Ruby](./algorithms/ruby/0862-shortest-subarray-with-sum-at-least-k.rb) | Hard |
 | 863 | All Nodes Distance K in Binary Tree | [Ruby](./algorithms/ruby/0863-all-nodes-distance-k-in-binary-tree.rb) | Medium |
 | 864 | Backspace String Compare | [Ruby](./algorithms/ruby/0864-shortest-path-to-get-all-keys.rb) | Hard |
 | 867 | Transpose Matrix | [Ruby](./algorithms/ruby/0867-transpose-matrix.rb) | Easy |
@@ -400,6 +401,7 @@
 | 1561 | Maximum Number of Coins You Can Get | [Ruby](./algorithms/ruby/1561-maximum-number-of-coins-you-can-get.rb) | Medium |
 | 1569 | Number of Ways to Reorder Array to Get Same BST | [Ruby](./algorithms/ruby/1569-number-of-ways-to-reorder-array-to-get-same-bst.rb) | Hard |
 | 1572 | Matrix Diagonal Sum | [Ruby](./algorithms/ruby/1572-matrix-diagonal-sum.rb) | Easy |
+| 1574 | Shortest Subarray to be Removed to Make Array Sorted | [Ruby](./algorithms/ruby/1574-shortest-subarray-to-be-removed-to-make-array-sorted.rb) | Medium |
 | 1575 | Count All Possible Routes | [Ruby](./algorithms/ruby/1575-count-all-possible-routes.rb) | Hard |
 | 1579 | Remove Max Number of Edges to Keep Graph Fully Traversable | [Ruby](./algorithms/ruby/1579-remove-max-number-of-edges-to-keep-graph-fully-traversable.rb) | Hard |
 | 1584 | Min Cost to Connect All Points | [Ruby](./algorithms/ruby/1584-min-cost-to-connect-all-points.rb) | Medium |
@@ -456,6 +458,8 @@
 | 2024 | Maximize the Confusion of an Exam | [Ruby](./algorithms/ruby/2024-maximize-the-confusion-of-an-exam.rb) | Medium |
 | 2044 | Count Number of Maximum Bitwise-OR Subsets | [Ruby](./algorithms/ruby/2044-count-number-of-maximum-bitwise-or-subsets.rb) | Medium |
 | 2050 | Parallel Courses III | [Ruby](./algorithms/ruby/2050-parallel-courses-iii.rb) | Hard |
+| 2064 | Minimized Maximum of Products Distributed to Any Store | [Ruby](./algorithms/ruby/2064-minimized-maximum-of-products-distributed-to-any-store.rb) | Medium |
+| 2070 | Most Beautiful Item for Each Query | [Ruby](./algorithms/ruby/2070-most-beautiful-item-for-each-query.rb) | Medium |
 | 2090 | K Radius Subarray Averages | [Ruby](./algorithms/ruby/2090-k-radius-subarray-averages.rb) | Medium |
 | 2095 | Delete the Middle Node of a Linked List | [Ruby](./algorithms/ruby/2095-delete-the-middle-node-of-a-linked-list.rb) | Medium |
 | 2101 | Detonate the Maximum Bombs | [Ruby](./algorithms/ruby/2101-detonate-the-maximum-bombs.rb) | Medium |
@@ -503,8 +507,10 @@
 | 2501 | Longest Square Streak in an Array | [Ruby](./algorithms/ruby/2501-longest-square-streak-in-an-array.rb) | Medium |
 | 2542 | Maximum Subsequence Score | [Ruby](./algorithms/ruby/2542-maximum-subsequence-score.rb) | Medium |
 | 2551 | Put Marbles in Bags | [Ruby](./algorithms/ruby/2551-put-marbles-in-bags.rb) | Hard |
+| 2563 | Count the Number of Fair Pairs | [Ruby](./algorithms/ruby/2563-count-the-number-of-fair-pairs.rb) | Medium |
 | 2583 | Kth Largest Sum in a Binary Tree | [Ruby](./algorithms/ruby/2583-kth-largest-sum-in-a-binary-tree.rb) | Medium |
 | 2595 | Number of Even and Odd Bits | [Ruby](./algorithms/ruby/2595-number-of-even-and-odd-bits.rb) | Easy |
+| 2601 | Prime Subtraction Operation | [Ruby](./algorithms/ruby/2601-prime-subtraction-operation.rb) | Medium |
 | 2616 | Minimize the Maximum Difference of Pairs | [Ruby](./algorithms/ruby/2616-minimize-the-maximum-difference-of-pairs.rb) | Medium |
 | 2641 | Cousins in Binary Tree II | [Ruby](./algorithms/ruby/2641-cousins-in-binary-tree-ii.rb) | Medium |
 | 2642 | Design Graph With Shortest Path Calculator | [Ruby](./algorithms/ruby/2642-design-graph-with-shortest-path-calculator.rb) | Hard |
@@ -519,7 +525,9 @@
 | 2849 | Determine if a Cell Is Reachable at a Given Time | [Ruby](./algorithms/ruby/2849-determine-if-a-cell-is-reachable-at-a-given-time) | Medium |
 | 2966 | Divide Array Into Arrays With Max Difference | [Ruby](./algorithms/ruby/2966-divide-array-into-arrays-with-max-difference) | Medium |
 | 3011 | Find if Array Can Be Sorted | [Ruby](./algorithms/ruby/3011-find-if-array-can-be-sorted.rb) | Medium |
+| 3097 | Shortest Subarray With OR At Least K II | [Ruby](./algorithms/ruby/3097-shortest-subarray-with-or-at-least-k-ii.rb) | Medium |
 | 3163 | String Compression III | [Ruby](./algorithms/ruby/3163-string-compression-iii.rb) | Medium |
+| 3254 | Find the Power of K-Size Subarrays I | [Ruby](./algorithms/ruby/3254-find-the-power-of-k-size-subarrays-i.rb) | Medium |
 
 ### Database
 | # | Title | Solution | Difficulty |

algorithms/ruby/0862-shortest-subarray-with-sum-at-least-k.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# 862. Shortest Subarray with Sum at Least K
+# https://leetcode.com/problems/shortest-subarray-with-sum-at-least-k
+# Hard
+
+=begin
+Given an integer array nums and an integer k, return the length of the shortest non-empty subarray of nums with a sum of at least k. If there is no such subarray, return -1.
+A subarray is a contiguous part of an array.
+
+Example 1:
+Input: nums = [1], k = 1
+Output: 1
+Example 2:
+Input: nums = [1,2], k = 4
+Output: -1
+Example 3:
+Input: nums = [2,-1,2], k = 3
+Output: 3
+
+Constraints:
+* 1 <= nums.length <= 105
+* -105 <= nums[i] <= 105
+* 1 <= k <= 109
+=end
+
+# @param {Integer[]} nums
+# @param {Integer} k
+# @return {Integer}
+def shortest_subarray(nums, k)
+  n = nums.length
+  sum = Array.new(n + 1, 0)
+
+  n.times do |i|
+    sum[i + 1] = sum[i] + nums[i]
+  end
+
+  q = Array.new(n + 1)
+  l = 0
+  r = 0
+  min_length = n + 1
+
+  sum.length.times do |i|
+    while r > l && sum[i] >= sum[q[l]] + k
+      min_length = [min_length, i - q[l]].min
+      l += 1
+    end
+
+    while r > l && sum[i] <= sum[q[r - 1]]
+      r -= 1
+    end
+
+    q[r] = i
+    r += 1
+  end
+
+  min_length <= n ? min_length : -1
+end
+
+# **************** #
+#       TEST       #
+# **************** #
+
+require "test/unit"
+class Test_shortest_subarray < Test::Unit::TestCase
+  def test_
+    assert_equal 1, shortest_subarray([1], 1)
+    assert_equal(-1, shortest_subarray([1, 2], 4))
+    assert_equal 3, shortest_subarray([2, -1, 2], 3)
+  end
+end

algorithms/ruby/1574-shortest-subarray-to-be-removed-to-make-array-sorted.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# 1574. Shortest Subarray to be Removed to Make Array Sorted
+# https://leetcode.com/problems/shortest-subarray-to-be-removed-to-make-array-sorted
+# Medium
+
+=begin
+Given an integer array arr, remove a subarray (can be empty) from arr such that the remaining elements in arr are non-decreasing.
+Return the length of the shortest subarray to remove.
+A subarray is a contiguous subsequence of the array.
+
+Example 1:
+Input: arr = [1,2,3,10,4,2,3,5]
+Output: 3
+Explanation: The shortest subarray we can remove is [10,4,2] of length 3. The remaining elements after that will be [1,2,3,3,5] which are sorted.
+Another correct solution is to remove the subarray [3,10,4].
+Example 2:
+Input: arr = [5,4,3,2,1]
+Output: 4
+Explanation: Since the array is strictly decreasing, we can only keep a single element. Therefore we need to remove a subarray of length 4, either [5,4,3,2] or [4,3,2,1].
+Example 3:
+Input: arr = [1,2,3]
+Output: 0
+Explanation: The array is already non-decreasing. We do not need to remove any elements.
+
+Constraints:
+* 1 <= arr.length <= 105
+* 0 <= arr[i] <= 109
+=end
+
+# @param {Integer[]} arr
+# @return {Integer}
+def find_length_of_shortest_subarray(arr)
+  n = arr.size
+  left = 0
+  left += 1 while left + 1 < n && arr[left] <= arr[left + 1]
+  return 0 if left == n - 1
+
+  right = n - 1
+  right -= 1 while right - 1 >= 0 && arr[right - 1] <= arr[right]
+
+  min_length = [n - left - 1, right].min
+
+  i = 0
+  j = right
+  while i <= left && j < n
+    if arr[i] <= arr[j]
+      min_length = [min_length, j - i - 1].min
+      i += 1
+    else
+      j += 1
+    end
+  end
+
+  min_length
+end
+
+# ********************#
+#       TEST         #
+# ********************#
+
+require "test/unit"
+class Test_find_length_of_shortest_subarray < Test::Unit::TestCase
+  def test_
+    assert_equal 3, find_length_of_shortest_subarray([1, 2, 3, 10, 4, 2, 3, 5])
+    assert_equal 4, find_length_of_shortest_subarray([5, 4, 3, 2, 1])
+    assert_equal 0, find_length_of_shortest_subarray([1, 2, 3])
+  end
+end

algorithms/ruby/2064-minimized-maximum-of-products-distributed-to-any-store.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# 2064. Minimized Maximum of Products Distributed to Any Store
+# https://leetcode.com/problems/minimized-maximum-of-products-distributed-to-any-store
+# Medium
+
+=begin
+You are given an integer n indicating there are n specialty retail stores. There are m product types of varying amounts, which are given as a 0-indexed integer array quantities, where quantities[i] represents the number of products of the ith product type.
+You need to distribute all products to the retail stores following these rules:
+* A store can only be given at most one product type but can be given any amount of it.
+* After distribution, each store will have been given some number of products (possibly 0). Let x represent the maximum number of products given to any store. You want x to be as small as possible, i.e., you want to minimize the maximum number of products that are given to any store.
+Return the minimum possible x.
+
+Example 1:
+Input: n = 6, quantities = [11,6]
+Output: 3
+Explanation: One optimal way is:
+- The 11 products of type 0 are distributed to the first four stores in these amounts: 2, 3, 3, 3
+- The 6 products of type 1 are distributed to the other two stores in these amounts: 3, 3
+The maximum number of products given to any store is max(2, 3, 3, 3, 3, 3) = 3.
+
+Example 2:
+Input: n = 7, quantities = [15,10,10]
+Output: 5
+Explanation: One optimal way is:
+- The 15 products of type 0 are distributed to the first three stores in these amounts: 5, 5, 5
+- The 10 products of type 1 are distributed to the next two stores in these amounts: 5, 5
+- The 10 products of type 2 are distributed to the last two stores in these amounts: 5, 5
+The maximum number of products given to any store is max(5, 5, 5, 5, 5, 5, 5) = 5.
+
+Example 3:
+Input: n = 1, quantities = [100000]
+Output: 100000
+Explanation: The only optimal way is:
+- The 100000 products of type 0 are distributed to the only store.
+The maximum number of products given to any store is max(100000) = 100000.
+
+Constraints:
+* m == quantities.length
+* 1 <= m <= n <= 105
+* 1 <= quantities[i] <= 105
+=end
+
+# @param {Integer} n
+# @param {Integer[]} quantities
+# @return {Integer}
+def minimized_maximum(n, quantities)
+  ok = quantities.max
+  ng = 0
+  while (ok - ng).abs > 1
+    mid = (ok + ng) / 2
+    if quantities.sum { |q| (q + mid - 1) / mid } <= n
+      ok = mid
+    else
+      ng = mid
+    end
+  end
+  ok
+end
+
+# **************** #
+#       TEST       #
+# **************** #
+
+require "test/unit"
+class Test_minimized_maximum < Test::Unit::TestCase
+  def test_
+    assert_equal 3, minimized_maximum(6, [11, 6])
+    assert_equal 5, minimized_maximum(7, [15, 10, 10])
+    assert_equal 100000, minimized_maximum(1, [100000])
+  end
+end

algorithms/ruby/2070-most-beautiful-item-for-each-query.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# 2070. Most Beautiful Item for Each Query
+# Medium
+# https://leetcode.com/problems/most-beautiful-item-for-each-query
+
+=begin
+You are given a 2D integer array items where items[i] = [pricei, beautyi] denotes the price and beauty of an item respectively.
+You are also given a 0-indexed integer array queries. For each queries[j], you want to determine the maximum beauty of an item whose price is less than or equal to queries[j]. If no such item exists, then the answer to this query is 0.
+Return an array answer of the same length as queries where answer[j] is the answer to the jth query.
+
+Example 1:
+Input: items = [[1,2],[3,2],[2,4],[5,6],[3,5]], queries = [1,2,3,4,5,6]
+Output: [2,4,5,5,6,6]
+Explanation:
+- For queries[0]=1, [1,2] is the only item which has price <= 1. Hence, the answer for this query is 2.
+- For queries[1]=2, the items which can be considered are [1,2] and [2,4].
+  The maximum beauty among them is 4.
+- For queries[2]=3 and queries[3]=4, the items which can be considered are [1,2], [3,2], [2,4], and [3,5].
+  The maximum beauty among them is 5.
+- For queries[4]=5 and queries[5]=6, all items can be considered.
+  Hence, the answer for them is the maximum beauty of all items, i.e., 6.
+Example 2:
+Input: items = [[1,2],[1,2],[1,3],[1,4]], queries = [1]
+Output: [4]
+Explanation:
+The price of every item is equal to 1, so we choose the item with the maximum beauty 4.
+Note that multiple items can have the same price and/or beauty.
+Example 3:
+Input: items = [[10,1000]], queries = [5]
+Output: [0]
+Explanation:
+No item has a price less than or equal to 5, so no item can be chosen.
+Hence, the answer to the query is 0.
+
+Constraints:
+* 1 <= items.length, queries.length <= 105
+* items[i].length == 2
+* 1 <= pricei, beautyi, queries[j] <= 109
+=end
+
+# @param {Integer[][]} items
+# @param {Integer[]} queries
+# @return {Integer[]}
+def maximum_beauty(items, queries)
+  items.sort_by!(&:last)
+  queries.collect { |q| items.reverse_each.inject(nil) { |res, (p, b)| break b if p <= q } || 0 }
+end
+
+# **************** #
+#       TEST       #
+# **************** #
+
+require "test/unit"
+class Test_maximum_beauty < Test::Unit::TestCase
+  def test_
+    assert_equal [2, 4, 5, 5, 6, 6], maximum_beauty([[1, 2], [3, 2], [2, 4], [5, 6], [3, 5]], [1, 2, 3, 4, 5, 6])
+    assert_equal [4], maximum_beauty([[1, 2], [1, 2], [1, 3], [1, 4]], [1])
+    assert_equal [0], maximum_beauty([[10, 1000]], [5])
+  end
+end

algorithms/ruby/2563-count-the-number-of-fair-pairs.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# 2563. Count the Number of Fair Pairs
+# https://leetcode.com/problems/count-the-number-of-fair-pairs
+# Medium
+
+=begin
+Given a 0-indexed integer array nums of size n and two integers lower and upper, return the number of fair pairs.
+A pair (i, j) is fair if:
+* 0 <= i < j < n, and
+* lower <= nums[i] + nums[j] <= upper
+
+Example 1:
+Input: nums = [0,1,7,4,4,5], lower = 3, upper = 6
+Output: 6
+Explanation: There are 6 fair pairs: (0,3), (0,4), (0,5), (1,3), (1,4), and (1,5).
+Example 2:
+Input: nums = [1,7,9,2,5], lower = 11, upper = 11
+Output: 1
+Explanation: There is a single fair pair: (2,3).
+
+Constraints:
+* 1 <= nums.length <= 105
+* nums.length == n
+* -109 <= nums[i] <= 109
+* -109 <= lower <= upper <= 109
+=end
+
+# @param {Integer[]} nums
+# @param {Integer} lower
+# @param {Integer} upper
+# @return {Integer}
+def count_fair_pairs(nums, lower, upper)
+  nums.sort!
+
+  nums.each_with_index.sum do |num, i|
+    lower_idx = nums.bsearch_index { |x| x >= lower - num } || nums.size
+    lower_idx = i + 1 if lower_idx <= i
+
+    upper_idx = nums.bsearch_index { |x| x > upper - num } || nums.size
+    next 0 if upper_idx < lower_idx
+
+    upper_idx - lower_idx
+  end
+end
+
+# **************** #
+#       TEST       #
+# **************** #
+
+require "test/unit"
+class Test_count_fair_pairs < Test::Unit::TestCase
+  def test_
+    assert_equal 6, count_fair_pairs([0, 1, 7, 4, 4, 5], 3, 6)
+    assert_equal 1, count_fair_pairs([1, 7, 9, 2, 5], 11, 11)
+  end
+end