Added erlang

Author: javadev

src/main/erlang/g0001_0100/s0049_group_anagrams/Solution.erl

@@ -1,24 +1,25 @@
 % #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #String #Hash_Table #Sorting
 % #Data_Structure_II_Day_8_String #Programming_Skills_II_Day_11 #Udemy_Strings
-% #Big_O_Time_O(n*k_log_k)_Space_O(n) #2025_01_12_Time_23_(_%)_Space_73.88_(100.00%)
+% #Big_O_Time_O(n*k_log_k)_Space_O(n) #2025_01_15_Time_13_(90.00%)_Space_73.34_(100.00%)
 
 -spec group_anagrams(Strs :: [unicode:unicode_binary()]) -> [[unicode:unicode_binary()]].
 group_anagrams(Strs) ->
-    group_anagrams(Strs, dict:new()).
+    AnagramMap = group_anagrams_helper(Strs, #{}),
+    maps:values(AnagramMap).
 
--spec group_anagrams(Strs :: [unicode:unicode_binary()], Acc :: dict:dict()) -> [[unicode:unicode_binary()]].
-group_anagrams([], Acc) ->
-    dict:fold(fun(_, Val, AccAcc) -> [Val | AccAcc] end, [], Acc);
-group_anagrams([Word | Rest], Acc) ->
-    Key = create_key(Word),
-    NewAcc = case dict:find(Key, Acc) of
-                {ok, List} -> dict:store(Key, [Word | List], Acc);
-                error -> dict:store(Key, [Word], Acc)
-              end,
-    group_anagrams(Rest, NewAcc).
+group_anagrams_helper([Head | Tail], Acc) ->
+    NewString = sort_string(Head),
+    NewMap = case maps:is_key(NewString, Acc) of
+        true ->
+            maps:update(NewString, [Head | maps:get(NewString, Acc)], Acc);
+        false ->
+            maps:put(NewString, [Head], Acc)
+    end,
+    group_anagrams_helper(Tail, NewMap);
+group_anagrams_helper([], Acc) ->
+    Acc.
 
--spec create_key(Word :: unicode:unicode_binary()) -> unicode:unicode_binary().
-create_key(Word) ->
-    CharList = unicode:characters_to_list(Word),  % Convert the binary string to a list of characters
-    SortedList = lists:sort(CharList),            % Sort the characters to create a canonical key
-    list_to_binary(SortedList).                   % Convert back to binary for the dictionary key
+sort_string(Str) ->
+    StrList = binary_to_list(Str),        % Convert string to list of characters
+    SortedList = lists:sort(StrList),       % Sort the list of characters
+    list_to_binary(SortedList).

src/main/erlang/g0001_0100/s0056_merge_intervals/Solution.erl

@@ -0,0 +1,22 @@
+% #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Sorting
+% #Data_Structure_II_Day_2_Array #Level_2_Day_17_Interval #Udemy_2D_Arrays/Matrix
+% #Big_O_Time_O(n_log_n)_Space_O(n) #2025_01_13_Time_8_(100.00%)_Space_70.88_(100.00%)
+
+-spec merge(Intervals :: [[integer()]]) -> [[integer()]].
+merge(Intervals) ->
+    SortedIntervals = lists:sort(fun([Start1, _], [Start2, _]) -> Start1 =< Start2 end, Intervals),
+    lists:reverse(
+        lists:foldl(fun([Start, Finish], Acc) ->
+            case Acc of
+                [] -> [[Start, Finish]];
+                [[PrevStart, PrevFinish] | Rest] ->
+                    if PrevFinish >= Start ->
+                        %% Merge overlapping intervals
+                        [[PrevStart, erlang:max(PrevFinish, Finish)] | Rest];
+                       true ->
+                        %% No overlap
+                        [[Start, Finish] | Acc]
+                    end
+            end
+        end, [], SortedIntervals)
+    ).

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

@@ -0,0 +1,27 @@
+56\. Merge Intervals
+
+Medium
+
+Given an array of `intervals` where <code>intervals[i] = [start<sub>i</sub>, end<sub>i</sub>]</code>, merge all overlapping intervals, and return _an array of the non-overlapping intervals that cover all the intervals in the input_.
+
+**Example 1:**
+
+**Input:** intervals = [[1,3],[2,6],[8,10],[15,18]]
+
+**Output:** [[1,6],[8,10],[15,18]]
+
+**Explanation:** Since intervals [1,3] and [2,6] overlap, merge them into [1,6].
+
+**Example 2:**
+
+**Input:** intervals = [[1,4],[4,5]]
+
+**Output:** [[1,5]]
+
+**Explanation:** Intervals [1,4] and [4,5] are considered overlapping.
+
+**Constraints:**
+
+*   <code>1 <= intervals.length <= 10<sup>4</sup></code>
+*   `intervals[i].length == 2`
+*   <code>0 <= start<sub>i</sub> <= end<sub>i</sub> <= 10<sup>4</sup></code>

src/main/erlang/g0001_0100/s0062_unique_paths/Solution.erl

@@ -0,0 +1,17 @@
+% #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Dynamic_Programming #Math
+% #Combinatorics #Algorithm_II_Day_13_Dynamic_Programming #Dynamic_Programming_I_Day_15
+% #Level_1_Day_11_Dynamic_Programming #Big_O_Time_O(m*n)_Space_O(m*n)
+% #2025_01_13_Time_0_(100.00%)_Space_58.34_(100.00%)
+
+-spec unique_paths(M :: integer(), N :: integer()) -> integer().
+unique_paths(M, N) ->
+    Ncr = fun(N, R) ->
+        lists:foldl(
+          fun(I, Acc) -> 
+              (Acc * (I + N - R)) div I
+          end, 
+          1, 
+          lists:seq(1, R)
+        )
+    end,
+    Ncr(M + N - 2, erlang:min(M, N) - 1).

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

@@ -0,0 +1,35 @@
+62\. Unique Paths
+
+Medium
+
+There is a robot on an `m x n` grid. The robot is initially located at the **top-left corner** (i.e., `grid[0][0]`). The robot tries to move to the **bottom-right corner** (i.e., `grid[m - 1][n - 1]`). The robot can only move either down or right at any point in time.
+
+Given the two integers `m` and `n`, return _the number of possible unique paths that the robot can take to reach the bottom-right corner_.
+
+The test cases are generated so that the answer will be less than or equal to <code>2 * 10<sup>9</sup></code>.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2018/10/22/robot_maze.png)
+
+**Input:** m = 3, n = 7
+
+**Output:** 28
+
+**Example 2:**
+
+**Input:** m = 3, n = 2
+
+**Output:** 3
+
+**Explanation:** From the top-left corner, there are a total of 3 ways to reach the bottom-right corner: 
+
+1. Right -> Down -> Down 
+
+2. Down -> Down -> Right 
+
+3. Down -> Right -> Down
+
+**Constraints:**
+
+*   `1 <= m, n <= 100`

