Added erlang

Author: javadev

README.md

@@ -0,0 +1,58 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 1\. Two Sum
+
+Easy
+
+Given an array of integers `nums` and an integer `target`, return _indices of the two numbers such that they add up to `target`_.
+
+You may assume that each input would have **_exactly_ one solution**, and you may not use the _same_ element twice.
+
+You can return the answer in any order.
+
+**Example 1:**
+
+**Input:** nums = [2,7,11,15], target = 9
+
+**Output:** [0,1]
+
+**Output:** Because nums[0] + nums[1] == 9, we return [0, 1]. 
+
+**Example 2:**
+
+**Input:** nums = [3,2,4], target = 6
+
+**Output:** [1,2] 
+
+**Example 3:**
+
+**Input:** nums = [3,3], target = 6
+
+**Output:** [0,1] 
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>4</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
+*   <code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code>
+*   **Only one valid answer exists.**
+
+**Follow-up:** Can you come up with an algorithm that is less than <code>O(n<sup>2</sup>) </code>time complexity?
+
+## Solution
+
+```erlang
+% #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Array #Hash_Table
+
+-spec two_sum(Nums :: [integer()], Target :: integer()) -> [integer()].
+two_sum(Nums, Target) ->
+    two_sum(Nums, Target, #{}, 0).
+
+two_sum([], _, _, _) -> undefined;
+two_sum([H|T], Target, M, Index) ->
+    case M of
+        #{ Target-H := Pair } -> [Pair, Index];
+        _ -> two_sum(T, Target, M#{ H => Index }, Index + 1)
+    end.
+```

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

@@ -0,0 +1,66 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 2\. Add Two Numbers
+
+Medium
+
+You are given two **non-empty** linked lists representing two non-negative integers. The digits are stored in **reverse order**, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.
+
+You may assume the two numbers do not contain any leading zero, except the number 0 itself.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/02/addtwonumber1.jpg)
+
+**Input:** l1 = [2,4,3], l2 = [5,6,4]
+
+**Output:** [7,0,8]
+
+**Explanation:** 342 + 465 = 807. 
+
+**Example 2:**
+
+**Input:** l1 = [0], l2 = [0]
+
+**Output:** [0] 
+
+**Example 3:**
+
+**Input:** l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
+
+**Output:** [8,9,9,9,0,0,0,1] 
+
+**Constraints:**
+
+*   The number of nodes in each linked list is in the range `[1, 100]`.
+*   `0 <= Node.val <= 9`
+*   It is guaranteed that the list represents a number that does not have leading zeros.
+
+## Solution
+
+```erlang
+%% Definition for singly-linked list.
+%%
+%% -record(list_node, {val = 0 :: integer(),
+%%                     next = null :: 'null' | #list_node{}}).
+
+-spec add_two_numbers(L1 :: #list_node{} | null, L2 :: #list_node{} | null) -> #list_node{} | null.
+add_two_numbers(L1, L2) ->
+    {Result, _} = add_two_numbers(L1, L2, 0),
+    Result.
+
+-spec add_two_numbers(L1 :: #list_node{} | null, L2 :: #list_node{} | null, Carry :: integer()) -> {#list_node{} | null, integer()}.
+add_two_numbers(null, null, 0) -> 
+    {null, 0};
+add_two_numbers(L1, L2, Carry) ->
+    X = if L1 =/= null -> L1#list_node.val; true -> 0 end,
+    Y = if L2 =/= null -> L2#list_node.val; true -> 0 end,
+    Sum = Carry + X + Y,
+    NewCarry = Sum div 10,
+    NewNode = #list_node{val = Sum rem 10},
+    {Next1, _} = if L1 =/= null -> {L1#list_node.next, 0}; true -> {null, 0} end,
+    {Next2, _} = if L2 =/= null -> {L2#list_node.next, 0}; true -> {null, 0} end,
+    {NextResult, _} = add_two_numbers(Next1, Next2, NewCarry),
+    {NewNode#list_node{next = NextResult}, NewCarry}.
+```

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

