Added tasks 17-98

Author: javadev

README.md

@@ -0,0 +1,66 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Erlang/LeetCode-in-Erlang?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Erlang/LeetCode-in-Erlang)
+[![](https://img.shields.io/github/forks/LeetCode-in-Erlang/LeetCode-in-Erlang?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Erlang/LeetCode-in-Erlang/fork)
+
+## 17\. Letter Combinations of a Phone Number
+
+Medium
+
+Given a string containing digits from `2-9` inclusive, return all possible letter combinations that the number could represent. Return the answer in **any order**.
+
+A mapping of digit to letters (just like on the telephone buttons) is given below. Note that 1 does not map to any letters.
+
+![](https://upload.wikimedia.org/wikipedia/commons/thumb/7/73/Telephone-keypad2.svg/200px-Telephone-keypad2.svg.png)
+
+**Example 1:**
+
+**Input:** digits = "23"
+
+**Output:** ["ad","ae","af","bd","be","bf","cd","ce","cf"]
+
+**Example 2:**
+
+**Input:** digits = ""
+
+**Output:** []
+
+**Example 3:**
+
+**Input:** digits = "2"
+
+**Output:** ["a","b","c"]
+
+**Constraints:**
+
+*   `0 <= digits.length <= 4`
+*   `digits[i]` is a digit in the range `['2', '9']`.
+
+## Solution
+
+```erlang
+-spec letter_combinations(Digits :: unicode:unicode_binary()) -> [unicode:unicode_binary()].
+letter_combinations(Digits) ->
+    Res = lists:foldl(fun(Digit, Acc) -> 
+        case Digit of
+            <<"2">> -> 
+                [<<Accbin/binary, Byte/binary>> || Byte <- [<<A>> || <<A:8>> <= <<"abc">>], Accbin <- Acc];
+            <<"3">> -> 
+                [<<Accbin/binary, Byte/binary>> || Byte <- [<<A>> || <<A:8>> <= <<"def">>], Accbin <- Acc];
+            <<"4">> -> 
+                [<<Accbin/binary, Byte/binary>> || Byte <- [<<A>> || <<A:8>> <= <<"ghi">>], Accbin <- Acc];
+            <<"5">> -> 
+                [<<Accbin/binary, Byte/binary>> || Byte <- [<<A>> || <<A:8>> <= <<"jkl">>], Accbin <- Acc];
+            <<"6">> -> 
+                [<<Accbin/binary, Byte/binary>> || Byte <- [<<A>> || <<A:8>> <= <<"mno">>], Accbin <- Acc];
+            <<"7">> -> 
+                [<<Accbin/binary, Byte/binary>> || Byte <- [<<A>> || <<A:8>> <= <<"pqrs">>], Accbin <- Acc];
+            <<"8">> -> 
+                [<<Accbin/binary, Byte/binary>> || Byte <- [<<A>> || <<A:8>> <= <<"tuv">>], Accbin <- Acc];
+            <<"9">> -> 
+                [<<Accbin/binary, Byte/binary>> || Byte <- [<<A>> || <<A:8>> <= <<"wxyz">>], Accbin <- Acc]
+        end
+    end, [<<>>], [<<B>> || <<B:8>> <= Digits]),
+    case Res of
+        [<<>>] -> [];
+        _ -> Res
+    end.
+```

src/main/erlang/g0001_0100/s0017_letter_combinations_of_a_phone_number/readme.md

@@ -0,0 +1,83 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Erlang/LeetCode-in-Erlang?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Erlang/LeetCode-in-Erlang)
+[![](https://img.shields.io/github/forks/LeetCode-in-Erlang/LeetCode-in-Erlang?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Erlang/LeetCode-in-Erlang/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
+
+```erlang
+-spec longest_valid_parentheses(S :: unicode:unicode_binary()) -> integer().
+longest_valid_parentheses(S) ->
+    Max1 = scan(S, 0, 0, 0, 1),
+    Max2 = scan(reverse_binary(S), 0, 0, 0, -1),
+    max(Max1, Max2).
+
+-spec scan(S :: unicode:unicode_binary(), Left :: integer(), Right :: integer(), Max :: integer(), Direction :: integer()) -> integer().
+scan(<<>>, _, _, Max, _) -> 
+    Max;
+scan(<<Ch, Rest/binary>>, Left, Right, Max, Direction) ->
+    {NewLeft, NewRight} = 
+        case Ch of
+            $( -> {Left + 1, Right};
+            $) -> {Left, Right + 1};
+            _ -> {Left, Right}
+        end,
+    NewMax = 
+        case NewLeft == NewRight of
+            true -> max(Max, NewLeft + NewRight);
+            false -> Max
+        end,
+    {ResetLeft, ResetRight} =
+        case Direction of
+            1 when NewRight > NewLeft -> {0, 0}; % Reset if right > left in forward scan
+            -1 when NewLeft > NewRight -> {0, 0}; % Reset if left > right in backward scan
+            _ -> {NewLeft, NewRight}
+        end,
+    scan(Rest, ResetLeft, ResetRight, NewMax, Direction).
+
+% Helper to reverse a binary string manually.
+-spec reverse_binary(S :: binary()) -> binary().
+reverse_binary(S) -> 
+    reverse_binary(S, <<>>).
+
+-spec reverse_binary(S :: binary(), Acc :: binary()) -> binary().
+reverse_binary(<<>>, Acc) -> 
+    Acc;
+reverse_binary(<<Ch, Rest/binary>>, Acc) -> 
+    reverse_binary(Rest, <<Ch, Acc/binary>>).
+
+-spec max(A :: integer(), B :: integer()) -> integer().
+max(A, B) when A >= B -> A;
+max(_, B) -> B.
+```

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

@@ -0,0 +1,66 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Erlang/LeetCode-in-Erlang?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Erlang/LeetCode-in-Erlang)
+[![](https://img.shields.io/github/forks/LeetCode-in-Erlang/LeetCode-in-Erlang?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Erlang/LeetCode-in-Erlang/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
+
+```erlang
+-spec search(Nums :: [integer()], Target :: integer()) -> integer().
+
+search(Nums, Target) ->
+    search(Nums, Target, 0, length(Nums) - 1).
+
+search(_, _, L, R) when L > R -> -1;
+search(Nums, Target, L, R) ->
+    Mid = (L + R) div 2,
+    Val = lists:nth(Mid + 1, Nums),
+    Start = lists:nth(L + 1, Nums),
+    case Val of
+        Target -> Mid;
+        _ -> 
+            if 
+                (Val >= Start andalso Target >= Start andalso Target < Val) 
+                orelse (Val < Start andalso (Target >= Start orelse Target < Val)) ->
+                    search(Nums, Target, L, Mid - 1);
+                true ->
+                    search(Nums, Target, Mid + 1, R)
+            end
+    end.
+```

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

@@ -0,0 +1,65 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Erlang/LeetCode-in-Erlang?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Erlang/LeetCode-in-Erlang)
+[![](https://img.shields.io/github/forks/LeetCode-in-Erlang/LeetCode-in-Erlang?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Erlang/LeetCode-in-Erlang/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
+
+```erlang
+-spec search_range(Nums :: [integer()], Target :: integer()) -> [integer()].
+search_range(Nums, Target) ->
+    [helper(Nums, Target, false), helper(Nums, Target, true)].
+
+-spec helper(Nums :: [integer()], Target :: integer(), Equals :: boolean()) -> integer().
+helper(Nums, Target, Equals) ->
+    helper(Nums, Target, Equals, 0, length(Nums) - 1, -1).
+
+-spec helper(Nums :: [integer()], Target :: integer(), Equals :: boolean(), L :: integer(), R :: integer(), Result :: integer()) -> integer().
+helper(_, _, _, L, R, Result) when L > R ->
+    Result;
+helper(Nums, Target, Equals, L, R, Result) ->
+    Mid = L + (R - L) div 2,
+    MidValue = lists:nth(Mid + 1, Nums), % Erlang lists are 1-based
+    NewResult = 
+        case MidValue == Target of
+            true -> Mid;
+            false -> Result
+        end,
+    case MidValue < Target orelse (MidValue == Target andalso Equals) of
+        true -> helper(Nums, Target, Equals, Mid + 1, R, NewResult);
+        false -> helper(Nums, Target, Equals, L, Mid - 1, NewResult)
+    end.
+```

src/main/erlang/g0001_0100/s0034_find_first_and_last_position_of_element_in_sorted_array/readme.md

@@ -0,0 +1,67 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Erlang/LeetCode-in-Erlang?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Erlang/LeetCode-in-Erlang)
+[![](https://img.shields.io/github/forks/LeetCode-in-Erlang/LeetCode-in-Erlang?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Erlang/LeetCode-in-Erlang/fork)
+
+## 35\. Search Insert Position
+
+Easy
+
+Given a sorted array of distinct integers and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.
+
+You must write an algorithm with `O(log n)` runtime complexity.
+
+**Example 1:**
+
+**Input:** nums = [1,3,5,6], target = 5
+
+**Output:** 2
+
+**Example 2:**
+
+**Input:** nums = [1,3,5,6], target = 2
+
+**Output:** 1
+
+**Example 3:**
+
+**Input:** nums = [1,3,5,6], target = 7
+
+**Output:** 4
+
+**Example 4:**
+
+**Input:** nums = [1,3,5,6], target = 0
+
+**Output:** 0
+
+**Example 5:**
+
+**Input:** nums = [1], target = 0
+
+**Output:** 0
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+*   `nums` contains **distinct** values sorted in **ascending** order.
+*   <code>-10<sup>4</sup> <= target <= 10<sup>4</sup></code>
+
+## Solution
+
+```erlang
+-spec search_insert(Nums :: [integer()], Target :: integer()) -> integer().
+search_insert(Nums, Target) ->
+  search_insert(Nums, Target, 1, length(Nums)) - 1.
+
+search_insert(Nums, Target, Low, High) when Low > High ->
+    Low;
+
+search_insert(Nums, Target, Low, High) ->
+    Mid = Low + (High - Low) div 2,
+    Mid_value = lists:nth(Mid, Nums),
+    Result = if
+                 Mid_value == Target -> Mid;
+                 Mid_value > Target -> search_insert(Nums, Target, Low, Mid - 1);
+                 true -> search_insert(Nums, Target, Mid + 1, High)
+            end.
+```