Merge pull request #673 from YeomChaeeun/main

[YeomChaeeun] Week 1

Author: YeomChaeeun

contains-duplicate/YeomChaeeun.ts

@@ -0,0 +1,36 @@
+function containsDuplicate(nums: number[]): boolean {
+
+    // 접근 (1) - 시간 복잡도가 매우 커서 실패
+    // const uniqueArr = nums.filter((item, index) => { return nums.indexOf(item) === index })
+    // console.log(uniqueArr)
+    //
+    // return nums.length !== uniqueArr.length;
+
+    // 접근 (2) - 양 옆의 값을 비교 =============
+    // if(nums.length === 1)
+    //     return false;
+    //
+    // // 정렬
+    // nums.sort()
+    //
+    // // 양 옆의 값을 비교
+    // for(let i = 0; i < nums.length; i++){
+    //     console.log(nums[i], nums[i+1])
+    //     if(nums[i] === nums[i+1]){
+    //         return true;
+    //     }
+    // }
+    // return false;
+
+    // 접근 (3) - obj를 이용 ================
+    let obj={}
+
+    for(let i = 0; i < nums.length; i++) {
+        if(obj[nums[i]]) {
+            return true;
+        }
+        obj[nums[i]] = 1;
+    }
+    return false;
+
+};

house-robber/YeomChaeeun.ts

@@ -0,0 +1,43 @@
+/**
+ * 하나 이상 건너 뛴 값을 더한 것중 가장 높은 값의 합을 구하기
+ * @param nums
+ */
+function rob(nums: number[]): number {
+
+    if(nums.length === 1) return nums[0];
+
+    // 0 + 2 ...
+    // 1 + 3 ...
+    // Max(인덱스 0부터 더한 것, 인덱스 1부터 더한 것)
+
+    // 접근 (1) - 양 옆의 값을 제외하고 홀수/짝수 인덱스 값들을 더했음
+    // [2, 1, 1, 2] 일 때, 답이 4가 나와야 함
+    // let max = 0
+    // let odd = 0
+    // let even = 0
+    // for(let i = 0; i < nums.length; i++) {
+    //     if(i % 2 == 0) {
+    //         console.log(nums[i], 'even >>>', even);
+    //         even += nums[i];
+    //     } else {
+    //         console.log(nums[i], 'odd >>>', odd);
+    //         odd += nums[i];
+    //     }
+    // }
+    // console.log(even, '===', odd);
+    // max = Math.max(even, odd);
+
+    // 접근 (2) - max 값을 저장해두고 Math.max(하나 이상 건너뛴 값 + 현재 값 더한 것, max) 를 구함
+    let prev = 0
+    let max = 0
+    let temp = 0
+    for(let i = 0; i < nums.length; i++) {
+        temp = max
+        max = Math.max(prev + nums[i], max) // 이전의 값과 하나 이상 건너뛰고 더한 값 중 최대 값을 구함
+        prev = temp
+
+        // console.log(temp, " - ", max, " - ", prev)
+    };
+    // console.log(max);
+    return max;
+};

longest-consecutive-sequence/YeomChaeeun.ts

@@ -0,0 +1,44 @@
+/**
+ * 가장 긴 연속의 시퀀스 구하기
+ * @param nums
+ */
+function longestConsecutive(nums: number[]): number {
+
+    // length 가 0, 1 인 경우
+    if(nums.length < 2)
+        return nums.length; // 0, 1
+
+    // 정렬
+    nums = nums.sort((a, b) => a - b)
+
+    // 접근 (1) 처음 연속된 count만 리턴함 =============
+    // let count = 1
+    // for(let i = 0; i < nums.length-1; i++) {
+    //     if(nums[i] === nums[i+1]) {
+    //         continue;
+    //     } else if(nums[i] - nums[i+1] === 1) {
+    //         count++;
+    //     } else {
+    //         break;
+    //     }
+    // };
+    // console.log(count);
+    // return count;
+
+    // =========
+
+    let longest = 0;
+    let current = 1;
+    for(let i = 0; i < nums.length-1; i++) {
+        if(nums[i] === nums[i - 1]) {
+            continue;
+        } else if(nums[i] + 1 === nums[i + 1] ) {
+            current += 1;
+        } else {
+            longest = Math.max(current, longest);
+            current = 1;
+        }
+    }
+
+    return longest;
+};

top-k-frequent-elements/YeomChaeeun.ts

@@ -0,0 +1,19 @@
+/**
+ *
+ * @param nums
+ * @param k
+ */
+function topKFrequent(nums: number[], k: number): number[] {
+    let obj = {}
+
+    for(const num of nums) {
+        if(!obj[num])
+            obj[num] = 0
+        ++obj[num]
+    }
+
+    return Object.entries(obj)
+        .sort((a, b) => Number(b[1]) - Number(a[1]))
+        .slice(0, k)
+        .map(entry => Number(entry[0]));
+};

valid-palindrome/YeomChaeeun.ts

@@ -0,0 +1,15 @@
+/**
+ * palindrom: 회문, 거꾸로 읽어도 제대로 읽는 것과 같은 문장
+ * @param s
+ */
+function isPalindrome(s: string): boolean {
+    let word = s.toLowerCase();
+    const reg = /[^a-z0-9]/g; // removing all non-alphanumeric characters
+    word = word.replace(reg, '');
+
+    for(let i = 0; i < word.length; i++) {
+        if(word[i] !== word[word.length-i-1])
+            return false;
+    }
+    return true;
+};