@@ -0,0 +1,63 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 3\. Longest Substring Without Repeating Characters
+
+Medium
+
+Given a string `s`, find the length of the **longest substring** without repeating characters.
+
+**Example 1:**
+
+**Input:** s = "abcabcbb"
+
+**Output:** 3
+
+**Explanation:** The answer is "abc", with the length of 3. 
+
+**Example 2:**
+
+**Input:** s = "bbbbb"
+
+**Output:** 1
+
+**Explanation:** The answer is "b", with the length of 1. 
+
+**Example 3:**
+
+**Input:** s = "pwwkew"
+
+**Output:** 3
+
+**Explanation:** The answer is "wke", with the length of 3. Notice that the answer must be a substring, "pwke" is a subsequence and not a substring. 
+
+**Example 4:**
+
+**Input:** s = ""
+
+**Output:** 0 
+
+**Constraints:**
+
+*   <code>0 <= s.length <= 5 * 10<sup>4</sup></code>
+*   `s` consists of English letters, digits, symbols and spaces.
+
+## Solution
+
+```erlang
+-spec length_of_longest_substring(S :: unicode:unicode_binary()) -> integer().
+length_of_longest_substring(S) ->
+    do(S, 0, #{}, 0, 1).
+
+do(<<Char, Rest/binary>>, Index, PrevPos, Max, Acc0) when is_map_key(Char, PrevPos) ->
+    PrevIndex = map_get(Char, PrevPos),
+    Acc1 = Index - PrevIndex,
+    Acc = min(Acc1, Acc0),
+    do(Rest, Index + 1, PrevPos#{Char => Index}, max(Max, Acc), Acc + 1);
+do(<<Char, Rest/binary>>, Index, PrevPos, Max, Acc) when Acc > Max ->
+    do(Rest, Index + 1, PrevPos#{Char => Index}, Acc, Acc + 1);
+do(<<Char, Rest/binary>>, Index, PrevPos, Max, Acc) ->
+    do(Rest, Index + 1, PrevPos#{Char => Index}, Max, Acc + 1);
+
+do(<<>>, _, _, Max, _) -> Max.
+```

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

@@ -0,0 +1,74 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 4\. Median of Two Sorted Arrays
+
+Hard
+
+Given two sorted arrays `nums1` and `nums2` of size `m` and `n` respectively, return **the median** of the two sorted arrays.
+
+The overall run time complexity should be `O(log (m+n))`.
+
+**Example 1:**
+
+**Input:** nums1 = [1,3], nums2 = [2]
+
+**Output:** 2.00000
+
+**Explanation:** merged array = [1,2,3] and median is 2. 
+
+**Example 2:**
+
+**Input:** nums1 = [1,2], nums2 = [3,4]
+
+**Output:** 2.50000
+
+**Explanation:** merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5. 
+
+**Example 3:**
+
+**Input:** nums1 = [0,0], nums2 = [0,0]
+
+**Output:** 0.00000 
+
+**Example 4:**
+
+**Input:** nums1 = [], nums2 = [1]
+
+**Output:** 1.00000 
+
+**Example 5:**
+
+**Input:** nums1 = [2], nums2 = []
+
+**Output:** 2.00000 
+
+**Constraints:**
+
+*   `nums1.length == m`
+*   `nums2.length == n`
+*   `0 <= m <= 1000`
+*   `0 <= n <= 1000`
+*   `1 <= m + n <= 2000`
+*   <code>-10<sup>6</sup> <= nums1[i], nums2[i] <= 10<sup>6</sup></code>
+
+## Solution
+
+```erlang
+-spec find_median_sorted_arrays(Nums1 :: [integer()], Nums2 :: [integer()]) -> float().
+find_median_sorted_arrays(Nums1, Nums2) -> 
+    Len = length(Nums1) + length(Nums2),
+    find_median_sorted_arrays(Nums1, Nums2, [], -1, 0, 0, Len rem 2, Len div 2).
+find_median_sorted_arrays(_, _, [H|T], Index, _, _, Even, Index) ->
+        if Even =:= 1 -> H;
+            true -> (H + lists:nth(1, T)) / 2
+        end;
+find_median_sorted_arrays([], [H2|T2], MyArr, Index, Indx1, Indx2, Even, Middle) ->
+    find_median_sorted_arrays([], T2, [H2|MyArr], Index + 1, Indx1, Indx2 + 1, Even, Middle);
+find_median_sorted_arrays([H1|T1], [], MyArr, Index, Indx1, Indx2, Even, Middle) ->
+    find_median_sorted_arrays(T1, [], [H1|MyArr], Index + 1, Indx1, Indx2 + 1, Even, Middle);
+find_median_sorted_arrays([H1|T1], [H2|T2], MyArr, Index, Indx1, Indx2, Even, Middle) when H1 < H2 -> 
+    find_median_sorted_arrays(T1, [H2|T2], [H1|MyArr], Index + 1, Indx1 + 1, Indx2, Even, Middle);
+find_median_sorted_arrays([H1|T1], [H2|T2], MyArr, Index, Indx1, Indx2, Even, Middle)-> 
+    find_median_sorted_arrays([H1|T1], T2, [H2|MyArr], Index + 1, Indx1, Indx2 + 1, Even, Middle).
+```

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

