june/2024 add 499 leetcode problems

1-100/0001_two_sum.rb

@@ -0,0 +1,13 @@
+def two_sum(nums, target)
+ ans = []
+ prev = Hash.new
+ nums.each_with_index do |num, i|
+ complement = target - num
+ if prev.has_key?(complement)
+ ans = [prev[complement], i]
+ break
+ end
+ prev[num] = i
+ end
+ ans
+end

1-100/0002_add_two_numbers.rb

@@ -0,0 +1,22 @@
+# Definition for singly-linked list.
+# class ListNode
+# attr_accessor :val, :next
+# def initialize(val = 0, _next = nil)
+# @val = val
+# @next = _next
+# end
+# end
+#
+def add_two_numbers(l1, l2)
+ root = ListNode.new
+ l = root; rem = 0
+
+ until l1.nil? && l2.nil? && rem.zero?
+ sum = (l1&.val || 0) + (l2&.val || 0) + rem
+ l = l.next = ListNode.new sum % 10
+ rem = sum >= 10 ? 1 : 0
+ l1 = l1&.next; l2 = l2&.next
+ end
+
+ root.next
+end

1-100/0003_longest_substring_without_repeating_characters.rb

@@ -0,0 +1,18 @@
+def length_of_longest_substring(s)
+ counter = Hash.new(0)
+ left = right = 0
+ max = 0
+
+ while right < s.length
+ counter[s[right]] += 1
+ until counter[s[right]] == 1
+ counter[s[left]] -= 1
+ left += 1
+ end
+
+ right += 1
+ if (len = right - left) > max then max = len end
+ end
+
+ max
+end

1-100/0004_median_of_two_sorted_arrays.rb

@@ -0,0 +1,25 @@
+def find_median_sorted_arrays(nums1, nums2)
+ longer, shorter = nums1.length > nums2.length ? [nums1, nums2] : [nums2, nums1]
+
+ bs_left = 0
+ bs_right = shorter.length
+ divide_1 = 0
+ divide_2 = 0
+ until bs_left > bs_right
+ divide_1 = (bs_left + bs_right) / 2
+ divide_2 = (longer.length + shorter.length + 1) / 2 - divide_1
+ if divide_1 < bs_right && longer[divide_2 - 1] > shorter[divide_1]
+ bs_left = divide_1 + 1
+ elsif divide_1 > bs_left && shorter[divide_1 - 1] > longer[divide_2]
+ bs_right = divide_1 - 1
+ else
+ break
+ end
+ end
+
+ max_left = divide_1 == 0 ? longer[divide_2 - 1] : (divide_2 == 0 ? shorter[divide_1 - 1] : [shorter[divide_1 - 1], longer[divide_2 - 1]].max)
+ return max_left if (longer.length + shorter.length)%2 == 1
+
+ min_right = [(shorter[divide_1] || Float::INFINITY), (longer[divide_2] || Float::INFINITY)].min
+ return (max_left + min_right)/2.0
+end

1-100/0005_longest_palindromic_substring.rb

@@ -0,0 +1,27 @@
+def longest_palindrome(s)
+ str = "^|#{s.chars.join("|")}|$"
+ dp = Array.new(str.length, 0)
+ i = 1; l = 1; r = 1; max = 0; max_i = -1
+
+ while i < str.length-1
+ dp[i] = [0, [r-i, dp[l + r - i]].min].max
+ while str[i - dp[i]] == str[i + dp[i]]
+ dp[i] += 1
+ end
+
+ if max < dp[i]
+ max = dp[i]
+ max_i = i
+ end
+
+ if i + dp[i] > r
+ r = i + dp[i]
+ l = i - dp[i]
+ end
+
+ i += 1
+ end
+
+ s[((max_i - dp[max_i]) / 2)..((max_i - 1 + dp[max_i]) / 2 - 1)]
+end
+

1-100/0006_zigzag_conversion.rb

