Merge branch 'DaleStudy:main' into main

Author: yolophg

3sum/WhiteHyun.swift

@@ -0,0 +1,41 @@
+//  
+//  15. 3Sum
+//  https://leetcode.com/problems/3sum/description/
+//  Dale-Study
+//  
+//  Created by WhiteHyun on 2024/06/04.
+//  
+
+class Solution {
+  func threeSum(_ nums: [Int]) -> [[Int]] {
+    var result: [[Int]] = []
+    let sorted = nums.sorted()
+
+    for (index, element) in sorted.enumerated() where index <= 0 || element != sorted[index - 1] {
+      var left = index + 1
+      var right = sorted.count - 1
+
+      while left < right {
+        let threeSum = element + sorted[left] + sorted[right]
+        if threeSum > 0 {
+          right -= 1
+          continue
+        }
+        if threeSum < 0 {
+          left += 1
+          continue
+        }
+
+        result.append([element, sorted[left], sorted[right]])
+        left += 1
+
+        while sorted[left] == sorted[left - 1] && left < right {
+          left += 1
+        }
+      }
+    }
+
+
+    return result
+  }
+}

3sum/han.exs

@@ -0,0 +1,38 @@
+defmodule Solution do
+  @spec three_sum(nums :: [integer]) :: [[integer]]
+  def three_sum(nums) do
+    length_of_nums = length nums
+    num_index_map = nums |> Enum.with_index |> Map.new
+    frequencies_of_num = nums |> Enum.frequencies()
+    tuple_nums = nums |> List.to_tuple
+    num_indexs_map = nums |>
+      Enum.with_index() |>
+      Enum.group_by(fn {v, _} -> v end, fn {_, i} -> i end)
+
+    Stream.unfold({0, 1}, fn {i, j} ->
+      if j < length_of_nums - 1,
+      do: {{i, j}, {i, j + 1}},
+      else: {{i, j}, {i + 1, i + 2}}
+    end) |>
+      Stream.take_while(fn {i, _} ->
+        i < length_of_nums - 1
+      end) |>
+      Stream.map(fn {i, j} ->
+        a = elem tuple_nums, i
+        b = elem tuple_nums, j
+        c = -(a + b)
+
+        case frequencies_of_num[c] do
+          nil -> nil
+          count when count >= 3 -> [a, b, c] |> Enum.sort()
+          _ ->
+            if num_indexs_map[c] |> Enum.filter(& &1 != i && &1 != j) |> Enum.at(0),
+            do: [a, b, c] |> Enum.sort(),
+            else: nil
+        end
+      end) |>
+      Stream.reject(& &1 == nil) |>
+      Stream.uniq |>
+      Enum.to_list
+  end
+end

counting-bits/bky373.java

@@ -0,0 +1,23 @@
+/**
+ * https://leetcode.com/problems/counting-bits/
+ *
+ * time: O(n * log n)
+ * space: O(1)
+ */
+class Solution {
+
+    public int[] countBits(int n) {
+        int[] ans = new int[n + 1];
+        for (int i = 0; i <= n; i++) {
+            int x = i;
+            int cnt = 0;
+            while (x != 0) {
+                cnt++;
+                x &= (x - 1);
+            }
+            ans[i] = cnt;
+        }
+        return ans;
+    }
+}
+

encode-and-decode-strings/han.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+class Solution:
+    """
+    @param: strs: a list of strings
+    @return: encodes a list of strings to a single string.
+    """
+    def encode(self, strs):
+        return '-'.join([
+            '.'.join([
+                str(ord(c))
+                for c in s
+            ])
+            for s in strs
+        ])
+
+    """
+    @param: str: A string
+    @return: decodes a single string to a list of strings
+    """
+    def decode(self, str):
+        return [
+            ''.join([
+                chr(int(c))
+                for c in s.split('.')
+            ])
+            for s in str.split('-')
+        ]
+
+
+# 아래는 간단한 테스트 코드
+import random
+
+def generate_random_string(min_length=5, max_length=20):
+    # Choose a random string length between min_length and max_length
+    string_length = random.randint(min_length, max_length)
+
+    # Define the character categories
+    alphabets = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+    numbers = '0123456789'
+    hanguls = '가나다라마바사아자차카타파하'
+    emojis = ['😀', '😂', '😉', '😍', '😎', '😭', '😊', '😜', '😢', '😱']
+
+    # Probability of selecting from each category
+    weights = [0.25, 0.25, 0.25, 0.25]
+
+    # Combine all categories into a single list
+    all_chars = list(alphabets + numbers + hanguls) + emojis
+
+    # Select characters based on the weights and create the final string
+    random_chars = random.choices(all_chars, k=string_length)
+    random_string = ''.join(random_chars)
+
+    return random_string
+
+def generate_multiple_random_strings():
+    strings_list = []
+    # Generate a random number of strings, between 1 and 10
+    number_of_strings = random.randint(1, 10)
+
+    for _ in range(number_of_strings):
+        random_string = generate_random_string()
+        strings_list.append(random_string)
+
+    return strings_list
+
+strs = generate_multiple_random_strings()
+print(strs)
+print(strs==Solution().decode(Solution().encode(strs)))

