feat: add Ruby solutions

Author: remy727

Diff for: README.md

@@ -266,6 +266,7 @@
 | 744 | Find Smallest Letter Greater Than Target | [Ruby](./algorithms/ruby/0744-find-smallest-letter-greater-than-target.rb) | Easy |
 | 746 | Min Cost Climbing Stairs | [Ruby](./algorithms/ruby/0746-min-cost-climbing-stairs.rb) | Easy |
 | 767 | Reorganize String | [Ruby](./algorithms/ruby/0767-reorganize-string.rb) | Medium |
+| 773 | Sliding Puzzle | [Ruby](./algorithms/ruby/0773-sliding-puzzle.rb) | Hard |
 | 779 | K-th Symbol in Grammar | [Ruby](./algorithms/ruby/0779-k-th-symbol-in-grammar.rb) | Medium |
 | 783 | Minimum Distance Between BST Nodes | [Ruby](./algorithms/ruby/0783-minimum-distance-between-bst-nodes.rb) [Python3](./algorithms/python3/0783-minimum-distance-between-bst-nodes.py) | Easy |
 | 785 | Is Graph Bipartite? | [Ruby](./algorithms/ruby/0785-is-graph-bipartite.rb) | Medium |
@@ -323,6 +324,7 @@
 | 1046 | Last Stone Weight | [Ruby](./algorithms/ruby/1046-last-stone-weight.rb) | Easy |
 | 1048 | Longest String Chain | [Ruby](./algorithms/ruby/1048-longest-string-chain.rb) | Medium |
 | 1071 | Greatest Common Divisor of Strings | [Ruby](./algorithms/ruby/1071-greatest-common-divisor-of-strings.rb) | Easy |
+| 1072 | Flip Columns For Maximum Number of Equal Rows | [Ruby](./algorithms/ruby/1072-flip-columns-for-maximum-number-of-equal-rows.rb) | Medium |
 | 1091 | Shortest Path in Binary Matrix | [Ruby](./algorithms/ruby/1091-shortest-path-in-binary-matrix.rb) | Medium |
 | 1106 | Parsing A Boolean Expression | [Ruby](./algorithms/ruby/1106-parsing-a-boolean-expression.rb) | Hard |
 | 1125 | Smallest Sufficient Team | [Ruby](./algorithms/ruby/1125-smallest-sufficient-team.rb) | Hard |
@@ -414,6 +416,7 @@
 | 1637 | Widest Vertical Area Between Two Points Containing No Points | [Ruby](./algorithms/ruby/1637-widest-vertical-area-between-two-points-containing-no-points.rb) | Medium |
 | 1639 | Number of Ways to Form a Target String Given a Dictionary | [Ruby](./algorithms/ruby/1639-number-of-ways-to-form-a-target-string-given-a-dictionary.rb) | Hard |
 | 1647 | Minimum Deletions to Make Character Frequencies Unique | [Ruby](./algorithms/ruby/1647-minimum-deletions-to-make-character-frequencies-unique.rb) | Medium |
+| 1652 | Defuse the Bomb | [Ruby](./algorithms/ruby/1652-defuse-the-bomb.rb) | Easy |
 | 1657 | Determine if Two Strings Are Close | [Ruby](./algorithms/ruby/1657-determine-if-two-strings-are-close.rb) | Medium |
 | 1658 | Minimum Operations to Reduce X to Zero | [Ruby](./algorithms/ruby/1658-minimum-operations-to-reduce-x-to-zero.rb) | Medium |
 | 1662 | Check If Two String Arrays are Equivalent | [Ruby](./algorithms/ruby/1662-check-if-two-string-arrays-are-equivalent.rb) | Easy |
@@ -443,6 +446,7 @@
 | 1845 | Seat Reservation Manager | [Ruby](./algorithms/ruby/1845-seat-reservation-manager.rb) | Medium |
 | 1846 | Maximum Element After Decreasing and Rearranging | [Ruby](./algorithms/ruby/1846-maximum-element-after-decreasing-and-rearranging.rb) | Medium |
 | 1857 | Largest Color Value in a Directed Graph | [Ruby](./algorithms/ruby/1857-largest-color-value-in-a-directed-graph.rb) | Hard |