src/main/erlang/g0001_0100/s0070_climbing_stairs/Solution.erl

@@ -0,0 +1,19 @@
+% #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Dynamic_Programming #Math #Memoization
+% #Algorithm_I_Day_12_Dynamic_Programming #Dynamic_Programming_I_Day_2
+% #Level_1_Day_10_Dynamic_Programming #Udemy_Dynamic_Programming #Big_O_Time_O(n)_Space_O(n)
+% #2025_01_13_Time_0_(100.00%)_Space_58.51_(100.00%)
+
+-spec climb_stairs(N :: integer()) -> integer().
+climb_stairs(N) ->
+    StairsRecursive = fun StairsRecursive(Res, Last, Curr) -> 
+        if Curr == N ->
+                Res;
+            true ->
+                StairsRecursive(Res + Last, Res, Curr + 1)
+        end
+    end,
+    if N =< 2 ->
+            N;
+        true ->
+            StairsRecursive(2,1,2)
+    end.

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

@@ -0,0 +1,37 @@
+70\. Climbing Stairs
+
+Easy
+
+You are climbing a staircase. It takes `n` steps to reach the top.
+
+Each time you can either climb `1` or `2` steps. In how many distinct ways can you climb to the top?
+
+**Example 1:**
+
+**Input:** n = 2
+
+**Output:** 2
+
+**Explanation:** There are two ways to climb to the top. 
+
+1. 1 step + 1 step 
+
+2. 2 steps
+
+**Example 2:**
+
+**Input:** n = 3
+
+**Output:** 3
+
+**Explanation:** There are three ways to climb to the top. 
+
+1. 1 step + 1 step + 1 step 
+
+2. 1 step + 2 steps 
+
+3. 2 steps + 1 step
+
+**Constraints:**
+
+*   `1 <= n <= 45`

src/main/erlang/g0001_0100/s0072_edit_distance/Solution.erl

