Merge branch 'DaleStudy:main' into main

Author: choidabom

3sum/easyone-jwlee.go

@@ -0,0 +1,46 @@
+// 풀이
+// 배열을 정렬하고
+// two pointer 사용
+
+// TC
+// 정렬 O(nlogn) + Two pointer 이중 루프 O(n^2) = O(n^2)
+
+// SC
+// Go의 sort.Ints()는 TimSort를 사용.
+// Merge Sort와 Insertion Sort의 조합으로 동작.
+// 정렬 O(n) + Two pointer O(1) + 결과 배열 O(n) = O(n)
+
+func threeSum(nums []int) [][]int {
+	result := [][]int{}
+	sort.Ints(nums) // nums를 정렬
+
+	for i := 0; i < len(nums)-2; i++ {
+		if i > 0 && nums[i] == nums[i-1] {
+			continue // 중복된 값 건너뜀
+		}
+
+		left, right := i+1, len(nums)-1
+		for left < right {
+			sum := nums[i] + nums[left] + nums[right]
+			if sum == 0 {
+				result = append(result, []int{nums[i], nums[left], nums[right]})
+				left++
+				right--
+
+				// 중복 제거
+				for left < right && nums[left] == nums[left-1] {
+					left++
+				}
+				for left < right && nums[right] == nums[right+1] {
+					right--
+				}
+			} else if sum < 0 {
+				left++
+			} else {
+				right--
+			}
+		}
+	}
+
+	return result
+}

climbing-stairs/easyone-jwlee.go

@@ -0,0 +1,23 @@
+// 풀이
+// 1 일 때, 가능한 step은 1 -> 1가지
+// 2 일 때, 가능한 step은 1 1, 2 -> 2가지
+// 3 일 때, 가능한 step은 1 1 1, 1 2, 2 1 -> 3가지
+// n 일 때, 가능한 stop은 n-1의 가짓수에 1이 붙고, n-2의 가짓수에 2가 붙는다.
+
+// TC
+// O(n)
+
+// SC
+// int타입 변수만 사용해서 O(1)
+
+func climbStairs(n int) int {
+	if n <= 2 {
+		return n
+	}
+	prev := 1 // climb1
+	curr := 2 // climb2
+	for i := 3; i <= n; i++ {
+		prev, curr = curr, (curr + prev)
+	}
+	return curr
+}

construct-binary-tree-from-preorder-and-inorder-traversal/easyone-jwlee.go

@@ -0,0 +1,40 @@
+// 풀이
+// preorder[0]이 제일 꼭대기
+// preorder 배열의 root index, inorder 배열의 시작, inorder 배열의 끝
+// 위의 세가지를 parameter로 받는 재귀함수를 만들어서
+// 왼쪽 서브트리, 오른쪽 서브트리를 순회
+
+// TC
+// map 만들기 O(n) + 재귀함수는 각 노드를 딱 한번씩만 방문하므로 O(n) = O(n)
+
+// SC
+// map O(n) + 재귀함수 최악의 경우 한쪽으로만 노드가 이어지는 경우 O(n) = O(n)
+
+func buildTree(preorder []int, inorder []int) *TreeNode {
+	inorderMap := make(map[int]int)
+	for i, n := range inorder {
+		inorderMap[n] = i
+	}
+
+	var recursive func(rootIndex, inStart, inEnd int) *TreeNode
+	recursive = func(rootIndex, inStart, inEnd int) *TreeNode {
+		if rootIndex >= len(preorder) || inStart > inEnd {
+			return nil
+		}
+		rootVal := preorder[rootIndex]
+		rootInorderIndex := inorderMap[rootVal]
+
+		result := &TreeNode{
+			Val: rootVal,
+		}
+
+		leftSize := rootInorderIndex - inStart
+
+		result.Left = recursive(rootIndex+1, inStart, rootInorderIndex-1)
+		result.Right = recursive(rootIndex+1+leftSize, rootInorderIndex+1, inEnd)
+
+		return result
+	}
+
+	return recursive(0, 0, len(inorder)-1)
+}

contains-duplicate/EstherKim97.py

@@ -0,0 +1,10 @@
+# Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct.
+
+def containsDuplicate(nums):
+    seen = set()
+    for num in nums:
+        if num in seen:
+            return True
+        seen.add(num)
+    return False
+

contains-duplicate/Totschka.ts