+| 1861 | Rotating the Box | [Ruby](./algorithms/ruby/1861-rotating-the-box.rb) | Medium |
 | 1870 | Minimum Speed to Arrive on Time | [Ruby](./algorithms/ruby/1870-minimum-speed-to-arrive-on-time.rb) | Medium |
 | 1877 | Minimize Maximum Pair Sum in Array | [Ruby](./algorithms/ruby/1877-minimize-maximum-pair-sum-in-array.rb) | Medium |
 | 1887 | Minimize Maximum Pair Sum in Array | [Ruby](./algorithms/ruby/1887-reduction-operations-to-make-the-array-elements-equal.rb) | Medium |
@@ -453,6 +457,7 @@
 | 1930 | Unique Length-3 Palindromic Subsequences | [Ruby](./algorithms/ruby/1930-unique-length-3-palindromic-subsequences.rb) | Medium |
 | 1964 | Find the Longest Valid Obstacle Course at Each Position | [Ruby](./algorithms/ruby/1964-find-the-longest-valid-obstacle-course-at-each-position.rb) | Hard |
 | 1970 | Last Day Where You Can Still Cross | [Ruby](./algorithms/ruby/1970-last-day-where-you-can-still-cross.rb) | Hard |
+| 1975 | Maximum Matrix Sum | [Ruby](./algorithms/ruby/1975-maximum-matrix-sum.rb) | Medium |
 | 1980 | Find Unique Binary String | [Ruby](./algorithms/ruby/1980-find-unique-binary-string.rb) | Medium |
 | 2009 | Minimum Number of Operations to Make Array Continuous | [Ruby](./algorithms/ruby/2009-minimum-number-of-operations-to-make-array-continuous.rb) | Hard |
 | 2024 | Maximize the Confusion of an Exam | [Ruby](./algorithms/ruby/2024-maximize-the-confusion-of-an-exam.rb) | Medium |
@@ -472,6 +477,7 @@
 | 2215 | Find the Difference of Two Arrays | [Ruby](./algorithms/ruby/2215-find-the-difference-of-two-arrays.rb) | Easy |
 | 2218 | Maximum Value of K Coins From Piles | [Ruby](./algorithms/ruby/2218-maximum-value-of-k-coins-from-piles.rb) | Hard |
 | 2251 | Number of Flowers in Full Bloom | [Ruby](./algorithms/ruby/2251-number-of-flowers-in-full-bloom.rb) | Hard |
+| 2257 | Count Unguarded Cells in the Grid | [Ruby](./algorithms/ruby/2257-count-unguarded-cells-in-the-grid.rb) | Medium |
 | 2264 | Largest 3-Same-Digit Number in String | [Ruby](./algorithms/ruby/2264-largest-3-same-digit-number-in-string.rb) | Easy |
 | 2265 | Count Nodes Equal to Average of Subtree | [Ruby](./algorithms/ruby/2265-count-nodes-equal-to-average-of-subtree.rb) | Medium |
 | 2272 | Substring With Largest Variance | [Ruby](./algorithms/ruby/2272-substring-with-largest-variance.rb) | Hard |
@@ -497,6 +503,7 @@
 | 2444 | Count Subarrays With Fixed Bounds | [Ruby](./algorithms/ruby/2444-count-subarrays-with-fixed-bounds.rb) | Hard |
 | 2448 | Minimum Cost to Make Array Equal | [Ruby](./algorithms/ruby/2448-minimum-cost-to-make-array-equal.rb) | Hard |
 | 2458 | Height of Binary Tree After Subtree Removal Queries | [Ruby](./algorithms/ruby/2458-height-of-binary-tree-after-subtree-removal-queries.rb) | Hard |
+| 2461 | Maximum Sum of Distinct Subarrays With Length K | [Ruby](./algorithms/ruby/2461-maximum-sum-of-distinct-subarrays-with-length-k.rb) | Medium |
 | 2462 | Total Cost to Hire K Workers | [Python3](./algorithms/python3/2462-total-cost-to-hire-k-workers.py) | Medium |
 | 2463 | Minimum Total Distance Traveled | [Ruby](./algorithms/ruby/2463-minimum-total-distance-traveled.rb) | Hard |
 | 2466 | Count Ways To Build Good Strings | [Ruby](./algorithms/ruby/2466-count-ways-to-build-good-strings.rb) | Medium |
@@ -505,6 +512,7 @@
 | 2490 | Circular Sentence | [Ruby](./algorithms/ruby/2490-circular-sentence.rb) | Easy |
 | 2492 | Minimum Score of a Path Between Two Cities | [Ruby](./algorithms/ruby/2492-minimum-score-of-a-path-between-two-cities.rb) | Medium |
 | 2501 | Longest Square Streak in an Array | [Ruby](./algorithms/ruby/2501-longest-square-streak-in-an-array.rb) | Medium |
