Added tasks 137-206

Author: javadev

README.md

@@ -0,0 +1,42 @@
+[![](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)
+
+## 137\. Single Number II
+
+Medium
+
+Given an integer array `nums` where every element appears **three times** except for one, which appears **exactly once**. _Find the single element and return it_.
+
+You must implement a solution with a linear runtime complexity and use only constant extra space.
+
+**Example 1:**
+
+**Input:** nums = [2,2,3,2]
+
+**Output:** 3
+
+**Example 2:**
+
+**Input:** nums = [0,1,0,1,0,1,99]
+
+**Output:** 99
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 3 * 10<sup>4</sup></code>
+*   <code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code>
+*   Each element in `nums` appears exactly **three times** except for one element which appears **once**.
+
+## Solution
+
+```erlang
+-spec single_number(Nums :: [integer()]) -> integer().
+single_number(Nums) ->
+    Frequencies = lists:foldl(fun count_frequency/2, #{}, Nums),
+    {Key, _} = lists:keyfind(1, 2, maps:to_list(Frequencies)),
+    Key.
+
+-spec count_frequency(Num :: integer(), Map :: map()) -> map().
+count_frequency(Num, Map) ->
+    maps:update_with(Num, fun(V) -> V + 1 end, 1, Map).
+```

src/main/erlang/g0101_0200/s0137_single_number_ii/readme.md

@@ -0,0 +1,84 @@
+[![](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)
+
+## 139\. Word Break
+
+Medium
+
+Given a string `s` and a dictionary of strings `wordDict`, return `true` if `s` can be segmented into a space-separated sequence of one or more dictionary words.
+
+**Note** that the same word in the dictionary may be reused multiple times in the segmentation.
+
+**Example 1:**
+
+**Input:** s = "leetcode", wordDict = ["leet","code"]
+
+**Output:** true
+
+**Explanation:** Return true because "leetcode" can be segmented as "leet code".
+
+**Example 2:**
+
+**Input:** s = "applepenapple", wordDict = ["apple","pen"]
+
+**Output:** true
+
+**Explanation:** Return true because "applepenapple" can be segmented as "apple pen apple". 
+
+Note that you are allowed to reuse a dictionary word.
+
+**Example 3:**
+
+**Input:** s = "catsandog", wordDict = ["cats","dog","sand","and","cat"]
+
+**Output:** false
+
+**Constraints:**
+
+*   `1 <= s.length <= 300`
+*   `1 <= wordDict.length <= 1000`
+*   `1 <= wordDict[i].length <= 20`
+*   `s` and `wordDict[i]` consist of only lowercase English letters.
+*   All the strings of `wordDict` are **unique**.
+
+## Solution
+
+```erlang
+-spec word_break(S :: unicode:unicode_binary(), WordDict :: [unicode:unicode_binary()]) -> boolean().
+word_break(S, WordDict) ->
+    % Initialize ETS table for memoization
+    ets:new(memo, [set, named_table]),
+    % Process word dict to include sizes
+    Words = [{Word, byte_size(Word)} || Word <- WordDict],
+    % Get result
+    Result = breakable(S, Words),
+    % Clean up
+    ets:delete(memo),
+    Result.
+
+-spec breakable(binary(), [{binary(), integer()}]) -> boolean().
+breakable(<<>>, _Words) ->
+    true;
+breakable(S, Words) ->
+    case ets:lookup(memo, S) of
+        [{_, Result}] ->
+            Result;
+        [] ->
+            Result = try_words(S, Words, Words),
+            ets:insert(memo, {S, Result}),
+            Result
+    end.
+
+try_words(_S, [], _AllWords) ->
+    false;
+try_words(S, [{Word, Len} | Rest], AllWords) ->
+    case S of
+        <<Prefix:Len/binary, Remaining/binary>> when Prefix =:= Word ->
+            case breakable(Remaining, AllWords) of
+                true -> true;
+                false -> try_words(S, Rest, AllWords)
+            end;
+        _ ->
+            try_words(S, Rest, AllWords)
+    end.
+```

src/main/erlang/g0101_0200/s0138_copy_list_with_random_pointer/readme.md

@@ -0,0 +1,129 @@
+[![](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)
+
+## 146\. LRU Cache
+
+Medium
+
+Design a data structure that follows the constraints of a **[Least Recently Used (LRU) cache](https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU)**.
+
+Implement the `LRUCache` class:
+
+*   `LRUCache(int capacity)` Initialize the LRU cache with **positive** size `capacity`.
+*   `int get(int key)` Return the value of the `key` if the key exists, otherwise return `-1`.
+*   `void put(int key, int value)` Update the value of the `key` if the `key` exists. Otherwise, add the `key-value` pair to the cache. If the number of keys exceeds the `capacity` from this operation, **evict** the least recently used key.
+
+The functions `get` and `put` must each run in `O(1)` average time complexity.
+
+**Example 1:**
+
+**Input** ["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"] [[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
+
+**Output:** [null, null, null, 1, null, -1, null, -1, 3, 4]
+
+**Explanation:** 
+
+LRUCache lRUCache = new LRUCache(2); 
+
+lRUCache.put(1, 1); // cache is {1=1} 
+
+lRUCache.put(2, 2); // cache is {1=1, 2=2} 
+
+lRUCache.get(1); // return 1 
+
+lRUCache.put(3, 3); // LRU key was 2, evicts key 2, cache is {1=1, 3=3} 
+
+lRUCache.get(2); // returns -1 (not found) 
+
+lRUCache.put(4, 4); // LRU key was 1, evicts key 1, cache is {4=4, 3=3}
+
+lRUCache.get(1); // return -1 (not found) 
+
+lRUCache.get(3); // return 3 
+
+lRUCache.get(4); // return 4
+
+**Constraints:**
+
+*   `1 <= capacity <= 3000`
+*   <code>0 <= key <= 10<sup>4</sup></code>
+*   <code>0 <= value <= 10<sup>5</sup></code>
+*   At most <code>2 * 10<sup>5</sup></code> calls will be made to `get` and `put`.
+
+## Solution
+
+```erlang
+%% Persistent Term Keys
+-define(CAPACITY_KEY, {lru_cache, capacity}).
+-define(CACHE_TABLE, lru_cache_cache_table).
+-define(TTL_TABLE, lru_cache_ttl_table).
+
+%% API Specifications
+-spec lru_cache_init_(Capacity :: integer()) -> ok.
+lru_cache_init_(Capacity) ->
+    persistent_term:put(?CAPACITY_KEY, Capacity),
+    case ets:info(?CACHE_TABLE) of
+        undefined ->
+            ets:new(?CACHE_TABLE, [set, public, named_table]),
+            ets:new(?TTL_TABLE, [ordered_set, public, named_table]);
+        _ ->
+            ets:delete_all_objects(?CACHE_TABLE),
+            ets:delete_all_objects(?TTL_TABLE)
+    end,
+    ok.
+
+-spec lru_cache_get(Key :: integer()) -> integer().
+lru_cache_get(Key) ->
+    case extract(Key) of
+        {Key, Value} ->
+            insert(Key, Value),
+            Value;
+        -1 ->
+            -1
+    end.
+
+-spec lru_cache_put(Key :: integer(), Value :: integer()) -> ok.
+lru_cache_put(Key, Value) ->
+    _ = extract(Key),
+    insert(Key, Value),
+    evict(),
+    ok.
+
+%% Internal Functions
+extract(Key) ->
+    case ets:lookup(?CACHE_TABLE, Key) of
+        [{Key, Uniq, Value}] ->
+            ets:delete(?TTL_TABLE, Uniq),
+            {Key, Value};
+        [] ->
+            -1
+    end.
+
+insert(Key, Value) ->
+    Uniq = unique_integer(),
+    ets:insert(?CACHE_TABLE, {Key, Uniq, Value}),
+    ets:insert(?TTL_TABLE, {Uniq, Key}).
+
+evict() ->
+    Capacity = persistent_term:get(?CAPACITY_KEY),
+    CurrentSize = ets:info(?CACHE_TABLE, size),
+    if
+        CurrentSize > Capacity ->
+            Uniq = ets:first(?TTL_TABLE),
+            [{_, Key}] = ets:lookup(?TTL_TABLE, Uniq),
+            ets:delete(?TTL_TABLE, Uniq),
+            ets:delete(?CACHE_TABLE, Key);
+        true ->
+            ok
+    end.
+
+unique_integer() ->
+    erlang:unique_integer([monotonic]).
+
+%% Your functions will be called as such:
+%% lru_cache_init_(Capacity),
+%% Param_1 = lru_cache_get(Key),
+%% lru_cache_put(Key, Value),
+
+%% lru_cache_init_ will be called before every test case, in which you can do some necessary initializations.
+```

src/main/erlang/g0101_0200/s0139_word_break/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)
+
+## 148\. Sort List
+
+Medium
+
+Given the `head` of a linked list, return _the list after sorting it in **ascending order**_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/14/sort_list_1.jpg)
+
+**Input:** head = [4,2,1,3]
+
+**Output:** [1,2,3,4]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/09/14/sort_list_2.jpg)
+
+**Input:** head = [-1,5,3,4,0]
+
+**Output:** [-1,0,3,4,5]
+
+**Example 3:**
+
+**Input:** head = []
+
+**Output:** []
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range <code>[0, 5 * 10<sup>4</sup>]</code>.
+*   <code>-10<sup>5</sup> <= Node.val <= 10<sup>5</sup></code>
+
+**Follow up:** Can you sort the linked list in `O(n logn)` time and `O(1)` memory (i.e. constant space)?
+
+## Solution
+
+```erlang
+%% Definition for singly-linked list.
+%%
+%% -record(list_node, {val = 0 :: integer(),
+%%                     next = null :: 'null' | #list_node{}}).
+
+%% @spec sort_list(Head :: #list_node{} | null) -> #list_node{} | null.
+-spec sort_list(Head :: #list_node{} | null) -> #list_node{} | null.
+sort_list(Head) ->
+    List = node_to_list(Head, []),
+    SortedList = lists:sort(fun(X, Y) -> X > Y end, List),
+    list_to_node(SortedList, null).
+
+%% Converts a linked list to an Erlang list.
+-spec node_to_list(Node :: #list_node{} | null, Acc :: [integer()]) -> [integer()].
+node_to_list(null, Acc) ->
+    Acc;
+node_to_list(#list_node{val = Val, next = Next}, Acc) ->
+    node_to_list(Next, [Val | Acc]).
+
+%% Converts an Erlang list to a linked list.
+-spec list_to_node(List :: [integer()], Node :: #list_node{} | null) -> #list_node{} | null.
+list_to_node([], Node) ->
+    Node;
+list_to_node([H | T], Node) ->
+    list_to_node(T, #list_node{val = H, next = Node}).
+```