@@ -0,0 +1,41 @@
+% #Medium #Top_100_Liked_Questions #String #Dynamic_Programming
+% #Algorithm_II_Day_18_Dynamic_Programming #Dynamic_Programming_I_Day_19
+% #Udemy_Dynamic_Programming #Big_O_Time_O(n^2)_Space_O(n2)
+% #2025_01_13_Time_251_(100.00%)_Space_122.91_(100.00%)
+
+-spec min_distance(Word1 :: unicode:unicode_binary(), Word2 :: unicode:unicode_binary()) -> integer().
+min_distance(Word1, Word2) ->
+    Word1List = [" " | unicode:characters_to_list(Word1)],
+    Word2List = [" " | unicode:characters_to_list(Word2)],
+    Len1 = length(Word1List) - 1,
+    Len2 = length(Word2List) - 1,
+    
+    Map = build_distance_map(Word1List, Word2List),
+    maps:get({Len1, Len2}, Map).
+
+build_distance_map(Word1List, Word2List) ->
+    Indices1 = lists:zip(Word1List, lists:seq(0, length(Word1List) - 1)),
+    Indices2 = lists:zip(Word2List, lists:seq(0, length(Word2List) - 1)),
+    lists:foldl(
+        fun({Ch1, I}, MapAcc1) ->
+            lists:foldl(
+                fun({Ch2, J}, MapAcc2) ->
+                    Value = calculate_distance(Ch1, Ch2, I, J, MapAcc2),
+                    maps:put({I, J}, Value, MapAcc2)
+                end,
+                MapAcc1,
+                Indices2
+            )
+        end,
+        maps:new(),
+        Indices1
+    ).
+
+calculate_distance(_, _, 0, J, _) -> J;
+calculate_distance(_, _, I, 0, _) -> I;
+calculate_distance(Ch, Ch, I, J, Map) ->
+    maps:get({I-1, J-1}, Map);
+calculate_distance(_, _, I, J, Map) ->
+    Min1 = min(maps:get({I-1, J}, Map), maps:get({I-1, J-1}, Map)),
+    Min2 = min(Min1, maps:get({I, J-1}, Map)),
+    Min2 + 1.

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

@@ -0,0 +1,48 @@
+72\. Edit Distance
+
+Hard
+
+Given two strings `word1` and `word2`, return _the minimum number of operations required to convert `word1` to `word2`_.
+
+You have the following three operations permitted on a word:
+
+*   Insert a character
+*   Delete a character
+*   Replace a character
+
+**Example 1:**
+
+**Input:** word1 = "horse", word2 = "ros"
+
+**Output:** 3
+
+**Explanation:** 
+
+horse -> rorse (replace 'h' with 'r') 
+
+rorse -> rose (remove 'r') 
+
+rose -> ros (remove 'e')
+
+**Example 2:**
+
+**Input:** word1 = "intention", word2 = "execution"
+
+**Output:** 5
+
+**Explanation:** 
+
+intention -> inention (remove 't') 
+
+inention -> enention (replace 'i' with 'e') 
+
+enention -> exention (replace 'n' with 'x') 
+
+exention -> exection (replace 'n' with 'c') 
+
+exection -> execution (insert 'u')
+
+**Constraints:**
+
+*   `0 <= word1.length, word2.length <= 500`
+*   `word1` and `word2` consist of lowercase English letters.

src/main/erlang/g0001_0100/s0074_search_a_2d_matrix/Solution.erl

@@ -0,0 +1,39 @@
+% #Medium #Top_100_Liked_Questions #Array #Binary_Search #Matrix #Data_Structure_I_Day_5_Array
+% #Algorithm_II_Day_1_Binary_Search #Binary_Search_I_Day_8 #Level_2_Day_8_Binary_Search
+% #Udemy_2D_Arrays/Matrix #Big_O_Time_O(endRow+endCol)_Space_O(1)
+% #2025_01_13_Time_0_(100.00%)_Space_61.38_(100.00%)
+
+-spec search_matrix(Matrix :: [[integer()]], Target :: integer()) -> boolean().
+search_matrix(Matrix, Target) -> 
+    % Get the total number of rows and columns
+    {Rows, Cols} = {length(Matrix), length(hd(Matrix))},
+    
+    % Perform binary search
+    binary_search(Matrix, Rows, Cols, Target, 0, Rows * Cols - 1).
+
+% Function to perform binary search
+-spec binary_search([[integer()]], integer(), integer(), integer(), integer(), integer()) -> boolean().
+binary_search(Matrix, Rows, Cols, Target, Left, Right) ->
+    if 
+        Left > Right -> 
+            false; % If left index exceeds the right one, return false
+        true ->
+            % Calculate mid index and get corresponding row and column
+            Mid = (Left + Right) div 2,
+            {Row, Col} = {Mid div Cols, Mid rem Cols},
+            
+            % Fetch the value from the matrix
+            Value = lists:nth(Col + 1, lists:nth(Row + 1, Matrix)),
+            
+            % If the value equals the target, return true
+            if
+                Value == Target -> 
+                    true;
+                Value < Target -> 
+                    % If the value is less than the target, search in the right half
+                    binary_search(Matrix, Rows, Cols, Target, Mid + 1, Right);
+                true -> 
+                    % If the value is greater than the target, search in the left half
+                    binary_search(Matrix, Rows, Cols, Target, Left, Mid - 1)
+            end
+    end.