├── README.md ├── intermediate ├── 05_효율성_슬라이딩윈도우 │ └── 5_최대매출.js ├── 05_효율성_투포인터 │ ├── 1_두배열합치기.js │ ├── 2_공통원소구하기.js │ ├── 3_연속부분수열.js │ └── 4_연속부분수열2.js ├── 05_효율성_해시맵 │ ├── 6_학급회장.js │ ├── 7_아나그램.js │ └── 8_모든아나그램찾기.js ├── 06_자료구조_스택 │ ├── 1_올바른괄호.js │ ├── 2_괄호문자제거.js │ └── 4_후위식연산.js ├── 06_자료구조_큐 │ ├── 6_공주구하기.js │ └── 7_교육과정설계.js ├── 07_결정알고리즘 │ ├── 10_이분검색.js │ ├── 11_뮤직비디오.js │ └── 12_마구간정하기.js └── 07_그리디 │ ├── 7_좌표정렬.js │ ├── 8_회의실배정.js │ └── 9_결혼식.js ├── jeju100 ├── 001~030 초급 │ ├── 001 배열의삭제.js │ ├── 002 배열의 내장함수.js │ ├── 003 변수의타입.js │ ├── 004 변수의타입2.js │ ├── 005 for문계산.js │ ├── 006 False.js │ ├── 007 변수명.js │ ├── 008 객체의키이름중복.js │ ├── 009 concat을활용한출력방법.js │ ├── 010 별찍기.js │ ├── 011 for기본활용.js │ ├── 012 게임캐릭터클래스만들기.js │ ├── 013 몇번째행성인가요.js │ ├── 014 3의배수인가요.js │ ├── 015 자기소개.js │ ├── 016 로꾸거.js │ ├── 017 놀이기구키제한.js │ ├── 018 평균점수.js │ ├── 019 제곱을구하자.js │ ├── 020 몫과나머지.js │ ├── 021 set은어떻게만드나요.js │ ├── 022 배수인지확인하기.js │ ├── 023 OX문제.js │ ├── 024 대문자로바꿔주세요.js │ ├── 025 원의넓이를구하세요.js │ ├── 026 행성문제2.js │ ├── 027 객체만들기.js │ ├── 028 2-gram.js │ ├── 029 대문자만지나가세요.js │ └── 030 문자열속문자찾기.js ├── 031~080 중급 │ ├── 031 자바스크립트자료형의복잡도.js │ ├── 032 문자열만들기.js │ ├── 033 거꾸로출력하기.js │ ├── 034 sort구현하기.js │ ├── 035 Factory함수사용하기.js │ ├── 036 구구단출력하기.js │ ├── 037 반장선거.js │ ├── 038 호준이의아르바이트.js │ ├── 039 오타수정하기.js │ ├── 040 놀이동산에가자.js │ ├── 041 소수판별.js │ ├── 042 2020년.js │ ├── 043 10진수를 2진수로.js │ ├── 044 각자리수의합.js │ ├── 045 getTime()함수사용하기.js │ ├── 046 각자리수의합2.js │ ├── 047 set자료형의응용.js │ ├── 048 대소문자바꿔서출력하기.js │ ├── 049 최댓값구하기.js │ ├── 050 버블정렬구현하기.js │ ├── 051 mergesort를만들어보자.js │ ├── 052 quicksork.js │ ├── 053 괄호문자열.js │ ├── 054 연속되는수.js │ ├── 055 하노이의탑.js │ ├── 056 객체의함수응용.js │ ├── 057 1의개수.js │ ├── 058 콤마찍기.js │ ├── 059 빈칸채우기.js │ ├── 060 번호매기기.js │ ├── 061 문자열압축하기.js │ ├── 062 20201023 출력하기.js │ ├── 063 친해지고싶어.js │ ├── 064 이상한 엘리베이터.js │ ├── 065 변형된리스트.js │ ├── 066 블럭탑쌓기.js │ ├── 067 민규의악수.js │ ├── 068 버스시간표.js │ ├── 069 골드바흐의추측.js │ ├── 070 행렬곱하기.js │ ├── 071 깊이우선탐색.js │ ├── 072 너비우선탐색.js │ ├── 073 최단경로찾기.js │ ├── 074 최장거리찾기.js │ ├── 075 이상한369.js │ ├── 076 안전한땅.js │ ├── 077 가장긴공통부분문자열.js │ ├── 078 원형테이블.js │ ├── 079 순회하는 리스트.js │ └── 080 순열과 조합.js └── 081~100 고급 │ ├── 081 지뢰찾기.js │ ├── 082 수학괄호파싱.js │ ├── 083 수학괄호파싱2.js │ ├── 084 숫자뽑기.js │ ├── 085 숫자놀이.js │ ├── 086 회전초밥.js │ ├── 087 천하제일먹기대회.js │ ├── 088 지식이의 게임개발.js │ ├── 089 지식이의 게임개발2.js │ ├── 090 같은의약성분을찾아라.js │ ├── 091 반평균등수.js │ ├── 092 키보드고장.js │ ├── 093 페이지교체-선입선출알고리즘.js │ ├── 094 페이지교체-LRU알고리즘.js │ ├── 095 도장찍기.js │ ├── 096 넓은텃밭만들기.js │ ├── 097 택배배달.js │ ├── 098 청길이의 패션대회.js │ ├── 099 토끼들의 행진.js │ └── 100 퍼즐게임.js └── leetcode ├── .gitignore ├── 1_Easy ├── 0001 Two Sum.js ├── 0007 Reverse Integer.js ├── 0008 String to Integer.js ├── 0013 Roman to Integer.js ├── 0014 Longest Common Prefix.js ├── 0020 Valid Parentheses.js ├── 0021 Merge Two Sorted Lists.js ├── 0026 Remove Duplicates from Sorted Array.js ├── 0028 Implement strStr().js ├── 0035 Search Insert Position.js ├── 0038 Count and Say.js ├── 0048 Rotate Image.js ├── 0069 Sqrt(x).js ├── 0088 Merge Sorted Array.js ├── 0101 Symmetric Tree.js ├── 0103 Binary Tree Zigzag Level Order Traversal.js ├── 0108 Convert Sorted Array to Binary Search Tree.js ├── 0118 Pascal's Triangle.js ├── 0121 Best Time to Buy and Sell Stock.js ├── 0125 Valid Palindrom.js ├── 0141 Linked List Cycle.js ├── 0160 Intersection of Two Linked Lists.js ├── 0202 Happy Number.js ├── 0217 Contains Duplicate.js ├── 0231 Power of Two.js ├── 0234 Palindrome Linked List.js ├── 0242 Valid Aagram.js ├── 0268 Missing Number.js ├── 0278 First Bad Version.js ├── 0290 Word Pattern.js ├── 0326 Power of Three.js ├── 0344 Reverse String.js ├── 0345 Reverse Vowels of a String.js ├── 0349 Intersection of Two Arrays.js ├── 0392 Is Subsequence.js ├── 0415 Add Strings.js ├── 0628 Maximum Product of Three Numbers.js ├── 0697 Degree of an Array.js ├── 0704 Binary Search.js ├── 0709 To Lower Case.js ├── 0744 Find Smallest Letter Greater Than Target.js ├── 0771 Jewels and Stones.js ├── 0819 Most Common Word.js ├── 0832 Flipping an Image.js ├── 0874 Walking Robot Simulation.js ├── 0938 Range Sum of BST.js ├── 1018 Binary Prefix Divisible By 5.js ├── 1021 Remove Outermost Parentheses.js ├── 1108 Defanging an IP Address.js ├── 1207 Unique Number of Occurrences.js ├── 1221 Split a String in Balanced Strings.js ├── 1252 Cells with Odd Values in a Matrix.js ├── 1266 Minimum Time Visiting All Points.js ├── 1281 Subtract the Product and Sum of Digits of an Integer.js ├── 1290 Convert Binary Number in a Linked List to Integer.js ├── 1295 Find Numbers with Even Number of Digits.js ├── 1313 Decompress Run-Length Encoded List.js ├── 1323 Maximum 69 Number.js ├── 1342 Number of Steps to Reduce a Number to Zero.js ├── 1365 How Many Numbers Are Smaller Than the Current Number.js ├── 1370 Increasing Decreasing String.js ├── 1389 Create Target Array in the Given Order.js ├── 1431 Kids With the Greatest Number of Candies.js ├── 1436 Destination City.js ├── 1450 Number of Students Doing Homework at a Given Time.js ├── 1464 Maximum Product of Two Elements in an Array.js ├── 1470 Shuffle the Array.js ├── 1480 Running Sum of 1d Array.js ├── 1486 XOR Operation in an Array.js ├── 1512 Number of Good Pairs.js ├── 1518 Water Bottles.js ├── 1528 Shuffle String.js ├── 1534 Count Good Triplets.js ├── 1572 Matrix Diagonal Sum.js ├── 1576 Replace All ?'s to Avoid Consecutive Repeating Characters.js └── 1582 Special Positions in a Binary Matrix.js ├── 2_Medium ├── 0002 Add Two Numbers.js ├── 0003 Longest Substring Without Repeating Characters.js ├── 0011 Container With Most Water.js ├── 0015 3Sum.js ├── 0017 Letter Combinations of a Phone Number.js ├── 0022 Generate Parentheses.js ├── 0034 Find First and Last Position of Element in Sorted Array.js ├── 0036 Valid Sudoku.js ├── 0046 Permutations.js ├── 0049 Group Anagrams.js ├── 0053 Maximum Subarray.js ├── 0055 Jump Game.js ├── 0062 Unique Paths.js ├── 0073 Set Matrix Zeroes.js ├── 0075 Sort Colors.js ├── 0078 Subsets.js ├── 0094 Binary Tree Inorder Traversal.js ├── 0102 Binary Tree Level Order Traversal.js ├── 0103 Binary Tree Zigzag Level Order Traversal.js ├── 0150. Evaluate Reverse Polish Notation.js ├── 0152 Maximum Product Subarray.js ├── 0153 Find Minimum in Rotated Sorted Array.js ├── 0155 Min Stack.js ├── 0162 Find Peak Element.js ├── 0172 Factorial Trailing Zeroes.js ├── 0198 House Robber.js ├── 0204 Count Primes.js ├── 0215 Kth Largest Element in an Array.js ├── 0238 Product of Array Except Self.js ├── 0300 Longest Increasing Subsequence.js ├── 0322 Coin Change.js ├── 0328 Odd Even Linked List.js ├── 0347 Top K Frequent Elements.js ├── 0371 Sum of Two Integers.js ├── 0384 Shuffle an Array.js ├── 0797 All Paths From Source to Target.js ├── 0807 Max Increase to Keep City Skyline.js ├── 1008 Construct Binary Search Tree from Preorder Traversal.js ├── 1038 Binary Search Tree to Greater Sum Tree.js ├── 1282 Group the People Given the Group Size They Belong To.js ├── 1302 Deepest Leaves Sum.js ├── 1315 Sum of Nodes with Even-Valued Grandparent.js ├── 1379 Find a Corresponding Node of a Binary Tree in a Clone of That Tree.js ├── 1395 Count Number of Teams.js ├── 1409 Queries on a Permutation With Key.js ├── 1476 Subrectangle Queries.js ├── 1551 Minimum Operations to Make Array Equal.js └── 1561 Maximum Number of Coins You Can Get.js ├── 3_Hard └── 0297 Serialize and Deserialize Binary Tree.js ├── jest.config.json ├── package-lock.json └── package.json /intermediate/05_효율성_슬라이딩윈도우/5_최대매출.js: -------------------------------------------------------------------------------- 1 | /* 2 | N일 동안의 매출기록을 주고 연속된 K일 동안의 최대 매출액이 얼마인지 구하세요. 3 | 4 | - 이중 for문: n^2 5 | - 슬라이딩 윈도우: n 6 | */ 7 | 8 | const solution = (revenues, n) => { 9 | let max = revenues.slice(0, n).reduce((acc, cur) => (acc += cur), 0); 10 | let sum = max; 11 | 12 | for (i = n; i < revenues.length; i++) { 13 | sum += revenues[i] - revenues[i - n]; 14 | max = sum > max ? sum : max; 15 | } 16 | 17 | return max; 18 | }; 19 | 20 | console.log(solution([12, 15, 11, 20, 25, 10, 20, 19, 13, 15], 3)); 21 | -------------------------------------------------------------------------------- /intermediate/05_효율성_투포인터/1_두배열합치기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 오름차순으로 정렬이 된 두 배열이 주어지면 두 배열을 오름차순으로 합쳐 출력하는 프로그램 을 작성하세요. 3 | 4 | - 두 배열을 합치고 sort할 경우: nlogn 5 | - 투포인터 알고리즘: n + m 6 | */ 7 | 8 | const solution = (arr1, arr2) => { 9 | const answer = []; 10 | let p1 = 0; 11 | let p2 = 0; 12 | 13 | while (p1 < arr1.length && p2 < arr2.length) { 14 | // 더 작은 값을 answer에 push하고 pointer를 옮겨준다. 15 | if (arr1[p1] < arr2[p2]) { 16 | answer.push(arr1[p1]); 17 | p1++; 18 | } else { 19 | answer.push(arr2[p2]); 20 | p2++; 21 | } 22 | } 23 | 24 | if (p1 === arr1.length) { 25 | answer.push(...arr2.slice(p2)); 26 | } else { 27 | answer.push(...arr1.slice(p1)); 28 | } 29 | 30 | return answer; 31 | }; 32 | 33 | console.log(solution([1, 3, 5], [2, 3, 6, 7, 9])); 34 | // [ 1, 2, 3, 3, 5, 6, 7, 9] 35 | -------------------------------------------------------------------------------- /intermediate/05_효율성_투포인터/2_공통원소구하기.js: -------------------------------------------------------------------------------- 1 | /* 2 | A, B 두 개의 집합이 주어지면 두 집합의 공통 원소를 추출하여 오름차순으로 출력하는 프로 그램을 작성하세요. 3 | 4 | - 이중 for문: n x m 5 | - 각 배열 정렬 후 투포인터 알고리즘: nlogn + n 6 | */ 7 | 8 | const solution = (unsortedArr1, unsortedArr2) => { 9 | const answer = []; 10 | const arr1 = unsortedArr1.sort((a, b) => a - b); 11 | const arr2 = unsortedArr2.sort((a, b) => a - b); 12 | 13 | let p1 = 0; 14 | let p2 = 0; 15 | 16 | while (p1 < arr1.length && p2 < arr2.length) { 17 | // 값이 같으면 push한다. 18 | if (arr1[p1] === arr2[p2]) { 19 | answer.push(arr1[p1]); 20 | p1++; 21 | p2++; 22 | continue; 23 | } 24 | if (arr1[p1] < arr2[p2]) { 25 | while (arr1[p1] < arr2[p2]) { 26 | p1++; 27 | } 28 | } else { 29 | while (arr1[p1] > arr2[p2]) { 30 | p2++; 31 | } 32 | } 33 | } 34 | return answer; 35 | }; 36 | 37 | console.log(solution([1, 3, 9, 5, 2], [3, 2, 5, 7, 8])); 38 | // [ 2, 3, 5 ] 39 | -------------------------------------------------------------------------------- /intermediate/05_효율성_투포인터/3_연속부분수열.js: -------------------------------------------------------------------------------- 1 | /* 2 | N개의 수로 이루어진 수열이 주어집니다. 3 | 이 수열에서 연속부분수열의 합이 특정숫자 target이 되는 경우가 몇 번 있는지 구하는 프로그램을 작성하세요. 4 | 5 | 이중 for문 : n^2 6 | 투포인터 알고리즘: n 7 | */ 8 | 9 | const solution = (arr, target) => { 10 | let left = 0; 11 | let sum = 0; 12 | let answer = 0; 13 | 14 | // sum보다 작으면 right를 증가시키면서 범위를 넓힌다. 15 | // 더할 때는 index를 먼저 옮긴 후 더해준다. 16 | for (let right = 0; right < arr.length; right++) { 17 | sum += arr[right]; 18 | 19 | if (sum < target) { 20 | continue; 21 | } 22 | 23 | if (sum === target) { 24 | answer++; 25 | } 26 | 27 | // sum보다 크거나 같으면 left를 증가시키면서 범위를 좁힌다. 28 | // 뺄 때는 먼저 빼주고 index를 옮겨준다. 29 | 30 | sum -= arr[left]; 31 | left++; 32 | 33 | if (sum === target) { 34 | answer++; 35 | } 36 | } 37 | 38 | return answer; 39 | }; 40 | 41 | console.log(solution([1, 2, 1, 3, 1, 1, 1, 2], 6)); 42 | // 3 43 | console.log(solution([1, 2, 1, 3, 1, 1, 1, 3], 6)); 44 | // 4 45 | -------------------------------------------------------------------------------- /intermediate/05_효율성_투포인터/4_연속부분수열2.js: -------------------------------------------------------------------------------- 1 | /* 2 | N개의 수로 이루어진 수열이 주어집니다. 3 | 이 수열에서 연속부분수열의 합이 특정숫자 target이하가 되는 경우가 몇 번 있는지 구하는 프로그램을 작성하세요. 4 | (중복 가능) 5 | */ 6 | 7 | const solution = (arr, target) => { 8 | let left = 0; 9 | let sum = 0; 10 | let answer = 0; 11 | 12 | for (let right = 0; right < arr.length; right++) { 13 | sum += arr[right]; 14 | 15 | if (sum <= target) { 16 | answer += right - left + 1; 17 | continue; 18 | } 19 | sum -= arr[left]; 20 | left++; 21 | } 22 | 23 | return answer; 24 | }; 25 | 26 | console.log(solution([1, 2, 1, 3, 1, 1, 1, 2], 6)); 27 | // 10 28 | console.log(solution([1, 1, 1, 1], 5)); 29 | // 10 30 | -------------------------------------------------------------------------------- /intermediate/05_효율성_해시맵/6_학급회장.js: -------------------------------------------------------------------------------- 1 | /* 2 | 학급 회장을 뽑는데 후보로 기호 A, B, C, D, E 후보가 등록을 했습니다. 3 | 투표용지에는 반 학생들이 자기가 선택한 후보의 기호(알파벳)가 쓰여져 있으며 선생님은 그 기호를 발표하고 있습니다. 4 | 선생님의 발표가 끝난 후 어떤 기호의 후보가 학급 회장이 되었는지 출력하는 프로그램을 작 성하세요. 반드시 한 명의 학급회장이 선출되도록 투표결과가 나왔다고 가정합니다. 5 | 6 | - 자바스크립트 map 주요 메서드: get, set, has, delete, keys, values, entries 7 | */ 8 | 9 | const solution = (votes) => { 10 | const map = new Map(); 11 | let answer = ''; 12 | let max = 0; 13 | 14 | votes.split('').forEach((vote) => { 15 | const newValue = map.has(vote) ? map.get(vote) + 1 : 1; 16 | 17 | map.set(vote, newValue); 18 | }); 19 | 20 | for (let [key, value] of map.entries()) { 21 | if (value > max) { 22 | max = value; 23 | answer = key; 24 | } 25 | } 26 | 27 | return answer; 28 | }; 29 | 30 | console.log(solution('BACBACCACCBDEDE')); 31 | -------------------------------------------------------------------------------- /intermediate/05_효율성_해시맵/7_아나그램.js: -------------------------------------------------------------------------------- 1 | /* 2 | Anagram이란 두 문자열이 알파벳의 나열 순서를 다르지만 그 구성이 일치하면 두 단어는 아나그램이라고 합니다. 3 | 예를 들면 AbaAeCe 와 baeeACA 는 알파벳을 나열 순서는 다르지만 그 구성을 살펴보면 A(2), a(1), b(1), C(1), e(2)로 알파벳과 그 개수가 모두 일치합니다. 즉 어느 한 단어를 재 배열하면 상대편 단어가 될 수 있는 것을 아나그램이라 합니다. 4 | 길이가 같은 두 개의 단어가 주어지면 두 단어가 아나그램인지 판별하는 프로그램을 작성하세요. 5 | 6 | 아나그램 판별시 대소문자가 구분됩니다. 7 | */ 8 | 9 | const solution = (str1, str2) => { 10 | const obj = {}; 11 | 12 | for (const char of str1.split('')) { 13 | obj[char] = obj[char] === undefined ? 1 : obj[char] + 1; 14 | } 15 | for (const char of str2.split('')) { 16 | if (obj[char] === undefined || obj[char] === 0) { 17 | return 'NO'; 18 | } 19 | obj[char] -= 1; 20 | } 21 | return 'YES'; 22 | }; 23 | 24 | console.log(solution('AbaAeCe', 'baeeACA')); 25 | // YES 26 | console.log(solution('abaCC', 'Caaab')); 27 | // NO 28 | -------------------------------------------------------------------------------- /intermediate/05_효율성_해시맵/8_모든아나그램찾기.js: -------------------------------------------------------------------------------- 1 | /* 2 | T문자열과 아나그램이 되는 S의 부분문자열의 개수를 구하는 프로그램을 작성하세요. 3 | 아나그램 판별시 대소문자가 구분됩니다. 4 | 부분문자열은 연속된 문자열이어야 합니다. 5 | 6 | - 투포인터, 슬라이딩윈도우, 해시 모두 적용 7 | 8 | */ 9 | 10 | const solution = (str1, str2) => { 11 | const strLong = str1.length > str2.length ? str1 : str2; 12 | const strShort = str1.length > str2.length ? str2 : str1; 13 | const mapLong = new Map(); 14 | const mapShort = new Map(); 15 | const lenLong = strLong.length; 16 | const lenShort = strShort.length; 17 | 18 | const isSameMap = (map1, map2) => { 19 | if (map1.size !== map2.size) { 20 | return false; 21 | } 22 | for (const [key, value] of map1.entries()) { 23 | if (map2.get(key) !== value) { 24 | return false; 25 | } 26 | } 27 | return true; 28 | }; 29 | let answer = 0; 30 | 31 | strShort.split('').forEach((char) => { 32 | const newValue = mapShort.has(char) ? mapShort.get(char) + 1 : 1; 33 | 34 | mapShort.set(char, newValue); 35 | }); 36 | 37 | for (let i = 0; i < lenShort; i++) { 38 | const char = strLong[i]; 39 | const newValue = mapLong.has(char) ? mapLong.get(char) + 1 : 1; 40 | 41 | mapLong.set(char, newValue); 42 | } 43 | 44 | for (let i = lenShort - 1; i < lenLong; i++) { 45 | answer += Number(isSameMap(mapLong, mapShort)); 46 | 47 | const leftKey = strLong[i - lenShort + 1]; 48 | const leftValue = mapLong.get(leftKey); 49 | const newRightKey = strLong[i + 1]; 50 | 51 | // left 삭제를 right 추가보다 먼저 해야 로직이 꼬이지 않는다. 52 | if (leftValue === 1) { 53 | mapLong.delete(leftKey); 54 | } else { 55 | mapLong.set(leftKey, leftValue - 1); 56 | } 57 | 58 | if (mapLong.has(newRightKey)) { 59 | mapLong.set(newRightKey, mapLong.get(newRightKey) + 1); 60 | } else { 61 | mapLong.set(newRightKey, 1); 62 | } 63 | } 64 | 65 | return answer; 66 | }; 67 | 68 | console.log(solution('bacaAacba', 'abc')); 69 | 70 | // 3 71 | -------------------------------------------------------------------------------- /intermediate/06_자료구조_스택/1_올바른괄호.js: -------------------------------------------------------------------------------- 1 | /* 2 | 괄호가 입력되면 올바른 괄호이면 “YES", 올바르지 않으면 ”NO"를 출력합니다. 3 | */ 4 | 5 | const solution = (str) => { 6 | const stack = []; 7 | 8 | for (let char of str) { 9 | if (char === '(') { 10 | stack.push(char); 11 | } else { 12 | // pop 할게 남아있지 않다면 올바르지 않다. 13 | if (stack.length === 0) { 14 | return 'NO'; 15 | } 16 | stack.pop(); 17 | } 18 | } 19 | 20 | // 순회를 마쳤는데도 pop 할게 남아있다면 올바르지 않다. 21 | if (stack.length !== 0) { 22 | return 'NO'; 23 | } 24 | return 'YES'; 25 | }; 26 | 27 | console.log(solution('(()(()))(()')); 28 | // NO 29 | console.log(solution('(()())(())')); 30 | // YES 31 | -------------------------------------------------------------------------------- /intermediate/06_자료구조_스택/2_괄호문자제거.js: -------------------------------------------------------------------------------- 1 | /* 2 | 입력된 문자열에서 소괄호 ( ) 사이에 존재하는 모든 문자를 제거하고 남은 문자만 출력하는 프로그램을 작성하세요. 3 | */ 4 | 5 | const solution = (str) => { 6 | const stack = []; 7 | 8 | for (const char of str) { 9 | if (char === ')') { 10 | while (stack.pop() !== '('); 11 | } else { 12 | stack.push(char); 13 | } 14 | } 15 | 16 | return stack.join(''); 17 | }; 18 | 19 | console.log(solution('(A(BC)D)EF(G(H)(IJ)K)LM(N)')); 20 | // 'EFLM' 21 | -------------------------------------------------------------------------------- /intermediate/06_자료구조_스택/4_후위식연산.js: -------------------------------------------------------------------------------- 1 | /* 2 | 후위연산식이 주어지면 연산한 결과를 출력하는 프로그램을 작성하세요. 3 | 식은 1~9의 숫자와 +, -, *, / 연산자로만 이루어집니다. 4 | 5 | 만약 3*(5+2)-9 을 후위연산식으로 표현하면 352+*9- 로 표현되며 그 결과는 12입니다. 6 | */ 7 | 8 | const solution = (equation) => { 9 | let stack = []; 10 | 11 | for (let char of equation) { 12 | if (isNaN(char)) { 13 | const right = stack.pop(); 14 | const left = stack.pop(); 15 | const temp = eval(`${left}${char}${right}`); 16 | 17 | stack.push(temp); 18 | } else { 19 | stack.push(char); 20 | } 21 | } 22 | 23 | return stack[0]; 24 | }; 25 | 26 | console.log(solution('352+*9-')); 27 | // 12 28 | -------------------------------------------------------------------------------- /intermediate/06_자료구조_큐/6_공주구하기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 정보 왕국의 이웃 나라 외동딸 공주가 숲속의 괴물에게 잡혀갔습니다. 3 | 정보 왕국에는 왕자가 N명이 있는데 서로 공주를 구하러 가겠다고 합니다. 정보왕국의 왕은 다음과 같은 방법으로 공주를 구하러 갈 왕자를 결정하기로 했습니다. 4 | 5 | - 왕은 왕자들을 나이 순으로 1번부터 N번까지 차례로 번호를 매긴다. 6 | - 1번 왕자부터 N번 왕자까지 순서대로 시계 방향으로 돌아가며 동그랗게 앉게 한다. 7 | - 1번 왕자부터 시 계방향으로 돌아가며 1부터 시작하여 번호를 외치게 한다. 8 | - 한 왕자가 K(특정숫자)를 외치면 그 왕자는 공주를 구하러 가는데서 제외되고 원 밖으로 나오게 된다. 9 | - 그리고 다음 왕자부터 다시 1부터 시작하여 번호를 외친다. 10 | - 이렇게 해서 마지막까지 남은 왕자가 공주를 구하러 갈 수 있다. 11 | 12 | N과 K가 주어질 때 공주를 구하러 갈 왕자의 번호를 출력하는 프로그램을 작성하시오. 13 | */ 14 | 15 | const solution = (n, k) => { 16 | let princes = Array.from({ length: n }, (_, i) => i + 1); 17 | let count = 1; 18 | 19 | while (princes.length > 1) { 20 | if (count !== k) { 21 | const prince = princes.shift(); 22 | princes.push(prince); 23 | count++; 24 | continue; 25 | } 26 | 27 | princes.shift(); 28 | count = 1; 29 | } 30 | 31 | return princes[0]; 32 | }; 33 | 34 | console.log(solution(8, 3)); 35 | // 36 | -------------------------------------------------------------------------------- /intermediate/06_자료구조_큐/7_교육과정설계.js: -------------------------------------------------------------------------------- 1 | /* 2 | 현수는 1년 과정의 수업계획을 짜야 합니다. 3 | 수업중에는 필수과목이 있습니다. 이 필수과목은 반드시 이수해야 하며, 그 순서도 정해져 있 습니다. 4 | 5 | 만약 총 과목이 A, B, C, D, E, F, G가 있고, 여기서 필수과목이 CBA로 주어지면 필수과목은 C, B, A과목이며 이 순서대로 꼭 수업계획을 짜야 합니다. 6 | 여기서 순서란 B과목은 C과목을 이수한 후에 들어야 하고, A과목은 C와 B를 이수한 후에 들어야 한다는 것입니다. 7 | 8 | 현수가 C, B, D, A, G, E로 수업계획을 짜면 제대로 된 설계이지만 C, G, E, A, D, B 순서로 짰다면 잘못 설계된 수업계획이 됩니다. 9 | 10 | 수업계획은 그 순서대로 앞에 수업이 이수되면 다음 수업을 시작하다는 것으로 해석합니다. 11 | 수업계획서상의 각 과목은 무조건 이수된다고 가정합니다. 12 | 13 | 필수과목순서가 주어지면 현수가 짠 N개의 수업설계가 잘된 것이면 “YES", 잘못된 것이면 ”NO“를 출력하는 프로그램을 작성하세요. 14 | 15 | */ 16 | 17 | const solution = (mandatory, curriculum) => { 18 | const mandatorySubjects = mandatory.split(''); 19 | const mySubjects = curriculum.split(''); 20 | 21 | for (let mandatorySubject of mandatorySubjects) { 22 | if (!mySubjects.length) { 23 | return 'NO'; 24 | } 25 | let mySubject = mySubjects.shift(); 26 | 27 | while (mySubjects.length && mySubject !== mandatorySubject) { 28 | mySubject = mySubjects.shift(); 29 | } 30 | 31 | if (mySubject !== mandatorySubject) { 32 | return 'NO'; 33 | } 34 | } 35 | 36 | return 'YES'; 37 | }; 38 | 39 | console.log(solution('CBA', 'CBDAGE')); 40 | // YES 41 | console.log(solution('ABC', 'BABC')); 42 | // YES 43 | console.log(solution('CBA', 'CBDAGAE')); 44 | // YES 45 | -------------------------------------------------------------------------------- /intermediate/07_결정알고리즘/10_이분검색.js: -------------------------------------------------------------------------------- 1 | /* 2 | 임의의 N개의 숫자가 입력으로 주어집니다. 3 | N개의 수를 오름차순으로 정렬한 다음 N개의 수 중 한 개의 수인 M이 주어지면 이분검색으로 M이 정렬된 상태에서 몇 번째에 있는지 구하는 프로그램을 작성하세요. 4 | 단 중복값은 존재하지 않습니다. 5 | 6 | 순차탐색: n 7 | 이분탐색: logn 8 | */ 9 | 10 | const solution = (array, target) => { 11 | const sorted = array.sort((a, b) => a - b); 12 | // 우선 배열을 정렬한다. 13 | let start = 0; 14 | let end = sorted.length - 1; 15 | let mid; 16 | 17 | while (start <= end) { 18 | mid = Math.floor((start + end) / 2); 19 | 20 | if (sorted[mid] === target) { 21 | break; 22 | } 23 | if (sorted[mid] > target) { 24 | end = mid; 25 | continue; 26 | } 27 | if (sorted[mid] < target) { 28 | start = mid; 29 | } 30 | } 31 | 32 | return mid + 1; 33 | }; 34 | 35 | console.log(solution([23, 87, 65, 12, 57, 32, 99, 81], 32)); 36 | // 3 37 | -------------------------------------------------------------------------------- /intermediate/07_결정알고리즘/11_뮤직비디오.js: -------------------------------------------------------------------------------- 1 | /* 2 | 결정 알고리즘 (이분검색) 3 | 4 | DVD에는 총 N개의 곡이 들어가는데, DVD에 녹화할 때에는 라이브에서의 순서가 그대로 유지 되어야 한다. 5 | 즉, 1번 노래와 5번 노래를 같은 DVD에 녹화하기 위해서는 1번과 5번 사이의 모든 노래도 같은 DVD에 녹화해야 한다. 6 | 또한 한 노래를 쪼개서 두 개의 DVD에 녹화하면 안된다. 7 | 지니레코드 입장에서는 이 DVD가 팔릴 것인지 확신할 수 없기 때문에 이 사업에 낭비되는 DVD를 가급적 줄이려고 한다. 8 | 고민 끝에 지니레코드는 M개의 DVD에 모든 동영상을 녹화하기 로 하였다. 이 때 DVD의 크기(녹화 가능한 길이)를 최소로 하려고 한다. 9 | 그리고 M개의 DVD는 모두 같은 크기여야 제조원가가 적게 들기 때문에 꼭 같은 크기로 해야 한다. 10 | 11 | 12 | 조영필이 라이브에서 부른 순서대로 부른 곡의 길이가 분 단위로(자연수) 주어진다. 13 | 부른 곡의 길이는 10,000분을 넘지 않는다고 가정하자. 14 | M(1≤M≤N) 15 | */ 16 | 17 | const solution = (songs, m) => { 18 | let start = Math.min(...songs); 19 | let end = songs.reduce((acc, cur) => (acc += cur), 0); 20 | let mid; 21 | 22 | while (start <= end) { 23 | mid = Math.floor((start + end) / 2); 24 | 25 | if (start === mid) { 26 | break; 27 | } 28 | 29 | const sums = Array.from({ length: m }, () => 0); 30 | let i = 0; 31 | let okay = true; 32 | 33 | for (const song of songs) { 34 | if (sums[i] + song < mid) { 35 | sums[i] += song; 36 | continue; 37 | } 38 | 39 | i++; 40 | 41 | if (i >= m) { 42 | okay = false; 43 | break; 44 | } 45 | } 46 | 47 | if (okay) { 48 | end = mid; 49 | } else { 50 | start = mid; 51 | } 52 | } 53 | return mid; 54 | }; 55 | 56 | console.log(solution([1, 2, 3, 4, 5, 6, 7, 8, 9], 3)); 57 | -------------------------------------------------------------------------------- /intermediate/07_결정알고리즘/12_마구간정하기.js: -------------------------------------------------------------------------------- 1 | /* 2 | N개의 마구간이 수직선상에 있습니다. 3 | 각 마구간은 x1, x2, x3, ......, xN의 좌표를 가지며, 마구간 간에 좌표가 중복되는 일은 없습니다. 4 | 각 마구간에는 한 마리의 말만 넣을 수 있고, 가장 가까운 두 말의 거리가 최대가 되게 말을 마구간에 배치하고 싶습니다. 5 | C마리의 말을 N개의 마구간에 배치했을 때 가장 가까운 두 말의 거리가 최대가 되는 그 최대값을 출력하는 프로그램을 작성하세요. 6 | */ 7 | 8 | const solution = (horseCount, roomPositions) => { 9 | roomPositions.sort((a, b) => a - b); 10 | 11 | let start = 1; 12 | let end = roomPositions.slice(-1) - roomPositions[0]; 13 | let mid; 14 | 15 | while (start <= end) { 16 | mid = Math.floor((start + end) / 2); // 최대간격 후보 17 | 18 | if (start === mid) { 19 | break; 20 | } 21 | 22 | let currHorseCount = 0; 23 | let prevPosition = -Infinity; 24 | 25 | for (const position of roomPositions) { 26 | if (position - prevPosition >= mid) { 27 | currHorseCount++; 28 | prevPosition = position; 29 | } 30 | } 31 | if (currHorseCount < horseCount) { 32 | end = mid; 33 | } else { 34 | start = mid; 35 | } 36 | } 37 | 38 | return mid; 39 | }; 40 | 41 | console.log(solution(3, [1, 2, 8, 4, 9])); 42 | -------------------------------------------------------------------------------- /intermediate/07_그리디/7_좌표정렬.js: -------------------------------------------------------------------------------- 1 | /* 2 | N개의 평면상의 좌표(x, y)가 주어지면 모든 좌표를 오름차순으로 정렬하는 프로그램을 작성하세요. 3 | 정렬기준은 먼저 x값의 의해서 정렬하고, x값이 같을 경우 y값에 의해 정렬합니다. 4 | */ 5 | 6 | const solution = (positions) => { 7 | return positions.sort(([ax, ay], [bx, by]) => { 8 | if (ax === bx) { 9 | return ay - by; 10 | } 11 | return ax - bx; 12 | }); 13 | }; 14 | 15 | console.log( 16 | solution([ 17 | [2, 7], 18 | [1, 3], 19 | [1, 2], 20 | [2, 5], 21 | [3, 6], 22 | ]) 23 | ); 24 | /* 25 | 1 2 26 | 1 3 27 | 2 5 28 | 2 7 29 | 3 6 30 | */ 31 | -------------------------------------------------------------------------------- /intermediate/07_그리디/8_회의실배정.js: -------------------------------------------------------------------------------- 1 | /* 2 | 대표적인 greedy 문제 3 | 4 | 한 개의 회의실이 있는데 이를 사용하고자 하는 n개의 회의들에 대하여 회의실 사용표를 만들려고 한다. 5 | 각 회의에 대해 시작시간과 끝나는 시간이 주어져 있고, 각 회의가 겹치지 않게 하 면서 회의실을 사용할 수 있는 최대수의 회의를 찾아라. 6 | 단, 회의는 한번 시작하면 중간에 중단될 수 없으며 한 회의가 끝나는 것과 동시에 다음 회의가 시작될 수 있다. 7 | 8 | 9 | */ 10 | 11 | const solution = (meetings) => { 12 | // 끝나는 시간으로 정렬한다. 13 | let sorted = meetings.slice().sort(([aStart, aEnd], [bStart, bEnd]) => { 14 | if (aEnd === bEnd) { 15 | return aStart - bStart; 16 | } 17 | return aEnd - bEnd; 18 | }); 19 | let currentEnd = 0; 20 | let answer = 0; 21 | 22 | for (const [start, end] of sorted) { 23 | if (start >= currentEnd) { 24 | answer++; 25 | currentEnd = end; 26 | } 27 | } 28 | return answer; 29 | }; 30 | 31 | console.log( 32 | solution([ 33 | [1, 4], 34 | [2, 3], 35 | [3, 5], 36 | [4, 6], 37 | [5, 7], 38 | ]) 39 | ); 40 | // 3 41 | 42 | console.log( 43 | solution([ 44 | [3, 3], 45 | [1, 3], 46 | [2, 3], 47 | ]) 48 | ); 49 | // 2 50 | -------------------------------------------------------------------------------- /intermediate/07_그리디/9_결혼식.js: -------------------------------------------------------------------------------- 1 | /* 2 | 대표적인 greedy 문제 3 | 4 | 현수는 다음 달에 결혼을 합니다. 5 | 현수는 결혼식 피로연을 장소를 빌려 3일간 쉬지 않고 하려고 합니다. 6 | 피로연에 참석하는 친구들 N명의 참석하는 시간정보를 현수는 친구들에게 미리 요구했습니다. 7 | 각 친구들은 자신이 몇 시에 도착해서 몇 시에 떠날 것인지 현수에게 알려주었습니다. 8 | 현수는 이 정보를 바탕으로 피로연 장소에 동시에 존재하는 최대 인원수를 구하여 그 인원을 수용할 수 있는 장소를 빌리려고 합니다. 9 | 10 | 만약 한 친구가 오는 시간 13, 가는시간 15라면 이 친구는 13시 정각에 피로연 장에 존재하는 것이고 15시 정각에는 존재하지 않는다고 가정합니다. 11 | */ 12 | 13 | const solution = (timelines) => { 14 | // 도착 이벤트와 떠나는 이벤트를 분리한다. 15 | let starts = timelines.map((v) => v[0]).sort((a, b) => a - b); 16 | let ends = timelines.map((v) => v[1]).sort((a, b) => a - b); 17 | let p1 = 0; 18 | let p2 = 0; 19 | 20 | let sum = 0; 21 | let max = 0; 22 | 23 | while (p1 < starts.length) { 24 | if (starts[p1] < ends[p2]) { 25 | p1++; 26 | sum++; 27 | max = sum > max ? sum : max; 28 | } else if (starts[p1] === ends[p2]) { 29 | p1++; 30 | p2++; 31 | } else { 32 | p2++; 33 | sum--; 34 | } 35 | } 36 | 37 | return max; 38 | }; 39 | 40 | console.log( 41 | solution([ 42 | [14, 18], 43 | [12, 15], 44 | [15, 20], 45 | [20, 30], 46 | [5, 14], 47 | ]) 48 | ); 49 | // 2 50 | 51 | console.log( 52 | solution([ 53 | [1, 10], 54 | [2, 8], 55 | [3, 9], 56 | ]) 57 | ); 58 | // 3 59 | -------------------------------------------------------------------------------- /jeju100/001~030 초급/001 배열의삭제.js: -------------------------------------------------------------------------------- 1 | /* 2 | 다음 배열에서 400, 500를 삭제하는 code를 입력하세요. 3 | */ 4 | 5 | let nums = [100, 200, 300, 400, 500]; 6 | 7 | nums.pop(); // 500 제거 8 | nums.pop(); // 400 제거 -------------------------------------------------------------------------------- /jeju100/001~030 초급/002 배열의 내장함수.js: -------------------------------------------------------------------------------- 1 | /* 2 | 배열 내장함수를 이용하여 코드를 입력하고 다음과 같이 출력되게 하세요. 3 | 출력결과 : [200, 100, 10000, 300] 4 | */ 5 | 6 | let arr = [200, 100, 300]; 7 | // arr.splice(startIndex, lengthToRemove, newValue); 8 | arr.splice(2, 0, 10000); 9 | -------------------------------------------------------------------------------- /jeju100/001~030 초급/003 변수의타입.js: -------------------------------------------------------------------------------- 1 | /* 2 | 다음 출력 값으로 올바른 것은? 3 | 4 | 1) undefined 5 | 2) string 6 | 3) number 7 | 4) object <- 정답 8 | */ 9 | 10 | let arr = [100, 200, 300]; 11 | console.log(typeof arr); 12 | 13 | // 자바스크립트 변수의 타입 14 | // 원시타입(5) : number, string, boolean, undefined, null 15 | // 참조타입(1) : object 16 | -------------------------------------------------------------------------------- /jeju100/001~030 초급/004 변수의타입2.js: -------------------------------------------------------------------------------- 1 | /* 2 | 다음 변수 a를 `typeof(a)`로 넣었을 때 출력될 값과의 연결이 알맞지 않은 것은? 3 | 4 | 1) 입력 : a =1, 출력 : number 5 | 2) 입력 : a = 2.22, 출력 : boolean <- number 6 | 3) 입력 : a = 'p', 출력 : string 7 | 4) 입력 : a = [1, 2, 3], 출력 : object 8 | */ 9 | 10 | console.log(typeof 1); 11 | console.log(typeof 2.22); 12 | console.log(typeof "p"); 13 | console.log(typeof [1, 2, 3]); 14 | -------------------------------------------------------------------------------- /jeju100/001~030 초급/005 for문계산.js: -------------------------------------------------------------------------------- 1 | /* 2 | 다음 코드의 출력 값으로 알맞은 것은? 3 | 4 | 1) 10 5 | 2) 12 6 | 3) 14 7 | 4) 16 <- 정답 8 | */ 9 | 10 | let a = 10; 11 | let b = 2; 12 | 13 | for (let i = 1; i < 5; i += 2) { 14 | a += i; 15 | } 16 | 17 | console.log(a + b); 18 | -------------------------------------------------------------------------------- /jeju100/001~030 초급/006 False.js: -------------------------------------------------------------------------------- 1 | /* 2 | 다음은 자바스크립트 문법 중에서 False로 취급하는 것들 입니다. 3 | 앗, False로 취급하지 않는 것이 하나 있네요! True를 찾아주세요. 4 | 5 | 1) NaN 6 | 2) 1 <- 정답 7 | 3) "" 8 | 4) 0 9 | 5) undefined 10 | */ 11 | 12 | // falsy : 0, "", NaN, null, undefined, false 13 | // truthy : 나머지 14 | 15 | console.log(isNaN("abc")); // true 16 | console.log(isNaN(1)); // false 17 | -------------------------------------------------------------------------------- /jeju100/001~030 초급/007 변수명.js: -------------------------------------------------------------------------------- 1 | /* 2 | 다음 중 변수명으로 사용할 수 없는 것 2개를 고르시오. 3 | 4 | 1) age 5 | 2) Age 6 | 3) let <- 정답 7 | 4) _age 8 | 5) 1age <- 정답 9 | */ 10 | 11 | let let; 12 | // SyntaxError: let is disallowed as a lexically bound name; 13 | let 1age; 14 | // SyntaxError : Invalid or unexpected token 15 | 16 | /* 17 | 변수의 식별자로 사용할 수 없는 것 18 | 19 | 1. 특수기호 (_ $ 2가지만 가능) 20 | 2. 문자열 (단, 예약어 제외) 21 | 3. 숫자 (단, 첫번째 순서로는 불가능) 22 | */ 23 | -------------------------------------------------------------------------------- /jeju100/001~030 초급/008 객체의키이름중복.js: -------------------------------------------------------------------------------- 1 | /* 2 | 자바스크립트 객체를 다음과 같이 만들었다. 3 | 출력값을 입력하시오. (출력값은 공백을 넣지 않습니다. ) 4 | */ 5 | 6 | let d = { 7 | height: 180, 8 | weight: 78, 9 | weight: 84, 10 | temperature: 36, 11 | eyesight: 1, 12 | 1: 180, 13 | 2: 84, 14 | }; 15 | 16 | // 객체에서 key 값이 중복될 경우 마지막 key 값을 가져온다 17 | console.log(d["weight"]); // 84 (각괄호 접근자로 가져오기) 18 | console.log(d.weight); // 84 (점 접근자로 가져오기) 19 | console.log(d[2]); // 84 (숫자 key값도 가능) 20 | -------------------------------------------------------------------------------- /jeju100/001~030 초급/009 concat을활용한출력방법.js: -------------------------------------------------------------------------------- 1 | /* 2 | 다음 소스 코드를 완성하여 날짜와 시간을 출력하시오. 3 | 출력결과 : 2019/04/26 11:34:27 4 | ``` 5 | */ 6 | 7 | let year = "2019"; 8 | let month = "04"; 9 | let day = "26"; 10 | let hour = "11"; 11 | let minute = "34"; 12 | let second = "27"; 13 | 14 | let result = year.concat( 15 | "/", 16 | month, 17 | "/", 18 | day, 19 | " ", 20 | hour, 21 | ":", 22 | minute, 23 | ":", 24 | second 25 | ); 26 | 27 | console.log(result); 28 | -------------------------------------------------------------------------------- /jeju100/001~030 초급/010 별찍기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 크리스마스 날, 은비는 친구들과 함께 파티를 하기로 했습니다. 그런데, 크리스마스 트리를 사는 것을 깜빡하고 말았습니다. 온 가게를 돌아다녀 봤지만 크리스마스 트리는 모두 품절이었습니다. 3 | 하는 수 없이 은비는 프로그래밍으로 트리를 만들기로 합니다. 4 | 5 | 은비를 위해 프로그램을 작성해 주세요. 6 | 7 | 입력 : 5 8 | 9 | 출력 : 10 | * 11 | *** 12 | ***** 13 | ******* 14 | ********* 15 | ``` 16 | */ 17 | 18 | const level = 5; 19 | 20 | for (let i = 0; i < level; i++) { 21 | let tree = ""; 22 | // 공백 증가 반복문 23 | for (let k = 0; k < level - i - 1; k++) { 24 | tree += " "; 25 | } 26 | // 별 증가 반복문 27 | for (let j = 0; j < 2 * i + 1; j++) { 28 | tree += "*"; 29 | } 30 | console.log(tree); 31 | } 32 | -------------------------------------------------------------------------------- /jeju100/001~030 초급/011 for기본활용.js: -------------------------------------------------------------------------------- 1 | /* 2 | 1부터 100까지 모두 더하는 코드를 완성하세요. 3 | `for`를 사용해야 합니다. 4 | */ 5 | 6 | let s = 0; 7 | 8 | for (let i = 0; i < 100; i++) { 9 | s += i + 1; 10 | } 11 | 12 | console.log(s); 13 | -------------------------------------------------------------------------------- /jeju100/001~030 초급/012 게임캐릭터클래스만들기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 다음 소스코드에서 클래스를 작성하여 게임 캐릭터의 능력치와 '파이어볼'이 출력되게 만드시오. 3 | 주어진 소스코드를 수정해선 안됩니다. 4 | 5 | 출력결과: 6 | 545 210 10 7 | 파이어볼 8 | 9 | */ 10 | 11 | // class 작성 12 | class Wizard { 13 | constructor(health, mana, armor) { 14 | // 객체 초기화 : 객체 생성시 반드시 실행되는 생성자 함수 15 | 16 | this.health = health; 17 | this.mana = mana; 18 | this.armor = armor; 19 | } 20 | attack() { 21 | console.log("파이어볼"); 22 | } 23 | } 24 | 25 | // 소스코드 26 | const x = new Wizard(545, 210, 10); 27 | console.log(x.health, x.mana, x.armor); 28 | x.attack(); 29 | -------------------------------------------------------------------------------- /jeju100/001~030 초급/013 몇번째행성인가요.js: -------------------------------------------------------------------------------- 1 | /* 2 | 우리 태양계를 이루고 있는 행성은 수성, 금성, 지구, 화성, 목성, 토성, 천왕성, 해왕성으로 총 8개 입니다. 저희는 우리 태양계의 n번째 행성이 무엇인지 알고 싶습니다. 3 | 4 | 입력으로 행성의 순서를 나타내는 숫자 n이 입력됩니다. 5 | 출력으로 그 순서에 해당하는 행성의 이름을 출력해 주세요. 6 | 7 | 예를들어 1이 입력되면, 첫번째 행성인 수성이 출력됩니다. 8 | 9 | 입력 : 1 10 | 출력 : 수성 11 | */ 12 | 13 | const planets = [ 14 | "수성", 15 | "금성", 16 | "지구", 17 | "화성", 18 | "목성", 19 | "토성", 20 | "천왕성", 21 | "해왕성", 22 | ]; 23 | 24 | const printPlanet = (n) => planets[n - 1]; 25 | 26 | console.log(printPlanet(1)); // 수성 27 | -------------------------------------------------------------------------------- /jeju100/001~030 초급/014 3의배수인가요.js: -------------------------------------------------------------------------------- 1 | /* 2 | 영희는 친구와 게임을 하고 있습니다. 서로 돌아가며 랜덤으로 숫자를 하나 말하고 그게 3의 배수이면 박수를 치고 아니면 그 숫자를 그대로 말하는 게임입니다. 3 | 입력으로 랜덤한 숫자 n이 주어집니다. 4 | 만약 그 수가 3의 배수라면 '짝'이라는 글자를, 3의 배수가 아니라면 n을 그대로 출력해 주세요. 5 | 6 | 입력 : 3 7 | 출력 : 짝 8 | 9 | 입력 : 2 10 | 출력 : 2 11 | 12 | */ 13 | 14 | const n = prompt(); // 브라우저 환경에서 사용 15 | if (n % 3 === 0 && n !== 0) { 16 | console.log("짝"); 17 | } else { 18 | console.log(n); 19 | } 20 | -------------------------------------------------------------------------------- /jeju100/001~030 초급/015 자기소개.js: -------------------------------------------------------------------------------- 1 | /* 2 | 신학기가 시작되고, 아이들이 돌아가면서 자기소개를 하기로 했습니다. 3 | 4 | 만약 입력으로 `김다정`이라는 이름이 주어지면 "안녕하세요. 저는 김다정입니다."라고 출력하게 5 | 해주세요. 6 | 7 | 8 | 입력 : 김다정 9 | 출력 : 안녕하세요. 저는 김다정입니다. 10 | 11 | */ 12 | 13 | const selfIntroduction = (name) => { 14 | console.log(`안녕하세요. 저는 ${name}입니다`); 15 | }; 16 | 17 | selfIntroduction("365kim"); 18 | -------------------------------------------------------------------------------- /jeju100/001~030 초급/016 로꾸거.js: -------------------------------------------------------------------------------- 1 | /* 2 | 문장이 입력되면 거꾸로 출력하는 프로그램을 만들어 봅시다. 3 | 4 | 입력 : 거꾸로 5 | 출력 : 로꾸거 6 | */ 7 | 8 | // 문자열을 뒤집는 함수는 없지만, 배열을 뒤집는 함수는 있음 9 | // 문자열을 배열로 변환해서 뒤집은 후 다시 문자열로 변환하기 10 | let str = "거꾸로"; 11 | 12 | console.log(str.split()); 13 | // [ '거꾸로' ] 14 | console.log(str.split("")); 15 | // [ '거', '꾸', '로' ] 16 | console.log(str.split("").reverse()); 17 | // [ '로', '꾸', '거' ] 18 | console.log(str.split("").reverse().join()); 19 | // 로,꾸,거 20 | console.log(str.split("").reverse().join("")); 21 | // 로꾸거 22 | -------------------------------------------------------------------------------- /jeju100/001~030 초급/017 놀이기구키제한.js: -------------------------------------------------------------------------------- 1 | /* 2 | 유주는 놀이공원 아르바이트 중입니다. 그런데 놀이기구마다 키 제한이 있습니다. 3 | 유주가 담당하는 놀이기구는 키가 150cm 이상만 탈 수 있습니다. 4 | 5 | 입력으로 키가 주어지면 6 | 키가 150보다 크거나 같으면 'YES'를, 틀리면 'NO'를 출력하는 프로그램을 작성하세요. 7 | */ 8 | 9 | const checkHeight = (height) => { 10 | if (height > 150) { 11 | console.log("YES"); 12 | } else { 13 | console.log("NO"); 14 | } 15 | }; 16 | -------------------------------------------------------------------------------- /jeju100/001~030 초급/018 평균점수.js: -------------------------------------------------------------------------------- 1 | /* 2 | 영하네 반은 국어, 수학, 영어 시험을 보았습니다. 영하는 친구들의 평균 점수를 구해주기로 했습니다. 3 | 4 | 공백으로 구분하여 세 과목의 점수가 주어지면 전체 평균 점수를 구하는 프로그램을 작성하세요. 5 | 단, 소숫점 자리는 모두 버립니다. 6 | 7 | 입력 : 20 30 40 8 | 출력 : 30 9 | */ 10 | 11 | let score = "20 30 40"; 12 | 13 | const getAverage = (score) => { 14 | let scoreArr = score.split(" "); 15 | let num = scoreArr.length; 16 | return Math.floor( 17 | scoreArr.reduce((acc, cur) => (acc += parseInt(cur, 10)), 0) / num 18 | ); 19 | }; 20 | 21 | console.log(getAverage(score)); 22 | -------------------------------------------------------------------------------- /jeju100/001~030 초급/019 제곱을구하자.js: -------------------------------------------------------------------------------- 1 | /* 2 | 공백으로 구분하여 두 숫자 a와 b가 주어지면, a의 b승을 구하는 프로그램을 작성하세요. 3 | */ 4 | 5 | // Math.pow(base, exponent) 메서드 활용 6 | // power메서드는 문자열도 알아서 숫자로 처리해줌 7 | let args = "2 6"; 8 | 9 | const aPoweredByB = (args) => { 10 | let [a, b] = args.split(" "); 11 | 12 | return Math.pow(a, b); 13 | }; 14 | 15 | console.log(aPoweredByB(args)); 16 | -------------------------------------------------------------------------------- /jeju100/001~030 초급/020 몫과나머지.js: -------------------------------------------------------------------------------- 1 | /* 2 | 공백으로 구분하여 두 숫자가 주어집니다. 3 | 두번째 숫자로 첫번째 숫자를 나누었을 때 그 몫과 나머지를 공백으로 구분하여 출력하세요. 4 | 5 | 입력 : 10 2 6 | 출력 : 5 0 7 | 8 | */ 9 | 10 | let num = "7 2"; 11 | 12 | const printQuotientAndRemainder = (num) => { 13 | let [a, b] = num.split(" "); 14 | console.log(Math.floor(a / b)); 15 | console.log(a % b); 16 | }; 17 | 18 | printQuotientAndRemainder(num); 19 | -------------------------------------------------------------------------------- /jeju100/001~030 초급/021 set은어떻게만드나요.js: -------------------------------------------------------------------------------- 1 | /* 2 | 다음 중 set을 만드는 방법으로 올바른 것을 모두 고르시오. 3 | 4 | 1) let x = {1, 2, 3, 5, 6, 7}; 5 | 2) let x = {}; //객체 6 | 3) let x = new Set('javascript'); <- 정답 7 | 4) let x = new Set(range(5)); 8 | 5) let x = new Set(); <- 정답 9 | */ 10 | 11 | // Set : 중복되지 않는 데이터를 저장하는 데이터 구조 12 | // add, delete, has 메서드 13 | const list = [1, 1, 2, 2, 3, 4, 5, 6]; 14 | let set = new Set(list); 15 | 16 | console.log(set); 17 | console.log(set.add(7)); // 결과 반환 18 | console.log(set.delete(7)); // 삭제여부 반환 19 | console.log(set.has(10)); // 존재여부 반환 -------------------------------------------------------------------------------- /jeju100/001~030 초급/022 배수인지확인하기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 다음 중 변수 i가 6의 배수인지 확인하는 방법으로 올바른 것은? 3 | 4 | 1) i / 6 == 0 5 | 2) i % 6 == 0 <- 정답 6 | 3) i & 6 == 0 7 | 4) i | 6 == 0 8 | 5) i // 6 == 0 9 | */ 10 | 11 | for (let i = 1; i <= 6; i++) { 12 | console.log("i:", i, "6의 배수:", i % 6 === 0); 13 | } -------------------------------------------------------------------------------- /jeju100/001~030 초급/023 OX문제.js: -------------------------------------------------------------------------------- 1 | /* 2 | `console.log(10/3)`의 출력 결과는 3이다. 3 | 정답 : X 4 | */ 5 | 6 | console.log(10 / 3); // 3.3333333333333335 7 | console.log(Math.floor(10 / 3)); // 3 -------------------------------------------------------------------------------- /jeju100/001~030 초급/024 대문자로바꿔주세요.js: -------------------------------------------------------------------------------- 1 | /* 2 | 민지는 국제 포럼에서 아르바이트를 하게 되었습니다. 민지는 각 국에서 온 참가자들의 명단을 엑셀로 정리하고 있는데 참가자들 이름이 어떤 이는 전부 소문자, 어떤 이는 전부 대문자로 써져 있는 등 형식이 제각각이었습니다. 3 | 4 | 민지를 위해 이름이 입력되면 전부 대문자로 출력되는 프로그램을 만들어주세요. 5 | 6 | 입력 : mary 7 | 출력 : MARY 8 | */ 9 | 10 | console.log("mary".toUpperCase()); 11 | // MARY 12 | console.log("MARY".toLowerCase()); 13 | // mary -------------------------------------------------------------------------------- /jeju100/001~030 초급/025 원의넓이를구하세요.js: -------------------------------------------------------------------------------- 1 | /* 2 | 원의 넓이는 `반지름의 길이 x 반지름의 길이 x 3.14`로 구할 수 있습니다. 3 | 함수를 사용하여 원의 넓이를 구하는 코드를 작성해봅시다. 4 | 5 | 입력으로 반지름의 길이 정수 n이 주어지면 원의 넓이를 반환하는 함수를 만들어 주세요. 6 | */ 7 | 8 | const getAreafromRadius = (n) => n * n * 3.14; 9 | 10 | console.log(getAreafromRadius(1)); 11 | console.log(getAreafromRadius(2)); 12 | console.log(getAreafromRadius(3)); -------------------------------------------------------------------------------- /jeju100/001~030 초급/026 행성문제2.js: -------------------------------------------------------------------------------- 1 | /* 2 | 우리 태양계를 이루는 행성은 수성, 금성, 지구, 화성, 목성, 토성, 천왕성, 해왕성이 있습니다. 3 | 이 행성들의 영어 이름은 Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune입니다. 4 | 5 | 행성의 한글 이름을 입력하면 영어 이름을 반환하는 프로그램을 만들어 주세요. 6 | */ 7 | 8 | const planets = { 9 | 수성: "Mercury", 10 | 금성: "Venus", 11 | 지구: "Earth", 12 | 화성: "Mars", 13 | 목성: "Jupiter", 14 | 토성: "Saturn", 15 | 천왕성: "Uranus", 16 | 해왕성: "Neptune", 17 | }; 18 | 19 | let str = "수성" 20 | console.log(planets[str]); 21 | // Mercury 22 | console.log(planets.str); 23 | // undefined 24 | console.log(planets.수성); 25 | // Mercury 26 | 27 | // .연산자 다음에는 반드시 (변수가 아닌) 키값이 와야 함 28 | // 객체에서 변수로 접근하려면 각괄호를 사용해야 함 -------------------------------------------------------------------------------- /jeju100/001~030 초급/027 객체만들기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 첫번째 입력에서는 학생의 이름이 공백으로 구분되어 입력되고, 두번째에는 그 학생의 수학 점수가 공백으로 구분되어 주어집니다. 3 | 4 | 두 개를 합쳐 학생의 이름이 key이고 value가 수학 점수인 객체를 출력해주세요. 5 | 6 | 입력 7 | Yujin Hyewon 8 | 70 100 9 | 10 | 출력 11 | {'Yujin': 70, 'Hyewon': 100} 12 | */ 13 | 14 | const printObj = (names, mathScores) => { 15 | let keys = names.split(" "); 16 | let vals = mathScores.split(" "); 17 | let obj = {}; 18 | 19 | for (let i = 0; i < keys.length; i++) { 20 | obj[keys[i]] = vals[i]; 21 | } 22 | return obj; 23 | } 24 | 25 | console.log(printObj("Yujin Hyewon", "70 100")); -------------------------------------------------------------------------------- /jeju100/001~030 초급/028 2-gram.js: -------------------------------------------------------------------------------- 1 | /* 2 | 2-gram이란 문자열에서 2개의 연속된 요소를 출력하는 방법입니다. 3 | 4 | 예를 들어 'Javascript'를 2-gram으로 반복해 본다면 다음과 같은 결과가 나옵니다. 5 | 6 | 입력 7 | Javascript 8 | 9 | 출력 10 | J a 11 | a v 12 | v a 13 | a s 14 | s c 15 | c r 16 | r i 17 | i p 18 | p t 19 | 20 | 21 | 입력으로 문자열이 주어지면 2-gram으로 출력하는 프로그램을 작성해 주세요. 22 | */ 23 | 24 | // N-gram 언어모델 : 문자열에서 N개의 연속된 요소를 추출하는 방법 25 | const print2gram = (str) => { 26 | for (let i = 0; i < str.length - 1; i++) { 27 | console.log(str.slice(i, i+2)); 28 | } 29 | } 30 | 31 | print2gram("Javascript") 32 | print2gram("안녕하세요") -------------------------------------------------------------------------------- /jeju100/001~030 초급/029 대문자만지나가세요.js: -------------------------------------------------------------------------------- 1 | /* 2 | 진구는 영어 학원 아르바이트를 하고 있습니다. 반 아이들은 알파벳을 공부하는 학생들인데 오늘은 대문자 쓰기 시험을 봤습니다. 3 | 4 | 알파벳 하나만을 입력하고 그 알파벳이 대문자이면 YES를 아니면 NO를 출력하는 프로그램을 만들어 주세요. 5 | */ 6 | 7 | 8 | const checkUpperCase = (c) => { 9 | if (c === c.toUpperCase()) { 10 | console.log("YES"); 11 | } else { 12 | console.log("NO"); 13 | } 14 | } 15 | 16 | checkUpperCase('A'); 17 | checkUpperCase('a'); -------------------------------------------------------------------------------- /jeju100/001~030 초급/030 문자열속문자찾기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 문자 pineapple에는 apple이라는 문자가 숨어 있습니다. 원범이는 이렇듯 문자열 속에 숨어있는 문자를 찾아보려고 합니다. 3 | 4 | 첫번째 입력에서는 문자열이 입력되고, 두번째에는 찾을 문자가 입력되어야 합니다. 5 | 그 문자가 시작하는 index를 반환하는 프로그램을 만들어 주세요 6 | 7 | 입력 8 | pineapple is yummy 9 | apple 10 | 11 | 출력 12 | 4 13 | */ 14 | 15 | const findSubstr = (str, keyword) => { 16 | console.log(str.indexOf(keyword)); 17 | } 18 | 19 | findSubstr("pineapple is yummy", "apple"); -------------------------------------------------------------------------------- /jeju100/031~080 중급/031 자바스크립트자료형의복잡도.js: -------------------------------------------------------------------------------- 1 | /* 2 | 다음 배열 내장함수의 시간 복잡도가 O(1)이 아닌 것을 모두 고르시오. 3 | 4 | 1) arr[i] 5 | 2) arr.push(5) 6 | 3) arr.slice() <- 정답 7 | 4) arr.pop() 8 | 5) arr.includes(5) <- 정답 9 | 10 | O(n) arr의 크기가 커짐에 따라 비례해서 시간복잡도가 증가함 11 | */ 12 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/032 문자열만들기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 취업 준비생인 혜림이는 자기소개서를 쓰고 있습니다. 열심히 자기소개서를 작성하던 도중 혜림이는 자기가 지금까지 단어를 얼마나 적었는지 궁금하게 됩니다. 3 | 4 | 혜림이를 위해 문자열을 입력받으면 단어의 갯수를 출력하는 프로그램을 작성해 주세요. 5 | 6 | 입력 : 안녕하세요. 저는 제주대학교 컴퓨터공학전공 혜림입니다. 7 | 출력 : 5 8 | */ 9 | 10 | const printWordNum = (str) => { 11 | console.log(str.split(" ").length); 12 | }; 13 | 14 | printWordNum("안녕하세요. 저는 제주대학교 컴퓨터공학전공 혜림입니다."); 15 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/033 거꾸로출력하기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 한 줄에 여러개의 숫자가 입력되면, 역순으로 그 숫자들을 하나씩 출력하는 프로그램을 작성하시오. 3 | 4 | 5 | 입력 : 1 2 3 4 5 6 | 출력 : 5 4 3 2 1 7 | 8 | 입력 : 2 4 6 7 8 9 | 출력 : 8 7 6 4 2 10 | */ 11 | 12 | const printReverse = (str) => { 13 | console.log(str.split(" ").reverse().join(" ")); 14 | }; 15 | 16 | printReverse("1 2 3 4 5"); 17 | printReverse("2 4 6 7 8"); 18 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/034 sort구현하기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 민주는 체육부장으로 체육시간이 되면 반 친구들이 제대로 키 순서대로 모였는지를 확인해야 한다. 3 | 그런데 요즘 민주는 그것이 너무 번거롭게 느껴져 한 번에 확인하고 싶어한다. 4 | 5 | 민주를 위해 키가 주어지면 순서대로 제대로 섰는지 확인하는 프로그램을 작성해보자. 6 | (키는 공백으로 구분하여 입력됩니다.) 7 | 8 | 입력 : 176 156 155 165 166 169 9 | 출력 : NO 10 | 11 | 입력 : 155 156 165 166 169 176 12 | 출력 : YES 13 | */ 14 | 15 | const checkIfSorted = (str) => { 16 | let arrOriginal = str.split(" "); 17 | let arrSorted = str.split(" ").sort((a, b) => a - b); 18 | 19 | if ( 20 | arrOriginal.length === arrSorted.length && 21 | arrOriginal.every((v, i) => v === arrSorted[i]) 22 | ) { 23 | console.log("YES"); 24 | } else { 25 | console.log("NO"); 26 | } 27 | }; 28 | 29 | checkIfSorted("176 156 155 165 166 169"); 30 | checkIfSorted("155 156 165 166 169 176"); 31 | 32 | let arr1 = [3, 6, 5, "kim"]; 33 | let arr2 = [3, 6, 5, "kim"]; 34 | console.log(arr1.length === arr2.length && arr1.every((v, i) => v === arr2[i])); 35 | // true 36 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/035 Factory함수사용하기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 2제곱, 3제곱, 4제곱을 할 수 있는 Factory 함수를 만들려고 합니다. 3 | 4 | 코드를 작성하여 two함수를 완성하세요. 5 | */ 6 | 7 | // function one(n) { 8 | // const two = (x) => Math.pow(x, n) 9 | // return two; 10 | // } 11 | const one = (n) => (x) => Math.pow(x, n); 12 | 13 | const a = one(2); // 2제곱 해주는 함수 14 | const b = one(3); // 3제곱 해주는 함수 15 | const c = one(4); // 4제곱 해주는 함수 16 | 17 | console.log(a(10)); 18 | console.log(b(10)); 19 | console.log(c(10)); 20 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/036 구구단출력하기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 1~9까지의 숫자 중 하나를 입력하면 그 단의 구구단 결과를 한 줄에 출력하는 프로그램을 작성하세요. 3 | 4 | 5 | 입력 : 2 6 | 출력 : 2 4 6 8 10 12 14 16 18 7 | 8 | */ 9 | 10 | const printGugudan = (n) => { 11 | let res = []; 12 | for (let i = 1; i <= 9; i++) { 13 | res.push(n * i); 14 | } 15 | console.log(res.join(" ")); 16 | }; 17 | 18 | printGugudan(2); 19 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/037 반장선거.js: -------------------------------------------------------------------------------- 1 | /* 2 | 새 학기를 맞아 호준이네 반은 반장 선거를 하기로 했습니다. 3 | 그런데 표를 하나씩 개표하는 과정이 너무 번거롭게 느껴진 당신은 학생들이 뽑은 후보들을 입력받으면 뽑힌 학생의 이름과 받은 표 수를 출력하는 프로그램을 작성하기로 하였습니다. 4 | 5 | 6 | 입력 7 | 원범 원범 혜원 혜원 혜원 혜원 유진 유진 8 | 9 | 출력 10 | 혜원(이)가 총 4표로 반장이 되었습니다. 11 | */ 12 | 13 | const solution = (str) => { 14 | let array = str.split(" "); 15 | let res = {}; 16 | 17 | for (let i in array) { 18 | let v = array[i]; 19 | res[v] = res[v] === undefined ? 1 : ++res[v]; 20 | } 21 | // {원범: 2, 혜원: 4, 유진: 2} 22 | let winner = Object.keys(res).reduce((acc, cur) => 23 | res[acc] >= res[cur] ? acc : cur 24 | ); 25 | console.log(`${winner}(이)가 총 ${res[winner]}표로 반장이 되었습니다`); 26 | }; 27 | 28 | solution("원범 원범 혜원 혜원 혜원 혜원 유진 유진"); 29 | 30 | const printResult = (str) => { 31 | let candidates = Array.from(new Set(str.split(" "))); 32 | let scores = new Array(candidates.length).fill(0); 33 | for (let vote of str.split(" ")) { 34 | let idx = candidates.indexOf(vote); 35 | scores[idx]++; 36 | } 37 | let res = []; 38 | for (let i = 0; i < candidates.length; i++) { 39 | res.push([candidates[i], scores[i]]); 40 | } 41 | res.sort((a, b) => b[1] - a[1]); 42 | console.log(`${res[0][0]}(이)가 총 ${res[0][1]}표로 반장이 되었습니다`); 43 | }; 44 | 45 | printResult("원범 원범 혜원 혜원 혜원 혜원 유진 유진"); 46 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/038 호준이의아르바이트.js: -------------------------------------------------------------------------------- 1 | /* 2 | 호준이는 아르바이트로 영어 학원에서 단어 시험지를 채점하는 일을 하고 있다. 호준이가 일하는 학원은 매번 1위부터 3위까지의 학생에게 상으로 사탕을 준다. 그런데 오늘은 마침 사탕이 다 떨어져서 호준이가 채점을 하고 점수를 보내면, 당신이 아이들의 숫자만큼 사탕을 사러 가기로 했다. 3 | 4 | 1위 ~ 3위 학생은 여러명일 수 있고 1~3위 학생 중 중복되는 학생까지 포함하여 사탕을 사기로 한다. 5 | 학생들의 점수를 공백으로 구분하여 입력을 받고 사탕을 받을 학생의 수를 출력하세요. 6 | 7 | 입력 : 97 86 75 66 55 97 85 97 97 95 8 | 출력 : 6 9 | */ 10 | 11 | const printStudentNum = (str) => { 12 | let scores = str.split(" ").sort((a, b) => b - a); 13 | let candy = 1; 14 | let rank = 1; 15 | 16 | for (let i = 1; i < scores.length; i++) { 17 | if (scores[i] !== scores[i - 1]) { 18 | rank++; 19 | } 20 | 21 | if (rank <= 3) { 22 | candy++; 23 | } else { 24 | break; 25 | } 26 | } 27 | console.log(candy); 28 | }; 29 | 30 | printStudentNum("97 86 75 66 55 97 85 97 97 95"); 31 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/039 오타수정하기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 혜원이는 평소 영타가 빠르고 정확한 것을 친구들에게 자랑하고 다녔습니다. 3 | 반 친구들이 혜원이의 타자 속도가 빠르다는 것을 모두 알게 되자 혜원이는 모두의 앞에서 타자 실력을 보여주게 됩니다. 4 | 5 | 그런데 막상 보여주려니 긴장이 되서 문장의 모든 e를 q로 잘못 친 것을 발견했습니다. 6 | 혜원이는 프로그램을 돌려 재빠르게 모든 q를 e로 바꾸는 프로그램을 작성하려고 합니다. 7 | 8 | 문장이 입력되면 모든 q를 e로 바꾸는 프로그램을 작성해 주세요. 9 | 10 | 입력 : querty 11 | 출력 : euerty 12 | 13 | 입력 : hqllo my namq is hyqwon 14 | 출력 : hello my name is hyewon 15 | 16 | */ 17 | 18 | console.log("querty".split("q").join("e")); 19 | console.log("hqllo my namq is hyqwon".split("q").join("e")); 20 | 21 | console.log("querty".replace(/q/g, "e")); 22 | console.log("hqllo my namq is hyqwon".replace(/q/g, "e")); 23 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/040 놀이동산에가자.js: -------------------------------------------------------------------------------- 1 | /* 2 | 테마파크에 온 원범이와 친구들은 놀이기구를 타려고 합니다. 모든 놀이기구는 한번에 타는 인원수에는 제한이 없지만 제한 무게를 넘으면 무조건 다음 기구를 타야 합니다. 3 | 4 | 원범이와 친구들이 총 몇 명 탈 수 있는지 알 수 있는 프로그램을 작성해 주세요. 5 | 6 | 첫번째 입력으로 제한 무게가 주어지고 두번째 입력으로는 함께한 친구들의 수 n이 주어집니다. 7 | 그 다음 차례대로 탑승할 친구들의 몸무게가 주어집니다. 몸무게는 무작위로 주어집니다. 8 | 9 | 입력 10 | 50 <- 제한무게 11 | 5 <- 인원수 12 | 20 13 | 20 14 | 20 15 | 20 16 | 20 17 | 18 | 출력 19 | 2 20 | */ 21 | 22 | const weightLimit = prompt("무게 제한을 입력해주세요"); 23 | const memberNum = prompt("몇 명이 탈 계획인가요?"); 24 | let count = 0; 25 | let accWeight = 0; 26 | for (let i = 0; i < memberNum; i++) { 27 | accWeight += parseInt(prompt("몸무게를 입력해주세요"), 10); 28 | if (accWeight <= weightLimit) { 29 | count++; 30 | } 31 | } 32 | 33 | console.log(count); 34 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/041 소수판별.js: -------------------------------------------------------------------------------- 1 | /* 2 | 숫자가 주어지면 소수인지 아닌지 판별하는 프로그램을 작성해주세요. 3 | 소수이면 YES로, 소수가 아니면 NO로 출력해주세요. 4 | 5 | (소수 : 1과 자기 자신만으로 나누어 떨어지는, 1보다 큰 양의 정수) 6 | */ 7 | 8 | const isPrime = (n) => { 9 | let sqrtN = Math.sqrt(n); 10 | for (let i = 2; i < sqrtN; i++) { 11 | if (n % i === 0) { 12 | console.log("NO"); 13 | return; 14 | } 15 | } 16 | if (n > 1) { 17 | console.log("YES"); 18 | } else { 19 | console.log("NO"); 20 | } 21 | }; 22 | 23 | isPrime(1); 24 | isPrime(3); 25 | isPrime(6); 26 | isPrime(7); 27 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/042 2020년.js: -------------------------------------------------------------------------------- 1 | /* 2 | 2020년 1월 1일은 수요일입니다. 2020년 a월 b일은 무슨 요일일까요? 3 | 두 수 a, b를 입력받아 2020년 a월 b일이 무슨 요일인지 리턴하는 함수 solution을 완성하세요. 4 | 요일의 이름은 일요일부터 토요일까지 각각 SUN, MON, TUE, WED, THU, FRI, SAT 입니다. 5 | 6 | 예를 들어 a = 5, b = 24라면 5월 24일은 일요일이므로 문자열 "SUN"를 반환하세요. 7 | 8 | 제한 조건 9 | 2020년은 윤년입니다. 10 | 2020년 a월 b일은 실제로 있는 날입니다. 11 | (13월 26일이나 2월 45일 같은 날짜는 주어지지 않습니다.) 12 | */ 13 | 14 | const daysEng = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"]; 15 | const daysKor = ["일", "월", "화", "수", "목", "금", "토"]; 16 | 17 | const solution = (a, b) => { 18 | let theDate = new Date(`2020-${a}-${b}`); 19 | console.log(theDate); 20 | // 2020-10-15T00:00:00.000Z 21 | 22 | let theDay = theDate.getDay(); 23 | console.log(theDay); 24 | // 4 (0부터 시작) 25 | 26 | let theDayEng = daysEng[theDay]; 27 | let theDayKor = daysKor[theDay]; 28 | console.log(theDayEng); 29 | // THU 30 | console.log(theDayKor); 31 | // 목 32 | }; 33 | 34 | solution(10, 15); 35 | 36 | const daysEn = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"]; 37 | const daysKo = ["일", "월", "화", "수", "목", "금", "토"]; 38 | 39 | const dateToDay = (y, m, d) => { 40 | let theDate = new Date(`${y}-${m}-${d}`); 41 | console.log(theDate); 42 | // 2020-10-15T00:00:00.000Z 43 | 44 | let theDay = theDate.getDay(); 45 | console.log(theDay); 46 | // 4 (0부터 시작) 47 | 48 | let theDayEn = daysEn[theDay]; 49 | let theDayKo = daysKo[theDay]; 50 | console.log(theDayEn); 51 | // THU 52 | console.log(theDayKo); 53 | // 목 54 | }; 55 | 56 | dateToDay(2020, 10, 15); 57 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/043 10진수를 2진수로.js: -------------------------------------------------------------------------------- 1 | /* 2 | 우리가 흔히 사용하는 숫자 1, 8, 19, 28893 등등...은 10진수 체계입니다. 3 | 이를 컴퓨터가 알아 들을 수 있는 2진수로 바꾸려고 합니다. 어떻게 해야할까요? 4 | 5 | 사용자에게 숫자를 입력받고 이를 2진수를 바꾸고 그 값을 출력해주세요. 6 | */ 7 | 8 | let num = 8; 9 | console.log(num.toString(2)); 10 | // "1000" 11 | console.log(+num.toString(2)); 12 | // 1000 13 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/044 각자리수의합.js: -------------------------------------------------------------------------------- 1 | /* 2 | 사용자가 입력한 양의 정수의 각 자리수의 합을 구하는 프로그램을 만들어주세요 3 | 4 | 예를 들어 5 | 18234 = 1+8+2+3+4 이고 정답은 18 입니다. 6 | 3849 = 3+8+4+9 이고 정답은 24입니다. 7 | 8 | 입력 : 18234 9 | 출력 : 18 10 | 11 | 입력 : 3849 12 | 출력 : 24 13 | 14 | */ 15 | 16 | const sumEachRemainder = (n) => { 17 | let result = 0; 18 | while (n) { 19 | result += n % 10; 20 | n = Math.floor(n / 10); 21 | } 22 | return result; 23 | }; 24 | 25 | console.log(sumEachRemainder(18234)); 26 | console.log(sumEachRemainder(3849)); 27 | 28 | const sumEachDigit = (n) => { 29 | let result = 0; 30 | let nSplit = n.toString().split(""); 31 | for (digit of nSplit) { 32 | result += +digit; 33 | } 34 | return result; 35 | }; 36 | 37 | console.log(sumEachDigit(18234)); 38 | console.log(sumEachDigit(3849)); 39 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/045 getTime()함수사용하기.js: -------------------------------------------------------------------------------- 1 | /* 2 | Date객체의 메소드 중 하나인 getTime()은 3 | 1970년 1월 1일 0시 0분 0초 이후로부터 지금까지 흐른 시간을 천분의 1초 단위(ms)로 반환합니다. 4 | 5 | 이를 이용하여 현재 연도를 출력해보세요. 6 | */ 7 | 8 | const theDate = new Date(); 9 | let msPassed = theDate.getTime(); 10 | // 1602749306000 (ms) 11 | let yearPassed = Math.floor(msPassed / (1000 * 60 * 60 * 24 * 365)); 12 | console.log(yearPassed); 13 | // 50 14 | let yearOfToday = yearPassed + 1970; 15 | console.log(yearOfToday); 16 | // 2020 17 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/046 각자리수의합2.js: -------------------------------------------------------------------------------- 1 | /* 2 | 1부터 20까지의(20을 포함) 모든 숫자를 일렬로 놓고 모든 자릿수의 총 합을 구하세요. 3 | 4 | 예를 들어 10부터 15까지의 모든 숫자를 일렬로 놓으면 101112131415이고 5 | 각 자리의 숫자를 더하면 21입니다. (1+0+1+1+1+2+1+3+1+4+1+5 = 21) 6 | */ 7 | 8 | const sumEachDigit = (a, b) => { 9 | let nStr = ""; 10 | let result = 0; 11 | 12 | for (let i = a; i <= b; i++) { 13 | nStr += i; 14 | } 15 | console.log(nStr); 16 | let nSplit = nStr.split(""); 17 | for (digit of nSplit) { 18 | result += +digit; 19 | } 20 | return result; 21 | }; 22 | 23 | console.log(sumEachDigit(10, 15)); 24 | console.log(sumEachDigit(1, 20)); 25 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/047 set자료형의응용.js: -------------------------------------------------------------------------------- 1 | /* 2 | 바울랩에서는 3월 29일 제주대학교에서 '제주 빅데이터 사회혁신 해커톤' 행사를 주최하게 되었습니다. 이에 구글 설문지를 배포하였으나 제주대학생들이 중복해서 n개씩 설문지를 제출하였습니다. 3 | 중복된 데이터들을 삭제하여 실제 접수 명단이 몇 명인지 알고 싶습니다. 4 | 5 | 아래 주어진 데이터들로부터 중복을 제거하여 실제 접수 인원을 출력해 주세요. 6 | 7 | */ 8 | 9 | const obj = { 10 | 이호준: "01050442903", 11 | 이호상: "01051442904", 12 | 이준호: "01050342904", 13 | 이호준: "01050442903", 14 | 이준: "01050412904", 15 | 이호: "01050443904", 16 | 이호준: "01050442903", 17 | }; 18 | 19 | //let set = new Set(obj); 20 | //TypeError: object is not iterable 21 | 22 | let arr = Object.entries(obj); 23 | // [key, value] 쌍이 담긴 배열을 반환 24 | console.log(arr); 25 | /* 26 | [ 27 | [ '이호준', '01050442903' ], 28 | [ '이호상', '01051442904' ], 29 | [ '이준호', '01050342904' ], 30 | [ '이준', '01050412904' ], 31 | [ '이호', '01050443904' ] 32 | ] 33 | */ 34 | let set = new Set(arr); 35 | 36 | console.log(set); 37 | /* 38 | Set { 39 | [ '이호준', '01050442903' ], 40 | [ '이호상', '01051442904' ], 41 | [ '이준호', '01050342904' ], 42 | [ '이준', '01050412904' ], 43 | [ '이호', '01050443904' ] 44 | } 45 | */ 46 | console.log(set.size); 47 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/048 대소문자바꿔서출력하기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 문자열이 주어지면 대문자와 소문자를 바꿔서 출력하는 프로그램을 작성하세요. 3 | 4 | 입력 : AAABBBcccddd 5 | 출력 : aaabbbCCCDDD 6 | 7 | */ 8 | 9 | const swapUpperWithLower = (str) => { 10 | let res = ""; 11 | for (let i = 0; i < str.length; i++) { 12 | res += 13 | str[i].toUpperCase() === str[i] 14 | ? str[i].toLowerCase() 15 | : str[i].toUpperCase(); 16 | } 17 | console.log(res); 18 | }; 19 | 20 | swapUpperWithLower("AAABBBcccddd"); 21 | // "aaabbbCCCDDD" 22 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/049 최댓값구하기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 순서가 없는 10개의 숫자가 공백으로 구분되어 주어진다. 3 | 주어진 숫자들 중 최댓값을 반환하라. 4 | 5 | 입력 : 10 9 8 7 6 5 4 3 2 1 6 | 출력 : 10 7 | */ 8 | 9 | const getMax = (str) => { 10 | let numArr = str.split(" ").map((v) => +v); 11 | return Math.max(...numArr); 12 | }; 13 | 14 | console.log(getMax("10 9 8 7 6 5 4 3 2 1")); 15 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/050 버블정렬구현하기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 버블정렬은 두 인접한 원소를 검사하여 정렬하는 방법을 말합니다. 3 | 시간복잡도는 느리지만 코드가 단순하기 때문에 자주 사용됩니다. 4 | 5 | 아래 코드의 빈 칸을 채워 버블정렬을 완성해 봅시다. 6 | */ 7 | 8 | const bubbleSort = (arr) => { 9 | let res = arr.slice(); // 깊은 복사 10 | 11 | for (let i = 0; i < res.length - 1; i++) { 12 | for (let j = 0; j < res.length - i; j++) { 13 | if (res[j] > res[j + 1]) { 14 | let temp = res[j]; 15 | res[j] = res[j + 1]; 16 | res[j + 1] = temp; 17 | } 18 | } 19 | } 20 | return res; 21 | }; 22 | 23 | const betterBubbleSort = (arr) => { 24 | let len = arr.length - 1; 25 | let swapped; 26 | do { 27 | swapped = false; 28 | 29 | for (let i = 0; i < len; i++) { 30 | if (arr[i] > arr[i + 1]) { 31 | let temp = arr[i]; 32 | arr[i] = arr[i + 1]; 33 | arr[i + 1] = temp; 34 | swapped = true; 35 | } 36 | } 37 | } while (swapped); 38 | return arr; 39 | }; 40 | 41 | console.log(bubbleSort([5, 4, 7, 9, 1, 3])); 42 | console.log(betterBubbleSort([5, 4, 7, 9, 1, 3])); 43 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/051 mergesort를만들어보자.js: -------------------------------------------------------------------------------- 1 | /* 2 | 병합정렬(merge sort)은 대표적인 정렬 알고리즘 중 하나로 다음과 같이 동작합니다. 3 | 4 | 1. 리스트의 길이가 0 또는 1이면 이미 정렬된 것으로 본다. 그렇지 않은 경우에는 5 | 2. 정렬되지 않은 리스트를 절반으로 잘라 비슷한 크기의 두 부분 리스트로 나눈다. 6 | 3. 각 부분 리스트를 '재귀적으로' 합병 정렬을 이용해 정렬한다. 7 | 4. 두 부분 리스트를 다시 하나의 정렬된 리스트로 합병한다. 8 | 출처: 위키피디아 9 | 10 | 예시) 11 | [1, 3, 5, 4, 8, 6, 7, 2] 12 | [1, 3, 5, 4][8, 6, 7, 2] 13 | [1, 3][5, 4][8, 6][7, 2] 14 | [1][3][5][4][8][6][7][2] // 크기가 1 15 | [1, 3][4, 5][6, 8][2, 7] // 맨 앞에 것끼리 비교 16 | [1, 3, 4, 5][2, 6, 7, 8] 17 | [1, 2, 3, 4, 5, 6, 7, 8] 18 | 19 | 다음 코드의 빈칸을 채워 병합정렬을 완성해 봅시다. 20 | */ 21 | 22 | // 반으로 쪼개며 1개까지 분할하는 부분 23 | const mergeSort = (arr) => { 24 | if (arr.length <= 1) return arr; 25 | 26 | const mid = Math.floor(arr.length / 2); 27 | const left = arr.slice(0, mid); 28 | const right = arr.slice(mid); 29 | 30 | return merge(mergeSort(left), mergeSort(right)); 31 | }; 32 | 33 | // 정렬하고 합치는 부분 34 | const merge = (left, right) => { 35 | let result = []; 36 | 37 | // 한쪽 길이가 끝날 때까지 38 | while (left.length && right.lenfth) { 39 | if (left[0] < right[0]) { 40 | result.push(left.shift()); 41 | } else { 42 | result.push(right.shift()); 43 | } 44 | } 45 | 46 | while (left.length) { 47 | result.push(left.shift()); 48 | } 49 | while (right.length) { 50 | result.push(right.shift()); 51 | } 52 | 53 | return result; 54 | }; 55 | 56 | console.log(mergeSort([1, 3, 5, 4, 8, 6, 7, 2])); 57 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/052 quicksork.js: -------------------------------------------------------------------------------- 1 | /* 2 | 다음 빈 칸을 채워 퀵 정렬을 완성해주세요. 3 | 4 | 예시) 5 | [1, 3, 2, 7, 5, 6, 4, 8, 9, 10] 6 | pivot 하나설정 : 6 (보통 맨끝 or 중앙) 7 | [1, 3, 2, 7, 5][6][4, 8, 9, 10] 8 | [1, 3, 2, 5, 4][6][7, 8, 9, 10] 9 | [1][2][3, 5, 4][6][7, 8][9][10] 10 | [1][2][3, 4][5][6][7][8][9][10] 11 | [1][2][3][4][5][6][7][8][9][10] 12 | // 길이가 하나라면 리턴 13 | */ 14 | 15 | function quickSort(arr) { 16 | if (arr.length <= 1) { 17 | return arr; 18 | } 19 | 20 | const pivot = arr[0]; 21 | const left = []; 22 | const right = []; 23 | 24 | for (let i = 1; i < arr.length; i++) { 25 | if (arr[t] < pivot) { 26 | left.push(arr[i]); 27 | } else { 28 | right.push(arr[i]); 29 | } 30 | } 31 | return quickSort(left).concat(pivot, quickSort(right)); 32 | } 33 | 34 | console.log(quickSort([1, 3, 2, 7, 5, 6, 4, 8, 9, 10])); 35 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/053 괄호문자열.js: -------------------------------------------------------------------------------- 1 | /* 2 | 괄호 문자열이란 괄호 기호인 '{', '}', '[', ']', '(', ')' 와 같은 것을 말한다. 3 | 그 중 괄호의 모양이 바르게 구성된 문자열을 바른 문자열, 그렇지 않은 문자열을 바르지 않은 문자열이라 부르도록 하자. 4 | 5 | (())와 같은 문자열은 바른 문자열이지만 ()()) 와 같은 문자열은 바르지 않은 문자열이다. 6 | (해당 문제에서는 소괄호만 판별하지만, 중괄호와 대괄호까지 판별해 보세요.) 7 | 8 | 입력으로 주어진 괄호 문자열이 바른 문자열인지 바르지 않은 문자열인지 9 | "YES"와 "NO"로 구분된 문자열을 출력해보자. 10 | */ 11 | 12 | const { SSL_OP_SSLEAY_080_CLIENT_DH_BUG } = require("constants"); 13 | 14 | const checkBalance = (arr) => { 15 | let count = 0; 16 | 17 | for (let i = 0; i < arr.length; i++) { 18 | if (arr[i] === "(") { 19 | count++; 20 | } else if (arr[i] === ")") { 21 | count--; 22 | } else { 23 | return false; 24 | } 25 | if (count < 0) return false; 26 | } 27 | return true; 28 | }; 29 | 30 | const printResult = (brackets) => { 31 | let arr = brackets.split(""); 32 | let bool = checkBalance(arr); 33 | if (bool) { 34 | console.log("YES"); 35 | } else { 36 | console.log("NO"); 37 | } 38 | }; 39 | 40 | printResult("(())"); // YES 41 | printResult("(()()())"); // YES 42 | printResult("()()()"); // YES 43 | printResult(")))((("); // NO 44 | printResult("())"); // NO 45 | printResult("())("); // NO 46 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/054 연속되는수.js: -------------------------------------------------------------------------------- 1 | /* 2 | 은주는 놀이공원 아르바이트를 하고 있다. 3 | 은주가 일하는 놀이공원에서는 현재 놀이공원 곳곳에 숨겨진 숫자 스탬프를 모아 오면 선물을 주는 이벤트를 하고 있다. 4 | 숫자 스탬프는 매일 그 수와 스탬프에 적힌 숫자가 바뀌지만 그 숫자는 항상 연속된다. 5 | 그런데 요즘 다른 날에 찍은 스탬프를 가지고 와 선물을 달라고 하는 손님이 늘었다. 6 | 7 | 스탬프에 적힌 숫자가 공백으로 구분되어 주어지면 이 숫자가 연속수인지 아닌지 "YES"와 "NO"로 판별하는 프로그램을 작성하시오 8 | 9 | 입력1 10 | 1 2 3 4 5 11 | 12 | 출력1 13 | YES 14 | 15 | 입력2 16 | 1 4 2 6 3 17 | 18 | 출력2 19 | NO 20 | */ 21 | 22 | const isConsecutive = (str) => { 23 | let arr = str 24 | .split(" ") 25 | .map((v) => +v) 26 | .sort((a, b) => a - b); 27 | 28 | for (let i = 1; i < arr.length; i++) { 29 | if (arr[i] !== arr[i - 1] + 1) { 30 | return console.log("NO"); 31 | } 32 | } 33 | return console.log("YES"); 34 | }; 35 | 36 | isConsecutive("1 2 3 4 5"); 37 | isConsecutive("1 4 2 6 3"); 38 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/055 하노이의탑.js: -------------------------------------------------------------------------------- 1 | /* 2 | 하노이의 탑은 프랑스 수학자 에두아르드가 처음으로 발표한 게임입니다. 3 | 2^(n-1) 순회 : O(2^n) 4 | 하노이의 탑은 A, B, C 3개의 기둥과 기둥에 꽂을 수 있는 N 개의 원판으로 이루어져 있습니다. 5 | 이 게임에서 다음의 규칙을 만족해야 합니다. 6 | 7 | 1. 처음에 모든 원판은 A 기둥에 꽂혀 있다. 8 | 2. 모든 원판의 지름은 다르다. 9 | 3. 이 원반은 세 개의 기둥 중 하나에 반드시 꽂혀야 한다. 10 | 4. 작은 원반 위에 큰 원반을 놓을 수 없다. 11 | 5. 한 번에 하나의 원판(가장 위에 있는 원판)만을 옮길 수 있다. 12 | 13 | 이 규칙을 만족하며 A 기둥에 있는 원반 N 개를 모두 C 원반으로 옮기고 싶습니다. 14 | 모든 원반을 옮기기 위해 실행되어야 할 "최소" 원반 이동횟수를 계산하는 프로그램을 완성해 주세요. 15 | */ 16 | 17 | const route = []; 18 | 19 | function hanoi(num, start, end, temp) { 20 | //원판이 한 개일 때에는 바로 옮기면 됩니다. 21 | if (num === 1) { 22 | route.push([start, end]); 23 | return NaN; 24 | } 25 | 26 | //원반이 n-1개를 경유기둥으로 옮기고 27 | hanoi(num - 1, start, temp, end); 28 | //가장 큰 원반은 목표기둥으로 29 | route.push([start, end]); 30 | //경유기둥과 시작기둥을 바꿉니다. 31 | hanoi(num - 1, temp, end, start); 32 | } 33 | 34 | hanoi(3, "A", "B", "C"); 35 | console.log(route); 36 | console.log(route.length); 37 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/056 객체의함수응용.js: -------------------------------------------------------------------------------- 1 | /* 2 | 다음의 객체가 주어졌을 때 한국의 면적과 가장 비슷한 국가와 그 차이를 출력하세요. 3 | 4 | 출력예시 5 | England 22023 6 | */ 7 | 8 | let nationWidth = { 9 | Korea: 220877, 10 | Rusia: 17098242, 11 | China: 9596961, 12 | France: 543965, 13 | Japan: 377915, 14 | England: 242900, 15 | }; 16 | 17 | let w = nationWidth.Korea; 18 | delete nationWidth.Korea; 19 | let entries = Object.entries(nationWidth); 20 | console.log(entries); 21 | let values = Object.values(nationWidth); 22 | console.log(entries); 23 | let gap = Math.max(...values); 24 | let entry; 25 | console.log(gap); 26 | for (let i in entries) { 27 | if (gap > Math.abs(entries[i][1] - w)) { 28 | gap = Math.abs(entries[i][1] - w; 29 | entry = entries[i]; 30 | } 31 | } 32 | console.log(entry[0], entry[1] - w); 33 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/057 1의개수.js: -------------------------------------------------------------------------------- 1 | /* 2 | 0부터 1000까지 1의 개수를 세는 프로그램을 만들려고 합니다. 3 | 예를 들어 0부터 20까지 1의 개수를 세어본다면 1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19에 각각 1이 들어가므로 12개의 1이 있게 됩니다. 4 | 11은 1이 2번 들어간 셈이죠. 5 | 6 | 그렇다면 0부터 1000까지 수에서 1은 몇 번이나 들어갔을까요? 7 | 출력해 주세요. 8 | */ 9 | 10 | const countOne = () => { 11 | let count = 0; 12 | let str = ""; 13 | for (let i = 0; i <= 1000; i++) { 14 | str += i; 15 | } 16 | 17 | str.match(/1/g); 18 | console.log(str.match(/1/g).length); 19 | 20 | let arr = str.split(""); 21 | for (let v of arr) { 22 | if (v === "1") { 23 | count++; 24 | } 25 | } 26 | return count; 27 | }; 28 | 29 | console.log(countOne()); 30 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/058 콤마찍기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 원범이는 편의점 아르바이트가 끝난 후 정산을 하고자 합니다. 3 | 정산을 빨리하고 집에 가고 싶은 원범이는 프로그램을 만들려고 합니다. 4 | 5 | 숫자를 입력받고 천 단위로 콤마(,)를 찍어주세요. 6 | 7 | 예를 들어, 123456789를 입력받았으면 123,456,789를 출력해야 합니다. 8 | */ 9 | 10 | const putComma = (s) => { 11 | if (s.length <= 3) { 12 | return s; 13 | } else { 14 | return putComma(s.slice(0, s.length - 3)) + "," + s.slice(s.length - 3); 15 | } 16 | }; 17 | 18 | console.log(putComma("123456789")); 19 | // "123,456,789" 20 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/059 빈칸채우기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 총 문자열의 길이는 50으로 제한하고 사용자가 문자열을 입력하면 3 | 그 문자열을 가운데 정렬을 해주고, 나머지 빈 부분에는 '='을 채워 넣어주세요. 4 | 5 | 입력 6 | hi 7 | 8 | 출력 9 | ========================hi======================== 10 | */ 11 | 12 | const alignCenter = (str) => { 13 | let totalLen = 50; 14 | let left = str.padStart(totalLen / 2 + str.length / 2, "-"); 15 | // 시작하는 부분을 25 + 1 까지 채워준다 16 | return left.padEnd(totalLen, "-"); 17 | // 끝나는 부분을 50까지 채워준다 18 | }; 19 | 20 | console.log(alignCenter("hi")); 21 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/060 번호매기기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 새 학기가 되어 이름을 가나다 순서대로 배정하고 번호를 매기려고 합니다. 3 | 데이터에 입력된 이름을 아래와 같이 출력해 주세요. 4 | 5 | 출력예시 6 | 번호: 1, 이름: 강은지 7 | 번호: 2, 이름: 강채연 8 | 번호: 3, 이름: 권윤일 9 | 번호: 4, 이름: 김민호 10 | 번호: 5, 이름: 김유정 11 | 번호: 6, 이름: 김진이 12 | 번호: 7, 이름: 김채리 13 | 번호: 8, 이름: 박지호 14 | 번호: 9, 이름: 박현서 15 | 번호: 10, 이름: 최성훈 16 | 번호: 11, 이름: 한지호 17 | 번호: 12, 이름: 홍유진 18 | */ 19 | 20 | let students = [ 21 | "강은지", 22 | "김유정", 23 | "박현서", 24 | "최성훈", 25 | "홍유진", 26 | "박지호", 27 | "권윤일", 28 | "김채리", 29 | "한지호", 30 | "김진이", 31 | "김민호", 32 | "강채연", 33 | ]; 34 | 35 | students.sort(); 36 | for (let i in students) { 37 | console.log(`번호 : ${+i + 1}, 이름: ${students[i]}`); 38 | } 39 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/061 문자열압축하기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 문자열을 입력받고 연속되는 문자열을 압축해서 표현하고 싶습니다. 3 | 4 | 입력 5 | aaabbbbcdddd 6 | 7 | 출력 8 | a3b4c1d4 9 | */ 10 | 11 | const countChar = (str) => { 12 | let cur = str[0]; 13 | let count = 1; 14 | let result = ""; 15 | for (let i = 1; i < str.length; i++) { 16 | if (cur !== str[i]) { 17 | result += cur + count; 18 | count = 1; 19 | cur = str[i]; 20 | } else { 21 | count++; 22 | } 23 | } 24 | result += cur + count; 25 | return result; 26 | }; 27 | 28 | console.log(countChar("aaabbbbcdddd")); 29 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/062 20201023 출력하기.js: -------------------------------------------------------------------------------- 1 | /* 2 | `20201023`을 출력합니다. 아래 기준만 만족하면 됩니다. 3 | 4 | 1. 코드 내에 숫자가 없어야 합니다. 5 | - 예) console.log(20201023)이라고 하시면 안됩니다. 6 | 2. 파일 이름이나 경로를 사용해서는 안됩니다. 7 | 3. 시간, 날짜 함수를 사용해서는 안됩니다. 8 | 4. 에러 번호 출력을 이용해서는 안됩니다. 9 | 5. input을 이용해서는 안됩니다. 10 | */ 11 | 12 | // 정규표현식 사용 13 | // abcd 14 | // 0123 15 | const str = "cacabacd"; 16 | console.log( 17 | str.replace(/a/g, 0).replace(/b/g, 1).replace(/c/g, 2).replace(/d/g, 3) 18 | ); 19 | 20 | // 날짜함수 사용 21 | let date = new Date(); 22 | console.log( 23 | date.getFullYear().toString() + 24 | (date.getMonth() + 1).toString() + 25 | date.getDate().toString() 26 | ); 27 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/063 친해지고싶어.js: -------------------------------------------------------------------------------- 1 | /* 2 | 한국 대학교의 김한국 교수님은 학생들과 친해지기 위해서 딸에게 줄임말을 배우기로 했습니다. 3 | 딸은 '복잡한 세상 편하게 살자'라는 문장을 '복세편살'로 줄여 말합니다. 4 | 5 | 교수님이 줄임말을 배우기 위해 아래와 같이 어떤 입력이 주어지면 앞 글자만 줄여 출력하도록 해주세요. 6 | 입력은 "한글" 혹은 "영어"로 입력되며, 띄어쓰기를 기준으로 하여 짧은 형태로 출력합니다. 7 | 8 | 입력 9 | 복잡한 세상 편하게 살자 10 | 11 | 출력 12 | 복세편살 13 | */ 14 | 15 | const abbreviation = (str) => { 16 | let arr = str.split(" "); 17 | let result = ""; 18 | for (let substr of arr) { 19 | result += substr[0]; 20 | } 21 | return result; 22 | }; 23 | 24 | console.log(abbreviation("복잡한 세상 편하게 살자")); 25 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/064 이상한 엘리베이터.js: -------------------------------------------------------------------------------- 1 | /* 2 | 정량 N에 정확히 맞춰야만 움직이는 화물용 엘리베이터가 있습니다. 3 | 화물은 7kg, 3kg 두 가지이며 팔이 아픈 은후는 가장 적게 화물을 옮기고 싶습니다. 4 | 5 | 예를 들어 정량이 24kg이라면 3kg 8개를 옮기는 것보다는 6 | 7kg 3개, 3kg 1개 즉 4개로 더 적게 옮길 수 있습니다. 7 | 8 | 입력 9 | 정량 N이 입력됩니다. 10 | 11 | 출력 12 | 가장 적게 옮길 수 있는 횟수를 출력합니다. 13 | 만약 어떻게 해도 정량이 N이 되지 않는다면 -1을 출력합니다. 14 | */ 15 | 16 | const strangeElevator = (n) => { 17 | let [capacityOfA, capacityOfB] = [7, 3]; 18 | 19 | let quotientA = Math.floor(n / capacityOfA); 20 | let remainderA = n % capacityOfA; 21 | 22 | if (remainderA % capacityOfB !== 0) { 23 | console.log(-1); 24 | } else { 25 | console.log(quotientA + remainderA / capacityOfB); 26 | } 27 | }; 28 | 29 | strangeElevator(24); 30 | strangeElevator(4); 31 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/065 변형된리스트.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | 아래와 같은 리스트가 있을 때, 4 | [[1, a], [b, 4], [9, c], [d, 16]] 이런 식으로 a, b 리스트가 번갈아가면서 출력되게 해주세요. 5 | */ 6 | 7 | let a = [1, 4, 9, 16]; 8 | let b = ["a", "b", "c", "d"]; 9 | 10 | // map 사용 : 리턴값 있음 11 | let arrByMap = a.map((v, i) => { 12 | if (i % 2 === 0) { 13 | return [v, b[i]]; 14 | } else { 15 | return [b[i], v]; 16 | } 17 | }); 18 | console.log(arrByMap); 19 | 20 | // forEach 사용 : 리턴값 없음 21 | let arrByForEach = []; 22 | a.forEach((v, i) => { 23 | if (i % 2 === 0) { 24 | arrByForEach.push([v, b[i]]); 25 | } else { 26 | arrByForEach.push([b[i], v]); 27 | } 28 | }); 29 | console.log(arrByForEach); 30 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/066 블럭탑쌓기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 탑을 쌓기 위해 각 크기별로 준비된 블럭들을 정해진 순서에 맞게 쌓아야 합니다. 3 | 순서에 맞게 쌓지 않으면 무너질 수 있습니다. 4 | 5 | 예를 들면 정해진 순서가 BAC 라면, A 다음 C가 쌓아져야 합니다. 6 | 선행으로 쌓아야 하는 블럭이 만족된 경우라면 탑이 무너지지 않습니다. 7 | 8 | - B를 쌓지 않아도 A와 C를 쌓을 수 있습니다. 9 | - B 다음 블럭이 C가 될 수 있습니다. 10 | 11 | 쌓아져 있는 블럭 탑이 순서에 맞게 쌓아져 있는지 확인하세요. 12 | 13 | 1. 블럭은 알파벳 대문자로 표기합니다. 14 | 2. 규칙에 없는 블럭이 사용될 수 있습니다. 15 | 3. 중복된 블럭은 존재하지 않습니다. 16 | 17 | 입력 18 | 탑 = ["ABCDEF", "BCAD", "ADEFQRX", "BEDFG", "EFGHZ"] 19 | 규칙 = "ABD" 20 | 21 | 출력 22 | ["가능", "불가능", "가능", "가능", "가능"] 23 | */ 24 | 25 | const solution = (arrTops, rule) => { 26 | let answer = []; 27 | for (let top of arrTops) { 28 | answer.push(availability(top, rule)); 29 | } 30 | return answer; 31 | }; 32 | 33 | const availability = (top, rule) => { 34 | let temp = 0; 35 | for (let block of top) { 36 | let idx = rule.indexOf(block); 37 | if (idx === -1) continue; 38 | if (idx < temp) return "불가능"; 39 | temp = idx; 40 | } 41 | return "가능"; 42 | }; 43 | 44 | console.log(solution(["ABCDEF", "BCAD", "ADEFQRX", "BEDFG", "EFGHZ"], "ABD")); 45 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/067 민규의악수.js: -------------------------------------------------------------------------------- 1 | /* 2 | 광장에서 모인 사람들과 악수를 하는 행사가 열렸습니다. 3 | 참가자인 민규는 몇 명의 사람들과 악수를 한 후 중간에 일이 생겨 집으로 갔습니다. 4 | 5 | 이 행사에서 진행된 악수는 총 all번이라고 했을 때, 6 | (문제1) 민규는 몇 번의 악수를 하고 집으로 돌아갔을까요? 7 | (문제2) 그리고 민규를 포함한 행사 참가자는 몇 명일까요? 8 | 9 | - 악수는 모두 1대 1로 진행이 됩니다. 10 | - 민규를 제외한 모든 참가자는 자신을 제외한 참가자와 모두 한 번씩 악수를 합니다. 11 | - 같은 상대와 중복된 악수는 카운트 하지 않습니다. 12 | - 민규를 제외한 참가자는 행사를 모두 마쳤습니다. 13 | 14 | 예를 들어 행사에서 59회의 악수가 진행되었다면 민규는 4번의 악수를 하였고 민규를 포함한 참가자는 12명이다. 15 | 16 | 행사에서 진행된 악수 횟수(all)를 입력으로 받으면 민규의 악수 횟수와 행사 참가자 수가 출력됩니다. 17 | 18 | 입력 19 | 59 20 | 21 | 출력 22 | [4, 12] //[m: 악수 횟수, n: 행사 참가자 수] 23 | */ 24 | 25 | // 조합 nCr : n!/(r!(n-r)!) 26 | // n!/(2!(n-2)!) = n(n-1) / 2 27 | 28 | const solution = (all) => { 29 | let [m, n] = [0, 0]; 30 | for (let i = 0; true; i++) { 31 | if (all < (i * (i - 1)) / 2) { 32 | n = --i; 33 | m = all - (n * (n - 1)) / 2; 34 | break; 35 | } 36 | } 37 | return [m, n + 1]; 38 | }; 39 | 40 | console.log(solution(59)); 41 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/068 버스시간표.js: -------------------------------------------------------------------------------- 1 | /* 2 | 학교가 끝난 지원이는 집에 가려고 합니다. 3 | 학교 앞에 있는 버스 시간표는 너무 복잡해서 버스 도착시간이 몇 분 남았는지 알려주는 프로그램을 만들고 싶습니다. 4 | 5 | 버스 시간표와 현재 시간이 주어졌을 때 버스 도착 시간이 얼마나 남았는지 알려주는 프로그램을 만들어주세요. 6 | 7 | - 버스 시간표와 현재 시간이 입력으로 주어집니다. 8 | - 출력 포맷은 "00시 00분"입니다. 9 | 만약 1시간 3분이 남았다면 "01시간 03분"으로 출력해야 합니다. 10 | - 버스 시간표에 현재 시간보다 이전인 버스가 있다면 "지나갔습니다."라고 출력합니다. 11 | 12 | 입력 13 | ["12:30", "13:20", "14:13"] 14 | "12:40" 15 | 16 | 출력 17 | ['지나갔습니다', '00시간 40분', '01시간 33분'] 18 | */ 19 | 20 | const solution = (schedule, now) => { 21 | let answer = []; 22 | let nowArr = now.split(":").map((v) => +v); 23 | let nowMin = nowArr[0] * 60 + nowArr[1]; 24 | for (let arrive of schedule) { 25 | let arriveArr = arrive.split(":").map((v) => +v); 26 | let arriveMin = arriveArr[0] * 60 + arriveArr[1]; 27 | 28 | let diff = arriveMin - nowMin; 29 | if (diff < 0) { 30 | answer.push("지나갔습니다"); 31 | } else { 32 | let diffHour = Math.floor(diff / 60) 33 | .toString() 34 | .padStart(2, "0"); 35 | let diffMin = (diff % 60).toString().padStart(2, "0"); 36 | answer.push(`${diffHour}시간 ${diffMin}분`); 37 | } 38 | } 39 | return answer; 40 | }; 41 | 42 | console.log(solution(["12:30", "13:20", "14:13"], "12:40")); 43 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/069 골드바흐의추측.js: -------------------------------------------------------------------------------- 1 | /* 2 | 골드바흐의 추측(Goldbach's conjecture)은 오래전부터 알려진 정수론의 미해결 문제로, 3 | 2보다 큰 모든 짝수는 두 개의 소수(Prime number)의 합으로 표시할 수 있다는 것이다. 4 | 이때 하나의 소수를 두 번 사용하는 것은 허용한다. - 위키백과 5 | 6 | 위 설명에서 2보다 큰 모든 짝수를 두 소수의 합으로 나타낸 것을 골드바흐 파티션이라고 합니다. 7 | 8 | 예) 9 | 100 == 47 + 53 10 | 56 == 19 + 37 11 | 12 | 2보다 큰 짝수 n이 주어졌을 때, 골드바흐 파티션을 출력하는 코드를 작성하세요. 13 | 14 | * 해당 문제의 출력 형식은 자유롭습니다. 15 | 가능하시다면 골드바흐 파티션 모두를 출력하거나, 16 | 그 차가 작은 것을 출력하거나 그 차가 큰 것 모두 출력해보세요. 17 | */ 18 | 19 | const isPrime = (n) => { 20 | let sqrtN = Math.sqrt(n); 21 | for (let i = 2; i <= sqrtN; i++) 22 | if (n % i === 0) { 23 | return false; 24 | } 25 | return n > 1; 26 | }; 27 | 28 | const goldbachsConjecture = (n) => { 29 | let primeArr = []; 30 | let answers = []; 31 | for (let i = 2; i < n - 1; i++) { 32 | if (isPrime(i)) { 33 | primeArr.push(i); 34 | } 35 | } 36 | for (let p of primeArr) { 37 | if (p > n / 2) break; 38 | if (primeArr.includes(n - p)) { 39 | answers.push([p, n - p]); 40 | } 41 | } 42 | // 차가 큰것 43 | // answers.sort((a, b) => b[1] - b[0] - (a[1] - a[0])); 44 | // 차가 작은것 45 | answers.sort((a, b) => a[1] - a[0] - (b[1] - b[0])); 46 | return answers[0]; 47 | }; 48 | 49 | console.log(goldbachsConjecture(100)); 50 | console.log(goldbachsConjecture(56)); 51 | 52 | // 에라토스테네스의 체 53 | const prime_list = (n) => { 54 | //에라토스테네스의 체 초기화: n개 요소에 True 설정(소수로 간주) 55 | let sieve = []; 56 | for (let i = 2; i < n; i++) { 57 | sieve.push(true); 58 | } 59 | console.log(sieve); 60 | 61 | //n의 최대 약수가 sqrt(n) 이하이므로 i=sqrt(n)까지 검사 62 | let m = parseInt(n ** 0.5, 10); 63 | // console.log(m); 64 | for (let i = 2; i < m + 1; i++) { 65 | if (sieve[i] == true) { 66 | // i가 소수인 경우 67 | for (let j = i + i; j < n; j += i) { 68 | // i이후 i의 배수들을 False 판정 69 | sieve[j] = false; 70 | } 71 | } 72 | } 73 | // 소수 목록 산출 74 | let 소수목록 = []; 75 | for (let i = 2; i < n; i++) { 76 | if (sieve[i] == true) { 77 | 소수목록.push(i); 78 | } 79 | } 80 | return 소수목록; 81 | }; 82 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/070 행렬곱하기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 행렬 2개가 주어졌을 때 곱할 수 있는 행렬인지 확인하고 곱할 수 있다면 그 결과를 출력하고, 3 | 곱할 수 없다면 -1을 출력하는 프로그램을 만들어주세요. 4 | 5 | 입력 6 | a = [[1, 2], 7 | [2, 4]] 8 | 9 | b = [[1, 0], 10 | [0, 3]] 11 | 12 | 출력 13 | [[1, 6], [2, 12]] 14 | */ 15 | 16 | // let xx = 1 스칼라 17 | // let yy = [1,2,3] 벡터 18 | // let zz = [[1,2,3], [1,2,3]] 행렬 19 | 20 | const solution = (a, b) => { 21 | let result = []; 22 | 23 | if (a[0].length !== b.length) { 24 | return -1; 25 | } 26 | 27 | for (let i = 0; i < a.length; i++) { 28 | let row = []; 29 | 30 | for (let j = 0; j < a[0].length; j++) { 31 | let val = 0; 32 | 33 | for (let k = 0; k < a[0].length; k++) { 34 | val += a[i][k] * b[k][j]; 35 | } 36 | row.push(val); 37 | } 38 | result.push(row); 39 | } 40 | return result; 41 | }; 42 | 43 | console.log( 44 | solution( 45 | (a = [1]), 46 | (b = [ 47 | [1, 0], 48 | [0, 3], 49 | ]) 50 | ) 51 | ); 52 | 53 | console.log( 54 | solution( 55 | (a = [ 56 | [1, 2], 57 | [2, 4], 58 | ]), 59 | (b = [ 60 | [1, 0], 61 | [0, 3], 62 | ]) 63 | ) 64 | ); 65 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/071 깊이우선탐색.js: -------------------------------------------------------------------------------- 1 | /* 2 | 그래프 탐색! 3 | 다음과 같이 리스트 형태로 노드들의 연결 관계가 주어진다고 할 때 4 | 깊이 우선 탐색으로 이 노드들을 탐색했을 때의 순서를 공백으로 구분하여 출력하세요. 5 | 6 | 출력예시 7 | E D F A C B 8 | 9 | 10 | ※ 깊이우선탐색 (DFS, Depth First Search) 11 | 목표한 노드를 찾기 위해 가장 우선순위가 높은 노드의 자식으로 깊이 들어갔다가 목표 노드가 존재하지 않으면 처음 방문한 노드와 연결된 다른 노드부터 그 자식 노드로 파고드는 검색방법 12 | - 클래스로 구현 13 | - 스택으로 구현 : 스택의 특징(LIFO)에 의해 자동으로 깊이 우선 탐색 14 | */ 15 | 16 | let myGraph = { 17 | E: ["D", "A"], 18 | F: ["D"], 19 | A: ["E", "C", "B"], 20 | B: ["A"], 21 | C: ["A"], 22 | D: ["E", "F"], 23 | }; 24 | 25 | const dfs = (graph, start) => { 26 | let visited = []; 27 | let stack = [start]; 28 | 29 | while (stack.length) { 30 | let cur = stack.pop(); 31 | if (!visited.includes(cur)) { 32 | let subs = graph[cur].filter((v) => !visited.includes(v)); 33 | visited.push(cur); 34 | for (let sub of subs) { 35 | stack.push(sub); 36 | } 37 | } 38 | } 39 | return visited; 40 | }; 41 | 42 | console.log(dfs(myGraph, "E")); 43 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/072 너비우선탐색.js: -------------------------------------------------------------------------------- 1 | /* 2 | 그래프 탐색! 3 | 다음과 같이 입력이 주어질 때 4 | 너비 우선 탐색을 한 순서대로 노드의 인덱스를 공백 구분으로 출력하세요. 5 | 6 | 출력예시 7 | E D A F C B 8 | 9 | ※ 너비 우선 탐색 (BFS, Breadth First Search) 10 | 어떤 노드를 방문하여 확인한 후, 목표한 노드가 아니면 그 노드와 연결된 정점들 중에서 우선순위가 동일한 다른 노드를 찾고 그 순위에 없으면 그다음 순위 노드를 차례대로 찾는 방법이다. 11 | - 클래스로 구현 12 | - 큐로 구현 (큐의 특징(FIFO) 때문에 자동으로 너비 우선 탐색) 13 | */ 14 | 15 | let myGraph = { 16 | E: ["D", "A"], 17 | F: ["D"], 18 | A: ["E", "C", "B"], 19 | B: ["A"], 20 | C: ["A"], 21 | D: ["E", "F"], 22 | }; 23 | 24 | const bfs = (graph, start) => { 25 | let visited = []; 26 | let queue = [start]; 27 | 28 | while (queue.length) { 29 | let cur = queue.shift(); 30 | if (!visited.includes(cur)) { 31 | visited.push(cur); 32 | let subs = graph[cur].filter((v) => !visited.includes(v)); 33 | for (let sub of subs) { 34 | queue.push(sub); 35 | } 36 | } 37 | } 38 | return visited; 39 | }; 40 | 41 | console.log(bfs(myGraph, "E")); 42 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/073 최단경로찾기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 두 정점 사이를 이동할 수 있는 최단 거리를 출력하는 프로그램을 작성해 주세요. 3 | 이때 최단 거리란, 정점의 중복 없이 한 정점에서 다른 정점까지 갈 수 있는 가장 적은 간선의 수를 의미합니다. 4 | (단, 가중치 없음) 5 | 6 | > 가까운 정점 먼저 방문 : BFS 7 | > 거리를 증가시켜가면서 순회하다가 만나면 종료 8 | 9 | 입력 10 | A F 11 | 12 | 출력 13 | 2 14 | ``` 15 | */ 16 | let = myGraph = { 17 | A: ["B", "C"], 18 | B: ["A", "D", "E"], 19 | C: ["A", "F"], 20 | D: ["B"], 21 | E: ["B", "F"], 22 | F: ["C", "E"], 23 | }; 24 | 25 | const shortestPath = (graph, start, end) => { 26 | let visited = []; 27 | let queue = [[start, 0]]; 28 | 29 | while (queue.length) { 30 | let cur = queue.shift(); 31 | if (!visited.includes(cur[0])) { 32 | visited.push(cur[0]); 33 | if (cur[0] == end) { 34 | return cur[1]; 35 | } 36 | let subs = graph[cur[0]].filter((v) => !visited.includes(v)); 37 | for (let sub of subs) { 38 | queue.push([sub, cur[1] + 1]); 39 | } 40 | } 41 | } 42 | return -1; 43 | }; 44 | 45 | console.log(shortestPath(myGraph, "A", "F")); 46 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/074 최장거리찾기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 우리는 이 두 정점으로 가기 위한 최대 거리를 구하고자 합니다. 3 | 4 | 최대 거리란, 정점의 중복 없이 한 정점에서 다른 정점까지 경유할 수 있는 가장 많은 간선의 수를 뜻합니다. 5 | (단, 가중치 없음) 6 | 7 | 입력 8 | 1 7 9 | 10 | 출력 11 | 6 12 | */ 13 | 14 | // 강의를 다시보자!!! 15 | 16 | let graph = { 17 | 1: [2, 3, 4], 18 | 2: [1, 3, 4, 5, 6], 19 | 3: [1, 2, 7], 20 | 4: [1, 2, 5, 6], 21 | 5: [2, 4, 6, 7], 22 | 6: [2, 4, 5, 7], 23 | 7: [3, 5, 6], 24 | }; 25 | 26 | const solution = (graph) => { 27 | let queue = []; // 경로 28 | 29 | let answers = []; 30 | let start = 1; 31 | let end = 7; 32 | queue.push([[], start]); 33 | 34 | while (queue.length) { 35 | let [visited, cur] = queue.shift(); // 문제지점 36 | 37 | if (visited.includes(cur)) { 38 | continue; 39 | } 40 | 41 | visited.push(cur); 42 | 43 | if (cur == end) { 44 | answers.push(visited); 45 | continue; 46 | } 47 | 48 | console.log(cur, graph[cur]); 49 | let nexts = graph[cur].filter((v) => !visited.includes(v)); 50 | console.log(nexts); 51 | for (let next of nexts) { 52 | queue.push([visited, next]); // 문제지점 53 | } 54 | } 55 | 56 | let result = answers.sort((a, b) => b.length - a.length)[0]; 57 | return `최장경로 : ${result}, 카운트 : ${result.length} `; 58 | }; 59 | console.log(solution(graph)); 60 | 61 | /* 62 | const solution = (graph) => { 63 | let queue = []; // 경로 64 | let answers = []; 65 | let start = 1; 66 | let end = 7; 67 | let top = 0; 68 | 69 | queue.push([[], start]); 70 | 71 | for (let i = 0; i <= top; i++) { 72 | let [visited, cur] = queue[i]; 73 | 74 | if (visited.includes(cur)) { 75 | continue; 76 | } 77 | 78 | visited.push(cur); 79 | 80 | if (cur == end) { 81 | answers.push(visited); 82 | continue; 83 | } 84 | 85 | console.log(cur, graph[cur]); 86 | let nexts = graph[cur].filter((v) => !visited.includes(v)); 87 | console.log(nexts); 88 | for (let next of nexts) { 89 | queue[top] = [visited, next]; 90 | top++; 91 | } 92 | } 93 | 94 | let result = answers.sort((a, b) => b.length - a.length)[0]; 95 | return `최장경로 : ${result}, 카운트 : ${result.length} `; 96 | }; 97 | console.log(solution(graph)); 98 | 99 | */ 100 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/075 이상한369.js: -------------------------------------------------------------------------------- 1 | /* 2 | 369 게임을 하는데 조금 이상한 규칙이 있습니다. 3 | 3이나 6, 9 일 때만 박수를 쳐야합니다. 4 | 예를 들어 13, 16과 같이 3과 6, 9 만으로 된 숫자가 아닐 경우엔 박수를 치지 않습니다. 5 | 수현이는 박수를 몇 번 쳤는지 확인하고 싶습니다. 6 | 36일 때 박수를 쳤다면 박수를 친 횟수는 5번입니다. 7 | 8 | n을 입력하면 박수를 몇 번 쳤는지 그 숫자를 출력해주세요. 9 | 10 | 입력 11 | '93' 12 | 13 | 출력 14 | 10 15 | */ 16 | 17 | /* 18 | 3, 6, 9 // (0*3) + 현재위치 19 | 20 | 33, 36, 39 // (1*3) + 현재위치 21 | 63, 66, 69 // (2*3) + 현재위치 22 | 93, 96, 99 // (3*3) + 현재위치 23 | 24 | 333, 336, 339 // ((1+3)*3) + 현재위치 25 | 633, 636, 639 // ((2+3)*3) + 현재위치 26 | */ 27 | 28 | const game369 = (n) => { 29 | let str = n.toString().split(""); 30 | let answer = 0; 31 | let count = 1; 32 | 33 | for (let digit of str) { 34 | answer *= 3; 35 | if (digit < 3) answer += 0; 36 | else if (digit < 6) answer += 1; 37 | else if (digit < 9) answer += 2; 38 | else answer += 3; 39 | } 40 | 41 | return answer; 42 | }; 43 | 44 | console.log(game369(33)); 45 | console.log(game369(34)); 46 | console.log(game369(35)); 47 | console.log(game369(36)); 48 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/076 안전한땅.js: -------------------------------------------------------------------------------- 1 | /* 2 | 전쟁이 끝난 후, A 나라에서는 폐허가 된 도시를 재건하려고 한다. 3 | 그런데 이 땅은 전쟁의 중심지였으므로 전쟁 중 매립된 지뢰가 아직도 많이 남아 있다는 것이 판명되었다. 4 | 정부는 가장 먼저 지뢰를 제거하기 위해 수색반을 꾸렸다. 5 | 6 | 수색반은 가장 효율적인 지뢰 제거가 하고 싶다. 7 | 수색반은 도시를 격자무늬로 나눠놓고 자신들이 수색할 수 있는 범위 내에 가장 많은 지뢰가 매립된 지역을 가장 먼저 작업하고 싶다. 8 | 9 | 가장 먼저 테스트 케이스의 수를 나타내는 1이상 100 이하의 자연수가 주어진다. 10 | 각 테스트 케이스의 첫 줄에는 수색할 도시의 크기 a와 수색반이 한 번에 수색 가능한 범위 b가 주어진다. (a와 b 모두 정사각형의 가로 또는 세로를 나타낸다. 예를 들어 10이 주어지면 10x10칸의 크기를 나타낸다.) 11 | 12 | 그 후 a 줄에 걸쳐 도시 내 지뢰가 있는지의 여부가 나타난다. 13 | 0은 지뢰가 없음 1은 지뢰가 있음을 뜻한다. 14 | 15 | 각 테스트 케이스에 대해 수색 가능한 범위 bxb 내에서 찾아낼 수 있는 가장 큰 지뢰의 개수를 구하라. 16 | 17 | 입력 18 | 1 19 | 5 3 // 전체크기(5x5), 수색크기(3x3) 20 | 1 0 0 1 0 21 | 0 1 0 0 1 22 | 0 0 0 1 0 23 | 0 0 0 0 0 24 | 0 0 1 0 0 25 | 26 | 출력 27 | 3 28 | */ 29 | let mapSize = 5; 30 | let searchSize = 3; 31 | let map = [ 32 | [1, 0, 0, 1, 0], 33 | [0, 1, 0, 0, 1], 34 | [0, 0, 0, 1, 0], 35 | [0, 0, 0, 0, 0], 36 | [0, 0, 1, 0, 0], 37 | ]; 38 | const minesweeper = (mapSize, searchSize, map) => { 39 | let max = 0; 40 | 41 | for (let i = 0; i + searchSize < mapSize; i++) { 42 | for (let j = 0; j + searchSize < mapSize; j++) { 43 | let temp = 0; 44 | for (let a = 0; a < searchSize; a++) { 45 | for (let b = 0; b < searchSize; b++) temp += map[i + a][j + b]; 46 | } 47 | if (max < temp) { 48 | max = temp; 49 | } 50 | } 51 | } 52 | return max; 53 | }; 54 | 55 | console.log(minesweeper(mapSize, searchSize, map)); 56 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/077 가장긴공통부분문자열.js: -------------------------------------------------------------------------------- 1 | /* 2 | 가장 긴 공통 부분 문자열(Longest Common Subsequence)이란 A, B 두 문자열이 주어졌을 때 두 열에 공통으로 들어 있는 요소로 만들 수 있는 가장 긴 부분열을 말합니다. 3 | 여기서 부분열이란 다른 문자열에서 몇몇의 문자가 빠져있어도 순서가 바뀌지 않은 열을 말합니다. 4 | 5 | 예를 들어 6 | S1 = ['T', 'H', 'I', 'S', 'I', 'S', 'S', 'T', 'R', 'I', 'N', 'G', 'S'] 7 | S2 = ['T', 'H', 'I', 'S', 'I', 'S'] 8 | 라는 두 문자열이 있을 때 둘 사이의 부분 공통 문자열의 길이는 ['T', 'H', 'I', 'S', 'I', 'S']의 6개가 됩니다. 9 | 10 | 이처럼 두 문자열이 주어지면 가장 긴 부분 공통 문자열의 길이를 반환하는 프로그램을 만들어 주세요. 11 | 12 | 두 개의 문자열이 한 줄에 하나씩 주어집니다. 13 | 문자열은 알파벳 대문자로만 구성되며 그 길이는 100글자가 넘어가지 않습니다. 14 | 출력은 이 두 문자열의 가장 긴 부분 공통 문자열의 길이를 반환하면 됩니다. 15 | 16 | 입력 17 | THISISSTRINGS 18 | THISIS 19 | 출력 20 | 6 21 | 22 | 입력 23 | THISISSTRINGS 24 | KIOTHIKESSISKKQQAEW 25 | 출력 26 | 3 27 | */ 28 | 29 | const powerSet = (str) => { 30 | let comb = []; 31 | for (let i = 0; i < str.length; i++) { 32 | for (let j = str.length; j > i; j--) { 33 | comb.push(str.slice(i, j)); 34 | } 35 | } 36 | return comb; 37 | }; 38 | 39 | const longestCommonSubstr = (str1, str2) => { 40 | let subset1 = powerSet(str1); 41 | let subset2 = powerSet(str2); 42 | let intersection = subset1.filter((v) => subset2.includes(v)); 43 | intersection.sort((a, b) => b.length - a.length); 44 | return intersection[0].length; 45 | }; 46 | 47 | console.log(longestCommonSubstr("THISISSTRINGS", "KIOTHIKESSISKKQQAEW")); 48 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/078 원형테이블.js: -------------------------------------------------------------------------------- 1 | /* 2 | 기린은 중국집에서 친구들과 만나기로 하고, 음식을 시켰습니다. 3 | 음식이 나오고 한참을 기다렸지만 만나기로 한 친구 2명이 오지 않았어요. 4 | 기린은 배가 너무 고파 혼자 음식을 먹기 시작합니다. 5 | 6 | 원형 테이블에는 N 개의 음식들이 있습니다. 7 | 한 개의 음식을 다 먹으면 그 음식의 시계방향으로 K 번째 음식을 먹습니다. 8 | 하지만 아직 오지 않은 친구들을 위해 2개의 접시를 남겨야 합니다. 9 | 마지막으로 남는 음식은 어떤 접시인가요? 10 | 11 | 입력은 2개의 정수로 이루어지며 공백으로 구분되어 입력됩니다. 12 | 첫 번째 숫자가 음식의 개수 N, 두 번째 숫자가 K입니다. 13 | 첫 번째 가져가는 음식이 K 번째 음식이며 나머지는 첫 번째 음식으로부터 시계방향으로 가져갑니다. 14 | 15 | 입력 16 | 6 3 17 | 18 | 남은 음식들의 번호를 배열의 형태로 출력합니다. 19 | 20 | 출력 21 | [3, 5] 22 | */ 23 | 24 | const circularTable = (dishNum, step) => { 25 | let dishes = new Array(dishNum).fill().map((v, i) => i + 1); 26 | let curr = 1; 27 | 28 | while (dishes.length > 2) { 29 | curr = curr % dishes.length; 30 | dishes.splice(curr - 1, 1); 31 | curr += step - 1; 32 | } 33 | return dishes; 34 | }; 35 | 36 | console.log(circularTable(6, 3)); 37 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/079 순회하는 리스트.js: -------------------------------------------------------------------------------- 1 | /* 2 | n번 순회했을 때 변하기 전 원소와 변한 후 원소의 값의 차가 가장 작은 값을 출력하는 프로그램을 작성하세요. 3 | 4 | 2번 순회했을 때 변하기 전의 리스트와 변한 후의 리스트의 값은 아래와 같습니다. 5 | 6 | 순회전_리스트 = [10, 20, 25, 27, 34, 35, 39] 7 | 순회후_리스트 = [35, 39, 10, 20, 25, 27, 34] 8 | 리스트의_차 = [25, 19, 15, 7, 9, 8, 5] 9 | 10 | 39와 변한 후의 34 값의 차가 5이므로 리스트의 차 중 최솟값입니다. 11 | 따라서 39와 34의 인덱스인 6과 39와 34를 출력하는 프로그램을 만들어주세요. 12 | 13 | 입력 14 | 순회횟수는 : 2 15 | 16 | 출력 17 | index : 6 18 | value : 39, 34 19 | ``` 20 | */ 21 | 22 | const rotate = (list, n) => { 23 | let len = list.length; 24 | let [index, value1, value2] = [0, list[0], list[len - n]]; 25 | let diff = Math.abs(value1 - value2); 26 | 27 | list.forEach((v, idx1) => { 28 | let idx2 = (idx1 + (len - n)) % len; 29 | if (diff > Math.abs(v - list[idx2])) { 30 | index = idx1; 31 | value1 = v; 32 | value2 = list[idx2]; 33 | } 34 | }); 35 | return `index: ${index} value: ${value1}, ${value2}`; 36 | }; 37 | 38 | console.log(rotate([10, 20, 25, 27, 34, 35, 39], 2)); 39 | -------------------------------------------------------------------------------- /jeju100/031~080 중급/080 순열과 조합.js: -------------------------------------------------------------------------------- 1 | /* 2 | '순열'이란 원소의 값이 같더라도 순서가 다르면 서로 다른 원소로 취급하는 선택법입니다. 3 | '조합'이란 원소들을 조합하여 만들 수 있는 경우의 수이며 원소의 순서는 신경쓰지 않습니다. 4 | 5 | 한글의 자모 24자 중 자음은 총 14개입니다. 6 | 이 중 입력받은 자음을 n 개를 선택하여 나올 수 있는 모든 조합과, 조합의 수를 출력하고 싶습니다. 7 | 8 | 나올 수 있는 모든 조합을 아래와 같이 출력해 주세요. 9 | 10 | <--요구 조건--> 11 | 1. 첫 번째 입력으로 선택할 한글 자음이 주어집니다. 12 | 2. 두 번째 입력으로 조합의 수가 주어집니다. 13 | 3. 주어진 조합의 수에 따라 조합과 조합의 수를 출력해 주세요. 14 | 15 | 입력 16 | ㄱ,ㄴ,ㄷ,ㄹ 17 | 3 18 | 19 | 출력 20 | ['ㄱㄴㄷ', 'ㄱㄴㄹ', 'ㄱㄷㄹ', 'ㄴㄷㄹ'] 21 | 4 22 | */ 23 | 24 | // prev arr push(curr) 25 | // i == 0 26 | // "" ["A", "B", "C", "D"] ["A"] 27 | // "A" ["B", "C", "D"] ["AB"] 28 | // "AB" ["C", "D"] ["ABC"] 29 | // "ABC" ["D"] ["ABCD"] 30 | // i == 1 31 | // "" ["A", "B", "C", "D"] ["B"] 32 | // "B" ["C", "D"] ["BC"] 33 | // "BC" ["D"] ["BCD"] 34 | // i == 2 35 | // "" ["A", "B", "C", "D"] ["C"] 36 | // "C" ["D"] ["CD"] 37 | // i == 3 38 | // "" ["A", "B", "C", "D"] ["D"] 39 | 40 | const nCr = (arr, r) => { 41 | let comb = []; 42 | 43 | const powerSet = (prev, arr) => { 44 | for (let i = 0; i < arr.length; i++) { 45 | curr = prev + arr[i]; 46 | comb.push(curr); 47 | powerSet(curr, arr.slice(i + 1)); 48 | } 49 | }; 50 | 51 | powerSet("", arr); 52 | let result = comb.filter((x) => x.length === r); 53 | return [result, result.length]; 54 | }; 55 | 56 | console.log(nCr(["A", "B", "C", "D"], 3)); 57 | 58 | const powerset = (arr) => { 59 | let comb = []; 60 | 61 | const powerSet = (prev, arr) => { 62 | for (let i = 0; i < arr.length; i++) { 63 | curr = prev + arr[i]; 64 | comb.push(curr); 65 | powerSet(curr, arr.slice(i + 1)); 66 | } 67 | }; 68 | powerSet("", arr); 69 | return comb; 70 | }; 71 | 72 | console.log(powerset(["A", "B", "C", "D"])); 73 | /* 74 | [ 75 | 'A', 'AB', 'ABC', 76 | 'ABCD', 'ABD', 'AC', 77 | 'ACD', 'AD', 'B', 78 | 'BC', 'BCD', 'BD', 79 | 'C', 'CD', 'D' 80 | ] 81 | */ 82 | -------------------------------------------------------------------------------- /jeju100/081~100 고급/081 지뢰찾기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 다음 그림처럼 깃발 주위에는 지뢰가 사방으로 있습니다. 3 | 깃발의 위치를 입력받아 지뢰와 함께 출력해주는 프로그램을 만드세요. 4 | https://www.notion.so/81-b18ce0051ecd4d7d9aa6cebbb966b679 5 | 6 | 입력 7 | 0 1 0 0 0 8 | 0 0 0 0 0 9 | 0 0 0 1 0 10 | 0 0 1 0 0 11 | 0 0 0 0 0 12 | //"0 1 0 0 0\n0 0 0 0 0\n0 0 0 1 0\n0 0 1 0 0\n0 0 0 0 0" 13 | 14 | 출력 15 | * f * 0 0 16 | 0 * 0 * 0 17 | 0 0 * f * 18 | 0 * f * 0 19 | 0 0 * 0 0 20 | 21 | */ 22 | 23 | const solution = (str) => { 24 | let strFlag = str.replace(/1/g, "f"); 25 | let arr = strFlag.split("\n").map((v) => v.split(" ")); 26 | let [height, width] = [arr.length, arr[0].length]; 27 | 28 | for (let i = 0; i < height; i++) { 29 | for (let j = 0; j < width; j++) { 30 | if (arr[i][j] != "f") { 31 | continue; 32 | } 33 | i > 0 ? (arr[i - 1][j] = "*") : 0; 34 | j > 0 ? (arr[i][j - 1] = "*") : 0; 35 | i < height - 1 ? (arr[i + 1][j] = "*") : 0; 36 | j < width - 1 ? (arr[i][j + 1] = "*") : 0; 37 | } 38 | } 39 | return arr; 40 | }; 41 | 42 | console.log(solution("0 1 0 0 0\n0 0 0 0 0\n0 0 0 1 0\n0 0 1 0 0\n0 0 0 0 0")); 43 | -------------------------------------------------------------------------------- /jeju100/081~100 고급/082 수학괄호파싱.js: -------------------------------------------------------------------------------- 1 | /* 2 | 수학공식이 제대로 입력이 되었는지 판단하는 코드를 작성하려 합니다. 3 | 괄호는 소괄호밖에 없습니다. 4 | 5 | 입출력 예시 6 | 7 | 입력: 3 + 5 8 | 출력: true 9 | 10 | 입력: 5 + 7) * (3 * 5) 11 | 출력: false 12 | 13 | */ 14 | function math(ex) { 15 | let count = 0; 16 | for (let c of ex) { 17 | if (c === "(") count++; 18 | if (c === ")") count--; 19 | if (count < 0) { 20 | return false; 21 | } 22 | } 23 | return true; 24 | } 25 | 26 | console.log(math("3 + 5")); 27 | console.log(math(")3 + 5(")); 28 | console.log(math("5 + 7) * (3 * 5)")); 29 | -------------------------------------------------------------------------------- /jeju100/081~100 고급/083 수학괄호파싱2.js: -------------------------------------------------------------------------------- 1 | /* 2 | 수학공식이 제대로 입력이 되었는지 판단하는 코드를 작성하려 합니다. 3 | 괄호는 소괄호와 중괄호가 있습니다. 4 | 5 | 5 + 7 * {(3 * 5)} 6 | true 7 | 8 | 5 + 7){ * (3 * 5) 9 | false 10 | 11 | */ 12 | 13 | const math = (ex) => { 14 | const obj = { 15 | ")": "(", 16 | "}": "{", 17 | "]": "[", 18 | }; 19 | let stack = []; 20 | for (let c of ex) { 21 | if (c === "(" || c === "{" || c === "[") { 22 | stack.push(c); 23 | continue; 24 | } 25 | if (c === ")" || c === "}" || c === "]") { 26 | let lastBracket = stack.pop(); 27 | if (lastBracket !== obj[c]) { 28 | return false; 29 | } 30 | } 31 | } 32 | return true; 33 | }; 34 | 35 | console.log(math("5 + 7 * {(3 * 5)}")); 36 | console.log(math("5 + 7){ * (3 * 5)")); 37 | -------------------------------------------------------------------------------- /jeju100/081~100 고급/084 숫자뽑기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 소정이는 어떤 숫자에서 k개의 수를 뽑았을 때 가장 큰 수를 찾는 놀이를 하고 있습니다. 3 | 예를 들어, 숫자 1723에서 두 개의 수를 뽑으면 [17, 12, 13, 72, 73, 23] 을 만들 수 있습니다. 4 | 이 중 가장 큰 수는 73입니다. 5 | 6 | 위 예시처럼 어떤 수 n에서 k개의 수를 선택하여 만들 수 있는 수 중에서 가장 큰 수를 찾아 주세요. 7 | */ 8 | 9 | const solution = (n, k) => { 10 | let arr = n.toString().split(""); 11 | arr.sort((a, b) => b - a); 12 | return Number(arr.splice(0, k).join("")); 13 | }; 14 | 15 | console.log(solution(1723, 2)); 16 | -------------------------------------------------------------------------------- /jeju100/081~100 고급/085 숫자놀이.js: -------------------------------------------------------------------------------- 1 | /* 2 | 일정한 규칙을 가지고 있는 숫자를 나열하는 놀이를 하는 중입니다. 3 | 이전 숫자에서 각 숫자의 개수를 나타내어 숫자로 만들고 다시 그 숫자를 같은 규칙으로 만들며 나열합니다. 4 | 5 | 이 놀이는 1부터 시작합니다. 6 | 다음 수는 1이 1개이기 때문에 '11'이 되고, 7 | '11'에서 1이 2개이기 때문에 그다음은 '12'가 됩니다. 8 | 9 | 즉, 10 | 1. 1 → (1) 11 | 2. 11 → (1이 1개) 12 | 3. 12 → (1이 2개) 13 | 4. 1121 → (1이 1개 2가 1개) 14 | 5. 1321 → (1이 3개 2가 1개) 15 | 6. 122131 → (1이 2개 2가 1개 3이 1개) 16 | 7. 132231 → (1이 3개 2가 2개 3이 1개) 17 | 8. 122232 18 | 9. 112431 19 | 20 | 위와 같이 진행되는 규칙을 통해 진행횟수 N을 입력받으면 해당되는 수를 출력하세요. 21 | 22 | */ 23 | 24 | const game = (turn) => { 25 | let res = "1"; 26 | for (let i = 2; i <= turn; i++) { 27 | let score = new Object(); 28 | 29 | for (let j of res) { 30 | score[j] = ++score[j] || 1; 31 | 32 | let temp = ""; 33 | for (let j in score) { 34 | if (score[j] > 0) { 35 | temp += j + score[j]; 36 | } 37 | } 38 | res = temp; 39 | } 40 | } 41 | return res; 42 | }; 43 | 44 | console.log(game(3)); //12 45 | console.log(game(4)); //1121 46 | console.log(game(5)); //1321 47 | console.log(game(6)); //122131 48 | console.log(game(7)); //132231 49 | 50 | /* 51 | 번외문제 52 | 1부터 10000까지 8의 갯수 세기 53 | */ 54 | let result = ""; 55 | for (let i = 1; i <= 10000; i++) { 56 | result += i; 57 | } 58 | console.log(result.match(/8/g).length); 59 | -------------------------------------------------------------------------------- /jeju100/081~100 고급/086 회전초밥.js: -------------------------------------------------------------------------------- 1 | /* 2 | 쉔은 회전 초밥집에 갔습니다. 3 | 초밥집에 간 쉔은 각 초밥에 점수를 매기고 낮은 점수의 순서로 초밥을 먹으려 합니다. 4 | 이때 n위치에 놓여진 초밥을 먹고자 할 때 접시가 몇 번 지나가고 먹을 수 있을지 출력하세요. 5 | 6 | 1. 초밥은 놓여진 위치에서 옮겨지지 않습니다. 7 | 2. 지나간 초밥은 나머지 초밥이 지나간 후에 다시 돌아옵니다. 8 | 3. 초밥은 1개 이상 존재합니다. 9 | 10 | 예) 11 | A, B, C, D, E 초밥이 있고 각 점수가 1, 1, 3, 2, 5 일 때 3번째(C초밥)을 먹게 되는 순서는 12 | 점수가 1인 초밥 A와 B를 먹고 다음으로 점수가 2인 D 초밥을 먹어야 . 13 | A B C D E 의 순서로 접시가 도착하지만 C가 도착했을때 먹지 못하는 상황이 옵니다. 14 | 2점을 주었던 D를 먼저 먹어야 C를 먹을 수 있습니다. 15 | 즉, A B C D E C 의 순서로, 접시가 5번 지나가고 먹게 된다. 16 | 17 | 1, 1, 3, 2, 5 18 | ▲ 19 | 0, 1, 3, 2, 5 20 | ▲ 21 | 0, 0, 3, 2, 5 22 | ▲ 23 | 0, 0, 3, 2, 5 24 | ▲ 25 | 0, 0, 3, 0, 5 26 | ▲ 27 | */ 28 | const EMPTY = 0; 29 | 30 | const sushi = (list, target) => { 31 | let i = 0; 32 | let count = -1; 33 | let sorted = list.slice().sort((a, b) => b - a); 34 | 35 | while (true) { 36 | let min = sorted.pop(); 37 | 38 | while (true) { 39 | if (list[i] !== EMPTY) count++; 40 | if (list[i] === min) break; 41 | i = i === list.length - 1 ? 0 : ++i; 42 | } 43 | if (i === target - 1) break; 44 | list[i] = EMPTY; 45 | } 46 | return count; 47 | }; 48 | 49 | console.log(sushi([1, 1, 3, 2, 5], 3)); //5 50 | console.log(sushi([5, 2, 3, 1, 2, 5], 1)); //10 51 | console.log(sushi([2, 1, 1], 1)); //3 52 | console.log(sushi([3, 2, 5, 5, 1, 3], 1)); //11 53 | -------------------------------------------------------------------------------- /jeju100/081~100 고급/087 천하제일먹기대회.js: -------------------------------------------------------------------------------- 1 | /* 2 | 천하제일 먹기 대회가 개최되었습니다. 3 | 이 대회는 정해진 시간이 끝난 후 음식을 먹은 그릇 개수를 파악한 후 각 선수들의 등수를 매깁니다. 4 | 5 | 1. 같은 이름의 선수는 없습니다. 6 | 2. 접시의 수가 같은 경우는 없습니다. 7 | 8 | 입력 예1) 9 | 손오공 야모챠 메지터 비콜로 10 | 70 10 55 40 11 | 12 | 출력 예1) 13 | {'손오공': 1, '메지터': 2, '비콜로': 3, '야모챠': 4} 14 | 15 | 입력 예2) 16 | ["홍길동","엄석대","연개소문","김첨지"] 17 | [2, 1, 10, 0] 18 | 19 | 출력 예2) 20 | {'연개소문': 1, '홍길동': 2, '엄석대': 3, '김첨지': 4} 21 | */ 22 | 23 | const solution = (name, score) => { 24 | let arr = []; 25 | let obj = {}; 26 | let nameSplit = Array.isArray(name) ? name : name.split(" "); 27 | let scoreSplit = Array.isArray(score) 28 | ? score 29 | : score.split(" ").map((v) => +v); 30 | nameSplit.map((v, i) => arr.push([v, scoreSplit[i]])); 31 | arr.sort((a, b) => b[1] - a[1]).forEach((v, i) => (obj[v[0]] = i + 1)); 32 | arr; 33 | console.log(obj); 34 | }; 35 | 36 | solution("손오공 야모챠 메지터 비콜로", "70 10 55 40"); 37 | solution(["홍길동", "엄석대", "연개소문", "김첨지"], [2, 1, 10, 0]); 38 | -------------------------------------------------------------------------------- /jeju100/081~100 고급/088 지식이의 게임개발.js: -------------------------------------------------------------------------------- 1 | /* 2 | 지식이는 게임을 만드는 것을 좋아합니다. 3 | 하지만 매번 다른 크기의 지도와 장애물을 배치하는데 불편함을 겪고 있습니다. 4 | 이런 불편함을 해결하기 위해 지도의 크기와 장애물의 위치, 캐릭터의 위치만 입력하면 게임 지형을 완성해 주는 프로그램을 만들고 싶습니다. 5 | 지식이를 위해 게임 지형을 만드는 프로그램을 작성해 주세요. 6 | 7 | - 가로(n), 세로(m)의 크기가 주어집니다. 8 | - 지형의 테두리는 벽으로 이루어져 있습니다. 9 | - 캐릭터가 있는 좌표가 배열 형태로 주어집니다. 10 | - 장애물이 있는 좌표가 2차원 배열 형태로 주어집니다. 11 | 12 | 지도는 n x m 크기의 배열이며 배열 안의 값은 13 | -움직일 수 있는 공간(0) 14 | -캐릭터(1) 15 | -벽(2) 16 | 3개로 구분되어 있습니다. 17 | 18 | 입력예시 19 | 가로 = 4 20 | 세로 = 5 21 | 캐릭터위치 = [0,0] 22 | 장애물 = [[0,1],[1,1],[2,3],[1,3]] 23 | 24 | 출력예시 25 | [2, 2, 2, 2, 2, 2] 26 | [2, 1, 2, 0, 0, 2] 27 | [2, 0, 2, 0, 2, 2] 28 | [2, 0, 0, 0, 2, 2] 29 | [2, 0, 0, 0, 0, 2] 30 | [2, 0, 0, 0, 0, 2] 31 | [2, 2, 2, 2, 2, 2] 32 | */ 33 | 34 | const [EMPTY, PLAYER, WALL] = [0, 1, 2]; 35 | const make_map = (width, height, pos, items) => { 36 | let board = new Array(height + 2) 37 | .fill() 38 | .map((v) => new Array(width + 2).fill().map((v) => 0)); 39 | for (let y = 0; y < height + 2; y++) { 40 | board[y][0] = WALL; 41 | board[y][width + 1] = WALL; 42 | } 43 | for (let x = 0; x < width + 2; x++) { 44 | board[0][x] = WALL; 45 | board[height + 1][x] = WALL; 46 | } 47 | board[pos[0] + 1][pos[1] + 1] = PLAYER; 48 | for (let item of items) { 49 | board[item[0] + 1][item[1] + 1] = WALL; 50 | } 51 | console.log(board); 52 | return board; 53 | }; 54 | 55 | make_map( 56 | 4, 57 | 5, 58 | [0, 0], 59 | [ 60 | [0, 1], 61 | [1, 1], 62 | [2, 3], 63 | [1, 3], 64 | ] 65 | ); 66 | -------------------------------------------------------------------------------- /jeju100/081~100 고급/090 같은의약성분을찾아라.js: -------------------------------------------------------------------------------- 1 | /* 2 | 의약품 성분이 총 8개인 약품들이 있습니다. 3 | 예를 들어 다음 데이터는 총 8개의 성분을 갖습니다. 4 | 5 | 판콜비 = 'ABCDEFGH' 6 | 넥타이레놀 = 'EFGHIJKL' 7 | 8 | 특정 약품 A의 성분이 공개되었을 때, 이와 유사한 성분을 가진 데이터들의 출력을 구하는 문제입니다. 9 | 10 | 입력 : 'ABCDEFGH' 4 11 | 데이터 : 'EFGHIJKL', 'EFGHIJKM', 'EFGHIJKZ' 등 1만 개의 데이터 12 | 출력 : 'EFGHIJKL', 'EFGHIJKM', 'EFGHIJKZ' 등 4개의 요소가 같은 약품 전부 13 | (4개 이상이 아니며 같은 요소가 4개인 것을 출력해야 합니다.) 14 | 15 | * 해당 문제는 시간제한이 있습니다. 16 | * 제약 데이터의 성분은 중복이 될 수 없습니다. 17 | (예를 들어 'AAABBBAB'와 같은 데이터는 없습니다.) 18 | */ 19 | 20 | const find = (str, n, data) => { 21 | let res = []; 22 | for (let med of data) { 23 | let strSet = new Set(str); 24 | let medSet = new Set(med); 25 | 26 | let intersection = new Set([...strSet].filter((v) => medSet.has(v))); 27 | if (intersection.size === n) { 28 | res.push(med); 29 | } 30 | } 31 | return res; 32 | }; 33 | 34 | console.log(find("ABCDEFGH", 4, ["EFGHIJKL", "EFGHIJKM", "EFGHIJKZ"])); 35 | -------------------------------------------------------------------------------- /jeju100/081~100 고급/091 반평균등수.js: -------------------------------------------------------------------------------- 1 | /* 2 | 한 반에 30명인 학생, 총 7개의 반 점수가 '국어, 영어, 수학, 사회, 과학' 순서로 있는 다중 리스트를 랜덤 한 값으로 만들어주시고 아래 값을 모두 출력하세요. 3 | 4 | 1. 반 점수 모두가 담긴 전교 점수 다중 리스트를 만들어주세요. 5 | 2. 반 평균을 구하세요. 6 | 3. 반 1등 점수를 구하세요. 7 | 4. 전교 평균을 구하세요. 8 | 9 | (출력 형식은 상관없습니다.) 10 | */ 11 | 12 | const generateData = (classNum, classSize, subjectNum) => { 13 | let res = []; 14 | while (res.length < classNum) { 15 | let oneClass = []; 16 | while (oneClass.length < classSize) { 17 | let oneStudent = []; 18 | while (oneStudent.length < subjectNum) { 19 | let score = Math.round(Math.random() * 100); 20 | oneStudent.push(score); 21 | } 22 | oneClass.push(oneStudent); 23 | } 24 | res.push(oneClass); 25 | } 26 | return res; 27 | }; 28 | 29 | const getClassAverage = (data) => { 30 | let res = []; 31 | for (let oneClass of data) { 32 | let sum = 0; 33 | for (let oneStudent of oneClass) { 34 | oneStudent.forEach((v) => (sum += v)); 35 | } 36 | res.push(Math.round(sum / (data[0].length * data[0][0].length))); 37 | } 38 | return res; 39 | }; 40 | 41 | const getAce = (data) => { 42 | let res = []; 43 | for (let oneClass of data) { 44 | let ace = []; 45 | let aceSum = 0; 46 | for (let oneStudent of oneClass) { 47 | let tmp = oneStudent.reduce((acc, val) => (acc += val), 0); 48 | if (tmp > aceSum) { 49 | ace = oneStudent; 50 | aceSum = tmp; 51 | } else if (tmp === aceSum) { 52 | ace.push(oneStudent); 53 | } 54 | } 55 | res.push(ace); 56 | } 57 | return res; 58 | }; 59 | 60 | const getWholeAverage = (data) => { 61 | let sum = 0; 62 | for (let oneClass of data) { 63 | for (let oneStudent of oneClass) { 64 | oneStudent.forEach((v) => (sum += v)); 65 | } 66 | } 67 | return Math.round(sum / (data.length * data[0].length * data[0][0].length)); 68 | }; 69 | 70 | const data = generateData(7, 30, 5); 71 | const classAverage = getClassAverage(data); 72 | const ace = getAce(data); 73 | const wholeAverage = getWholeAverage(data); 74 | console.log( 75 | "data", 76 | data, 77 | "classAverage", 78 | classAverage, 79 | "ace", 80 | ace, 81 | "wholeAverage", 82 | wholeAverage 83 | ); 84 | -------------------------------------------------------------------------------- /jeju100/081~100 고급/092 키보드고장.js: -------------------------------------------------------------------------------- 1 | /* 2 | P 회사의 회계를 처리하던 은정은 커피를 마시다가 키보드에 커피를 쏟고 말았습니다. 3 | 휴지로 닦고 말려보았지만 숫자 3, 4, 6이 도통 눌리지 않습니다. 4 | 10분 뒤, 모든 직원들에게 월급을 입금해 주어야 합니다. 5 | 여유 키보드는 없으며, 프로그래밍을 매우 잘하고, 모든 작업을 수작업으로 하고 있습니다. 6 | 7 | 이에 눌리지 않는 키보드를 누르지 않고 월급 입금을 두 번에 나눠주고 싶습니다. 8 | 9 | 1. 직원은 2000명이며, 3초 이내 수행을 해야합니다. 10 | 2. 입력값의 형식은 csv파일형식이며 이과장 '3,000,000', 'S은행', '100-0000-0000-000' 형식으로 주어집니다. 11 | 3. 출력값의 형식은 csv파일형식이며 이과장 '1,500,000', '1,500,000', 'S은행', '100-0000-0000-000' 입니다. 또는 '1,000,000', '2,000,000', 'S은행', '100-0000-0000-000' 도 괜찮습니다. 12 | 13 | */ 14 | 15 | let data = `이대표,'333,356,766','S은행','100-0000-0000-001' 16 | 최차장,'5,000,000','S은행','100-0000-0000-002' 17 | 이과장,'3,200,000','S은행','100-0000-0000-003' 18 | 홍팀장,'3,300,000','S은행','100-0000-0000-004' 19 | 이대리,'5,300,000','S은행','100-0000-0000-005'`; 20 | 21 | const solution = (data) => { 22 | let res = []; 23 | let obj = { 24 | 1: [1, 0], 25 | 2: [2, 0], 26 | 3: [2, 1], 27 | 4: [2, 2], 28 | 5: [5, 0], 29 | 6: [5, 1], 30 | 7: [5, 2], 31 | 8: [8, 0], 32 | 9: [9, 0], 33 | 0: [0, 0], 34 | }; 35 | let draft = data.split("\n").map((v, i) => v.split(",")); 36 | for (let p of draft) { 37 | let amount = p.splice(1, 3).join().replace(/,/g, "").replace(/'/g, ""); 38 | let a = "", 39 | b = ""; 40 | for (let n of amount) { 41 | a += obj[n][0]; 42 | b += obj[n][1]; 43 | } 44 | let newP = []; 45 | newP.push(p[0], (+a).toLocaleString()); 46 | if (+b !== 0) newP.push((+b).toLocaleString()); 47 | newP.push( 48 | p[p.length - 2].replace(/'/g, ""), 49 | p[p.length - 1].replace(/'/g, "") 50 | ); 51 | res.push(newP); 52 | } 53 | return res; 54 | }; 55 | 56 | console.log(solution(data)); 57 | -------------------------------------------------------------------------------- /jeju100/081~100 고급/093 페이지교체-선입선출알고리즘.js: -------------------------------------------------------------------------------- 1 | /* 2 | 페이지 교체 알고리즘은 메모리를 관리하는 운영체제에서 페이지 부재가 발생하여 새로운 페이지를 할당하기 위해 현재 할당된 페이지 중 어느 것을 교체할지를 결정하는 방법입니다. 3 | 이 알고리즘이 사용되는 시기는 페이지 부재(Page Fault)가 발생해 새로운 페이지를 적재해야 하지만 페이지를 적재할 공간이 없어 이미 적재되어 있는 페이지 중 교체할 페이지를 정할 때 사용됩니다. 4 | 빈 페이지가 없는 상황에서 메모리에 적재된 페이지와 적재할 페이지를 교체함으로 페이지 부재 문제를 해결할 수 있습니다. 5 | 이 중 선입선출(FIFO) 알고리즘은 가장 먼저 들어와서 가장 오래있었던 페이지를 우선으로 교체시키는 방법을 의미합니다. 6 | 7 | 메모리의 크기가 i로 주어지고 들어올 페이지들이 n으로 주어졌을 때, 전체 실행시간을 구해주세요. 8 | 만약 스택 안에 같은 스케줄이 있다면 hit 이라고 하며 실행시간은 1초 입니다. 9 | 스택 안에 스케줄이 없다면 miss 라고 하며 실행시간은 6초 입니다. 10 | 11 | 입출력예시 12 | BCBAEBCE, 3 13 | 38 14 | [B] 6 15 | [B, C] 6 16 | [B, C] 1 17 | [B, C, A] 6 18 | [C, A, E] 6 19 | [A, E, B] 6 20 | [E, B, C] 6 21 | [E, B, C] 1 22 | 23 | 예제 1번을 보면 페이지 프레임의 개수는 3개이고 스케줄은 'BCBAEBCE' 입니다. 24 | 6번의 miss를 기록하므로 6번 * 6초 = 36초가 되고 2번의 hit을 기록하므로 2번 * 1초 = 2초입니다. 25 | 2개를 합한 값이 실행시간이므로, 38초가 됩니다. 26 | 27 | */ 28 | 29 | const replacePage = (pages, nFrame) => { 30 | let frame = []; 31 | let count = 0; 32 | for (let p of pages) { 33 | if (frame.includes(p)) { 34 | count += 1; 35 | continue; 36 | } 37 | if (frame.length === 3) { 38 | frame.shift(); 39 | } 40 | frame.push(p); 41 | count += 6; 42 | } 43 | return count; 44 | }; 45 | 46 | console.log(replacePage("BCBAEBCE", 3)); 47 | -------------------------------------------------------------------------------- /jeju100/081~100 고급/094 페이지교체-LRU알고리즘.js: -------------------------------------------------------------------------------- 1 | /* 2 | LRU 알고리즘이란 페이지 교체 알고리즘으로써, Least Resently Used의 약자입니다. 즉 페이지 부재가 발생했을 경우 가장 오랫동안 사용되지 않은 페이지를 제거하는 알고리즘입니다. 3 | 이 알고리즘의 기본 가설은 가장 오랫동안 이용되지 않은 페이지는 앞으로도 사용할 확률이 적다는 가정하에 페이지 교체가 진행됩니다. 4 | 다음 그림을 참고해주세요. 5 | 6 | 메모리의 크기가 i로 주어지고 들어올 페이지들이 n으로 주어졌을 때, 전체 실행시간을 구해주세요. 7 | 8 | 만약 스택 안에 같은 스케줄이 있다면 hit 이라고 하며 실행시간은 1초 입니다. 스택 안에 스케줄이 없다면 miss 라고 하며 실행시간은 6초 입니다. 9 | 10 | 입출력예시 11 | BCBAEBCE, 3 12 | 33 13 | 14 | */ 15 | 16 | const replacePage = (pages, nFrame) => { 17 | let frame = []; 18 | let count = 0; 19 | for (let p of pages) { 20 | let idx = frame.indexOf(p); 21 | if (idx != -1) { 22 | frame.splice(idx, 1); 23 | frame.push(p); 24 | count += 1; 25 | continue; 26 | } 27 | if (frame.length === 3) { 28 | frame.shift(); 29 | } 30 | frame.push(p); 31 | count += 6; 32 | } 33 | return count; 34 | }; 35 | 36 | console.log(replacePage("BCBAEBCE", 3)); 37 | -------------------------------------------------------------------------------- /jeju100/081~100 고급/096 넓은텃밭만들기.js: -------------------------------------------------------------------------------- 1 | /* 2 | 수연이는 밭농사를 시작하기로 마음을 먹었다. 3 | 집 앞 텃밭을 만들기로 하고 돌들을 제거하고 있는데 매우 큰 바위는 옮기지 못해 고심하고 있다. 4 | 5 | 이에 수연이는 다음과 같은 규칙을 정한다. 바위는 '1'로 표기한다. 6 | 7 | 1. 바위를 피해 텃밭을 만들되 정사각형 모양으로 텃밭을 만든다. 8 | 2. 텃밭은 가장 넓은 텃밭 1개만 만들고 그 크기를 반환한다. 9 | 3. 만든 텃밭은 모두 '#'으로 처리한다. 10 | 11 | 입력 12 | 13 | 0 0 0 0 0 14 | 0 1 0 0 0 15 | 0 1 0 0 0 16 | 0 0 1 0 0 17 | 0 0 0 1 0 18 | 19 | 출력 20 | 21 | 3 X 3 22 | 23 | 0 0 # # # 24 | 0 1 # # # 25 | 0 1 # # # 26 | 0 0 1 0 0 27 | 0 0 0 1 0 28 | 29 | 입력 30 | 31 | 0 0 0 1 0 32 | 0 0 0 0 0 33 | 0 0 1 0 0 34 | 0 0 1 0 0 35 | 0 0 0 1 0 36 | 37 | 출력 38 | 39 | 2 X 2 40 | 41 | # # 0 1 0 42 | # # 0 0 0 43 | 1 0 1 0 0 44 | 0 0 1 0 0 45 | 1 0 0 1 0 46 | */ 47 | 48 | const STONE = '1'; 49 | 50 | const printResult = (field, size, a, b) => { 51 | console.log(`${size} X ${size}`); 52 | for (let i = 0; i < size; i++) { 53 | for (let j = 0; j < size; j++) { 54 | field[a + i][b + j] = '#'; 55 | } 56 | } 57 | console.log(field); 58 | } 59 | 60 | const isAvailable = (field, size, a, b) => { 61 | for (let i = 0; a + i < size; i++) { 62 | for (let j = 0; b + j < size; j++) { 63 | if (field[a + i][b + j] == STONE) 64 | return false; 65 | } 66 | } 67 | return true; 68 | } 69 | 70 | const getBiggestField = (field) => { 71 | let max = field.length; 72 | for (let size = max; size >= 1 ; size--) { 73 | for (let a = 0; a + size <= max; a++) { 74 | for (let b = 0; b + size <= max; b++) { 75 | if (isAvailable(field, size, a, b)) { 76 | return printResult(field, size, a, b); 77 | } 78 | } 79 | } 80 | } 81 | return printResult(field, 0, 0, 0); 82 | } 83 | 84 | getBiggestField([ 85 | [ '0', '0', '0', '0', '0' ], 86 | [ '0', '1', '0', '0', '0' ], 87 | [ '0', '1', '0', '0', '0' ], 88 | [ '0', '0', '1', '0', '0' ], 89 | [ '0', '0', '0', '1', '0' ] 90 | ]); -------------------------------------------------------------------------------- /jeju100/081~100 고급/097 택배배달.js: -------------------------------------------------------------------------------- 1 | /* 2 | https://www.notion.so/97-849a9acbdea34198ace2e5bcd3f274ad 3 | n 명의 택배 배달원은 쌓인 택배를 배달해야 합니다. 4 | 각 택배는 접수된 순서로 배달이 되며 택배마다 거리가 주어집니다. 5 | 거리1당 1의 시간이 걸린다고 가정하였을 때 모든 택배가 배달 완료될 시간을 구하세요. 6 | 7 | 1. 모든 택배의 배송 시간 1 이상이며 배달지에 도착하고 돌아오는 왕복 시간입니다. 8 | 2. 택배는 물류창고에서 출발합니다. 9 | 3. 배달을 완료하면 다시 물류창고로 돌아가 택배를 받습니다. 10 | 4. 물류창고로 돌아가 택배를 받으면 배달을 시작합니다. 11 | 5. 택배를 상차할 때 시간은 걸리지 않습니다. 12 | 13 | 입력은 배달원의 수와 택배를 배달하는 배달 시간이 주어집니다. 14 | 15 | ex) 배달원이 3명이고 각 거리가 [1,2,1,3,3,3]인 순서로 들어오는 경우 16 | 17 | */ 18 | 19 | function solution(n, l) { 20 | let count = 0; 21 | let mans = new Array(n).fill(0); 22 | 23 | while (l.length > 0) { 24 | for (let i = 0; i < mans.length; i++) { 25 | if (mans[i] === 0 && l.length > 0) { 26 | mans[i] = l.shift(); 27 | } 28 | } 29 | count++; 30 | mans = mans.map((v) => --v); 31 | } 32 | return count + Math.max(...mans); 33 | } 34 | 35 | console.log(solution(3, [1, 2, 1, 3, 3, 3])); 36 | // 출력값 = 5 37 | -------------------------------------------------------------------------------- /jeju100/081~100 고급/098 청길이의 패션대회.js: -------------------------------------------------------------------------------- 1 | /* 2 | 패션의 선도주자 청길이는 패션의 발전을 위해 패션쇼를 방문해 유니크한 아이템을 조사하기로 하였습니다. 3 | 청길이는 입장하는 사람들의 패션에서 처음보는 아이템 만을 기록합니다. 4 | 이때 청길이의 기록에서 아래 규칙에 맞게 배열로 출력해 주세요. 5 | 6 | 1. 청길이는 각 옷의 종류를 정수로 기록해 놓습니다. 7 | ex) 입력은 "1번: 3,1 2번: 4 3번: 2,1,3 4번: 2,1,3,4" 형태의 문자열입니다. 8 | 2. 기록은 청길이가 번호 순서로 유니크한 옷의 번호를 적습니다. 9 | 3. 유니크한 옷은 기록된 순서로 추출되고 출력됩니다. 10 | ex) 출력은 [3,1,4,2]입니다. 11 | 12 | 입출력예시 13 | 14 | 입력 15 | "1번: 4,2,3 2번: 3 3번: 2,3,4,1 4번: 2,3" 16 | 17 | 출력 18 | [4, 2, 3, 1] 19 | 20 | 입력 21 | "1번: 3,1 2번: 4 3번: 2,1,3 4번: 2,1,3,4" 22 | 23 | 출력 24 | [3, 1, 4, 2] 25 | */ 26 | 27 | const solution = (records) => { 28 | let res = []; 29 | let arrRecords = records 30 | .split(" ") 31 | .filter((v, i) => i % 2) 32 | .map((v) => v.split(",")); 33 | let arrClothes = [].concat(...arrRecords); 34 | let set = new Set(arrClothes); 35 | return new Array(...set); 36 | }; 37 | 38 | console.log(solution("1번: 4,2,3 2번: 3 3번: 2,3,4,1 4번: 2,3")); 39 | console.log(solution("1번: 3,1 2번: 4 3번: 2,1,3 4번: 2,1,3,4")); 40 | 41 | console.log("1번: a,b 2번: c,d 3번: e".split(/[0-9]번: /)); 42 | // [ '', 'a,b ', 'c,d ', 'e' ] 43 | 44 | let arr2D = [[1, 2], [3, 4], [5]]; 45 | console.log([].concat(...arr2D)); 46 | // [ 1, 2, 3, 4, 5 ] 47 | 48 | let arr1D = []; 49 | arr2D.forEach((v) => v.forEach((e) => arr1D.push(e))); 50 | console.log(arr1D); 51 | // [ 1, 2, 3, 4, 5 ] 52 | -------------------------------------------------------------------------------- /jeju100/081~100 고급/099 토끼들의 행진.js: -------------------------------------------------------------------------------- 1 | /* 2 | 토끼들이 징검다리를 건너려고 합니다. 3 | 하지만 돌이 부실해서 몇 번 건너지 못할 것 같습니다. 4 | 대기 중인 토끼들의 통과여부를 배열에 담아 출력해 주세요. 5 | 6 | 1. 각 돌들이 얼마나 버틸 수 있는지 배열로 주어집니다. 7 | 8 | 2. 토끼가 착지하면 해당 돌의 내구도는 1씩 줄어듭니다. 9 | ex) [1,2,1,4] 각 돌마다 1마리 2마리 1마리 4마리의 착지를 버틸 수 있습니다. 10 | 11 | 3. 토끼들은 점프력이 각자 다릅니다. 12 | ex) [2,1] 첫 번째 토끼는 2칸씩, 두 번째 토끼는 1칸씩 점프합니다. 13 | 14 | 4. 각 토끼들은 순서대로 다리를 건넙니다. 15 | 16 | 입력 17 | 돌의내구도 = [1, 2, 1, 4, 5, 2] 18 | 토끼의점프력 = [2, 1, 3, 1] 19 | 20 | 처음 [1, 2, 1, 4, 5, 2] 21 | 토끼1 [1, 1, 1, 3, 5, 1] 22 | 토끼2 [0, 0, 0, 2, 4, 0] 23 | 토끼3 [0, 0, -1, 2, 4, 0] fail 24 | 토끼4 [-1, 0, 0, 2, 4, 0] fail 25 | 26 | 출력 27 | ['pass', 'pass', 'fail', 'fail'] 28 | */ 29 | 30 | const solution = (stones, rabbits) => { 31 | let res = []; 32 | for (let jump of rabbits) { 33 | let pass = true; 34 | for (let i = jump - 1; i < stones.length; i += jump) { 35 | if (stones[i] <= 0) { 36 | pass = false; 37 | break; 38 | } 39 | stones[i]--; 40 | } 41 | pass ? res.push("pass") : res.push("fail"); 42 | } 43 | return res; 44 | }; 45 | 46 | console.log(solution([1, 2, 1, 4], [2, 1])); 47 | // ['pass', 'pass'] 48 | console.log(solution([1, 2, 1, 4, 5, 2], [2, 1, 3, 1])); 49 | // ['pass', 'pass', 'fail', 'fail'] 50 | -------------------------------------------------------------------------------- /jeju100/081~100 고급/100 퍼즐게임.js: -------------------------------------------------------------------------------- 1 | /* 2 | https://www.notion.so/100-f504032e06ba4329808a21d7b49944c8 3 | 4 | N x M으로 이루어진 아래와 같은 공간에 퍼즐이 쌓여져 있습니다. 5 | 6 | 퍼즐을 맞추기 위해서는 반드시 맨 오른쪽 줄로 이동시켜 줘야 합니다. 7 | 만약 종류가 같은 퍼즐이 연속될 시에 점수가 추가되며 그 퍼즐은 사라집니다. 8 | 9 | 점수는 다음과 같습니다. 10 | - 파란색 공 : 1점 11 | - 빨간색 공 : 2점 12 | - 노란색 공 : 3점 13 | - 초록색 공 : 4점 14 | - 주황색 공 : 5점 15 | 점수는 공의 개수만큼 추가됩니다 16 | 17 | 예를 들어 빨간색 공이 2개 연속되어 없어졌을 경우 2*2 = 4점입니다. 18 | 19 | 게임 플레이어는 게임이 시작되면 어떤 퍼즐을 이동할 것인지 모두 작성합니다. 20 | 만약 비어있는 곳을 선택하게 된다면 점수가 1점 감소하며 그대로 진행합니다. 21 | 위 규칙에 맞는 점수를 리턴하는 함수를 작성하세요. 22 | 23 | 입력 24 | 퍼즐판 = [[0,0,0,0],[0,1,0,3],[2,5,0,1],[2,4,4,1],[5,1,1,1]] 25 | 조작 = [1,1,1,1,3,3,3] 26 | 27 | 출력 28 | 2 29 | */ 30 | 31 | const BLUE = 1; 32 | const RED = 2; 33 | const YELLOW = 3; 34 | const GREEN = 4; 35 | const ORANGE = 5; 36 | 37 | const solution = (board, manipulation) => { 38 | let score = 0; 39 | let [width, height] = [board[0].length, board.length]; 40 | let stack = []; 41 | 42 | let newBoard = new Array(width).fill().map(() => []); 43 | for (let i = 0; i < height; i++) { 44 | for (let j = 0; j < width; j++) { 45 | if (board[i][j] !== 0) newBoard[j].push(board[i][j]); 46 | } 47 | } 48 | 49 | for (let m of manipulation) { 50 | if (newBoard[m - 1].length === 0) { 51 | score--; 52 | continue; 53 | } 54 | stack.push(newBoard[m - 1].shift()); 55 | if (stack.length >= 2 && stack[0] == stack[1]) { 56 | score += stack[0] * 2; 57 | stack.splice(0, 2); 58 | } 59 | } 60 | return score; 61 | }; 62 | 63 | console.log( 64 | solution( 65 | [ 66 | [0, 0, 0, 0], 67 | [0, 1, 0, 3], 68 | [2, 5, 0, 1], 69 | [2, 4, 4, 1], 70 | [5, 1, 1, 1], 71 | ], 72 | [1, 1, 1, 1, 3, 3, 3] 73 | ) 74 | ); 75 | -------------------------------------------------------------------------------- /leetcode/.gitignore: -------------------------------------------------------------------------------- 1 | /node_modules -------------------------------------------------------------------------------- /leetcode/1_Easy/0001 Two Sum.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/two-sum/ */ 2 | 3 | const twoSum = (nums, target) => { 4 | for (i = 0; i < nums.length; i++) { 5 | for (j = i + 1; j < nums.length; j++) { 6 | if (nums[i] + nums[j] === target) { 7 | return [i, j]; 8 | } 9 | } 10 | } 11 | }; 12 | 13 | console.log(twoSum((nums = [2, 7, 11, 15]), (target = 9))); // [0, 1] 14 | console.log(twoSum((nums = [2, 7, 11, 15]), (target = 9))); // [0, 1] 15 | 16 | // O(n) 17 | function twoSum2(nums, target) { 18 | const map = new Map(); // 19 | 20 | for (let i = 0; i < nums.length; i++) { 21 | const remainder = target - nums[i]; 22 | 23 | if (map.has(remainder)) { 24 | const j = map.get(remainder); 25 | return [j, i]; 26 | } 27 | 28 | map.set(nums[i], i); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0007 Reverse Integer.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/reverse-integer/ */ 2 | 3 | var reverse = function (x) { 4 | let strX = x.toString().split(''); 5 | let result = ''; 6 | 7 | if (strX[0] === '-') { 8 | result += '-'; 9 | strX = strX.slice(1); 10 | } 11 | result += +strX.reverse().join(''); 12 | if (result < -Math.pow(2, 31) || result > Math.pow(2, 31) - 1) { 13 | return 0; 14 | } 15 | return result; 16 | }; 17 | 18 | console.log(reverse((x = 123))); 19 | console.log(reverse((x = -123))); 20 | console.log(reverse((x = 120))); 21 | console.log(reverse((x = 0))); 22 | console.log(reverse((x = 1534236469))); 23 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0008 String to Integer.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/longest-common-prefix/ */ 2 | 3 | /** 4 | * @param {string} s 5 | * @return {number} 6 | */ 7 | 8 | // s consists of English letters (lower-case and upper-case), digits (0-9), ' ', '+', '-', and '.'. 9 | 10 | const myAtoi = (s) => { 11 | let i = 0; 12 | 13 | // 1. Read in and ignore any leading whitespace. 14 | while (s[i] === ' ') { 15 | i++; 16 | } 17 | 18 | // 2. Check if the next character is '-' or '+'. Read this character in if it is either. This determines if the final result is negative or positive respectively. 19 | let signFactor = +1; 20 | if (s[i] === '+') { 21 | i++; 22 | signFactor = +1; 23 | } else if (s[i] === '-') { 24 | i++; 25 | signFactor = -1; 26 | } 27 | 28 | if (s[i] === undefined) { 29 | return 0; 30 | } 31 | 32 | // 3. Read in next the characters until the next non-digit character or the end of the input is reached 33 | let digits = ''; 34 | 35 | while (s[i] === '0') { 36 | i++; 37 | } 38 | // 4. Convert these digits into an integer (i.e. "123" -> 123, "0032" -> 32) 39 | while (s[i] >= '0' && s[i] <= '9') { 40 | digits += s[i]; 41 | i++; 42 | } 43 | const number = Number(digits); 44 | 45 | // Change the sign as necessary. 46 | let signedNumber = number * signFactor; 47 | 48 | const MAX = Math.pow(2, 31) - 1; 49 | const MIN = -Math.pow(2, 31); 50 | 51 | if (signedNumber > MAX) { 52 | return MAX; 53 | } 54 | if (signedNumber < MIN) { 55 | return MIN; 56 | } 57 | return signedNumber; 58 | }; 59 | 60 | // console.log(myAtoi('42')); // 42 61 | // console.log(myAtoi(' -42')); // -42 62 | // console.log(myAtoi('4193')); // 4193 63 | console.log(myAtoi(' -42')); // -42 64 | console.log(myAtoi('-91283472332')); // -2147483648 65 | console.log(myAtoi('words and 987')); // 0; 66 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0013 Roman to Integer.js: -------------------------------------------------------------------------------- 1 | const map = { 2 | I: 1, 3 | IV: 4, 4 | V: 5, 5 | IX: 9, 6 | X: 10, 7 | XL: 40, 8 | L: 50, 9 | XC: 90, 10 | C: 100, 11 | CD: 400, 12 | D: 500, 13 | CM: 900, 14 | M: 1000, 15 | }; 16 | 17 | const romanToInt = (s) => { 18 | let result = 0; 19 | 20 | for (let i = 0; i < s.length; i++) { 21 | if (i + 1 < s.length) { 22 | const twoDigits = s[i] + s[i + 1]; 23 | const twoDigitsToInt = map[twoDigits]; 24 | 25 | if (twoDigitsToInt) { 26 | result += twoDigitsToInt; 27 | i++; 28 | continue; 29 | } 30 | } 31 | 32 | const oneDigit = s[i]; 33 | const oneDigitToInt = map[oneDigit]; 34 | result += oneDigitToInt; 35 | } 36 | 37 | return result; 38 | }; 39 | 40 | console.log(romanToInt('III')); // 3 41 | console.log(romanToInt('LVIII')); // 58 42 | console.log(romanToInt('MCMXCIV')); // 1994 43 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0014 Longest Common Prefix.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/longest-common-prefix/ */ 2 | 3 | /** 4 | * @param {string[]} strs 5 | * @return {string} 6 | */ 7 | const longestCommonPrefix = (strs) => { 8 | const str = strs[0]; 9 | let result = ''; 10 | 11 | for (let n = 0; n < str.length; n++) { 12 | const char = str[n]; 13 | 14 | if (char === undefined) { 15 | return result; 16 | } 17 | 18 | for (let j = 1; j < strs.length; j++) { 19 | if (char !== strs[j][n]) { 20 | return result; 21 | } 22 | } 23 | result += char; 24 | console.log(result); 25 | } 26 | return result; 27 | }; 28 | 29 | console.log(longestCommonPrefix((strs = ['flower', 'flow', 'flight']))); // "fl" 30 | console.log(longestCommonPrefix((strs = ['dog', 'racecar', 'car']))); // "" 31 | console.log(longestCommonPrefix((strs = ['flower', 'flower', 'flower', 'flower']))); // "flower" 32 | console.log(longestCommonPrefix((strs = []))); // "" 33 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0020 Valid Parentheses.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} s 3 | * @return {boolean} 4 | */ 5 | 6 | const isValid = function (s) { 7 | const STARTS = ['(', '[', '{']; 8 | const stack = []; 9 | const top = () => stack[stack.length - 1]; 10 | 11 | for (let char of s) { 12 | if (STARTS.includes(char)) { 13 | stack.push(char); 14 | continue; 15 | } 16 | if (stack.length === 0) return false; 17 | 18 | if (char === ')') { 19 | if (top() !== '(') return false; 20 | stack.pop(); 21 | continue; 22 | } 23 | if (char === ']') { 24 | if (top() !== '[') return false; 25 | stack.pop(); 26 | continue; 27 | } 28 | if (char === '}') { 29 | if (top() !== '{') return false; 30 | stack.pop(); 31 | } 32 | } 33 | 34 | if (stack.length > 0) return false; 35 | 36 | return true; 37 | }; 38 | 39 | console.log(isValid((s = '()'))); 40 | console.log(isValid((s = '()[]{}'))); 41 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0021 Merge Two Sorted Lists.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * function ListNode(val, next) { 4 | * this.val = (val===undefined ? 0 : val) 5 | * this.next = (next===undefined ? null : next) 6 | * } 7 | */ 8 | /** 9 | * @param {ListNode} list1 10 | * @param {ListNode} list2 11 | * @return {ListNode} 12 | */ 13 | const mergeTwoLists = (list1, list2) => { 14 | if (!list1 && !list2) return null; 15 | if (!list1) return list2; 16 | if (!list2) return list1; 17 | 18 | const head = list1.val <= list2.val ? list1 : list2; 19 | let cur = head; 20 | let p1 = list1.val <= list2.val ? list1.next : list1; 21 | let p2 = list1.val <= list2.val ? list2 : list2.next; 22 | 23 | while (p1 || p2) { 24 | if (!p2 || (p1 && p1.val <= p2.val)) { 25 | cur.next = p1; 26 | cur = cur.next; 27 | p1 = p1.next; 28 | continue; 29 | } 30 | cur.next = p2; 31 | cur = cur.next; 32 | p2 = p2.next; 33 | } 34 | return head; 35 | }; 36 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0026 Remove Duplicates from Sorted Array.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/remove-duplicates-from-sorted-array/ */ 2 | 3 | var removeDuplicates = function (nums) { 4 | for (let i = nums.length - 1; i >= 0; i--) { 5 | if (nums[i] === nums[i - 1]) { 6 | nums.splice(i, 1); 7 | } 8 | } 9 | return nums.length; 10 | }; 11 | 12 | console.log(removeDuplicates((nums = [1, 1, 2]))); 13 | console.log(removeDuplicates((nums = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4]))); 14 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0028 Implement strStr().js: -------------------------------------------------------------------------------- 1 | // https://leetcode.com/problems/implement-strstr/ 2 | 3 | /** 4 | * @param {string} haystack 5 | * @param {string} needle 6 | * @return {number} 7 | */ 8 | const strStr = (haystack, needle) => { 9 | for (let i = 0; i < haystack.length; i++) { 10 | for (let j = 0; j < needle.length; j++) { 11 | if (haystack[i + j] !== needle[j]) { 12 | break; 13 | } 14 | if (j === needle.length - 1) { 15 | return i; 16 | } 17 | } 18 | } 19 | return -1; 20 | }; 21 | 22 | console.log(strStr((haystack = 'hello'), (needle = 'll'))); // 2 23 | console.log(strStr((haystack = 'aaaaa'), (needle = 'bba'))); // -1 24 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0035 Search Insert Position.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/search-insert-position/ */ 2 | 3 | var searchInsert = function (nums, target) { 4 | let idx = nums.indexOf(target); 5 | 6 | if (idx !== -1) { 7 | return idx; 8 | } 9 | for (idx = 0; idx < nums.length; idx++) { 10 | if (nums[idx] > target) { 11 | break; 12 | } 13 | } 14 | return idx; 15 | }; 16 | 17 | console.log(searchInsert((nums = [1, 3, 5, 6]), (target = 5))); 18 | console.log(searchInsert((nums = [1, 3, 5, 6]), (target = 2))); 19 | console.log(searchInsert((nums = [1, 3, 5, 6]), (target = 7))); 20 | console.log(searchInsert((nums = [1, 3, 5, 6]), (target = 0))); 21 | console.log(searchInsert((nums = [1]), (target = 0))); 22 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0038 Count and Say.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/count-and-say/ */ 2 | 3 | var countAndSay = function (n) { 4 | let str = '1'; 5 | let newStr; 6 | 7 | if (n === 1) { 8 | return str; 9 | } 10 | while (n > 1) { 11 | newStr = ''; 12 | 13 | while (str.length > 0) { 14 | for (let i = 0; i < str.length; i++) { 15 | if (i === str.length - 1 || str[i] !== str[i + 1]) { 16 | newStr += `${i + 1}${str[i]}`; 17 | str = str.slice(i + 1); 18 | break; 19 | } 20 | } 21 | } 22 | str = newStr; 23 | n--; 24 | } 25 | return newStr; 26 | }; 27 | 28 | console.log(countAndSay((n = 1))); 29 | console.log(countAndSay((n = 4))); //"1211" 30 | console.log(countAndSay((n = 5))); //"111221" 31 | /* 32 | Input: n = 4 33 | Output: "1211" 34 | Explanation: 35 | countAndSay(1) = "1" 36 | countAndSay(2) = say "1" = one 1 = "11" 37 | countAndSay(3) = say "11" = two 1's = "21" 38 | countAndSay(4) = say "21" = one 2 + one 1 = "12" + "11" = "1211" 39 | countAndSay(5) = say "1211" = one 1 + one 2 two 1 = "11" + "12" + "21" = "111221" 40 | */ 41 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0048 Rotate Image.js: -------------------------------------------------------------------------------- 1 | /** 2 | Do not return anything, modify matrix in-place instead. 3 | 4 | n == matrix.length == matrix[i].length 5 | 1 <= n <= 20 6 | -1000 <= matrix[i][j] <= 1000 7 | */ 8 | 9 | function rotate(matrix) { 10 | const n = matrix.length; 11 | const clone = Array(n) 12 | .fill(0) 13 | .map(() => Array(n)); 14 | 15 | // rotate 16 | for (let i = 0; i < n; i++) { 17 | for (let j = 0; j < n; j++) { 18 | clone[j][n - 1 - i] = matrix[i][j]; 19 | } 20 | } 21 | 22 | // copy 23 | for (let i = 0; i < n; i++) { 24 | for (let j = 0; j < n; j++) { 25 | matrix[i][j] = clone[i][j]; 26 | } 27 | } 28 | } 29 | 30 | console.log( 31 | rotate([ 32 | [1, 2, 3], 33 | [4, 5, 6], 34 | [7, 8, 9], 35 | ]) 36 | ); // [[7,4,1],[8,5,2],[9,6,3]] 37 | 38 | console.log( 39 | rotate([ 40 | [5, 1, 9, 11], 41 | [2, 4, 8, 10], 42 | [13, 3, 6, 7], 43 | [15, 14, 12, 16], 44 | ]) 45 | ); // [[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]] 46 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0069 Sqrt(x).js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/sqrtx/ */ 2 | 3 | var mySqrt = function (x) { 4 | return Math.floor(Math.pow(x, 1 / 2)); 5 | }; 6 | 7 | console.log(mySqrt(4)); 8 | console.log(mySqrt(8)); 9 | console.log(mySqrt(1)); 10 | console.log(mySqrt(0)); 11 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0088 Merge Sorted Array.js: -------------------------------------------------------------------------------- 1 | const merge = (nums1, m, nums2, n) => { 2 | if (n === 0) return nums1; 3 | let p1 = 0; 4 | let p2 = 0; 5 | let temps = []; 6 | 7 | while (p1 < nums1.length) { 8 | const num1 = nums1[p1]; 9 | const num2 = nums2[p2]; 10 | const temp = temps[0]; 11 | 12 | /* 케이스0: 종료 */ 13 | if (temp === undefined && num2 === undefined) return nums1; 14 | 15 | const min = 16 | p1 < m 17 | ? Math.min(num1 ?? +Infinity, num2 ?? +Infinity, temp ?? +Infinity) 18 | : Math.min(num2 ?? +Infinity, temp ?? +Infinity); 19 | 20 | /* 케이스1: num1 */ 21 | if (p1 < m && min === num1) { 22 | p1++; 23 | continue; 24 | } 25 | 26 | /* 케이스2: num2 */ 27 | if (temp === undefined || min === num2) { 28 | p1 < m && temps.push(num1); 29 | nums1[p1] = num2; 30 | p1++; 31 | p2++; 32 | continue; 33 | } 34 | 35 | /* 케이스3: temp */ 36 | if (num2 === undefined || min === temp) { 37 | p1 < m && temps.push(num1); 38 | temps.shift(); 39 | nums1[p1] = temp; 40 | p1++; 41 | continue; 42 | } 43 | } 44 | 45 | return nums1; 46 | }; 47 | 48 | console.log(merge((nums1 = [1, 2, 3, 0, 0, 0]), (m = 3), (nums2 = [2, 5, 6]), (n = 3))); 49 | console.log(merge([1], 1, [], 0)); 50 | console.log(merge([2, 0], 1, [1], 1)); 51 | console.log(merge([1, 2, 4, 5, 6, 0], 5, [3], 1)); 52 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0101 Symmetric Tree.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * function TreeNode(val, left, right) { 4 | * this.val = (val===undefined ? 0 : val) 5 | * this.left = (left===undefined ? null : left) 6 | * this.right = (right===undefined ? null : right) 7 | * } 8 | */ 9 | /** 10 | * @param {TreeNode} root 11 | * @return {boolean} 12 | */ 13 | 14 | const recursive = (left, right) => { 15 | if (left === null || right === null) return left === right; 16 | if (left.val !== right.val) return false; 17 | 18 | return recursive(left.left, right.right) && recursive(left.right, right.left); 19 | }; 20 | 21 | const isSymmetric = (root) => { 22 | return recursive(root.left, root.right); 23 | }; 24 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0103 Binary Tree Zigzag Level Order Traversal.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * function TreeNode(val, left, right) { 4 | * this.val = (val===undefined ? 0 : val) 5 | * this.left = (left===undefined ? null : left) 6 | * this.right = (right===undefined ? null : right) 7 | * } 8 | */ 9 | /** 10 | * @param {TreeNode} root 11 | * @return {number[][]} 12 | */ 13 | const zigzagLevelOrder = function (root) { 14 | if (!root) return []; 15 | let answer = []; 16 | let curLevelNodes = [root]; 17 | let level = 0; 18 | 19 | while (curLevelNodes.length > 0) { 20 | const isFromLeftToRight = level % 2 === 0; 21 | const curLevelValues = curLevelNodes.map((node) => node.val); 22 | 23 | answer.push(isFromLeftToRight ? curLevelValues : curLevelValues.reverse()); 24 | 25 | // 다음 level 준비 26 | curLevelNodes = curLevelNodes.reduce((acc, cur) => { 27 | if (cur.left) acc.push(cur.left); 28 | if (cur.right) acc.push(cur.right); 29 | return acc; 30 | }, []); 31 | level++; 32 | } 33 | 34 | return answer; 35 | }; 36 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0108 Convert Sorted Array to Binary Search Tree.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * function TreeNode(val, left, right) { 4 | * this.val = (val===undefined ? 0 : val) 5 | * this.left = (left===undefined ? null : left) 6 | * this.right = (right===undefined ? null : right) 7 | * } 8 | */ 9 | /** 10 | * @param {number[]} nums 11 | * @return {TreeNode} 12 | */ 13 | 14 | const recursive = (node, array) => { 15 | if (array.length === 1) { 16 | node.val = array[0]; 17 | return; 18 | } 19 | let mid = Math.floor(array.length / 2); 20 | node.val = array[mid]; 21 | 22 | const leftArray = array.slice(0, mid); 23 | 24 | if (leftArray.length >= 1) { 25 | recursive((node.left = new TreeNode()), leftArray); 26 | } 27 | 28 | const rightArray = array.slice(mid + 1); 29 | 30 | if (rightArray.length >= 1) { 31 | recursive((node.right = new TreeNode()), rightArray); 32 | } 33 | }; 34 | 35 | const sortedArrayToBST = (nums) => { 36 | const root = new TreeNode(); 37 | const sortedNums = nums.sort((a, b) => a - b); 38 | 39 | recursive(root, sortedNums); 40 | 41 | return root; 42 | }; 43 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0118 Pascal's Triangle.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} numRows 3 | * @return {number[][]} 4 | */ 5 | const generate = (numRows) => { 6 | const result = new Array(numRows).fill().map((_, i) => new Array(i + 1).fill().map(() => 1)); 7 | 8 | for (let i = 2; i < numRows; i++) { 9 | const row = result[i]; 10 | const prevRow = result[i - 1]; 11 | 12 | for (let j = 1; j < row.length - 1; j++) { 13 | row[j] = prevRow[j - 1] + prevRow[j]; 14 | } 15 | } 16 | 17 | return result; 18 | }; 19 | 20 | console.log(generate((numRows = 1))); 21 | console.log(generate((numRows = 5))); 22 | /* [ 23 | * [1], 24 | * [1, 1], 25 | * [1, 2, 1], 26 | * [1, 3, 3, 1], 27 | * [1, 4, 6, 4, 1] 28 | * ]; 29 | */ 30 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0121 Best Time to Buy and Sell Stock.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/best-time-to-buy-and-sell-stock/ */ 2 | 3 | var maxProfit = function (prices) { 4 | let maxProfit = 0; 5 | let priceOfBuying = prices[0]; 6 | 7 | for (let priceOfToday of prices) { 8 | if (priceOfToday < priceOfBuying) { 9 | // buy 10 | priceOfBuying = priceOfToday; 11 | } else if (priceOfToday - priceOfBuying > maxProfit) { 12 | // sell 13 | maxProfit = priceOfToday - priceOfBuying; 14 | } 15 | } 16 | return maxProfit; 17 | }; 18 | 19 | console.log(maxProfit((prices = [7, 1, 5, 3, 6, 4]))); // 5 20 | console.log(maxProfit((prices = [7, 6, 4, 3, 1]))); // 0 21 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0125 Valid Palindrom.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/valid-palindrome/ */ 2 | 3 | var isPalindrome = function (s) { 4 | let temp = s.replace(/ /g, ''); 5 | let processedString = ''; 6 | 7 | for (let char of temp) { 8 | let lowChar = char.toLowerCase(); 9 | let lowCharCode = lowChar.charCodeAt(0); 10 | 11 | if ( 12 | (lowCharCode >= 'a'.charCodeAt(0) && lowCharCode <= 'z'.charCodeAt(0)) || 13 | (lowCharCode >= '0'.charCodeAt(0) && lowCharCode <= '9'.charCodeAt(0)) 14 | ) { 15 | processedString += lowChar; 16 | } 17 | } 18 | //console.log(processedString); 19 | 20 | let len = processedString.length; 21 | let iteration = Math.floor(len / 2); 22 | for (let i = 0; i < iteration; i++) { 23 | if (processedString[i] !== processedString[len - 1 - i]) { 24 | return false; 25 | } 26 | } 27 | return true; 28 | }; 29 | 30 | console.log(isPalindrome('A man, a plan, a canal: Panama')); 31 | console.log(isPalindrome('race a car')); 32 | console.log(isPalindrome('"0P"')); 33 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0141 Linked List Cycle.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * function ListNode(val) { 4 | * this.val = val; 5 | * this.next = null; 6 | * } 7 | */ 8 | 9 | /** 10 | * @param {ListNode} head 11 | * @return {boolean} 12 | */ 13 | const hasCycle = (head) => { 14 | let cur = head; 15 | 16 | while (cur && cur.next) { 17 | if (cur.visited) { 18 | return true; 19 | } 20 | 21 | cur.visited = true; 22 | cur = cur.next; 23 | } 24 | 25 | return false; 26 | }; 27 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0160 Intersection of Two Linked Lists.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * function ListNode(val) { 4 | * this.val = val; 5 | * this.next = null; 6 | * } 7 | */ 8 | 9 | /** 10 | * @param {ListNode} headA 11 | * @param {ListNode} headB 12 | * @return {ListNode} 13 | */ 14 | const getIntersectionNode = (headA, headB) => { 15 | let curA = headA; 16 | 17 | while (curA) { 18 | let curB = headB; 19 | 20 | while (curB) { 21 | if (curA === curB) { 22 | return curA; 23 | } 24 | curB = curB.next; 25 | } 26 | 27 | curA = curA.next; 28 | } 29 | 30 | return null; 31 | }; 32 | 33 | /** 34 | * @link https://leetcode.com/problems/intersection-of-two-linked-lists/solutions/1092898 35 | */ 36 | 37 | const getIntersectionNode2 = (headA, headB) => { 38 | let curA = headA; 39 | let curB = headB; 40 | 41 | while (curA !== curB) { 42 | curA = curA ? curA.next : headB; 43 | curB = curB ? curB.next : headA; 44 | } 45 | return curA; 46 | }; 47 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0202 Happy Number.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {boolean} 4 | */ 5 | const isHappy = function (n) { 6 | const TRY_COUNT = 10; 7 | let cur = n; 8 | 9 | for (let i = 0; i < TRY_COUNT; i++) { 10 | let sum = 0; 11 | while (cur > 0) { 12 | sum += Math.pow(cur % 10, 2); 13 | cur = Math.floor(cur / 10); 14 | } 15 | 16 | if (sum === 1) return true; 17 | cur = sum; 18 | } 19 | return false; 20 | }; 21 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0217 Contains Duplicate.js: -------------------------------------------------------------------------------- 1 | /*https://leetcode.com/problems/contains-duplicate/ */ 2 | 3 | var containsDuplicate = function (nums) { 4 | let set = new Set(nums); 5 | if (set.size === nums.length) { 6 | return false; 7 | } 8 | return true; 9 | }; 10 | 11 | console.log(containsDuplicate([1, 2, 3, 1])); 12 | console.log(containsDuplicate([1, 2, 3, 4])); 13 | console.log(containsDuplicate([1, 1, 1, 3, 3, 4, 3, 2, 4, 2])); 14 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0231 Power of Two.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/power-of-two/ */ 2 | 3 | var isPowerOfTwo = function (n) { 4 | let num = n; 5 | 6 | if (num < 1) { 7 | return false; 8 | } 9 | while (num > 1) { 10 | num = num / 2; 11 | } 12 | if (num === 1) { 13 | return true; 14 | } 15 | return false; 16 | }; 17 | 18 | console.log(isPowerOfTwo(-1)); // false 19 | console.log(isPowerOfTwo(0)); // false 20 | console.log(isPowerOfTwo(1 / 2)); // false 21 | console.log(isPowerOfTwo(1)); // true 22 | console.log(isPowerOfTwo(16)); // true 23 | console.log(isPowerOfTwo(3)); // false 24 | console.log(isPowerOfTwo(4)); // true 25 | console.log(isPowerOfTwo(5)); // false 26 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0234 Palindrome Linked List.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * function ListNode(val, next) { 4 | * this.val = (val===undefined ? 0 : val) 5 | * this.next = (next===undefined ? null : next) 6 | * } 7 | */ 8 | /** 9 | * @param {ListNode} head 10 | * @return {boolean} 11 | */ 12 | const isPalindrome = (head) => { 13 | let cur = head; 14 | 15 | while (cur && cur.next) { 16 | cur.next.prev = cur; 17 | cur = cur.next; 18 | } 19 | 20 | let tail = cur; 21 | 22 | while (head !== tail) { 23 | if (head.val !== tail.val) return false; 24 | 25 | head = head.next; 26 | if (head === tail) return true; 27 | tail = tail.prev; 28 | } 29 | 30 | return true; 31 | }; 32 | 33 | /* Time Limit Exceeded */ 34 | const isPalindrome2 = (head) => { 35 | let cur = head; 36 | // let array = []; 37 | 38 | while (cur && cur.next) { 39 | // array.push(cur.val); 40 | cur.next.prev = cur; 41 | cur = cur.next; 42 | } 43 | let tail = cur; 44 | while (head !== tail) { 45 | if (head.val !== tail.val) { 46 | return false; 47 | } 48 | head = head.next; 49 | if (head === tail) return true; 50 | tail = tail.next; 51 | } 52 | 53 | return true; 54 | // while (array.length) { 55 | // if (array[0] !== array[array.length - 1]) { 56 | // return false; 57 | // } 58 | // array = array.slice(1, length - 1); 59 | // } 60 | // return true; 61 | }; 62 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0242 Valid Aagram.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/valid-anagram/ */ 2 | 3 | var isAnagram = function (s, t) { 4 | let obj = {}; 5 | 6 | if (s.length !== t.length) { 7 | return false; 8 | } 9 | for (let char of s) { 10 | obj[char] = obj[char] === undefined ? 1 : ++obj[char]; 11 | } 12 | 13 | for (let char of t) { 14 | if (obj[char] === undefined || obj[char] < 1) { 15 | return false; 16 | } 17 | obj[char]--; 18 | } 19 | return true; 20 | }; 21 | 22 | console.log(isAnagram((s = 'anagram'), (t = 'nagaram'))); //true 23 | console.log(isAnagram((s = 'rat'), (t = 'car'))); //false 24 | console.log(isAnagram((s = 'a'), (t = 'ab'))); //false 25 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0268 Missing Number.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | const missingNumber = (nums) => { 6 | const n = nums.length; 7 | const array = new Array(n + 1).fill().map(() => true); 8 | 9 | nums.forEach((num) => (array[num] = false)); 10 | 11 | return array.findIndex(Boolean); 12 | }; 13 | 14 | console.log(missingNumber((nums = [3, 0, 1]))); //2 15 | console.log(missingNumber((nums = [0, 1]))); //2 16 | console.log(missingNumber((nums = [9, 6, 4, 2, 3, 5, 7, 0, 1]))); //8 17 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0278 First Bad Version.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for isBadVersion() 3 | * 4 | * @param {integer} version number 5 | * @return {boolean} whether the version is bad 6 | * isBadVersion = function(version) { 7 | * ... 8 | * }; 9 | */ 10 | 11 | /** 12 | * @param {function} isBadVersion() 13 | * @return {function} 14 | */ 15 | const solution = (isBadVersion) => { 16 | /** 17 | * @param {integer} n Total versions 18 | * @return {integer} The first bad version 19 | */ 20 | return (n) => { 21 | const result = {}; 22 | let left = 1; 23 | let right = n; 24 | 25 | let i = Math.floor((left + right) / 2); 26 | 27 | while (true) { 28 | result[i] = isBadVersion(i); 29 | 30 | /* 종료 조건 */ 31 | if ((result[i - 1] === false || i === 1) && result[i] == true) return i; 32 | if (result[i] === false && result[i + 1] == true) return i + 1; 33 | 34 | /* 범위 조정 */ 35 | if (result[i] === true) right = i - 1; 36 | if (result[i] === false) left = i + 1; 37 | 38 | i = Math.floor((right + left) / 2); 39 | } 40 | }; 41 | }; 42 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0290 Word Pattern.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/word-pattern/ */ 2 | 3 | var wordPattern = function(pattern, s) { 4 | let objOfPattern = {} 5 | let objOfString = {} 6 | let arrOfString = s.split(' '); 7 | 8 | if (pattern.length != arrOfString.length) { 9 | return false 10 | } 11 | for (let i in pattern) { 12 | if (objOfPattern[`${pattern[i]}`] === undefined && objOfString[`${arrOfString[i]}`] === undefined) { 13 | objOfPattern[`${pattern[i]}`] = arrOfString[i]; 14 | objOfString[`${arrOfString[i]}`] = pattern[i]; 15 | } 16 | //console.log(objOfPattern, objOfString); 17 | if (objOfPattern[`${pattern[i]}`] !== arrOfString[i] 18 | || objOfString[`${arrOfString[i]}`] !== pattern[i]) { 19 | return false; 20 | } 21 | } 22 | return true; 23 | }; 24 | 25 | console.log(wordPattern(pattern = "abba", s = "dog cat cat dog")); 26 | console.log(wordPattern(pattern = "abba", s = "dog cat cat fish")); 27 | console.log(wordPattern(pattern = "aaaa", s = "dog cat cat dog")); 28 | console.log(wordPattern(pattern = "abba", s = "dog dog dog dog")); 29 | console.log(wordPattern(pattern = "abc", s = "dog cat dog")); 30 | console.log(wordPattern(pattern = "aaa", s = "aa aa aa aa")); 31 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0326 Power of Three.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * -231 <= n <= 231 - 1 4 | * @return {boolean} 5 | */ 6 | 7 | const isPowerOfThree = (n) => { 8 | if (n <= 0) return false; 9 | 10 | while (n > 1) { 11 | n /= 3; 12 | } 13 | while (n < 1) { 14 | n *= 3; 15 | } 16 | 17 | return n === 1; 18 | }; 19 | 20 | console.log(isPowerOfThree(27)); 21 | console.log(isPowerOfThree(0)); 22 | console.log(isPowerOfThree(9)); 23 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0344 Reverse String.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/reverse-string/ */ 2 | 3 | var reverseString = function (s) { 4 | // return s.reverse(); 5 | 6 | let iterationNum = Math.floor(s.length / 2); 7 | 8 | for (let i = 0; i < iterationNum; i++) { 9 | let temp = s[i]; 10 | 11 | s[i] = s[s.length - 1 - i]; 12 | s[s.length - 1 - i] = temp; 13 | } 14 | return s; 15 | }; 16 | 17 | console.log(reverseString((Input = ['h', 'e', 'l', 'l', 'o']))); 18 | console.log(reverseString((Input = ['H', 'a', 'n', 'n', 'a', 'h']))); 19 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0345 Reverse Vowels of a String.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/reverse-vowels-of-a-string/ */ 2 | 3 | var reverseVowels = function (s) { 4 | let arr = [...s]; 5 | let lowercaseVowels = ['a', 'e', 'i', 'o', 'u']; 6 | let uppercaseVowels = lowercaseVowels.map((v) => v.toUpperCase()); 7 | let vowels = lowercaseVowels.concat(uppercaseVowels); 8 | let start = 0; 9 | let end = arr.length - 1; 10 | 11 | while (start <= end) { 12 | let temp; 13 | 14 | while (!vowels.includes(arr[start]) && start <= end) { 15 | start++; 16 | } 17 | while (!vowels.includes(arr[end]) && start <= end) { 18 | end--; 19 | } 20 | if (start >= end) { 21 | break; 22 | } 23 | temp = arr[start]; 24 | arr[start] = arr[end]; 25 | arr[end] = temp; 26 | start++; 27 | end--; 28 | } 29 | return arr.join(''); 30 | }; 31 | 32 | console.log(reverseVowels('hello')); // holle 33 | console.log(reverseVowels('leetcode')); //leotcede 34 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0349 Intersection of Two Arrays.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/intersection-of-two-arrays/ */ 2 | 3 | var intersection = function (nums1, nums2) { 4 | let set1 = new Set(nums1); 5 | let set2 = new Set(nums2); 6 | let setA = set1.size < set2.size ? set1 : set2; 7 | let setB = set1.size < set2.size ? set2 : set1; 8 | let result = []; 9 | 10 | for (let element of setA) { 11 | if (setB.has(element)) { 12 | result.push(element); 13 | } 14 | } 15 | return result; 16 | }; 17 | 18 | console.log(intersection((nums1 = [1, 2, 2, 1]), (nums2 = [2, 2]))); 19 | console.log(intersection((nums1 = [4, 9, 5]), (nums2 = [9, 4, 9, 8, 4]))); 20 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0392 Is Subsequence.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/is-subsequence/ */ 2 | 3 | //0 <= s.length <= 100 4 | //0 <= t.length <= 10^4 5 | var isSubsequence = function (s, t) { 6 | let target = t.slice(); 7 | 8 | for (let char of s) { 9 | let idx = target.indexOf(char); 10 | //console.log('char', char, 'idx', idx); 11 | 12 | if (idx === -1) { 13 | return false; 14 | } 15 | target = target.slice(idx + 1); 16 | //console.log(target); 17 | } 18 | return true; 19 | }; 20 | 21 | console.log(isSubsequence((s = 'abc'), (t = 'ahbgdc'))); //true 22 | console.log(isSubsequence((s = 'axc'), (t = 'ahbgdc'))); //false 23 | console.log(isSubsequence((s = 'acb'), (t = 'ahbgdc'))); //false 24 | console.log(isSubsequence((s = 'aaaaaa'), (t = 'bbaaaaa'))); //false 25 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0415 Add Strings.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/add-strings/ */ 2 | 3 | var addStrings = function (num1, num2) { 4 | let result = ''; 5 | let len1 = num1.length; 6 | let len2 = num2.length; 7 | let carryflag = 0; 8 | 9 | for (let i = 0; i < num1.length || i < num2.length; i++) { 10 | let sum = 11 | (+num1[len1 - 1 - i] || 0) + (+num2[len2 - 1 - i] || 0) + carryflag; 12 | 13 | if (sum >= 10) { 14 | carryflag = 1; 15 | sum -= 10; 16 | } else { 17 | carryflag = 0; 18 | } 19 | result += sum; 20 | } 21 | if (carryflag === 1) { 22 | result += carryflag; 23 | } 24 | console.log(result); 25 | return result.split('').reverse().join(''); 26 | }; 27 | 28 | console.log(addStrings((num1 = '9333852702227987'), (num2 = '85731737104263'))); 29 | // 9419584439332250 30 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0628 Maximum Product of Three Numbers.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/maximum-product-of-three-numbers/ */ 2 | 3 | var maximumProduct = function (nums) { 4 | let sorted = nums.slice().sort((a, b) => a - b); 5 | let len = sorted.length; 6 | 7 | return Math.max( 8 | sorted[0] * sorted[1] * sorted[2], 9 | sorted[0] * sorted[1] * sorted[len - 1], 10 | sorted[len - 1] * sorted[len - 2] * sorted[len - 3] 11 | ); 12 | }; 13 | 14 | console.log(maximumProduct((nums = [1, 2, 3]))); 15 | console.log(maximumProduct((nums = [1, 2, 3, 4]))); 16 | console.log(maximumProduct((nums = [-1, -2, -3]))); 17 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0697 Degree of an Array.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/degree-of-an-array/ */ 2 | 3 | class Elem { 4 | constructor(firstIndex) { 5 | this.count = 1; 6 | this.firstIndex = firstIndex; 7 | this.lastIndex = firstIndex; 8 | } 9 | 10 | getLength = () => { 11 | return this.lastIndex - this.firstIndex + 1; 12 | }; 13 | 14 | recordOccurence = (index) => { 15 | this.count++; 16 | this.lastIndex = index; 17 | }; 18 | } 19 | 20 | var findShortestSubArray = function (nums) { 21 | let mostFrequentElement = nums[0]; 22 | let maxFrequency = 0; 23 | let obj = {}; 24 | 25 | nums.forEach((v, i) => { 26 | if (obj[v] === undefined) { 27 | obj[v] = new Elem(i); 28 | } else { 29 | obj[v].recordOccurence(i); 30 | } 31 | if ( 32 | maxFrequency < obj[v].count || 33 | (maxFrequency === obj[v].count && 34 | obj[v].getLength() < obj[mostFrequentElement].getLength()) 35 | ) { 36 | maxFrequency = obj[v].count; 37 | mostFrequentElement = v; 38 | } 39 | }); 40 | return obj[mostFrequentElement].getLength(); 41 | }; 42 | 43 | console.log(findShortestSubArray((nums = [1, 2, 3, 4]))); 44 | console.log(findShortestSubArray((nums = [1, 2, 2, 3, 1]))); 45 | console.log(findShortestSubArray((nums = [1, 2, 2, 3, 1, 4, 2]))); 46 | console.log( 47 | findShortestSubArray((nums = [2, 1, 1, 2, 1, 3, 3, 3, 1, 3, 1, 3, 2])) 48 | ); 49 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0704 Binary Search.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/binary-search/ */ 2 | 3 | const search = (nums, target) => { 4 | let s = 0 5 | let e = nums.length - 1 6 | 7 | while (s <= e) { 8 | const mid = Math.floor((s + e) / 2) 9 | 10 | if (nums[mid] === target) { 11 | return mid 12 | } 13 | 14 | if (nums[mid] < target) { 15 | s = mid + 1 16 | } else { 17 | e = mid - 1 18 | } 19 | } 20 | 21 | return -1 22 | } 23 | 24 | console.log(search((nums = [-1, 0, 3, 5, 9, 12]), (target = 9))) 25 | console.log(search((nums = [-1, 0, 3, 5, 9, 12]), (target = 2))) 26 | console.log(search((nums = [-1, 0, 3, 5, 9, 12]), (target = 12))) 27 | console.log(search((nums = [-1]), (target = 2))) 28 | console.log(search((nums = [-1]), (target = -1))) 29 | console.log(search((nums = [-1]), (target = -3))) 30 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0709 To Lower Case.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/to-lower-case/ */ 2 | 3 | let toLowerCase = (str) => { 4 | return str.toLowerCase(); 5 | }; 6 | 7 | console.log(toLowerCase("HELLO")); 8 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0744 Find Smallest Letter Greater Than Target.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/find-smallest-letter-greater-than-target/ */ 2 | 3 | var nextGreatestLetter = function (letters, target) { 4 | letters.sort((a, b) => a - b); 5 | for (let letter of letters) { 6 | if (letter > target) { 7 | return letter; 8 | } 9 | } 10 | return letters[0]; 11 | }; 12 | 13 | console.log(nextGreatestLetter((letters = ['c', 'f', 'j']), (target = 'a'))); //c 14 | console.log(nextGreatestLetter((letters = ['c', 'f', 'j']), (target = 'c'))); //f 15 | console.log(nextGreatestLetter((letters = ['c', 'f', 'j']), (target = 'd'))); //f 16 | console.log(nextGreatestLetter((letters = ['c', 'f', 'j']), (target = 'g'))); //j 17 | console.log(nextGreatestLetter((letters = ['c', 'f', 'j']), (target = 'j'))); //c 18 | console.log(nextGreatestLetter((letters = ['c', 'f', 'j']), (target = 'k'))); //c 19 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0771 Jewels and Stones.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/jewels-and-stones/ */ 2 | 3 | var numJewelsInStones = function (J, S) { 4 | let count = 0; 5 | for (stone of S) { 6 | if (J.indexOf(stone) != -1) { 7 | count++; 8 | } 9 | } 10 | return count; 11 | }; 12 | 13 | console.log(numJewelsInStones("aA", "aAAbbbb")); 14 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0819 Most Common Word.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/most-common-word/ */ 2 | 3 | var mostCommonWord = function (paragraph, banned) { 4 | let string = paragraph 5 | .slice() 6 | .replace(/[!?',;.]/g, ' ') 7 | .toLowerCase() 8 | .split(' ') 9 | .filter((v) => v); 10 | let frequency = {}; 11 | let mostCommon = ''; 12 | let candidates = []; 13 | 14 | string.forEach( 15 | (v) => (frequency[v] = frequency[v] === undefined ? 1 : ++frequency[v]) 16 | ); 17 | candidates = Object.keys(frequency); 18 | for (let c of candidates) { 19 | if (banned.includes(c)) { 20 | continue; 21 | } 22 | if (frequency[c] > (frequency[mostCommon] || 0)) { 23 | mostCommon = c; 24 | } 25 | } 26 | return mostCommon; 27 | }; 28 | 29 | console.log( 30 | mostCommonWord( 31 | (paragraph = 'Bob hit a ball, the hit BALL flew far after it was hit.'), 32 | (banned = ['hit']) 33 | ) 34 | ); // "ball" 35 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0832 Flipping an Image.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/flipping-an-image/ */ 2 | 3 | let flipAndInvertImage = (A) => { 4 | let result = []; 5 | 6 | for (row of A) { 7 | row.reverse(); 8 | result.push(row.map((v) => !v)); 9 | } 10 | return result; 11 | }; 12 | 13 | console.log( 14 | flipAndInvertImage([ 15 | [1, 1, 0], 16 | [1, 0, 1], 17 | [0, 0, 0], 18 | ]) 19 | ); 20 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0874 Walking Robot Simulation.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/walking-robot-simulation/ */ 2 | 3 | var robotSim = function (commands, obstacles) { 4 | let [x, y] = [0, 0]; 5 | let weightOfX = [0, 1, 0, -1]; 6 | let weightOfY = [1, 0, -1, 0]; 7 | let dir = 0; 8 | let objectOfObstacles = {}; 9 | let max = 0; 10 | 11 | for (let obs of obstacles) { 12 | objectOfObstacles[obs] = true; 13 | } 14 | for (let k of commands) { 15 | if (k === -2) { 16 | dir = (dir - 1 + 4) % 4; 17 | continue; 18 | } 19 | if (k === -1) { 20 | dir = (dir + 1) % 4; 21 | continue; 22 | } 23 | while (k > 0) { 24 | x = x + weightOfX[dir]; 25 | y = y + weightOfY[dir]; 26 | 27 | if (objectOfObstacles[`${x},${y}`]) { 28 | x = x - weightOfX[dir]; 29 | y = y - weightOfY[dir]; 30 | break; 31 | } 32 | k--; 33 | } 34 | max = Math.max(max, Math.pow(x, 2) + Math.pow(y, 2)); 35 | } 36 | return max; 37 | }; 38 | 39 | console.log(robotSim((commands = [4, -1, 3]), (obstacles = []))); 40 | console.log(robotSim((commands = [4, -1, 4, -2, 4]), (obstacles = [[2, 4]]))); 41 | -------------------------------------------------------------------------------- /leetcode/1_Easy/0938 Range Sum of BST.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/range-sum-of-bst/ */ 2 | 3 | let rangeSumBST = (rootNode, L, R) => { 4 | if (rootNode === null) { 5 | return 0; 6 | } 7 | 8 | let sum = 0; 9 | let stack = new Array(); 10 | stack.push(rootNode); 11 | 12 | while (stack.length) { 13 | let curr = stack.pop(); // current node 14 | 15 | if (curr === null) { 16 | continue; 17 | } 18 | if (curr.val >= L && curr.val <= R) { 19 | sum += curr.val; 20 | } 21 | if (curr.left) { 22 | stack.push(curr.left); 23 | } 24 | if (curr.right) { 25 | stack.push(curr.right); 26 | } 27 | } 28 | 29 | return sum; 30 | }; 31 | 32 | console.log( 33 | rangeSumBST((rootNode = [10, 5, 15, 3, 7, null, 18]), (L = 7), (R = 15)) 34 | ); 35 | 36 | /* 37 | * Definition for a binary tree node. 38 | * function TreeNode(val, left, right) { 39 | * this.val = (val===undefined ? 0 : val) 40 | * this.left = (left===undefined ? null : left) 41 | * this.right = (right===undefined ? null : right) 42 | * } 43 | */ 44 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1018 Binary Prefix Divisible By 5.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/binary-prefix-divisible-by-5/ */ 2 | 3 | var prefixesDivBy5 = function (A) { 4 | let curr = 0; 5 | let answer = []; 6 | 7 | for (let i = 0; i < A.length; i++) { 8 | curr = (curr * 2 + A[i]) % 5; 9 | answer.push(curr === 0); 10 | } 11 | return answer; 12 | }; 13 | 14 | console.log(prefixesDivBy5([0, 1, 1])); 15 | console.log(prefixesDivBy5([1, 1, 1])); 16 | console.log(prefixesDivBy5([0, 1, 1, 1, 1, 1])); 17 | console.log(prefixesDivBy5([1, 1, 1, 0, 1])); 18 | console.log(prefixesDivBy5([0, 1, 1, 1, 1])); 19 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1021 Remove Outermost Parentheses.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/remove-outermost-parentheses/ */ 2 | 3 | const removeOuterParentheses = (S) => { 4 | let answer = ""; 5 | let [OPENER, CLOSER] = ["(", ")"]; 6 | let balance = 0; 7 | let start = 0; 8 | for (let i = 0; i < S.length; i++) { 9 | if (S[i] === OPENER) { 10 | balance++; 11 | } else { 12 | balance--; 13 | } 14 | if (balance === 0) { 15 | answer += S.slice(start + 1, i); 16 | start = i + 1; 17 | } 18 | } 19 | return answer; 20 | }; 21 | 22 | console.log(removeOuterParentheses("(()())(())")); 23 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1108 Defanging an IP Address.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/defanging-an-ip-address/ */ 2 | 3 | var defangIPaddr = function (address) { 4 | let pos = 0, 5 | newPos = 0; 6 | let result = ""; 7 | 8 | while (true) { 9 | newPos = address.indexOf(".", pos); 10 | if (newPos == -1) break; 11 | result += address.slice(pos, newPos) + "[.]"; 12 | pos = newPos + 1; 13 | } 14 | result += address.slice(pos); 15 | 16 | return result; 17 | }; 18 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1207 Unique Number of Occurrences.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/unique-number-of-occurrences/ */ 2 | 3 | var uniqueOccurrences = function (arr) { 4 | let obj = {}; 5 | let set; 6 | let reverseSet; 7 | 8 | for (let element of arr) { 9 | obj[element] = obj[element] === undefined ? 1 : ++obj[element]; 10 | } 11 | 12 | set = new Set(Object.keys(obj)); 13 | reverseSet = new Set(Object.values(obj)); 14 | console.log(set); 15 | console.log(reverseSet); 16 | if (set.size !== reverseSet.size) { 17 | return false; 18 | } 19 | return true; 20 | }; 21 | 22 | console.log(uniqueOccurrences((arr = [1, 2, 2, 1, 1, 3]))); 23 | console.log(uniqueOccurrences((arr = [1, 2]))); 24 | console.log(uniqueOccurrences((arr = [-3, 0, 1, -3, 1, 1, 1, -3, 10, 0]))); 25 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1221 Split a String in Balanced Strings.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/split-a-string-in-balanced-strings/ */ 2 | 3 | var balancedStringSplit = function (s) { 4 | let count = 0; 5 | let firstLetter, unbalance; 6 | let i = 0; 7 | 8 | while (i < s.length) { 9 | firstLetter = s[i]; 10 | unbalance = 1; 11 | i++; 12 | while (unbalance) { 13 | if (s[i] == firstLetter) { 14 | unbalance++; 15 | } else { 16 | unbalance--; 17 | } 18 | i++; 19 | } 20 | count++; 21 | } 22 | 23 | return count; 24 | }; 25 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1252 Cells with Odd Values in a Matrix.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/cells-with-odd-values-in-a-matrix/ */ 2 | 3 | let oddCells = (n, m, indices) => { 4 | let countOdds = 0; 5 | let arr = new Array(n).fill().map(() => new Array(m).fill(0)); 6 | for (indice of indices) { 7 | let row = indice[0]; 8 | let col = indice[1]; 9 | for (let i = 0; i < m; i++) { 10 | arr[row][i]++; 11 | } 12 | for (let i = 0; i < n; i++) { 13 | arr[i][col]++; 14 | } 15 | } 16 | console.log(arr); 17 | return arr.reduce((acc, curr) => acc.concat(curr.filter((v) => v % 2)), []) 18 | .length; 19 | }; 20 | 21 | console.log( 22 | oddCells( 23 | (n = 2), 24 | (m = 3), 25 | (indices = [ 26 | [0, 1], 27 | [1, 1], 28 | ]) 29 | ) 30 | ); 31 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1266 Minimum Time Visiting All Points.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/minimum-time-visiting-all-points/ */ 2 | 3 | let minTimeToVisitAllPoints = (points) => { 4 | let count = 0; 5 | let [x1, y1] = points.shift(); 6 | while (points.length) { 7 | let [x2, y2] = points.shift(); 8 | count += Math.max(Math.abs(x2 - x1), Math.abs(y2 - y1)); 9 | [x1, y1] = [x2, y2]; 10 | } 11 | return count; 12 | }; 13 | 14 | console.log( 15 | minTimeToVisitAllPoints( 16 | (points = [ 17 | [1, 1], 18 | [3, 4], 19 | [-1, 0], 20 | ]) 21 | ) 22 | ); 23 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1281 Subtract the Product and Sum of Digits of an Integer.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/subtract-the-product-and-sum-of-digits-of-an-integer/ */ 2 | 3 | var subtractProductAndSum = function (n) { 4 | let array = n.toString().split(""); 5 | let product = 1; 6 | let sum = 0; 7 | 8 | for (i of array) { 9 | product = product * i; 10 | sum = sum + +i; // convert to Number to avoid String operation 11 | } 12 | 13 | return product - sum; 14 | }; 15 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1290 Convert Binary Number in a Linked List to Integer.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/convert-binary-number-in-a-linked-list-to-integer/ */ 2 | 3 | const getDecimalValue = (head) => { 4 | let value = 0; 5 | let curr = head; 6 | 7 | while (curr) { 8 | value = value * 2 + curr.val; 9 | curr = curr.next; 10 | } 11 | return value; 12 | }; 13 | 14 | console.log(getDecimalValue((head = [1, 0, 1]))); 15 | 16 | /** 17 | * Definition for singly-linked list. 18 | * function ListNode(val, next) { 19 | * this.val = (val===undefined ? 0 : val) 20 | * this.next = (next===undefined ? null : next) 21 | * } 22 | */ 23 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1295 Find Numbers with Even Number of Digits.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/find-numbers-with-even-number-of-digits/ */ 2 | 3 | const findNumbers = function (nums) { 4 | return nums.filter((v) => v.toString().length % 2 === 0).length; 5 | }; 6 | 7 | console.log(findNumbers([12, 345, 2, 6, 7896])); 8 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1313 Decompress Run-Length Encoded List.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/decompress-run-length-encoded-list/ */ 2 | 3 | var decompressRLElist = function (nums) { 4 | let result = []; 5 | let len = nums.length; 6 | for (let i = 0; i < len / 2; i++) { 7 | result.push(...Array(nums[2 * i]).fill(nums[2 * i + 1])); 8 | } 9 | return result; 10 | }; 11 | 12 | console.log(decompressRLElist([1, 2, 3, 4])); 13 | console.log(decompressRLElist([1, 1, 2, 3])); 14 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1323 Maximum 69 Number.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/maximum-69-number/ */ 2 | 3 | let maximum69Number = (num) => { 4 | let numStr = num.toString(); 5 | let idx6 = numStr.indexOf(6); 6 | if (idx6 === -1) { 7 | return num; 8 | } 9 | return Number(numStr.replace("6", "9")); 10 | }; 11 | 12 | console.log(maximum69Number((num = 9669))); 13 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1342 Number of Steps to Reduce a Number to Zero.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/number-of-steps-to-reduce-a-number-to-zero/ */ 2 | 3 | var numberOfSteps = function (num) { 4 | let count = 0; 5 | while (num) { 6 | if (num % 2 == 0) { 7 | num /= 2; 8 | } else { 9 | num--; 10 | } 11 | count++; 12 | } 13 | return count; 14 | }; 15 | 16 | console.log(numberOfSteps(14)); 17 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1365 How Many Numbers Are Smaller Than the Current Number.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/how-many-numbers-are-smaller-than-the-current-number/ */ 2 | 3 | var smallerNumbersThanCurrent = function (nums) { 4 | let sortedNums = nums.slice().sort((a, b) => a - b); 5 | let result = []; 6 | 7 | for (let num of nums) { 8 | result.push(sortedNums.indexOf(num)); 9 | } 10 | 11 | return result; 12 | }; 13 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1370 Increasing Decreasing String.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/increasing-decreasing-string/ */ 2 | 3 | let sortString = (s) => { 4 | let arr = Array.from(s).sort(); 5 | let ans = ""; 6 | let lastChar = ""; 7 | 8 | while (arr.length) { 9 | arr = arr.filter((v, i) => { 10 | if (i === 0 || v !== lastChar) { 11 | ans += v; 12 | lastChar = v; 13 | return false; 14 | } 15 | return true; 16 | }); 17 | arr.reverse(); 18 | } 19 | return ans; 20 | }; 21 | 22 | console.log(sortString((s = "bbbbaaaacccc"))); 23 | //abc cba abc cba 24 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1389 Create Target Array in the Given Order.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/create-target-array-in-the-given-order/ */ 2 | 3 | var createTargetArray = function (nums, index) { 4 | let target = []; 5 | let len = nums.length; 6 | 7 | for (let i = 0; i < len; i++) { 8 | target = [].concat( 9 | target.slice(0, index[i]), 10 | [nums[i]], 11 | target.slice(index[i]) 12 | ); 13 | } 14 | 15 | return target; 16 | }; 17 | 18 | console.log(createTargetArray([0, 1, 2, 3, 4], [0, 1, 2, 2, 1])); 19 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1431 Kids With the Greatest Number of Candies.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/kids-with-the-greatest-number-of-candies/ */ 2 | 3 | var kidsWithCandies = function (candies, extraCandies) { 4 | let len = candies.length; 5 | let max = Math.max(...candies); 6 | let result = []; 7 | for (let i = 0; i < len; i++) { 8 | if (candies[i] + extraCandies >= max) { 9 | result.push(true); 10 | continue; 11 | } 12 | result.push(false); 13 | } 14 | console.log(max); 15 | 16 | return result; 17 | }; 18 | 19 | console.log(kidsWithCandies([2, 3, 5, 1, 3], 3)); 20 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1436 Destination City.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/destination-city/ */ 2 | 3 | var destCity = function (paths) { 4 | let pathObj = {}; 5 | let startCity = paths[0][0]; 6 | 7 | for (let path of paths) { 8 | pathObj[path[0]] = path[1]; 9 | } 10 | while (true) { 11 | let endCity = pathObj[startCity]; 12 | if (pathObj[startCity] === undefined) { 13 | break; 14 | } 15 | startCity = endCity; 16 | } 17 | return startCity; 18 | }; 19 | 20 | console.log( 21 | destCity( 22 | (paths = [ 23 | ['London', 'New York'], 24 | ['New York', 'Lima'], 25 | ['Lima', 'Sao Paulo'], 26 | ]) 27 | ) 28 | ); 29 | console.log( 30 | destCity( 31 | (paths = [ 32 | ['B', 'C'], 33 | ['D', 'B'], 34 | ['C', 'A'], 35 | ]) 36 | ) 37 | ); 38 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1450 Number of Students Doing Homework at a Given Time.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/number-of-students-doing-homework-at-a-given-time/ */ 2 | 3 | let busyStudent = (startTime, endTime, queryTime) => { 4 | return startTime.filter((v, i) => v <= queryTime && endTime[i] >= queryTime) 5 | .length; 6 | }; 7 | 8 | console.log( 9 | busyStudent((startTime = [1, 2, 3]), (endTime = [3, 2, 7]), (queryTime = 4)) 10 | ); 11 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1464 Maximum Product of Two Elements in an Array.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/maximum-product-of-two-elements-in-an-array/ */ 2 | 3 | let maxProduct = (nums) => { 4 | nums.sort((a, b) => b - a); 5 | return (nums[0] - 1) * (nums[1] - 1); 6 | }; 7 | 8 | console.log(maxProduct((nums = [3, 4, 5, 2]))); 9 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1470 Shuffle the Array.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/shuffle-the-array/ */ 2 | 3 | var shuffle = function (nums, n) { 4 | let result = []; 5 | 6 | for (let i = 0; i < n; i++) { 7 | result.push(nums[i]); 8 | result.push(nums[n + i]); 9 | } 10 | return result; 11 | }; 12 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1480 Running Sum of 1d Array.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/running-sum-of-1d-array/ */ 2 | 3 | var runningSum = function (nums) { 4 | let result = []; 5 | let tempSum = 0; 6 | for (let i = 0; i < nums.length; i++) { 7 | tempSum += nums[i]; 8 | result.push(tempSum); 9 | } 10 | return result; 11 | }; 12 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1486 XOR Operation in an Array.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/xor-operation-in-an-array/ */ 2 | 3 | var xorOperation = function (n, start) { 4 | if (n === 1) return start; 5 | 6 | let nums = []; 7 | let result = 0; 8 | 9 | for (let i = 0; i < n; i++) { 10 | nums.push(start + 2 * i); 11 | result ^= nums[i]; 12 | } 13 | 14 | return result; 15 | }; 16 | 17 | console.log(xorOperation(5, 0)); 18 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1512 Number of Good Pairs.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/number-of-good-pairs/ */ 2 | 3 | var numIdenticalPairs = function (nums) { 4 | let count = 0; 5 | 6 | for (let i = 0; i < nums.length - 1; i++) { 7 | for (let j = i + 1; j < nums.length; j++) { 8 | if (nums[i] == nums[j]) count++; 9 | } 10 | } 11 | 12 | return count; 13 | }; 14 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1518 Water Bottles.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/water-bottles/ */ 2 | 3 | var numWaterBottles = function (numBottles, numExchange) { 4 | let numDrinking = numBottles; 5 | let numEmptyBottles = numDrinking; 6 | 7 | while (numEmptyBottles >= numExchange) { 8 | let quotient = Math.floor(numEmptyBottles / numExchange); 9 | let remainder = numEmptyBottles - numExchange * quotient; 10 | 11 | numEmptyBottles = quotient + remainder; 12 | numDrinking += quotient; 13 | } 14 | return numDrinking; 15 | }; 16 | 17 | console.log(numWaterBottles(9,3)); 18 | console.log(numWaterBottles(15, 4)); 19 | console.log(numWaterBottles(5,5)); 20 | console.log(numWaterBottles(2,3)); 21 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1528 Shuffle String.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/shuffle-string/ */ 2 | 3 | var restoreString = function (s, indices) { 4 | let array = []; 5 | for (i of indices) { 6 | array[indices[i]] = s[i]; 7 | } 8 | return array.join(""); 9 | }; 10 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1534 Count Good Triplets.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/count-good-triplets/ */ 2 | 3 | const countGoodTriplets = (arr, a, b, c) => { 4 | let triplets = 0; 5 | 6 | for (let i = 0; i < arr.length - 2; i++) { 7 | for (let j = i + 1; j < arr.length - 1; j++) { 8 | for (let k = j + 1; k < arr.length; k++) { 9 | if ( 10 | Math.abs(arr[i] - arr[j]) <= a && 11 | Math.abs(arr[j] - arr[k]) <= b && 12 | Math.abs(arr[i] - arr[k]) <= c 13 | ) 14 | triplets++; 15 | } 16 | } 17 | } 18 | return triplets; 19 | }; 20 | 21 | console.log( 22 | countGoodTriplets((arr = [3, 0, 1, 1, 9, 7]), (a = 7), (b = 2), (c = 3)) 23 | ); 24 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1572 Matrix Diagonal Sum.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/matrix-diagonal-sum/ */ 2 | 3 | const diagonalSum = (mat) => { 4 | let sum = 0; 5 | 6 | for (let i = 0; i < mat.length; i++) { 7 | for (let j = 0; j < mat.length; j++) { 8 | if (i === j || i + j === mat.length - 1) { 9 | sum += mat[i][j]; 10 | } 11 | } 12 | } 13 | return sum; 14 | }; 15 | 16 | console.log( 17 | diagonalSum( 18 | (mat = [ 19 | [1, 2, 3], 20 | [4, 5, 6], 21 | [7, 8, 9], 22 | ]) 23 | ) 24 | ); 25 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1576 Replace All ?'s to Avoid Consecutive Repeating Characters.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/replace-all-s-to-avoid-consecutive-repeating-characters/ */ 2 | 3 | /* 4 | * @param {string} s 5 | * @return {string} 6 | */ 7 | var modifyString = function (s) { 8 | const res = s.split(''); 9 | const alphas = new Array(26) 10 | .fill() 11 | .map((v, i) => String.fromCharCode(97 + i)); 12 | 13 | for (let i = 0; i < s.length; i++) { 14 | if (res[i] == '?') { 15 | res[i] = alphas.find((v) => { 16 | if (v !== (res[i - 1] || '') && v !== (res[i + 1] || '')) { 17 | return v; 18 | } 19 | }); 20 | } 21 | } 22 | return res.join(''); 23 | }; 24 | 25 | console.log(modifyString((s = '?zs'))); 26 | console.log(modifyString((s = 'ubv?w'))); 27 | console.log(modifyString((s = 'j?qg??b'))); 28 | console.log(modifyString((s = '??yw?ipkj?'))); 29 | -------------------------------------------------------------------------------- /leetcode/1_Easy/1582 Special Positions in a Binary Matrix.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/special-positions-in-a-binary-matrix/ */ 2 | 3 | var numSpecial = function (mat) { 4 | let count = 0; 5 | let k; 6 | 7 | for (let i = 0; i < mat.length; i++) { 8 | for (let j = 0; j < mat[0].length; j++) { 9 | if (mat[i][j] === 0) { 10 | continue; 11 | } 12 | for (k = 0; k < mat[0].length; k++) { 13 | if (k === j) { 14 | continue; 15 | } 16 | if (mat[i][k] === 1) { 17 | break; 18 | } 19 | } 20 | if (k !== mat[0].length) { 21 | continue; 22 | } 23 | for (k = 0; k < mat.length; k++) { 24 | if (k === i) { 25 | continue; 26 | } 27 | if (mat[k][j] === 1) { 28 | break; 29 | } 30 | } 31 | if (k !== mat.length) { 32 | continue; 33 | } 34 | //console.log(i, j); 35 | count++; 36 | } 37 | } 38 | return count; 39 | }; 40 | 41 | console.log( 42 | numSpecial( 43 | (mat = [ 44 | [1, 0, 0], 45 | [0, 0, 1], 46 | [1, 0, 0], 47 | ]) 48 | ) 49 | ); 50 | console.log( 51 | numSpecial( 52 | (mat = [ 53 | [1, 0, 0], 54 | [0, 1, 0], 55 | [0, 0, 1], 56 | ]) 57 | ) 58 | ); 59 | console.log( 60 | numSpecial( 61 | (mat = [ 62 | [0, 0, 0, 1], 63 | [1, 0, 0, 0], 64 | [0, 1, 1, 0], 65 | [0, 0, 0, 0], 66 | ]) 67 | ) 68 | ); 69 | console.log( 70 | numSpecial( 71 | (mat = [ 72 | [0, 0, 0, 0, 0], 73 | [1, 0, 0, 0, 0], 74 | [0, 1, 0, 0, 0], 75 | [0, 0, 1, 0, 0], 76 | [0, 0, 0, 1, 1], 77 | ]) 78 | ) 79 | ); 80 | console.log( 81 | numSpecial( 82 | (mat = [ 83 | [0, 1, 0], 84 | [0, 0, 0], 85 | [1, 0, 0], 86 | [1, 0, 0], 87 | ]) 88 | ) 89 | ); 90 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0002 Add Two Numbers.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/add-two-numbers/ */ 2 | /** 3 | * Definition for singly-linked list. 4 | * function ListNode(val, next) { 5 | * this.val = (val===undefined ? 0 : val) 6 | * this.next = (next===undefined ? null : next) 7 | * } 8 | */ 9 | 10 | const addTwoNumbers = (list1, list2) => { 11 | let root = new ListNode(-1); 12 | let cur = root; 13 | let carry = 0; 14 | 15 | while (list1 || list2 || carry !== 0) { 16 | const val1 = list1?.val ?? 0; 17 | const val2 = list2?.val ?? 0; 18 | let sum = val1 + val2 + carry; 19 | 20 | if (sum >= 10) { 21 | carry = 1; 22 | sum -= 10; 23 | } else { 24 | carry = 0; 25 | } 26 | 27 | cur.next = new ListNode(sum); 28 | cur = cur.next; 29 | 30 | if (list1) list1 = list1.next; 31 | if (list2) list2 = list2.next; 32 | } 33 | 34 | return root.next; 35 | }; 36 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0003 Longest Substring Without Repeating Characters.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/longest-substring-without-repeating-characters/ */ 2 | 3 | /** 4 | * @param {string} s 5 | * @return {number} 6 | */ 7 | const lengthOfLongestSubstring = (s) => { 8 | let candidate = ''; 9 | let max = 0; 10 | 11 | for (const char of s) { 12 | if (candidate.includes(char)) { 13 | const index = candidate.lastIndexOf(char); 14 | candidate = candidate.slice(index + 1) + char; 15 | } else { 16 | candidate += char; 17 | } 18 | max = Math.max(max, candidate.length); 19 | } 20 | return max; 21 | }; 22 | 23 | console.log(lengthOfLongestSubstring('abcabcbb')); // 3 24 | console.log(lengthOfLongestSubstring('pwwkew')); // 3 25 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0011 Container With Most Water.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} heights 3 | * @return {number} 4 | */ 5 | 6 | const maxArea = (heights) => { 7 | let answer = 0; 8 | let l = 0; 9 | let r = heights.length - 1; 10 | 11 | while (l < r) { 12 | const w = r - l; 13 | const h = Math.min(heights[l], heights[r]); 14 | const area = w * h; 15 | 16 | // answer 업데이트 17 | answer = Math.max(answer, area); 18 | 19 | // 다음 좌표 설정 20 | if (heights[l] < heights[r]) { 21 | let nextL = l; 22 | while (heights[l] >= heights[nextL] && nextL <= r) { 23 | nextL++; 24 | } 25 | l = nextL; 26 | } else { 27 | let nextR = r; 28 | while (heights[r] >= heights[nextR] && l <= nextR) { 29 | nextR--; 30 | } 31 | r = nextR; 32 | } 33 | } 34 | 35 | return Math.max(answer); 36 | }; 37 | 38 | describe('My Solution', () => { 39 | test('case 1', () => { 40 | expect(maxArea([1, 8, 6, 2, 5, 4, 8, 3, 7])).toBe(49); 41 | }); 42 | 43 | test('case 2', () => { 44 | expect(maxArea([1, 1])).toBe(1); 45 | }); 46 | }); 47 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0015 3Sum.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number[][]} 4 | */ 5 | 6 | const threeSum = (nums) => { 7 | const sorted = nums.sort((a, b) => a - b); 8 | const results = []; 9 | 10 | for (let i = 0; i < nums.length - 2; i++) { 11 | let j = i + 1; 12 | let k = sorted.length - 1; 13 | 14 | while (j < k) { 15 | const sum = sorted[i] + sorted[j] + sorted[k]; 16 | 17 | if (sum < 0) { 18 | while (sorted[j] === sorted[j + 1]) j++; 19 | j++; 20 | } else if (sum > 0) { 21 | while (sorted[k] === sorted[k - 1]) k--; 22 | k--; 23 | } else { 24 | // sum === 0 25 | results.push([sorted[i], sorted[j], sorted[k]]); 26 | 27 | while (sorted[i] === sorted[i + 1]) i++; 28 | while (sorted[j] === sorted[j + 1]) j++; 29 | j++; 30 | while (sorted[k] === sorted[k - 1]) k--; 31 | k--; 32 | } 33 | } 34 | } 35 | return results; 36 | }; 37 | 38 | console.log(threeSum((nums = [-1, 0, 1, 2, -1, -4]))); 39 | console.log(threeSum((nums = [0, 1, 1]))); 40 | console.log(threeSum((nums = [0, 0, 0]))); 41 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0017 Letter Combinations of a Phone Number.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string} digits 3 | * @return {string[]} 4 | */ 5 | 6 | const PHONE_MAP = { 7 | 2: ['a', 'b', 'c'], 8 | 3: ['d', 'e', 'f'], 9 | 4: ['g', 'h', 'i'], 10 | 5: ['j', 'k', 'l'], 11 | 6: ['m', 'n', 'o'], 12 | 7: ['p', 'q', 'r', 's'], 13 | 8: ['t', 'u', 'v'], 14 | 9: ['w', 'x', 'y', 'z'], 15 | }; 16 | 17 | const letterCombinations = (digits) => { 18 | let answer = []; 19 | 20 | for (const digit of digits) { 21 | const alphas = PHONE_MAP[digit]; 22 | 23 | if (answer.length === 0) { 24 | answer = alphas; 25 | } else { 26 | answer = alphas.reduce((acc, cur) => [...acc, ...answer.map((elem) => elem + cur)], []); 27 | } 28 | } 29 | return answer; 30 | }; 31 | 32 | describe('My Solution', () => { 33 | test('case 1', () => { 34 | expect(letterCombinations('23')).toEqual( 35 | expect.arrayContaining(['ad', 'ae', 'af', 'bd', 'be', 'bf', 'cd', 'ce', 'cf']) 36 | ); 37 | }); 38 | 39 | test('case 2', () => { 40 | expect(letterCombinations('')).toEqual([]); 41 | }); 42 | 43 | test('case 3', () => { 44 | expect(letterCombinations('2')).toEqual(['a', 'b', 'c']); 45 | }); 46 | }); 47 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0022 Generate Parentheses.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {string[]} 4 | */ 5 | 6 | const generateParenthesis = (n) => { 7 | const queue = [{ str: '(', open: 1, close: 0 }]; 8 | const answer = []; 9 | 10 | while (queue.length) { 11 | const item = queue.shift(); 12 | const { str, open, close } = item; 13 | 14 | if (open === n && close === n) { 15 | answer.push(str); 16 | continue; 17 | } 18 | 19 | if (open < n) queue.push({ str: str + '(', open: open + 1, close }); 20 | if (open > close) queue.push({ str: str + ')', open, close: close + 1 }); 21 | } 22 | return answer; 23 | }; 24 | 25 | describe('My Solution', () => { 26 | test('case 1', () => { 27 | expect(generateParenthesis(1)).toEqual(['()']); 28 | }); 29 | 30 | test('case 2', () => { 31 | expect(generateParenthesis(2)).toEqual(expect.arrayContaining(['()()', '(())'])); 32 | }); 33 | 34 | test('case 3', () => { 35 | expect(generateParenthesis(3)).toEqual(expect.arrayContaining(['((()))', '(()())', '(())()', '()(())', '()()()'])); 36 | }); 37 | }); 38 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0034 Find First and Last Position of Element in Sorted Array.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} target 4 | * @return {number[]} 5 | */ 6 | const searchRange = (nums, target) => { 7 | let left = 0 8 | let right = nums.length - 1 9 | 10 | while (left < right) { 11 | const mid = Math.floor((left + right) / 2) 12 | 13 | if (nums[mid] < target) { 14 | left = mid + 1 15 | } else if (nums[mid] > target) { 16 | right = mid - 1 17 | } else { 18 | let start = mid 19 | let end = mid 20 | 21 | while (nums[start] === target) { 22 | start-- 23 | } 24 | while (nums[end] === target) { 25 | end++ 26 | } 27 | return [start + 1, end - 1] 28 | } 29 | } 30 | return [-1, -1] 31 | } 32 | 33 | console.log(searchRange((nums = [5, 7, 7, 8, 8, 10]), (target = 8))) 34 | // [3,4] 35 | 36 | console.log(searchRange((nums = [5, 7, 7, 8, 8, 10]), (target = 6))) 37 | // [-1,-1] 38 | 39 | console.log(searchRange((nums = []), (target = 0))) 40 | // [-1,-1] 41 | 42 | console.log(searchRange((nums = [1]), (target = 1))) 43 | // [0,0] 44 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0046 Permutations.js: -------------------------------------------------------------------------------- 1 | /* 2 | * Given an array nums of distinct integers, return all the possible permutations. You can return the answer in any order. 3 | * n개의 수 중 k개를 고르는 순열 경우의 수: n! / (n-k)! 4 | * 5 | * - 1 <= nums.length <= 6 6 | * - -10 <= nums[i] <= 10 7 | * - All the integers of nums are unique. 8 | */ 9 | 10 | /** 11 | * @param {number[]} nums 12 | * @return {number[][]} 13 | */ 14 | const permute = (nums) => { 15 | const answer = []; 16 | 17 | recursive([], nums, answer); 18 | return answer; 19 | }; 20 | 21 | function recursive(cur, rest, answer) { 22 | if (rest.length === 0) { 23 | answer.push(cur); 24 | return; 25 | } 26 | rest.forEach((n, i) => recursive([...cur, n], [...rest.slice(0, i), ...rest.slice(i + 1)], answer)); 27 | } 28 | 29 | console.log(permute((nums = [1, 2, 3]))); 30 | // [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]] 31 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0049 Group Anagrams.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {string[]} strs 3 | * @return {string[][]} 4 | */ 5 | 6 | const isAnagram = (str1, str2) => { 7 | if (str1.length !== str2.length) return false; 8 | 9 | for (const char of str1) { 10 | const index = str2.indexOf(char); 11 | 12 | if (index === -1) return false; 13 | str2 = str2.slice(0, index) + str2.slice(index + 1); 14 | } 15 | return str2 === ''; 16 | }; 17 | 18 | const groupAnagrams = (strs) => { 19 | const groups = []; 20 | 21 | for (const str of strs) { 22 | const index = groups.findIndex((group) => isAnagram(group[0], str)); 23 | if (index === -1) { 24 | groups.push([str]); 25 | } else { 26 | groups[index].push(str); 27 | } 28 | } 29 | return groups; 30 | }; 31 | 32 | console.log(groupAnagrams(['eat', 'tea', 'tan', 'ate', 'nat', 'bat'])); 33 | // [["bat"],["nat","tan"],["ate","eat","tea"]] 34 | 35 | console.log(groupAnagrams([''])); 36 | // [[""]] 37 | 38 | console.log(groupAnagrams(['a'])); 39 | // [['a']]; 40 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0053 Maximum Subarray.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | 6 | const maxSubArray = (nums) => { 7 | let max = nums[0]; 8 | let subSum = 0; 9 | 10 | for (let num of nums) { 11 | if (subSum + num < num) { 12 | subSum = num; 13 | } else { 14 | subSum += num; 15 | } 16 | if (subSum > max) { 17 | max = subSum; 18 | } 19 | } 20 | return max; 21 | }; 22 | 23 | console.log(maxSubArray((nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]))); // 6 24 | console.log(maxSubArray((nums = [1]))); // 1 25 | console.log(maxSubArray((nums = [5, 4, -1, 7, 8]))); // 23 26 | console.log(maxSubArray((nums = [-2, 1]))); // 1 27 | console.log(maxSubArray((nums = [2, 1]))); // 3 28 | console.log(maxSubArray((nums = [-2, -1]))); // -1 29 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0055 Jump Game.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {boolean} 4 | */ 5 | 6 | const canJump = (nums) => { 7 | const pushed = Array(nums) 8 | .fill(undefined) 9 | .map(() => false); 10 | const stack = [0]; 11 | 12 | pushed[0] = true; 13 | 14 | while (stack.length > 0) { 15 | const current = stack.shift(); 16 | const maxJump = nums[current]; 17 | 18 | if (current === nums.length - 1) return true; 19 | 20 | for (let j = 1; j <= maxJump; j++) { 21 | const nextIndex = current + j; 22 | 23 | if (pushed[nextIndex]) continue; 24 | 25 | stack.push(nextIndex); 26 | pushed[nextIndex] = true; 27 | } 28 | } 29 | 30 | return false; 31 | }; 32 | 33 | console.log(canJump([2, 3, 1, 1, 4])); // true 34 | console.log(canJump([3, 2, 1, 0, 4])); // false 35 | console.log(canJump([0, 2, 3])); // false 36 | console.log(canJump([0])); // true 37 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0062 Unique Paths.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} m 3 | * @param {number} n 4 | * @return {number} 5 | */ 6 | const uniquePaths = (m, n) => { 7 | const grid = Array(m) 8 | .fill(undefined) 9 | .map(() => 10 | Array(n) 11 | .fill(undefined) 12 | .map(() => 1) 13 | ); 14 | 15 | for (i = 1; i < m; i++) { 16 | for (j = 1; j < n; j++) { 17 | grid[i][j] = grid[i - 1][j] + grid[i][j - 1]; 18 | } 19 | } 20 | return grid[m - 1][n - 1]; 21 | }; 22 | 23 | console.log(uniquePaths((m = 3), (n = 7))); // 28 24 | console.log(uniquePaths((m = 3), (n = 2))); // 3 25 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0073 Set Matrix Zeroes.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[][]} matrix 3 | * @return {void} Do not return anything, modify matrix in-place instead. 4 | */ 5 | 6 | const setRowZero = (row, matrix) => { 7 | for (let i = 0; i < matrix[0].length; i++) { 8 | matrix[row][i] = 0; 9 | } 10 | }; 11 | 12 | const setColZero = (col, matrix) => { 13 | for (let i = 0; i < matrix.length; i++) { 14 | matrix[i][col] = 0; 15 | } 16 | }; 17 | 18 | const setZeroes = (matrix) => { 19 | const iMap = new Array(matrix.length).fill().map(() => false); 20 | const jMap = new Array(matrix[0].length).fill().map(() => false); 21 | 22 | for (let i = 0; i < matrix.length; i++) { 23 | for (let j = 0; j < matrix[0].length; j++) { 24 | if (matrix[i][j] === 0) { 25 | iMap[i] = true; 26 | jMap[j] = true; 27 | } 28 | } 29 | } 30 | 31 | iMap.forEach((v, i) => v && setRowZero(i, matrix)); 32 | jMap.forEach((v, j) => v && setColZero(j, matrix)); 33 | 34 | return matrix; 35 | }; 36 | 37 | console.log( 38 | setZeroes([ 39 | [1, 1, 1], 40 | [1, 0, 1], 41 | [1, 1, 1], 42 | ]) 43 | ); 44 | console.log( 45 | setZeroes([ 46 | [0, 1, 2, 0], 47 | [3, 4, 5, 2], 48 | [1, 3, 1, 5], 49 | ]) 50 | ); 51 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0075 Sort Colors.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {void} Do not return anything, modify nums in-place instead. 4 | */ 5 | 6 | // Bubble Sort 7 | const sortColors = (nums) => { 8 | const n = nums.length; 9 | 10 | for (let i = 0; i < n; i++) { 11 | for (let j = 0; j < n; j++) { 12 | if (nums[j] > nums[j + 1]) { 13 | let temp = nums[j + 1]; 14 | nums[j + 1] = nums[j]; 15 | nums[j] = temp; 16 | } 17 | } 18 | } 19 | console.log(nums); 20 | }; 21 | 22 | console.log(sortColors((nums = [2, 0, 2, 1, 1, 0]))); // [0, 0, 1, 1, 2, 2] 23 | console.log(sortColors((nums = [2, 0, 1]))); // [0,1,2] 24 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0078 Subsets.js: -------------------------------------------------------------------------------- 1 | /* 2 | * Given an integer array nums of unique elements, return all possible subsets (the power set). 3 | * - The solution set must not contain duplicate subsets. Return the solution in any order. 4 | * - 1 <= nums.length <= 10 5 | * - -10 <= nums[i] <= 10 6 | * - All the numbers of nums are unique. 7 | */ 8 | 9 | /** 10 | * @param {number[]} nums 11 | * @return {number[][]} 12 | */ 13 | const subsets = (nums) => { 14 | return nums.reduce((acc, cur) => [...acc, ...acc.map((arr) => [...arr, cur])], [[]]); 15 | }; 16 | 17 | console.log(subsets((nums = [1, 2, 3]))); 18 | // [[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]] 19 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0094 Binary Tree Inorder Traversal.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * function TreeNode(val, left, right) { 4 | * this.val = (val===undefined ? 0 : val) 5 | * this.left = (left===undefined ? null : left) 6 | * this.right = (right===undefined ? null : right) 7 | * } 8 | */ 9 | /** 10 | * @param {TreeNode} root 11 | * @return {number[]} 12 | */ 13 | 14 | // inorder(중위순회): left-visit-right 15 | const inorderTraversal = (root) => { 16 | const answer = []; 17 | 18 | const recursive = (parent) => { 19 | if (!parent) return; 20 | 21 | recursive(parent.left); 22 | answer.push(parent.val); 23 | recursive(parent.right); 24 | }; 25 | 26 | recursive(root); 27 | 28 | return answer; 29 | }; 30 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0102 Binary Tree Level Order Traversal.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * function TreeNode(val, left, right) { 4 | * this.val = (val===undefined ? 0 : val) 5 | * this.left = (left===undefined ? null : left) 6 | * this.right = (right===undefined ? null : right) 7 | * } 8 | */ 9 | /** 10 | * @param {TreeNode} root 11 | * @return {number[][]} 12 | */ 13 | const levelOrder = (root) => { 14 | let levels = []; 15 | 16 | if (!root || !root.val) levels; 17 | 18 | let queue = [root]; 19 | 20 | while (queue.length !== 0) { 21 | let level = []; 22 | const n = queue.length; 23 | 24 | for (let i = 0; i < n; i++) { 25 | let node = queue.shift(); 26 | 27 | if (node) level.push(node.val); 28 | if (node?.left) queue.push(node.left); 29 | if (node?.right) queue.push(node.right); 30 | } 31 | 32 | if (level.length !== 0) levels.push(level); 33 | } 34 | 35 | return levels; 36 | }; 37 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0103 Binary Tree Zigzag Level Order Traversal.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * function TreeNode(val, left, right) { 4 | * this.val = (val===undefined ? 0 : val) 5 | * this.left = (left===undefined ? null : left) 6 | * this.right = (right===undefined ? null : right) 7 | * } 8 | */ 9 | /** 10 | * @param {TreeNode} root 11 | * @return {number[][]} 12 | */ 13 | const zigzagLevelOrder = function (root) { 14 | const answer = []; 15 | if (root === null) return answer; 16 | 17 | let parents = [root]; 18 | 19 | while (parents.length > 0) { 20 | const valuesOfLevel = parents.map((node) => node.val); 21 | const filteredValuesOfLevel = valuesOfLevel.filter((v) => v !== null); 22 | 23 | const level = answer.length; 24 | const isLeftToRight = level % 2 === 0; 25 | answer.push(isLeftToRight ? filteredValuesOfLevel : filteredValuesOfLevel.reverse()); 26 | 27 | const children = parents.reduce((acc, cur) => [...acc, cur.left, cur.right], []); 28 | const filteredChildren = children.filter((v) => v !== null); 29 | parents = filteredChildren; 30 | } 31 | 32 | return answer; 33 | }; 34 | 35 | /** 36 | * @link https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/solutions/2008737 37 | */ 38 | function zigzagLevelOrder2(root) { 39 | let answer = []; 40 | traverse(root, answer, 0); 41 | 42 | return answer; 43 | } 44 | 45 | function traverse(node, answer, level) { 46 | if (!node) return; 47 | 48 | if (answer[level] === null) { 49 | answer.push([]); 50 | } 51 | 52 | if (level % 2 === 0) { 53 | answer[level].push(node.val); 54 | } else { 55 | answer[level].unshift(node.val); 56 | } 57 | 58 | traverse(node.left, answer, level + 1); 59 | traverse(node.right, answer, level + 1); 60 | } 61 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0150. Evaluate Reverse Polish Notation.js: -------------------------------------------------------------------------------- 1 | const operate = (a, b, operator) => { 2 | switch (operator) { 3 | case '+': 4 | return a + b; 5 | case '-': 6 | return a - b; 7 | case '*': 8 | return a * b; 9 | case '/': 10 | return Math.trunc(a / b); 11 | } 12 | }; 13 | 14 | /** 15 | * @param {string[]} tokens 16 | * @return {number} 17 | */ 18 | 19 | const evalRPN = (tokens) => { 20 | const getValidNumberTokens = (cur) => { 21 | let backwardIndex = cur; 22 | const answer = []; 23 | 24 | while (backwardIndex >= 0 && answer.length !== 2) { 25 | const char = tokens[backwardIndex]; 26 | const num = Number(char); 27 | const visited = char === null; 28 | if (!visited && !Number.isNaN(num)) { 29 | answer.push(num); 30 | tokens[backwardIndex] = null; 31 | } 32 | backwardIndex--; 33 | } 34 | return answer; 35 | }; 36 | 37 | let i = 0; 38 | 39 | while (i < tokens.length) { 40 | const char = tokens[i]; 41 | 42 | if (!Number.isNaN(Number(char))) { 43 | i++; 44 | continue; 45 | } 46 | 47 | const [a, b] = getValidNumberTokens(i); 48 | const result = operate(b, a, char); 49 | 50 | tokens[i] = result; 51 | i++; 52 | } 53 | 54 | return tokens[tokens.length - 1]; 55 | }; 56 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0152 Maximum Product Subarray.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/maximum-product-subarray/ */ 2 | 3 | var maxProduct = function (nums) { 4 | let result = nums[0]; 5 | let prevMax = nums[0]; 6 | let prevMin = nums[0]; 7 | 8 | for (let i = 1; i < nums.length; i++) { 9 | const currMax = Math.max(nums[i], nums[i] * prevMax, nums[i] * prevMin); 10 | const currMin = Math.min(nums[i], nums[i] * prevMin, nums[i] * prevMax); 11 | 12 | prevMax = currMax; 13 | prevMin = currMin; 14 | 15 | // log MaxProduct 16 | result = Math.max(result, currMax); 17 | } 18 | return result; 19 | }; 20 | 21 | console.log(maxProduct([-2, 3, -4])); // 24 22 | console.log(maxProduct([2, 3, -2, 4])); // 6 23 | console.log(maxProduct([-2, 0, -1])); // 0 24 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0153 Find Minimum in Rotated Sorted Array.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/ */ 2 | 3 | var findMin = function (nums) { 4 | let start = 0; 5 | let end = nums.length - 1; 6 | let mid = Math.floor((end + start) / 2); 7 | 8 | while (end - start > 1) { 9 | if (nums[start] > nums[mid]) { 10 | end = mid; 11 | mid = Math.floor((end + start) / 2); 12 | continue; 13 | } 14 | if (nums[mid] > nums[end]) { 15 | start = mid; 16 | mid = Math.floor((end + start) / 2); 17 | continue; 18 | } 19 | break; 20 | } 21 | return Math.min(nums[start], nums[end]); 22 | }; 23 | 24 | console.log(findMin((nums = [3, 4, 5, 1, 2]))); // 1 25 | console.log(findMin((nums = [4, 5, 6, 7, 0, 1, 2]))); // 0 26 | console.log(findMin((nums = [11, 13, 15, 17]))); // 11 27 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0155 Min Stack.js: -------------------------------------------------------------------------------- 1 | class MinStack { 2 | constructor() { 3 | this.stack = []; 4 | this.minStack = []; 5 | } 6 | 7 | push(val) { 8 | const currentMin = this.minStack.length === 0 ? +Infinity : this.minStack[this.minStack.length - 1]; 9 | const newMin = val < currentMin ? val : currentMin; 10 | 11 | this.stack.push(val); 12 | this.minStack.push(newMin); 13 | } 14 | 15 | pop() { 16 | this.stack.pop(); 17 | this.minStack.pop(); 18 | } 19 | 20 | top() { 21 | return this.stack[this.stack.length - 1]; 22 | } 23 | 24 | getMin() { 25 | return this.minStack[this.minStack.length - 1]; 26 | } 27 | } 28 | 29 | /** 30 | * Your MinStack object will be instantiated and called as such: 31 | * var obj = new MinStack() 32 | * obj.push(val) 33 | * obj.pop() 34 | * var param_3 = obj.top() 35 | * var param_4 = obj.getMin() 36 | */ 37 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0162 Find Peak Element.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Requirement: O(log n) time complexity 3 | * Solution: Binary Search 4 | * 5 | * @param {number[]} nums 6 | * @return {number} 7 | */ 8 | const findPeakElement = (nums) => { 9 | let left = 0 10 | let right = nums.length - 1 11 | 12 | while (left < right) { 13 | const mid = Math.floor((left + right) / 2) 14 | if (nums[mid] < nums[mid + 1]) { 15 | left = mid + 1 16 | } else { 17 | right = mid 18 | } 19 | } 20 | return left 21 | } 22 | 23 | console.log(findPeakElement([1, 2, 3, 1])) // 2 24 | console.log(findPeakElement([1, 2, 1, 3, 5, 6, 4])) // 2 or 5 25 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0172 Factorial Trailing Zeroes.js: -------------------------------------------------------------------------------- 1 | const trailingZeroes = function (n) { 2 | const fivePowers = []; 3 | 4 | for (let i = 1; Math.pow(5, i) < Math.pow(10, 4); i++) { 5 | fivePowers.push(Math.pow(5, i)); 6 | } 7 | 8 | return fivePowers.reduce((acc, cur) => (acc += Math.floor(n / cur)), 0); 9 | }; 10 | 11 | console.log(trailingZeroes(30)); // 7 12 | console.log(trailingZeroes(3125)); // 781 13 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0198 House Robber.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | 6 | const rob = (nums) => { 7 | let totals = []; 8 | 9 | const recursive = (total, i) => { 10 | if (nums[i] == undefined) { 11 | totals.push(total); 12 | return; 13 | } 14 | 15 | recursive(total + nums[i], i + 2); 16 | 17 | if (nums[i + 1] !== undefined) { 18 | recursive(total + nums[i + 1], i + 3); 19 | } 20 | }; 21 | 22 | recursive(0, 0); 23 | 24 | // console.log({ totals }); 25 | 26 | return Math.max(...totals); 27 | }; 28 | 29 | console.log(rob((nums = [1]))); // 1 30 | console.log(rob((nums = [1, 1]))); // 1 31 | console.log(rob((nums = [1, 2, 1]))); // 2 32 | console.log(rob((nums = [1, 2, 2, 1]))); // 3 33 | 34 | console.log(rob((nums = [1, 2, 3, 1]))); // 4 35 | console.log(rob((nums = [2, 7, 9, 3, 1]))); // 12 36 | console.log(rob((nums = [0, 3, 2, 0]))); // 3 37 | console.log(rob((nums = [2, 8, 3, 1, 9]))); // 17 38 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0204 Count Primes.js: -------------------------------------------------------------------------------- 1 | /** 2 | * 에라토스테네스의 체 3 | * Reference: https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes 4 | * */ 5 | 6 | const countPrimes = (n) => { 7 | const array = Array(n) 8 | .fill(0) 9 | .map(() => true); 10 | 11 | array[0] = false; 12 | array[1] = false; 13 | 14 | // 제곱근까지만 검사하면 소수여부를 알 수 있다. 15 | for (let i = 2; i < Math.sqrt(n); i++) { 16 | // 소수가 아니면, 넘어간다 17 | if (!array[i]) { 18 | continue; 19 | } 20 | 21 | // 소수라면, cross out 해준다. 22 | // i ** 2 이전거는 그 전에 다 지워졌기 때문에 i ** 2 부터 시작한다. 23 | for (let j = i ** 2; j < n; j += i) { 24 | array[j] = false; 25 | } 26 | } 27 | 28 | return array.filter(Boolean).length; 29 | }; 30 | 31 | console.log(countPrimes(10)); // 4 32 | console.log(countPrimes(0)); // 0 33 | console.log(countPrimes(1)); // 0 34 | console.log(countPrimes(2)); // 0 35 | console.log(countPrimes(499979)); // 41537 36 | console.log(countPrimes(5000000)); // 348513 37 | 38 | describe('countPrimes', () => { 39 | test('case', () => { 40 | expect(countPrimes(10).toEqual(4)); 41 | }); 42 | }); 43 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0215 Kth Largest Element in an Array.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/kth-largest-element-in-an-array/ 2 | * 3 | * Constraints: 4 | * 1 <= k <= nums.length <= 105 5 | * -104 <= nums[i] <= 104 6 | * 7 | */ 8 | 9 | /** 10 | * @param {number[]} nums 11 | * @param {number} k 12 | * @return {number} 13 | * 14 | */ 15 | const findKthLargest = (nums, k) => { 16 | let min = Number.MAX_SAFE_INTEGER 17 | let max = Number.MIN_SAFE_INTEGER 18 | 19 | for (const n of nums) { 20 | min = Math.min(n, min) 21 | max = Math.max(n, max) 22 | } 23 | 24 | const len = max - min + 1 // min이 인덱스 0으로 25 | const frequencyArray = new Array(len).fill(undefined).map(() => 0) 26 | 27 | for (let i = 0; i < nums.length; i++) { 28 | const n = nums[i] 29 | const _n = n - min // min값이 인덱스 0자리에 있어서 맞춰준다. 30 | 31 | frequencyArray[_n] = frequencyArray[_n] === undefined ? 1 : frequencyArray[_n] + 1 32 | } 33 | 34 | let i = 0 // array 맨 뒤부터 움직일 인덱스 35 | 36 | while (k > 0 && i < frequencyArray.length) { 37 | const _i = frequencyArray.length - 1 - i 38 | if (frequencyArray[_i] === 0) { 39 | i++ 40 | continue 41 | } 42 | frequencyArray[_i] = frequencyArray[_i] - 1 43 | k-- 44 | } 45 | 46 | return max - i // array 맨 뒤에서부터 움직였으니 max에서 i를 빼준다. 47 | } 48 | 49 | console.log(findKthLargest((nums = [3, 2, 1, 5, 6, 4]), (k = 2))) // 5 50 | console.log(findKthLargest((nums = [3, 2, 3, 1, 2, 4, 5, 5, 6]), (k = 4))) //4 51 | console.log(findKthLargest((nums = [99, 99]), (k = 1))) // 99 52 | console.log(findKthLargest((nums = [-1, 2, 0]), (k = 3))) // -1 53 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0238 Product of Array Except Self.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/product-of-array-except-self/ */ 2 | 3 | var productExceptSelf = function (nums) { 4 | let product = 1; 5 | let zeroNum = 0; 6 | nums.forEach((v) => { 7 | if (v === 0) { 8 | zeroNum++; 9 | return; 10 | } 11 | product *= v; 12 | }); 13 | if (zeroNum >= 2) { 14 | return nums.map((v) => 0); 15 | } 16 | if (zeroNum == 1) { 17 | return nums.map((v) => { 18 | if (v === 0) { 19 | return product; 20 | } 21 | return 0; 22 | }); 23 | } 24 | return nums.map((v) => product / v); 25 | }; 26 | 27 | console.log(productExceptSelf([1, 2, 3, 4])); // [24,12,8,6] 28 | console.log(productExceptSelf([0, 2, 3, 4])); // [24,0,0,0] 29 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0300 Longest Increasing Subsequence.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @return {number} 4 | */ 5 | const lengthOfLIS = (nums) => { 6 | const dp = new Array(nums.length).fill(1) // 나 자신 7 | 8 | for (let i = 1; i < nums.length; i++) { 9 | for (let j = 0; j < i; j++) { 10 | const isIncreasing = nums[i] > nums[j] 11 | if (isIncreasing) { 12 | const a = dp[i] // 원래 값 13 | const b = dp[j] + 1 // j의 값 + 나 자신 14 | 15 | dp[i] = Math.max(a, b) // 더 큰 값으로 업데이트 16 | } 17 | } 18 | } 19 | return Math.max(...dp) 20 | } 21 | 22 | console.log(lengthOfLIS([10, 9, 2, 5, 3, 7, 101, 18])) 23 | // Output: 4 24 | 25 | console.log(lengthOfLIS([0, 1, 0, 3, 2, 3])) 26 | // Output: 4 27 | 28 | console.log(lengthOfLIS([7, 7, 7, 7, 7, 7, 7])) 29 | // Output: 1 30 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0322 Coin Change.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} coins 3 | * @param {number} amount 4 | * @return {number} 5 | */ 6 | const INITIAL_VALUE = Infinity 7 | const coinChange = (coins, amount) => { 8 | const dp = Array(amount + 1).fill(INITIAL_VALUE) 9 | 10 | dp[0] = 0 // 0원을 만들기 위한 동전의 개수는 0개 11 | 12 | for (const coin of coins) { 13 | for (let i = coin; i <= amount; i++) { 14 | const a = dp[i] // coin 사용 X 경우 15 | const b = dp[i - coin] + 1 // coin 사용 O 경우 16 | 17 | dp[i] = Math.min(a, b) // 더 작은 값으로 업데이트 18 | } 19 | } 20 | 21 | if (dp[amount] === INITIAL_VALUE) { 22 | return -1 23 | } 24 | return dp[amount] 25 | } 26 | 27 | console.log(coinChange((coins = [1, 2, 5]), (amount = 11))) 28 | //Output: 3 29 | 30 | console.log(coinChange((coins = [2]), (amount = 3))) 31 | // //Output: -1 32 | 33 | console.log(coinChange((coins = [1]), (amount = 0))) 34 | // //Output: 0 35 | 36 | console.log(coinChange((coins = [1]), (amount = 1))) 37 | // //Output: 1 38 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0328 Odd Even Linked List.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * function ListNode(val, next) { 4 | * this.val = (val===undefined ? 0 : val) 5 | * this.next = (next===undefined ? null : next) 6 | * } 7 | */ 8 | /** 9 | * @param {ListNode} head 10 | * @return {ListNode} 11 | */ 12 | 13 | const oddEvenList = (head) => { 14 | let rootOdd = null; 15 | let curOdd = null; 16 | 17 | let rootEven = null; 18 | let curEven = null; 19 | 20 | let cur = head; 21 | let index = 1; 22 | 23 | while (cur) { 24 | if (index % 2 === 1) { 25 | // odd 26 | if (rootOdd === null) { 27 | rootOdd = cur; 28 | curOdd = rootOdd; 29 | } else { 30 | curOdd.next = cur; 31 | curOdd = curOdd.next; 32 | } 33 | } else { 34 | //even 35 | if (rootEven === null) { 36 | rootEven = cur; 37 | curEven = rootEven; 38 | } else { 39 | curEven.next = cur; 40 | curEven = curEven.next; 41 | } 42 | } 43 | 44 | index++; 45 | cur = cur.next; 46 | } 47 | 48 | if (curOdd) curOdd.next = rootEven; 49 | if (curEven) curEven.next = null; 50 | 51 | return head; 52 | }; 53 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0347 Top K Frequent Elements.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} nums 3 | * @param {number} k 4 | * @return {number[]} 5 | */ 6 | 7 | const mergeSort = (entries, start, end) => { 8 | const clone = JSON.parse(JSON.stringify(entries)); 9 | 10 | // p 11 | // i j 12 | // [ start ~ mid ] [ mid + 1 ~ end ] 13 | const mid = Math.floor((start + end) / 2); 14 | let i = start; 15 | let j = mid + 1; 16 | 17 | let p = start; 18 | 19 | if (start >= end) return; 20 | 21 | mergeSort(entries, start, mid); 22 | mergeSort(entries, mid + 1, end); 23 | 24 | while (p <= end) { 25 | if (i > mid) { 26 | clone[p++] = entries[j++]; // 왼쪽 파트에서는 더 넣을게 없음 27 | } else if (j > end) { 28 | clone[p++] = entries[i++]; // 오른쪽 파트에서는 더 넣을게 없음 29 | } else if (entries[i][1] < entries[j][1]) { 30 | clone[p++] = entries[i++]; // 왼쪽게 더 작음 31 | } else { 32 | clone[p++] = entries[j++]; 33 | } 34 | } 35 | 36 | // 옮겨적기 37 | for (let i = start; i <= end; i++) { 38 | entries[i] = clone[i]; 39 | } 40 | }; 41 | 42 | const topKFrequent = (nums, k) => { 43 | const obj = {}; 44 | nums.forEach((num) => (obj[num] = obj[num] === undefined ? 1 : obj[num] + 1)); 45 | 46 | const entries = Object.entries(obj); // [key, freq] 47 | mergeSort(entries, 0, entries.length - 1); 48 | 49 | return entries 50 | .reverse() 51 | .slice(0, k) 52 | .map(([key]) => key); 53 | }; 54 | 55 | console.log(topKFrequent((nums = [1, 1, 1, 2, 2, 3]), (k = 2))); // [1, 2] 56 | console.log(topKFrequent((nums = [1]), (k = 1))); // [1] 57 | console.log(topKFrequent((nums = [3, 0, 1, 0]), (k = 1))); // [0] 58 | console.log(topKFrequent((nums = [4, 1, -1, 2, -1, 2, 3]), (k = 2))); // [-1,2] 59 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0371 Sum of Two Integers.js: -------------------------------------------------------------------------------- 1 | const getSum = (a, b) => { 2 | // ex) 1111 100 3 | 4 | while (b != 0) { 5 | /** 6 | * 1) a+b 자릿수가 올라가야할 digit을 찾는 단계 7 | * 연산: AND 8 | * - 0 AND 0 => 0 9 | * - 0 AND 1 => 0 10 | * - 1 AND 0 => 0 11 | * - 1 AND 1 => 1 12 | */ 13 | let carryHint = a & b; // ex) 0100, 1000, 10000, 0 14 | /** 15 | * 2) a에서 살려야할 1 살리는 단계 16 | * 연산: XOR 17 | * - 0 XOR 0 => 0 18 | * - 0 XOR 1 => 1 19 | * - 1 XOR 0 => 1 20 | * - 1 XOR 1 => 0 21 | */ 22 | a = a ^ b; // ex) 1011, 0011, 10011, 10011 23 | /** 24 | * 3) a+b 자릿수 digit을 실제로 올려주는 단계 25 | * 연산: Left Shift 26 | * - 1000 << 1 => 10000 27 | */ 28 | b = carry = carryHint << 1; // ex) 1000, 10000, 100000, 0 29 | } 30 | 31 | return a; 32 | }; 33 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0384 Shuffle an Array.js: -------------------------------------------------------------------------------- 1 | class Solution { 2 | constructor(nums) { 3 | this.nums = nums; 4 | } 5 | 6 | reset() { 7 | return this.nums; 8 | } 9 | 10 | shuffle() { 11 | let shuffled = []; 12 | let clone = [...this.nums]; 13 | 14 | while (clone.length > 0) { 15 | const randomIndex = Math.floor(Math.random() * clone.length); 16 | const randomElement = clone.splice(randomIndex, 1); 17 | 18 | shuffled.push(randomElement); 19 | } 20 | 21 | return shuffled; 22 | } 23 | } 24 | 25 | /** 26 | * Your Solution object will be instantiated and called as such: 27 | * var obj = new Solution(nums) 28 | * var param_1 = obj.reset() 29 | * var param_2 = obj.shuffle() 30 | */ 31 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0797 All Paths From Source to Target.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/all-paths-from-source-to-target/ */ 2 | 3 | let allPathsSourceTarget = (graph) => { 4 | let answer = []; 5 | const followPath = (queue, n) => { 6 | if (n === graph.length - 1) { 7 | return answer.push(queue); 8 | } 9 | for (next of graph[n]) { 10 | let temp = queue.slice(); 11 | temp.push(next); 12 | followPath(temp, next); 13 | } 14 | }; 15 | 16 | followPath([0], 0); 17 | 18 | return answer; 19 | }; 20 | 21 | console.log(allPathsSourceTarget([[1, 2], [3], [3], []])); 22 | -------------------------------------------------------------------------------- /leetcode/2_Medium/0807 Max Increase to Keep City Skyline.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/max-increase-to-keep-city-skyline/ */ 2 | 3 | var maxIncreaseKeepingSkyline = function (grid) { 4 | let iLen = grid.length; 5 | let jLen = grid[0].length; 6 | 7 | let iMax = Array(iLen).fill(0); 8 | let jMax = Array(jLen).fill(0); 9 | 10 | for (i = 0; i < iLen; i++) { 11 | for (j = 0; j < jLen; j++) { 12 | iMax[i] = grid[i][j] > iMax[i] ? grid[i][j] : iMax[i]; 13 | jMax[j] = grid[i][j] > jMax[j] ? grid[i][j] : jMax[j]; 14 | } 15 | } 16 | 17 | let answer = 0; 18 | for (i = 0; i < iLen; i++) { 19 | for (j = 0; j < jLen; j++) { 20 | let temp = Math.min(iMax[i] - grid[i][j], jMax[j] - grid[i][j]); 21 | if (temp <= 0) continue; 22 | answer += temp; 23 | } 24 | } 25 | return answer; 26 | }; 27 | 28 | console.log( 29 | maxIncreaseKeepingSkyline([ 30 | [13, 47, 91, 34, 20, 33, 39, 22, 80, 62], 31 | [73, 97, 88, 51, 38, 36, 52, 75, 25, 99], 32 | [95, 43, 32, 26, 82, 74, 60, 69, 59, 55], 33 | [20, 41, 77, 95, 79, 46, 70, 50, 17, 51], 34 | [51, 0, 93, 27, 46, 41, 58, 49, 8, 5], 35 | [92, 58, 38, 56, 73, 93, 34, 47, 23, 62], 36 | [97, 66, 57, 72, 26, 46, 4, 90, 82, 74], 37 | [7, 44, 67, 96, 0, 82, 75, 22, 53, 100], 38 | [95, 48, 46, 68, 41, 53, 69, 42, 13, 87], 39 | [79, 48, 96, 39, 21, 35, 3, 12, 22, 42], 40 | ]) 41 | ); 42 | 43 | // console.log( 44 | // maxIncreaseKeepingSkyline([ 45 | // [3, 0, 8, 4], 46 | // [2, 4, 5, 7], 47 | // [9, 2, 6, 3], 48 | // [0, 3, 1, 0], 49 | // ]) 50 | // ); 51 | -------------------------------------------------------------------------------- /leetcode/2_Medium/1008 Construct Binary Search Tree from Preorder Traversal.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/construct-binary-search-tree-from-preorder-traversal/ */ 2 | 3 | let bstFromPreorder = (preorder) => { 4 | if (preorder.length === 0) { 5 | return null; 6 | } 7 | 8 | let root = new TreeNode(preorder.shift()); 9 | while (preorder.length) { 10 | root = insertNode(root, preorder.shift()); 11 | } 12 | 13 | return root; 14 | }; 15 | 16 | function insertNode(curr, value) { 17 | if (curr === null) { 18 | return new TreeNode(value); 19 | } 20 | if (value < curr.val) { 21 | curr.left = insertNode(curr.left, value); 22 | } else { 23 | curr.right = insertNode(curr.right, value); 24 | } 25 | return curr; 26 | } 27 | 28 | console.log(bstFromPreorder([8, 5, 1, 7, 10, 12])); 29 | 30 | /* 31 | * Definition for a binary tree node. 32 | * function TreeNode(val, left, right) { 33 | * this.val = (val===undefined ? 0 : val) 34 | * this.left = (left===undefined ? null : left) 35 | * this.right = (right===undefined ? null : right) 36 | * } 37 | */ 38 | -------------------------------------------------------------------------------- /leetcode/2_Medium/1038 Binary Search Tree to Greater Sum Tree.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/binary-search-tree-to-greater-sum-tree/ */ 2 | 3 | var bstToGst = function (root) { 4 | let sum = 0; 5 | const rightParentLeft = (parent) => { 6 | if (parent === null) return; 7 | 8 | rightParentLeft(parent.right); 9 | parent.val += sum; 10 | sum = parent.val; 11 | rightParentLeft(parent.left); 12 | }; 13 | 14 | rightParentLeft(root); 15 | return root; 16 | }; 17 | 18 | console.log( 19 | bstToGst([4, 1, 6, 0, 2, 5, 7, null, null, null, 3, null, null, null, 8]) 20 | ); 21 | -------------------------------------------------------------------------------- /leetcode/2_Medium/1282 Group the People Given the Group Size They Belong To.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/group-the-people-given-the-group-size-they-belong-to/ */ 2 | 3 | var groupThePeople = function (groupSizes) { 4 | let answer = []; 5 | 6 | let max = Math.max(...groupSizes); 7 | let temp = Array(max + 1).fill([]); // to cover index 'max' 8 | temp = JSON.parse(JSON.stringify(temp)); 9 | 10 | let n = groupSizes.length; 11 | 12 | for (let i = n - 1; i >= 0; i--) { 13 | let size = groupSizes.pop(); 14 | temp[size].push(i); 15 | 16 | if (temp[size].length == size) { 17 | answer.push(temp[size]); 18 | temp[size] = []; 19 | } 20 | } 21 | 22 | return answer; 23 | }; 24 | 25 | console.log(groupThePeople([3, 3, 3, 3, 3, 1, 3])); 26 | // console.log(groupThePeople([2, 1, 3, 3, 3, 2])); 27 | -------------------------------------------------------------------------------- /leetcode/2_Medium/1302 Deepest Leaves Sum.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/deepest-leaves-sum/ */ 2 | 3 | let deepestLeavesSum = (rootNode) => { 4 | if (rootNode === null) return 0; 5 | 6 | let sums = new Array().fill(0); // [depth0, depth1, depth2, ...] 7 | let max = -1; 8 | let queue = new Array(); // [node, depth] 9 | queue.push([rootNode, 0]); 10 | 11 | while (queue.length) { 12 | let [curr, depth] = queue.shift(); 13 | 14 | if (depth > max) { 15 | max = depth; 16 | sums[max] = 0; // 초기화 17 | } 18 | sums[depth] += curr.val; 19 | 20 | if (curr.left) queue.push([curr.left, depth + 1]); 21 | if (curr.right) queue.push([curr.right, depth + 1]); 22 | } 23 | 24 | return sums[max]; 25 | }; 26 | 27 | console.log( 28 | deepestLeavesSum( 29 | (rootNode = [1, 2, 3, 4, 5, null, 6, 7, null, null, null, null, 8]) 30 | ) 31 | ); 32 | 33 | /* 34 | * Definition for a binary tree node. 35 | * function TreeNode(val, left, right) { 36 | * this.val = (val===undefined ? 0 : val) 37 | * this.left = (left===undefined ? null : left) 38 | * this.right = (right===undefined ? null : right) 39 | * } 40 | */ 41 | -------------------------------------------------------------------------------- /leetcode/2_Medium/1315 Sum of Nodes with Even-Valued Grandparent.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/sum-of-nodes-with-even-valued-grandparent/ */ 2 | 3 | let sumEvenGrandparent = (rootNode) => { 4 | if (rootNode === null) return 0; 5 | 6 | let queue = new Array(); 7 | let sum = 0; 8 | 9 | queue.push([rootNode, false, false]); //[rootNode, parentEven, grandParentEven] 10 | while (queue.length) { 11 | let [curr, parentEven, grandParentEven] = queue.shift(); 12 | if (grandParentEven === true) { 13 | sum += curr.val; 14 | } 15 | let currEven = !(curr.val % 2); 16 | if (curr.left) { 17 | queue.push([curr.left, currEven, parentEven]); 18 | } 19 | if (curr.right) { 20 | queue.push([curr.right, currEven, parentEven]); 21 | } 22 | } 23 | return sum; 24 | }; 25 | 26 | /* 27 | * Definition for a binary tree node. 28 | * function TreeNode(val, left, right) { 29 | * this.val = (val===undefined ? 0 : val) 30 | * this.left = (left===undefined ? null : left) 31 | * this.right = (right===undefined ? null : right) 32 | * } 33 | */ 34 | -------------------------------------------------------------------------------- /leetcode/2_Medium/1379 Find a Corresponding Node of a Binary Tree in a Clone of That Tree.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree/ */ 2 | 3 | /** 4 | * Definition for a binary tree node. 5 | * function TreeNode(val) { 6 | * this.val = val; 7 | * this.left = this.right = null; 8 | * } 9 | */ 10 | 11 | let getTargetCopy = (original, cloned, target) => { 12 | if (original === null || cloned === null) { 13 | return null; 14 | } 15 | 16 | let queue = []; 17 | queue.push(cloned); 18 | while (queue.length) { 19 | let curr = queue.shift(); 20 | 21 | if (curr.val === target.val) { 22 | return curr; 23 | } 24 | if (curr.left) { 25 | queue.push(curr.left); 26 | } 27 | if (curr.right) { 28 | queue.push(curr.right); 29 | } 30 | } 31 | return null; 32 | }; 33 | 34 | console.log(getTargetCopy((tree = [7, 4, 3, null, null, 6, 19]), (target = 3))); 35 | -------------------------------------------------------------------------------- /leetcode/2_Medium/1395 Count Number of Teams.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/count-number-of-teams/ */ 2 | 3 | var numTeams = function (rating) { 4 | if (rating.length < 2) return 0; 5 | 6 | let count = 0; 7 | 8 | for (let i = 0; i < rating.length - 2; i++) { 9 | for (let j = i + 1; j < rating.length - 1; j++) { 10 | for (let k = j + 1; k < rating.length; k++) { 11 | if ( 12 | (rating[i] < rating[j] && rating[j] < rating[k]) || 13 | (rating[i] > rating[j] && rating[j] > rating[k]) 14 | ) 15 | count++; 16 | } 17 | } 18 | } 19 | 20 | return count; 21 | }; 22 | -------------------------------------------------------------------------------- /leetcode/2_Medium/1409 Queries on a Permutation With Key.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/queries-on-a-permutation-with-key/ */ 2 | 3 | const processQueries = (queries, m) => { 4 | let len = queries.length; 5 | let answers = new Array(); 6 | let permutation = new Array(m).fill().map((v, i) => i + 1); 7 | 8 | for (let i = 0; i < len; i++) { 9 | let q = queries[i]; 10 | let p = permutation.indexOf(q); 11 | 12 | answers.push(p); 13 | permutation = [].concat( 14 | q, 15 | permutation.slice(0, p), 16 | permutation.slice(p + 1) 17 | ); 18 | } 19 | return answers; 20 | }; 21 | 22 | console.log(processQueries([10, 7, 3, 3, 9, 4, 1, 4, 9, 9], 10)); 23 | // Expected [9,7,4,0,9,6,5,1,2,0] 24 | -------------------------------------------------------------------------------- /leetcode/2_Medium/1476 Subrectangle Queries.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/subrectangle-queries/ */ 2 | 3 | class SubrectangleQueries { 4 | constructor(rectangle) { 5 | this.rectangle = rectangle; 6 | } 7 | 8 | updateSubrectangle = (row1, col1, row2, col2, newValue) => { 9 | for (let i = row1; i <= row2; i++) { 10 | for (let j = col1; j <= col2; j++) { 11 | this.rectangle[i][j] = newValue; //[row][col] 12 | } 13 | } 14 | }; 15 | 16 | getValue = (row, col) => { 17 | return this.rectangle[row][col]; 18 | }; 19 | } 20 | 21 | let obj = new SubrectangleQueries([ 22 | [1, 2, 1], 23 | [4, 3, 4], 24 | [3, 2, 1], 25 | [1, 1, 1], 26 | ]); 27 | 28 | obj.updateSubrectangle(0, 0, 3, 2, 5); 29 | console.log(obj.getValue(0, 2)); 30 | console.log(obj.getValue(3, 1)); 31 | 32 | obj.updateSubrectangle(3, 0, 3, 2, 10); 33 | console.log(obj.getValue(3, 1)); 34 | console.log(obj.getValue(0, 2)); 35 | -------------------------------------------------------------------------------- /leetcode/2_Medium/1551 Minimum Operations to Make Array Equal.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/minimum-operations-to-make-array-equal/ */ 2 | 3 | let minOperations = (n) => { 4 | if (n % 2 === 0) { 5 | return (n / 2) * (n / 2); 6 | } 7 | n++; 8 | return (n / 2) * (n / 2 - 1); 9 | }; 10 | 11 | console.log(minOperations((n = 3))); 12 | -------------------------------------------------------------------------------- /leetcode/2_Medium/1561 Maximum Number of Coins You Can Get.js: -------------------------------------------------------------------------------- 1 | /* https://leetcode.com/problems/maximum-number-of-coins-you-can-get/ */ 2 | 3 | let maxCoins = function (piles) { 4 | if (piles.length % 3 !== 0) return 0; 5 | 6 | piles.sort((a, b) => a - b); 7 | const n = piles.length / 3; 8 | let sum = 0; 9 | for (let i = 1; i <= n; i++) { 10 | sum += piles[3 * n - 2 * i]; 11 | } 12 | return sum; 13 | }; 14 | 15 | console.log(maxCoins([2, 4, 1, 2, 7, 8])); 16 | -------------------------------------------------------------------------------- /leetcode/jest.config.json: -------------------------------------------------------------------------------- 1 | { 2 | "testMatch": ["**/*.js"] 3 | } 4 | -------------------------------------------------------------------------------- /leetcode/package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "leetcode", 3 | "version": "1.0.0", 4 | "author": "365kim", 5 | "main": "index.js", 6 | "scripts": { 7 | "test": "jest --watch" 8 | }, 9 | "devDependencies": { 10 | "jest": "^28.1.0" 11 | }, 12 | "license": "ISC" 13 | } 14 | --------------------------------------------------------------------------------