@@ -0,0 +1,15 @@
+def convert(s, num_rows)
+ return s if num_rows == 1
+
+ rows = Array.new(num_rows) { "" }
+ cur_row = 0
+ direction = 1
+
+ s.chars.each do |c|
+ rows[cur_row] << c
+ cur_row += direction
+ direction *= -1 if cur_row == 0 || cur_row == num_rows-1
+ end
+
+ rows.reduce("") { |converted, row| converted << row }
+end

1-100/0007_reverse_integer.rb

@@ -0,0 +1,17 @@
+FIX_MAX = 2147483647 
+FIX_MIN = -2147483648
+
+def reverse(x)
+ return 0 if x <= FIX_MIN || x > FIX_MAX + 1
+
+ sign = x < 0 ? -1 : 1;
+ x = x.abs
+ reverser = 0
+ while x > 0
+ reverser = (reverser * 10) + (x % 10)
+ x = x / 10
+ end
+
+ reverser = reverser * sign;
+ reverser >= FIX_MIN && reverser <= FIX_MAX ? reverser : 0;
+end

1-100/0008_string_to_integer_atoi.rb

@@ -0,0 +1,28 @@
+FIX_MAX = 2147483647 
+FIX_MIN = -2147483648
+ZERO = "0".ord
+
+def my_atoi(s)
+ atoi = nil
+ sign = nil
+ i = 0
+ while i < s.length
+ if s[i] >= "0" && s[i] <= "9"
+ atoi ||= 0
+ atoi = (atoi * 10) + (s[i].ord - ZERO)
+ else
+ break unless atoi.nil? && sign.nil?
+ if s[i] == "+"
+ sign = 1
+ elsif s[i] == "-"
+ sign = -1
+ elsif s[i] != " "
+ break
+ end
+ end
+ i += 1
+ end
+
+ atoi = (atoi || 0) * (sign || 1)
+ atoi < FIX_MIN ? FIX_MIN : (atoi > FIX_MAX ? FIX_MAX : atoi)
+end

1-100/0009_palindrome_number.rb

@@ -0,0 +1,12 @@
+def is_palindrome(x)
+ return false if x < 0
+
+ reverse = 0
+ cp_x = x
+ while x != 0
+ reverse = reverse * 10 + x % 10
+ x = x / 10
+ end
+
+ reverse == cp_x
+end

1-100/0010_regular_expression_matching.rb

@@ -0,0 +1,23 @@
+# @param {String} s
+# @param {String} p
+# @return {Boolean}
+def is_match(s, p)
+ dp = Array.new(s.size + 1) { Array.new(p.size + 1) { false } }
+ dp[0][0] = true
+
+ (0...p.size).each { |i|
+ dp[0][i+1] = dp[0][i-1] if p[i] == "*"
+ }
+
+ (0...s.size).each { |j|
+ (0...p.size).each { |i|
+ if p[i] == "*"
+ dp[j+1][i+1] = dp[j+1][i-1] || ((p[i-1] == "." || p[i-1] == s[j]) && dp[j][i+1])
+ else
+ dp[j+1][i+1] = (p[i] == "." || p[i] == s[j]) && dp[j][i]
+ end
+ }
+ }
+
+ dp[s.size][p.size]
+end

1-100/0011_container_with_most_water.rb

@@ -0,0 +1,31 @@
+def min(x, y)
+ x <= y ? x : y
+end
+
+def max(x, y)
+ x >= y ? x : y
+end
+
+# @param {Integer[]} height
+# @return {Integer}
+def max_area(height)
+ max = 0
+ l, r = 0, height.size-1
+ while l < r
+ max = max(max, (r-l) * min(height[l], height[r]))
+
+ if height[l] < height[r]
+ loop do
+ l += 1
+ break if l >= height.size || height[l] > height[l-1]
+ end
+ else
+ loop do
+ r -= 1
+ break if r <= 0 || height[r] > height[r+1]
+ end
+ end
+ end
+
+ max
+end

