[JustDevRae] 25.01.09

JustDevRae/Array/array_algorithm.md

@@ -0,0 +1,190 @@
+# 배열 알고리즘 & 시간복잡도 정리
+
+## 1. 배열 관련 내장 함수
+
+### 1.1 map
+- 설명: 각 요소에 함수를 적용하여 새 배열을 만듭니다.
+- 시간복잡도: O(n)
+- 예시 코드:
+  ```javascript
+  const arr = [1, 2, 3];
+  const doubled = arr.map(x => x * 2);
+  console.log(doubled); // [2, 4, 6]
+  ```
+
+### 1.2 filter
+- 설명: 조건을 충족하는 요소만으로 새 배열을 만듭니다.
+- 시간복잡도: O(n)
+- 예시 코드:
+  ```javascript
+  const arr = [1, 2, 3, 4];
+  const evens = arr.filter(x => x % 2 === 0);
+  console.log(evens); // [2, 4]
+  ```
+
+### 1.3 reduce
+- 설명: 배열을 하나의 값으로 축소합니다.
+- 시간복잡도: O(n)
+- 예시 코드:
+  ```javascript
+  const arr = [1, 2, 3, 4];
+  const sum = arr.reduce((acc, cur) => acc + cur, 0);
+  console.log(sum); // 10
+  ```
+
+### 1.4 forEach
+- 설명: 배열의 각 요소에 대해 제공된 함수를 실행합니다.
+- 시간복잡도: O(n)
+- 예시 코드:
+  ```javascript
+  const arr = [1, 2, 3];
+  arr.forEach(x => console.log(x));
+  ```
+
+### 1.5 push
+- 설명: 배열의 끝에 하나 이상의 요소를 추가합니다.
+- 시간복잡도: O(1)
+- 예시 코드:
+  ```javascript
+  const arr = [1, 2, 3];
+  arr.push(4);
+  console.log(arr); // [1, 2, 3, 4]
+  ```
+
+### 1.6 pop
+- 설명: 배열의 마지막 요소를 제거합니다.
+- 시간복잡도: O(1)
+- 예시 코드:
+  ```javascript
+  const arr = [1, 2, 3, 4];
+  arr.pop();
+  console.log(arr); // [1, 2, 3]
+  ```
+
+### 1.7  unshift
+- 설명: 배열의 시작 부분에 하나 이상의 요소를 추가합니다.
+- 시간복잡도: O(n)
+- 예시 코드:
+  ```javascript
+  const arr = [1, 2, 3];
+  arr.unshift(0);
+  console.log(arr); // [0, 1, 2, 3]
+  ```
+
+### 1.8 shift
+- 설명: 배열의 첫 번째 요소를 제거합니다.
+- 시간복잡도: O(n)
+- 예시 코드:
+  ```javascript
+  const arr = [1, 2, 3];
+  arr.shift();
+  console.log(arr); // [2, 3]
+  ```
+
+## 2. 검색 알고리즘
+
+### 2.1 선형 검색
+- 설명: 배열의 각 요소를 순차적으로 확인하여 목표값을 찾습니다.
+- 시간복잡도: O(n)
+- 예시 코드:
+  ```javascript
+  const arr = [1, 2, 3, 4, 5];
+  console.log(arr.indexOf(3)); // 2
+  console.log(arr.find(x => x > 3)); // 4
+  ```
+
+### 2.2 이진 검색
+- 설명: 정렬된 배열에서 중간값을 기준으로 탐색 범위를 좁혀가며 목표값을 찾습니다.
+- 시간복잡도: O(log n)
+- 예시 코드:
+  ```javascript
+  function binarySearch(arr, target) {
+    let left = 0;
+    let right = arr.length - 1;
+    while (left <= right) {
+      const mid = Math.floor((left + right) / 2);
+      if (arr[mid] === target) return mid;
+      if (arr[mid] < target) left = mid + 1;
+      else right = mid - 1;
+    }
+    return -1;
+  }
+
+  const arr = [1, 2, 3, 4, 5];
+  console.log(binarySearch(arr, 3)); // 2
+  ```
+
+## 3. 정렬 알고리즘
+
+### 3.1 기본 정렬
+- 설명: 배열의 요소를 사전순 또는 사용자 정의 순서에 따라 정렬합니다.
+- 시간복잡도: 평균 O(n log n)
+- 예시 코드:
+  ```javascript
+  const arr = [4, 2, 5, 1, 3];
+  arr.sort((a, b) => a - b); // [1, 2, 3, 4, 5]
+  ```
+
+### 3.2 버블 정렬
+- 설명: 인접한 두 요소를 비교하여 정렬합니다.
+- 시간복잡도: O(n^2)
+- 예시 코드:
+  ```javascript
+  function bubbleSort(arr) {
+    for (let i = 0; i < arr.length; i++) {
+      for (let j = 0; j < arr.length - i - 1; j++) {
+        if (arr[j] > arr[j + 1]) {
+          [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
+        }
+      }
+    }
+    return arr;
+  }
+
+  const arr = [4, 2, 5, 1, 3];
+  console.log(bubbleSort(arr)); // [1, 2, 3, 4, 5]
+  ```
+
+### 3.3 퀵 정렬
+- 설명: 기준 값을 정하고 이를 기준으로 배열을 분할하여 정렬합니다.
+- 시간복잡도: 평균 O(n log n)
+- 예시 코드:
+  ```javascript
+  function quickSort(arr) {
+    if (arr.length <= 1) return arr;
+    const pivot = arr[0];
+    const left = arr.slice(1).filter(x => x < pivot);
+    const right = arr.slice(1).filter(x => x >= pivot);
+    return [...quickSort(left), pivot, ...quickSort(right)];
+  }
+
+  const arr = [4, 2, 5, 1, 3];
+  console.log(quickSort(arr)); // [1, 2, 3, 4, 5]
+  ```
+
+### 3.4 병합 정렬
+- 설명: 배열을 반으로 나누어 정렬한 뒤 병합합니다.
+- 시간복잡도: O(n log n)
+- 예시 코드:
+  ```javascript
+  function mergeSort(arr) {
+    if (arr.length <= 1) return arr;
+    const mid = Math.floor(arr.length / 2);
+    const left = mergeSort(arr.slice(0, mid));
+    const right = mergeSort(arr.slice(mid));
+
+    function merge(left, right) {
+      const result = [];
+      while (left.length && right.length) {
+        if (left[0] < right[0]) result.push(left.shift());
+        else result.push(right.shift());
+      }
+      return [...result, ...left, ...right];
+    }
+
+    return merge(left, right);
+  }
+
+  const arr = [4, 2, 5, 1, 3];
+  console.log(mergeSort(arr)); // [1, 2, 3, 4, 5]
+  ```