@@ -0,0 +1,12 @@
+// https://leetcode.com/problems/contains-duplicate/
+function containsDuplicate(nums: number[]): boolean {
+  const counter = {};
+  for (const n of nums) {
+    if (!counter[n]) {
+      counter[n] = 1;
+    } else {
+      return true;
+    }
+  }
+  return false;
+}

contains-duplicate/Yjason-K.ts

@@ -0,0 +1,18 @@
+/**
+ * Set 자료구조를 사용하여 중복 확인 (시간 복잡도: O(n) )
+ * @param nums 중복 검사할 숫자 배열
+ * @returns boolean 중복 여부
+ */
+
+function containsDuplicate(nums: number[]): boolean {
+    let unique: Set<number> = new Set([]);
+    for (const num of nums) {
+        if (unique.has(num)) {
+            return true
+        } else {
+            unique.add(num)
+        }
+    }
+    return false;
+};
+

contains-duplicate/csucom.cpp

@@ -0,0 +1,32 @@
+#include <malloc.h>
+#include <string.h>
+
+bool containsDuplicate(int* nums, int numsSize) {
+    char* pflag = (char*)malloc(1000000001);
+    char* mflag = (char*)malloc(1000000001);
+    memset(pflag, 0, 1000000001);
+    memset(mflag, 0, 1000000001);
+    for (int i = 0; i < numsSize; ++i) {
+        if (nums[i] < 0) {
+            if (mflag[-nums[i]] == 1) {
+                free(pflag);
+                free(mflag);
+                return true;
+            }
+            mflag[-nums[i]] = 1;
+        }
+        else {
+            if (pflag[nums[i]] == 1) {
+                free(pflag);
+                free(mflag);
+                return true;
+            }
+            pflag[nums[i]] = 1;
+        }
+    }
+    free(pflag);
+    free(mflag);
+    return false;
+}
+
+

contains-duplicate/easyone-jwlee.go

@@ -0,0 +1,24 @@
+// 풀이
+// map으로 중복된 값이 있는지 체크
+
+// TC
+// 중복이 하나도 없는 경우에 최대 n번 조회
+// n번 반복시 총 작업의 복잡도는 O(n)
+
+// SC
+// n개의 숫자를 저장하면 map이 사용하는 공간은 최대 O(n)
+
+// (+) 정렬을 사용한다면?
+// 입력된 배열을 정렬해서 서로 인접한 값을 비교하면 O(1)의 SC로 중복 확인 가능.
+// 그러나 정렬을 사용하면 TC가 O(nlogn).
+
+func containsDuplicate(nums []int) bool {
+	m := make(map[int]int)
+	for _, num := range nums {
+		if _, ok := m[num]; ok {
+			return true
+		}
+		m[num] = num
+	}
+	return false
+}

contains-duplicate/ekgns33.java

@@ -0,0 +1,49 @@
+import java.util.HashSet;
+import java.util.Set;
+
+/*
+start 7:06~7:14 PASS
+input : integer array
+output : return if input contains duplicate
+constraint : 
+1) empty array?
+    nope. at least one 
+2) size?
+    [1, 10^5]
+3) sorted?
+    nope.
+4) range of elements in the array?
+    [-10^9, 10^9] >> max 2 * 10*9 +1
+
+brute force:
+ds : array. algo : just nested for-loop
+iterate through the array, for index i 0 to n. n indicates the size of input
+    nested loop fo r index j from i+1 to n
+        if nums[j] == nums[i] return true;
+
+return false;
+
+time : O(n^2), space : O(1)
+
+better:
+ds : hashset. algo : one for-loop
+iterate through the array:
+    if set contains current value:
+        return true;
+    else
+        add current value to set
+
+return false;
+time : O(n) space :O(n) 
+
+ */
+class Solution {
+  public boolean containsDuplicate(int[] nums) {
+    Set<Integer> set = new HashSet<>();
+    for(int num : nums) {
+      if(set.contains(num)) return true;
+      set.add(num);
+    }
+    return false;
+  }
+}

contains-duplicate/hancrysta1.java

@@ -0,0 +1,8 @@
+import java.util.*;
+class Solution {
+    public boolean containsDuplicate(int[] nums) {
+        Set<Integer> numSet = Arrays.stream(nums).boxed().collect(Collectors.toSet());
+        if(numSet.size()!=nums.length) return true;
+        else return false;
+    }
+}