+| 2516 | Take K of Each Character From Left and Right | [Ruby](./algorithms/ruby/2516-take-k-of-each-character-from-left-and-right.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 |
@@ -523,10 +531,12 @@
 | 2785 | Sort Vowels in a String | [Ruby](./algorithms/ruby/2785-sort-vowels-in-a-string.rb) | Medium |
 | 2842 | Difference Between Ones and Zeros in Row and Column | [Ruby](./algorithms/ruby/2842-difference-between-ones-and-zeros-in-row-and-column.rb) | Medium |
 | 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 |
+| 2924 | Find Champion II | [Ruby](./algorithms/ruby/2924-find-champion-ii.rb) | 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 |
+| 3243 | Shortest Distance After Road Addition Queries I | [Ruby](./algorithms/ruby/3243-shortest-distance-after-road-addition-queries-i.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

Diff for: algorithms/ruby/0773-sliding-puzzle.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# 773. Sliding Puzzle
+# https://leetcode.com/problems/sliding-puzzle
+# Hard
+
+=begin
+On an 2 x 3 board, there are five tiles labeled from 1 to 5, and an empty square represented by 0. A move consists of choosing 0 and a 4-directionally adjacent number and swapping it.
+The state of the board is solved if and only if the board is [[1,2,3],[4,5,0]].
+Given the puzzle board board, return the least number of moves required so that the state of the board is solved. If it is impossible for the state of the board to be solved, return -1.
+
+Example 1:
+Input: board = [[1,2,3],[4,0,5]]
+Output: 1
+Explanation: Swap the 0 and the 5 in one move.
+
+Example 2:
+Input: board = [[1,2,3],[5,4,0]]
+Output: -1
+Explanation: No number of moves will make the board solved.
+
+Example 3:
+Input: board = [[4,1,2],[5,0,3]]
+Output: 5
+Explanation: 5 is the smallest number of moves that solves the board.
+An example path:
+After move 0: [[4,1,2],[5,0,3]]
+After move 1: [[4,1,2],[0,5,3]]
+After move 2: [[0,1,2],[4,5,3]]
+After move 3: [[1,0,2],[4,5,3]]
+After move 4: [[1,2,0],[4,5,3]]
+After move 5: [[1,2,3],[4,5,0]]
+
+Constraints:
+* board.length == 2
+* board[i].length == 3
+* 0 <= board[i][j] <= 5
+* Each value board[i][j] is unique.
+=end
+
+
+# @param {Integer[][]} board
+# @return {Integer}
+def sliding_puzzle(board)
+  target = [[1, 2, 3], [4, 5, 0]].flatten.join
+  start = board.flatten.join
+  can_move = {
+    0 => [1, 3],
+    1 => [0, 2, 4],
+    2 => [1, 5],
+    3 => [0, 4],
+    4 => [1, 3, 5],
+    5 => [2, 4]
+  }
+  visited = Set.new
+  steps = 0
+  queue = [[start, steps]]
+
+  until queue.empty?
+    current, steps = queue.shift
+    return steps if current == target
+
+    zero_index = current.index("0")
+    can_move[zero_index].each do |move|
+      next_board = current.dup
+      next_board[zero_index], next_board[move] = next_board[move], next_board[zero_index]
+      next if visited.include?(next_board)
+
+      visited << next_board
+      queue.push([next_board, steps + 1])
+    end
+  end
+
+  -1
+end
+
+# **************** #
+#       TEST       #
+# **************** #
+
+require "test/unit"
+class Test_sliding_puzzle < Test::Unit::TestCase
+  def test_
+    assert_equal 1, sliding_puzzle([[1, 2, 3], [4, 0, 5]])
+    assert_equal(-1, sliding_puzzle([[1, 2, 3], [5, 4, 0]]))
+    assert_equal 5, sliding_puzzle([[4, 1, 2], [5, 0, 3]])
+  end
+end

Diff for: algorithms/ruby/1072-flip-columns-for-maximum-number-of-equal-rows.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# 1072. Flip Columns For Maximum Number of Equal Rows
+# https://leetcode.com/problems/flip-columns-for-maximum-number-of-equal-rows
+# Medium
+
+=begin
+You are given an m x n binary matrix matrix.
+You can choose any number of columns in the matrix and flip every cell in that column (i.e., Change the value of the cell from 0 to 1 or vice versa).
+Return the maximum number of rows that have all values equal after some number of flips.
+
+Example 1:
+Input: matrix = [[0,1],[1,1]]
+Output: 1
+Explanation: After flipping no values, 1 row has all values equal.
+
+Example 2:
+Input: matrix = [[0,1],[1,0]]
+Output: 2
+Explanation: After flipping values in the first column, both rows have equal values.
+
+Example 3:
+Input: matrix = [[0,0,0],[0,0,1],[1,1,0]]
+Output: 2
+Explanation: After flipping values in the first two columns, the last two rows have equal values.
+
+
+Constraints:
+* m == matrix.length
+* n == matrix[i].length
+* 1 <= m, n <= 300
+matrix[i][j] is either 0 or 1.
+=end
+
+# @param {Integer[][]} matrix
+# @return {Integer}
+def max_equal_rows_after_flips(mat)
+  pat_freq = Hash.new(0)
+
+  mat.each do |row|
+    pattern = row[0] == 0 ? row.join : row.map { |bit| bit ^ 1 }.join
+    pat_freq[pattern] += 1
+  end
+
+  pat_freq.values.max
+end
+
+# **************** #
+#       TEST       #
+# **************** #
+
+require "test/unit"
+class Test_max_equal_rows_after_flips < Test::Unit::TestCase
+  def test_
+    assert_equal(1, max_equal_rows_after_flips([[0, 1], [1, 1]]))
+    assert_equal(2, max_equal_rows_after_flips([[0, 1], [1, 0]]))
+    assert_equal(2, max_equal_rows_after_flips([[0, 0, 0], [0, 0, 1], [1, 1, 0]]))
+  end
+end

Diff for: algorithms/ruby/1652-defuse-the-bomb.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# 1652. Defuse the Bomb
+# https://leetcode.com/problems/defuse-the-bomb
+# Easy
+
+=begin
+You have a bomb to defuse, and your time is running out! Your informer will provide you with a circular array code of length of n and a key k.
+To decrypt the code, you must replace every number. All the numbers are replaced simultaneously.
+* If k > 0, replace the ith number with the sum of the next k numbers.
+* If k < 0, replace the ith number with the sum of the previous k numbers.
+* If k == 0, replace the ith number with 0.
+As code is circular, the next element of code[n-1] is code[0], and the previous element of code[0] is code[n-1].
+Given the circular array code and an integer key k, return the decrypted code to defuse the bomb!
+
+Example 1:
+Input: code = [5,7,1,4], k = 3
+Output: [12,10,16,13]
+Explanation: Each number is replaced by the sum of the next 3 numbers. The decrypted code is [7+1+4, 1+4+5, 4+5+7, 5+7+1]. Notice that the numbers wrap around.
+Example 2:
+Input: code = [1,2,3,4], k = 0
+Output: [0,0,0,0]
+Explanation: When k is zero, the numbers are replaced by 0.
+Example 3:
+Input: code = [2,4,9,3], k = -2
+Output: [12,5,6,13]
+Explanation: The decrypted code is [3+9, 2+3, 4+2, 9+4]. Notice that the numbers wrap around again. If k is negative, the sum is of the previous numbers.
+
+Constraints:
+* n == code.length
+* 1 <= n <= 100
+* 1 <= code[i] <= 100
+* -(n - 1) <= k <= n - 1
+=end
+
+# @param {Integer[]} code
+# @param {Integer} k
+# @return {Integer[]}
+def decrypt(circ, k)
+  n = circ.size
+  result = Array.new(n, 0)
+
+  return result if k == 0
+
+  w_sum = 0
+  start = k > 0 ? 1 : n + k
+  end_pos = k > 0 ? k : n - 1
+
+  (start..end_pos).each do |i|
+    w_sum += circ[i % n]
+  end
+
+  n.times do |i|
+    result[i] = w_sum
+    w_sum -= circ[(start + i) % n]
+    w_sum += circ[(end_pos + i + 1) % n]
+  end
+
+  result
+end
+
+# **************** #
+#       TEST       #
+# **************** #
+
+require "test/unit"
+
+class Test_decrypt < Test::Unit::TestCase
+  def test_
+    assert_equal [12, 10, 16, 13], decrypt([5, 7, 1, 4], 3)
+    assert_equal [0, 0, 0, 0], decrypt([1, 2, 3, 4], 0)
+    assert_equal [12, 5, 6, 13], decrypt([2, 4, 9, 3], -2)
+  end
+end