JustDevRae/Array/array_element_length.js

@@ -0,0 +1,6 @@
+function solution(strlist) {
+  var answer = [];
+  answer = strlist.map((str) => str.length);
+
+  return answer;
+}

JustDevRae/Array/divisible_numbers_array.js

@@ -0,0 +1,10 @@
+function solution(arr, divisor) {
+  var answer = [];
+
+  answer = arr.filter((element) => element % divisor === 0);
+  answer.sort((a, b) => a - b);
+
+  if (answer.length === 0) answer.push(-1);
+
+  return answer;
+}

JustDevRae/Array/duplicate_number_count.js

@@ -0,0 +1,6 @@
+function solution(array, n) {
+  var answer = 0;
+  answer = array.filter((el) => el === n);
+
+  return answer.length;
+}

JustDevRae/Array/matrix_addition.js

@@ -0,0 +1,12 @@
+function solution(arr1, arr2) {
+  var answer = [[]];
+
+  for (let i = 0; i < arr1.length; i++) {
+    answer[i] = [];
+    for (let j = 0; j < arr1[i].length; j++) {
+      answer[i][j] = arr1[i][j] + arr2[i][j];
+    }
+  }
+
+  return answer;
+}

JustDevRae/Array/remove_smallest_number.js

@@ -0,0 +1,8 @@
+function solution(arr) {
+  var answer = [];
+  const minValue = Math.min(...arr);
+  answer = arr.filter((element) => element > minValue);
+  if (answer.length === 0) answer.push(-1);
+
+  return answer;
+}