1-100/0012_integer_to_roman.rb

@@ -0,0 +1,23 @@
+# @param {Integer} num
+# @return {String}
+def int_to_roman(num)
+ [
+ [1000, "M"],
+ [900, "CM"],
+ [500, "D"],
+ [400, "CD"],
+ [100, "C"],
+ [90, "XC"],
+ [50, "L"],
+ [40, "XL"],
+ [10, "X"],
+ [9, "IX"],
+ [5, "V"],
+ [4, "IV"],
+ [1, "I"]
+ ].map do |value, symbol|
+ chars = symbol * (num/value)
+ num %= value
+ chars
+ end.join
+end

1-100/0013_roman_to_integer.rb

@@ -0,0 +1,23 @@
+Roman_To_Int = {
+ 'I' => 1,
+ 'V' => 5,
+ 'X' => 10,
+ 'L' => 50,
+ 'C' => 100,
+ 'D' => 500,
+ 'M' => 1000,
+}
+
+# @param {String} s
+# @return {Integer}
+def roman_to_int(s)
+ sum = 0
+ prev = 0
+ s.chars.reverse.each do |c|
+ i = Roman_To_Int[c]
+ sum += i >= prev ? i : -i
+ prev = i
+ end
+
+ sum
+end

1-100/0014_longest_common_prefix.rb

@@ -0,0 +1,37 @@
+TrieNode = Struct.new(:chars) do
+ def build(str)
+ node = self
+ str.each_char do |c|
+ node.chars[c.ord] ||= TrieNode.new([])
+ node = node.chars[c.ord]
+ end
+ self
+ end
+
+ def common_prefix_len(str)
+ l = 0
+ node = self
+ str.each_char do |c|
+ break if node.chars[c.ord].nil?
+ l += 1
+ node = node.chars[c.ord]
+ end
+ l
+ end
+end
+
+# @param {String[]} strs
+# @return {String}
+def longest_common_prefix(strs)
+ first = strs.shift()
+ return first if strs.empty?
+
+ trie = TrieNode.new([]).build(first)
+ common_longest = first.size
+ strs.each do |str|
+ cpl = trie.common_prefix_len(str)
+ common_longest = cpl if cpl < common_longest
+ end
+
+ first[0...common_longest]
+end

1-100/0015_three_sum.rb

@@ -0,0 +1,28 @@
+def three_sum(nums)
+ return [] if (nums.length < 3)
+
+ nums.sort!
+
+ solutions = []
+ nums.each_with_index do |num, i|
+ break if nums[i] > 0
+ next if i > 0 && nums[i] === nums[i-1]
+
+ l = i + 1; r = nums.length-1
+ while l < r
+ sum = nums[i] + nums[l] + nums[r]
+ if sum == 0
+ solutions << [nums[i], nums[l], nums[r]]
+ l += 1; r -= 1
+ l += 1 while l < r && nums[l] == nums[l-1]
+ r -= 1 while l < r && nums[r] == nums[r+1]
+ elsif sum < 0
+ l += 1
+ else
+ r -= 1
+ end
+ end
+ end
+
+ solutions
+end

1-100/0016_three_sum_closest.rb

@@ -0,0 +1,27 @@
+def three_sum_closest(nums, target)
+ nums.sort!
+
+ closest_sum = 0; closest_dis = Float::INFINITY
+ for start in (0..nums.length - 3)
+ next if start > 0 && nums[start] == nums[start - 1]
+
+ low = start + 1; high = nums.length - 1
+ while low < high
+ sum = nums[start] + nums[low] + nums[high]
+ return sum if sum == target
+
+ if (new_dis = (sum - target).abs) < closest_dis
+ closest_sum = sum
+ closest_dis = new_dis
+ end
+
+ if sum > target
+ high -= 1
+ else
+ low += 1
+ end
+ end
+ end
+
+ closest_sum
+end