@@ -0,0 +1,85 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 5\. Longest Palindromic Substring
+
+Medium
+
+Given a string `s`, return _the longest palindromic substring_ in `s`.
+
+**Example 1:**
+
+**Input:** s = "babad"
+
+**Output:** "bab" **Note:** "aba" is also a valid answer. 
+
+**Example 2:**
+
+**Input:** s = "cbbd"
+
+**Output:** "bb" 
+
+**Example 3:**
+
+**Input:** s = "a"
+
+**Output:** "a" 
+
+**Example 4:**
+
+**Input:** s = "ac"
+
+**Output:** "a" 
+
+**Constraints:**
+
+*   `1 <= s.length <= 1000`
+*   `s` consist of only digits and English letters.
+
+## Solution
+
+```erlang
+-spec longest_palindrome(S :: unicode:unicode_binary()) -> unicode:unicode_binary().
+longest_palindrome(S) ->
+    Length = byte_size(S),
+    case Length of
+        0 -> <<>>; % Return empty binary if input is empty
+        _ ->
+            % Initialize variables for the best palindrome
+            {Start, Len} = lists:foldl(
+                fun(Index, {BestStart, BestLen}) ->
+                    % Find the longest palindrome for odd and even length centers
+                    {NewStart1, NewLen1} = find_longest_palindrome(S, Index, Index),
+                    {NewStart2, NewLen2} = find_longest_palindrome(S, Index, Index + 1),
+                    % Choose the longer of the two found palindromes
+                    case NewLen1 >= NewLen2 of
+                        true  -> update_best(BestStart, BestLen, NewStart1, NewLen1);
+                        false -> update_best(BestStart, BestLen, NewStart2, NewLen2)
+                    end
+                end,
+                {0, 0}, % Initial best palindrome start and length
+                lists:seq(0, Length - 1) % Iterate through all positions
+            ),
+            % Extract the longest palindromic substring
+            binary:part(S, Start, Len)
+    end.
+
+% Helper function to find the longest palindrome around the center
+-spec find_longest_palindrome(S :: unicode:unicode_binary(), L :: integer(), R :: integer()) -> {integer(), integer()}.
+find_longest_palindrome(S, L, R) ->
+    Length = byte_size(S),
+    case (L >= 0 andalso R < Length andalso binary:part(S, L, 1) =:= binary:part(S, R, 1)) of
+        true ->
+            find_longest_palindrome(S, L - 1, R + 1);
+        false ->
+            {L + 1, R - L - 1}
+    end.
+
+% Helper function to update the best palindrome found so far
+-spec update_best(BestStart :: integer(), BestLen :: integer(), NewStart :: integer(), NewLen :: integer()) -> {integer(), integer()}.
+update_best(BestStart, BestLen, NewStart, NewLen) ->
+    case NewLen > BestLen of
+        true  -> {NewStart, NewLen};
+        false -> {BestStart, BestLen}
+    end.
+```