JustDevRae/Array/rotate_array.js

@@ -0,0 +1,13 @@
+function solution(numbers, direction) {
+  var answer = [];
+
+  if (direction == "left") {
+    numbers.push(numbers.shift());
+  }
+
+  if (direction == "right") {
+    numbers.unshift(numbers.pop());
+  }
+
+  return (answer = numbers);
+}

JustDevRae/Array/slice_array.js

@@ -0,0 +1,5 @@
+function solution(numbers, num1, num2) {
+  var answer = [];
+
+  return (answer = numbers.slice(num1, num2 + 1));
+}

JustDevRae/Stack/control_Z.js

@@ -0,0 +1,15 @@
+function solution(s) {
+  var answer = 0;
+  let Z = 0;
+  const controlArray = s.split(" ");
+  for (let i = 0; i < controlArray.length; i++) {
+    if (controlArray[i] == "Z") {
+      answer -= Z;
+      continue;
+    }
+    answer += Number(controlArray[i]);
+    Z = Number(controlArray[i]);
+  }
+
+  return answer;
+}

JustDevRae/Stack/crane_claw_game.js

@@ -0,0 +1,23 @@
+function solution(board, moves) {
+  let answer = 0;
+  const stack = [];
+
+  for (let move of moves) {
+    for (let i = 0; i < board.length; i++) {
+      if (board[i][move - 1] !== 0) {
+        let doll = board[i][move - 1];
+        board[i][move - 1] = 0;
+
+        if (stack.length > 0 && stack[stack.length - 1] === doll) {
+          stack.pop();
+          answer += 2;
+        } else {
+          stack.push(doll);
+        }
+        break;
+      }
+    }
+  }
+
+  return answer;
+}

JustDevRae/Stack/dart_game.js

@@ -0,0 +1,41 @@
+function solution(dartResult) {
+  var answer = 0;
+  const dartResultArray = dartResult.match(/\d+|[SDT]|\#|\*/g);
+  const stack = [];
+  let value;
+
+  for (str of dartResultArray) {
+    if (str === "S") {
+      value = stack.pop();
+      stack.push(value);
+    } else if (str === "D") {
+      value = stack.pop();
+      stack.push(value * value);
+    } else if (str === "T") {
+      value = stack.pop();
+      stack.push(value * value * value);
+    } else if (str === "*") {
+      let firtPopValue = stack.pop();
+      firtPopValue *= 2;
+      let secondPopValue = stack.pop();
+      if (secondPopValue === undefined) {
+        stack.push(firtPopValue);
+      } else {
+        secondPopValue *= 2;
+        stack.push(secondPopValue);
+        stack.push(firtPopValue);
+      }
+    } else if (str === "#") {
+      value = stack.pop();
+      stack.push(value * -1);
+    } else {
+      stack.push(Number(str));
+    }
+  }
+
+  for (element of stack) {
+    answer += element;
+  }
+
+  return answer;
+}

JustDevRae/Stack/reverse_string.js

@@ -0,0 +1,10 @@
+function solution(my_string) {
+  var answer = "";
+  const string = [...my_string];
+
+  for (let i = 0; i < my_string.length; i++) {
+    answer += string.pop();
+  }
+
+  return answer;
+}

JustDevRae/Stack/valid_parentheses.js

@@ -0,0 +1,16 @@
+function solution(s) {
+  const stack = [];
+  for (const c of s) {
+    if (c === "(") {
+      stack.push(c);
+    } else if (c === ")") {
+      if (stack.length === 0) {
+        continue;
+      } else {
+        stack.pop();
+      }
+    }
+  }
+
+  return stack.length === 0;
+}