Added tasks 31-136

Author: javadev

README.md

@@ -45,8 +45,6 @@ Given a string `s`, find the length of the **longest substring** without repeati
 ## Solution
 
 ```ruby
-# #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Hash_Table #Sliding_Window
-
 # @param {String} s
 # @return {Integer}
 def length_of_longest_substring(s)

src/main/ruby/g0001_0100/s0003_longest_substring_without_repeating_characters/readme.md

@@ -0,0 +1,82 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Ruby/LeetCode-in-Ruby?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Ruby/LeetCode-in-Ruby)
+[![](https://img.shields.io/github/forks/LeetCode-in-Ruby/LeetCode-in-Ruby?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Ruby/LeetCode-in-Ruby/fork)
+
+## 31\. Next Permutation
+
+Medium
+
+Implement **next permutation**, which rearranges numbers into the lexicographically next greater permutation of numbers.
+
+If such an arrangement is not possible, it must rearrange it as the lowest possible order (i.e., sorted in ascending order).
+
+The replacement must be **[in place](http://en.wikipedia.org/wiki/In-place_algorithm)** and use only constant extra memory.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3]
+
+**Output:** [1,3,2] 
+
+**Example 2:**
+
+**Input:** nums = [3,2,1]
+
+**Output:** [1,2,3] 
+
+**Example 3:**
+
+**Input:** nums = [1,1,5]
+
+**Output:** [1,5,1] 
+
+**Example 4:**
+
+**Input:** nums = [1]
+
+**Output:** [1] 
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `0 <= nums[i] <= 100`
+
+## Solution
+
+```ruby
+# @param {Integer[]} nums
+# @return {Void} Do not return anything, modify nums in-place instead.
+def next_permutation(nums)
+  return if nums.nil? || nums.length <= 1
+
+  i = nums.length - 2
+  while i >= 0 && nums[i] >= nums[i + 1]
+    i -= 1
+  end
+
+  if i >= 0
+    j = nums.length - 1
+    while nums[j] <= nums[i]
+      j -= 1
+    end
+    swap_next(nums, i, j)
+  end
+
+  reverse_next(nums, i + 1, nums.length - 1)
+end
+
+private
+
+def swap_next(nums, i, j)
+  temp = nums[i]
+  nums[i] = nums[j]
+  nums[j] = temp
+end
+
+def reverse_next(nums, i, j)
+  while i < j
+    swap_next(nums, i, j)
+    i += 1
+    j -= 1
+  end
+end
+```

src/main/ruby/g0001_0100/s0031_next_permutation/readme.md

@@ -0,0 +1,90 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Ruby/LeetCode-in-Ruby?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Ruby/LeetCode-in-Ruby)
+[![](https://img.shields.io/github/forks/LeetCode-in-Ruby/LeetCode-in-Ruby?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Ruby/LeetCode-in-Ruby/fork)
+
+## 32\. Longest Valid Parentheses
+
+Hard
+
+Given a string containing just the characters `'('` and `')'`, find the length of the longest valid (well-formed) parentheses substring.
+
+**Example 1:**
+
+**Input:** s = "(()"
+
+**Output:** 2
+
+**Explanation:** The longest valid parentheses substring is "()". 
+
+**Example 2:**
+
+**Input:** s = ")()())"
+
+**Output:** 4
+
+**Explanation:** The longest valid parentheses substring is "()()". 
+
+**Example 3:**
+
+**Input:** s = ""
+
+**Output:** 0 
+
+**Constraints:**
+
+*   <code>0 <= s.length <= 3 * 10<sup>4</sup></code>
+*   `s[i]` is `'('`, or `')'`.
+
+## Solution
+
+```ruby
+# @param {String} s
+# @return {Integer}
+def longest_valid_parentheses(s)
+  max = 0
+  left = 0
+  right = 0
+  n = s.length
+  ch = nil
+
+  (0...n).each do |i|
+    ch = s[i]
+    if ch == '('
+      left += 1
+    else
+      right += 1
+    end
+
+    if right > left
+      left = 0
+      right = 0
+    end
+
+    if left == right
+      max = [max, left + right].max
+    end
+  end
+
+  left = 0
+  right = 0
+
+  (n - 1).downto(0) do |i|
+    ch = s[i]
+    if ch == '('
+      left += 1
+    else
+      right += 1
+    end
+
+    if left > right
+      left = 0
+      right = 0
+    end
+
+    if left == right
+      max = [max, left + right].max
+    end
+  end
+
+  max
+end
+```

src/main/ruby/g0001_0100/s0032_longest_valid_parentheses/readme.md

@@ -0,0 +1,72 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Ruby/LeetCode-in-Ruby?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Ruby/LeetCode-in-Ruby)
+[![](https://img.shields.io/github/forks/LeetCode-in-Ruby/LeetCode-in-Ruby?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Ruby/LeetCode-in-Ruby/fork)
+
+## 33\. Search in Rotated Sorted Array
+
+Medium
+
+There is an integer array `nums` sorted in ascending order (with **distinct** values).
+
+Prior to being passed to your function, `nums` is **possibly rotated** at an unknown pivot index `k` (`1 <= k < nums.length`) such that the resulting array is `[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]` (**0-indexed**). For example, `[0,1,2,4,5,6,7]` might be rotated at pivot index `3` and become `[4,5,6,7,0,1,2]`.
+
+Given the array `nums` **after** the possible rotation and an integer `target`, return _the index of_ `target` _if it is in_ `nums`_, or_ `-1` _if it is not in_ `nums`.
+
+You must write an algorithm with `O(log n)` runtime complexity.
+
+**Example 1:**
+
+**Input:** nums = [4,5,6,7,0,1,2], target = 0
+
+**Output:** 4 
+
+**Example 2:**
+
+**Input:** nums = [4,5,6,7,0,1,2], target = 3
+
+**Output:** -1 
+
+**Example 3:**
+
+**Input:** nums = [1], target = 0
+
+**Output:** -1 
+
+**Constraints:**
+
+*   `1 <= nums.length <= 5000`
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+*   All values of `nums` are **unique**.
+*   `nums` is an ascending array that is possibly rotated.
+*   <code>-10<sup>4</sup> <= target <= 10<sup>4</sup></code>
+
+## Solution
+
+```ruby
+# @param {Integer[]} nums
+# @param {Integer} target
+# @return {Integer}
+def search(nums, target)
+  lo = 0
+  hi = nums.length - 1
+
+  while lo <= hi
+    mid = ((hi - lo) >> 1) + lo
+
+    return mid if target == nums[mid]
+
+    if nums[lo] <= nums[mid]
+      if nums[lo] <= target && target <= nums[mid]
+        hi = mid - 1
+      else
+        lo = mid + 1
+      end
+    elsif nums[mid] <= target && target <= nums[hi]
+      lo = mid + 1
+    else
+      hi = mid - 1
+    end
+  end
+
+  -1
+end
+```

src/main/ruby/g0001_0100/s0033_search_in_rotated_sorted_array/readme.md

@@ -0,0 +1,69 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Ruby/LeetCode-in-Ruby?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Ruby/LeetCode-in-Ruby)
+[![](https://img.shields.io/github/forks/LeetCode-in-Ruby/LeetCode-in-Ruby?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Ruby/LeetCode-in-Ruby/fork)
+
+## 34\. Find First and Last Position of Element in Sorted Array
+
+Medium
+
+Given an array of integers `nums` sorted in non-decreasing order, find the starting and ending position of a given `target` value.
+
+If `target` is not found in the array, return `[-1, -1]`.
+
+You must write an algorithm with `O(log n)` runtime complexity.
+
+**Example 1:**
+
+**Input:** nums = [5,7,7,8,8,10], target = 8
+
+**Output:** [3,4] 
+
+**Example 2:**
+
+**Input:** nums = [5,7,7,8,8,10], target = 6
+
+**Output:** [-1,-1] 
+
+**Example 3:**
+
+**Input:** nums = [], target = 0
+
+**Output:** [-1,-1] 
+
+**Constraints:**
+
+*   <code>0 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
+*   `nums` is a non-decreasing array.
+*   <code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code>
+
+## Solution
+
+```ruby
+# @param {Integer[]} nums
+# @param {Integer} target
+# @return {Integer[]}
+def search_range(nums, target)
+  ans = [helper(nums, target, false), helper(nums, target, true)]
+  ans
+end
+
+private
+
+def helper(nums, target, equals)
+  l = 0
+  r = nums.length - 1
+  result = -1
+
+  while l <= r
+    mid = l + (r - l) / 2
+    result = mid if nums[mid] == target
+    if nums[mid] < target || (nums[mid] == target && equals)
+      l = mid + 1
+    else
+      r = mid - 1
+    end
+  end
+
+  result
+end
+```