Added elixir

Author: javadev

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

@@ -0,0 +1,59 @@
+[![](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
+
+```elixir
+defmodule Solution do
+  @spec two_sum(nums :: [integer], target :: integer) :: [integer]
+  def two_sum(nums, target) do
+    nums
+        |> Enum.with_index()
+        |> Enum.reduce_while(%{}, fn {num, index}, map ->
+            case map[target - num] do
+                nil -> {:cont, Map.put(map, num, index)}
+                found -> {:halt, [index, found]}
+            end
+        end)
+  end
+end
+```

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

@@ -0,0 +1,69 @@
+[![](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
+
+```elixir
+# Definition for singly-linked list.
+#
+# defmodule ListNode do
+#   @type t :: %__MODULE__{
+#           val: integer,
+#           next: ListNode.t() | nil
+#         }
+#   defstruct val: 0, next: nil
+# end
+defmodule Solution do
+  @spec add_two_numbers(l1 :: ListNode.t | nil, l2 :: ListNode.t | nil) :: ListNode.t | nil
+  def add_two_numbers(l1, l2) do
+    add(l1, l2, 0)
+  end
+
+  defp add(nil, nil, 0), do: nil
+  defp add(l1, l2, carry) do
+    {val1, next1} = content(l1)
+    {val2, next2} = content(l2)
+    sum = val1 + val2 + carry
+    %ListNode{val: rem(sum, 10), next: add(next1, next2, div(sum, 10))}
+  end
+
+  defp content(nil), do: {0, nil}
+  defp content(node), do: {node.val, node.next}
+end
+```

src/main/elixir/g0001_0100/s0003_longest_substring_without_repeating_characters/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)
+
+## 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
+
+```elixir
+defmodule Solution do
+  @spec length_of_longest_substring(s :: String.t()) :: integer
+  def length_of_longest_substring(s) do
+    sublen([], String.codepoints(s), 0, 0, 0)
+  end
+
+  defp sublen(_, [], _, _, m), do: m
+  
+  defp sublen(left, [next | rest] = right, start, stop, m) do
+    if Enum.member?(left, next) do
+      [_ | mid] = left
+      sublen(mid, right, start + 1, stop, m)
+    else
+      stop = stop + 1
+      sublen(left ++ [next], rest, start, stop, max(m, stop - start))
+    end
+  end
+end
+```

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

@@ -0,0 +1,77 @@
+[![](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
+
+```elixir
+defmodule Solution do
+  @spec find_median_sorted_arrays(nums1 :: [integer], nums2 :: [integer]) :: float
+  def find_median_sorted_arrays(nums1, nums2) do
+    list = Enum.sort(nums1 ++ nums2)
+
+    cond do
+        length(list) === 1 -> 
+            Enum.at(list, 0)
+
+        rem(length(list), 2) === 0 -> 
+            start_index = trunc(length(list) / 2 - 1)
+            (Enum.at(list, start_index) + Enum.at(list, start_index + 1)) / 2
+
+        true -> 
+            start_index = div(length(list), 2)
+            Enum.at(list, start_index)
+    end
+  end
+end
+```

src/main/elixir/g0001_0100/s0005_longest_palindromic_substring/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)
+
+## 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
+
+```elixir
+defmodule Solution do
+  @spec longest_palindrome(s :: String.t()) :: String.t()
+  def longest_palindrome(<<>>), do: ""
+  def longest_palindrome(<<f::binary-size(1)>>), do: f
+  def longest_palindrome(s) do
+    {ri,rj} =String.to_charlist(s) |> List.to_tuple |>  do_longest_palindrome(0, {0,0})
+    String.slice(s,ri..rj)
+  end
+
+  defp do_longest_palindrome(s_t,i,{ri,rj}) when i == tuple_size(s_t), do: {ri,rj}
+  defp do_longest_palindrome(s_t,i,{ri,rj}) do
+    {ri,rj} = do_longest_palindrome(s_t,i,i,{ri,rj})
+    {ri,rj} = do_longest_palindrome(s_t,i,i+1,{ri,rj})
+    do_longest_palindrome(s_t, i+1, {ri, rj})
+  end
+
+  defp do_longest_palindrome(s_t,i,j,{ri,rj}) when (i<0 or j==tuple_size(s_t)) or (elem(s_t,i) != elem(s_t,j)) do
+    if ((j-1)-(i+1)) > rj-ri, do: {i+1,j-1}, else: {ri,rj}
+  end
+  defp do_longest_palindrome(s_t,i,j,{ri,rj}), do: do_longest_palindrome(s_t, i-1, j+1, {ri,rj})
+end
+```