Merge pull request #1 from theforestvn88/june

june/2024 add 499 leetcode problems

Author: theforestvn88

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