group-anagrams/bky373.java

@@ -0,0 +1,19 @@
+/**
+ * https://leetcode.com/problems/group-anagrams/
+ *
+ * time: O(n * m log m)
+ * space: O(nm)
+ */
+class Solution {
+
+    public List<List<String>> groupAnagrams(String[] strs) {
+        Map<String, List<String>> groups = new HashMap();
+        for (String str : strs) {
+            char[] arr = str.toCharArray();
+            Arrays.sort(arr);
+            groups.computeIfAbsent(new String(arr), k -> new ArrayList<>())
+                  .add(str);
+        }
+        return new ArrayList(groups.values());
+    }
+}

longest-consecutive-sequence/WhiteHyun.swift

@@ -0,0 +1,25 @@
+//  
+//  128. Longest Consecutive Sequence
+//  https://leetcode.com/problems/longest-consecutive-sequence/description/
+//  Dale-Study
+//  
+//  Created by WhiteHyun on 2024/06/01.
+//  
+
+final class Solution {
+  func longestConsecutive(_ nums: [Int]) -> Int {
+    let set = Set(nums)
+    var best = 0
+    for number in set where !set.contains(number - 1) {
+      var next = number + 1
+      while set.contains(next) {
+        next += 1
+      }
+      if best < next - number {
+        best = next - number
+      }
+    }
+
+    return best
+  }
+}

missing-number/bky373.java

@@ -0,0 +1,15 @@
+/**
+ * https://leetcode.com/problems/missing-number/
+ *
+ * time: O(n)
+ * space: O(1)
+ */
+class Solution {
+    public int missingNumber(int[] nums) {
+        int sum = nums.length * (nums.length+1) / 2;
+        for (int num : nums) {
+            sum -= num;
+        }
+        return sum;
+    }
+}

number-of-1-bits/bky373.java

@@ -0,0 +1,17 @@
+/**
+ * https://leetcode.com/problems/number-of-1-bits/
+ *
+ * time: O(log n)
+ * space: O(1)
+ */
+class Solution {
+
+    public int hammingWeight(int n) {
+        int cnt = 0;
+        while (n != 0) {
+            cnt++;
+            n &= (n - 1);
+        }
+        return cnt;
+    }
+}

product-of-array-except-self/WhiteHyun.swift

@@ -0,0 +1,27 @@
+//  
+//  238. Product of Array Except Self
+//  https://leetcode.com/problems/product-of-array-except-self/description/
+//  Dale-Study
+//  
+//  Created by WhiteHyun on 2024/06/01.
+//  
+
+final class Solution {
+  func productExceptSelf(_ nums: [Int]) -> [Int] {
+    var answer: [Int] = .init(repeating: 1, count: nums.count)
+
+    var left_product = 1
+    for i in nums.indices {
+      answer[i] = left_product
+      left_product *= nums[i]
+    }
+
+    var right_product = 1
+    for i in nums.indices.reversed() {
+      answer[i] *= right_product
+      right_product *= nums[i]
+    }
+
+    return answer
+  }
+}

reverse-bits/bky373.java

@@ -0,0 +1,17 @@
+/**
+ * https://leetcode.com/problems/reverse-bits/
+ *
+ * time: O(1)
+ * space: O(1)
+ */
+public class Solution {
+
+    public int reverseBits(int n) {
+        int ans = 0;
+        for (int i = 0; i < 32; i++) {
+            ans = ans << 1 | n & 1;
+            n >>= 1;
+        }
+        return ans;
+    }
+}