dsa-week1-assignment 윤영서

problem-1/problem-1.test.js

@@ -1,18 +1,57 @@
+//1.가장 익숙한 방법으로 문제를 해결해 주세요.
+{
+  /*
 const solution = (numbers) => {
+  let sum = 0;
+  if (numbers.length === 0) {
+    return 0;
+  }
+  for (let i = 0; i < numbers.length; i++) {
+    sum += parseInt(numbers[i], 10);
+  }
+
+  return sum;
+};*/
+}
+//2.이번에는 재귀 함수로 문제를 해결해 주세요.
+{
+  /*
+  const solution = (numbers, index = 0) => {
+  if (index >= numbers.length) {
+    return 0;
+  } else {
+    return numbers[index] + solution(numbers, index + 1);
+  }
 };
+*/
+}
+
+//3. 꼬리 재귀 함수로 바꿔보세요.
+//4. 꼬리 재귀 최적화를 통해서 최적화해 보세요.
+const solution = (numbers) => {
+  let index = 0;
+  let acc = 0;
 
-test('빈 배열은 0을 반환한다', () => {
+  while (index < numbers.length) {
+    acc = acc + numbers[index];
+    index++;
+  }
+
+  return acc;
+};
+test("빈 배열은 0을 반환한다", () => {
   expect(solution([])).toBe(0);
 });
 
-test('배열의 합을 반환한다', () => {
+test("배열의 합을 반환한다", () => {
   expect(solution([1, 2, 3, 4])).toBe(10);
   expect(solution([-1, 3, 8, 9, 10, 11])).toBe(40);
 });
 
-test('큰 배열이 입력으로 주어져도 RangeError를 던지지 않는다', () => {
+test("큰 배열이 입력으로 주어져도 RangeError를 던지지 않는다", () => {
   const input = Array.from({ length: 10000 }, (_, i) => i + 1);
 
-  expect(() => solution(input))
-    .not.toThrowError(new RangeError('Maximum call stack size exceeded'));
+  expect(() => solution(input)).not.toThrowError(
+    new RangeError("Maximum call stack size exceeded")
+  );
 });

problem-2/problem-2.test.js

@@ -1,26 +1,59 @@
+//1. 가장 익숙한 방법으로 문제를 해결해 주세요.
+//2. 이번에는 재귀 함수로 문제를 해결해 주세요.
+{
+  /*
 const solution = (n) => {
+  if (n <= -1) {
+    return 0;
+  } else if (n === 0 || n === 1) {
+    return n;
+  } else {
+    return solution(n - 1) + solution(n - 2);
+  }
+};
+*/
+}
+//3. 꼬리 재귀 함수로 바꿔보세요.
+//4. 꼬리 재귀 최적화를 통해서 최적화해 보세요.
+const solution = (n) => {
+  let pre = 0;
+  let curr = 1;
+  let temp = 0;
+  if (n <= -1) {
+    return 0;
+  } else if (n === 0 || n === 1) {
+    return n;
+  }
+  while (n >= 2) {
+    temp = pre;
+    pre = pre + curr;
+    curr = temp;
+    n--;
+  }
+  return pre + curr;
 };
 
-test('음수가 주어지면 0을 반환한다', () => {
+test("음수가 주어지면 0을 반환한다", () => {
   expect(solution(-1)).toBe(0);
 });
 
-test('0부터 1까지는 정해진 수를 반환한다', () => {
+test("0부터 1까지는 정해진 수를 반환한다", () => {
   expect(solution(0)).toBe(0);
   expect(solution(1)).toBe(1);
 });
 
-test('2이상 주어지면 앞 두 항의 합을 반환한다', () => {
+test("2이상 주어지면 앞 두 항의 합을 반환한다", () => {
   expect(solution(2)).toBe(1);
   expect(solution(3)).toBe(2);
   expect(solution(4)).toBe(3);
   expect(solution(5)).toBe(5);
   expect(solution(6)).toBe(8);
 });
 
-test('큰 입력이 주어져도 RangeError를 던지지 않는다', () => {
+test("큰 입력이 주어져도 RangeError를 던지지 않는다", () => {
   const input = 100000;
 
-  expect(() => solution(input))
-    .not.toThrowError(new RangeError('Maximum call stack size exceeded'));
+  expect(() => solution(input)).not.toThrowError(
+    new RangeError("Maximum call stack size exceeded")
+  );
 });

problem-3/problem-3.test.js

@@ -1,21 +1,64 @@
+//1. 가장 익숙한 방법으로 문제를 해결해 주세요.
+{
+  /*
 const solution = (n) => {
+  let binaryString = "";
+  if (n <= 1) {
+    return "" + n;
+  }
+  while (n >= 1) {
+    binaryString += (n % 2).toString();
+    n = parseInt(n / 2);
+  }
+  return binaryString.split("").reverse().join("");
+};*/
+}
+//2. 이번에는 재귀 함수로 문제를 해결해 주세요.
+{
+  /*
+const solution = (n, binaryString = "") => {
+  if (n <= 1) {
+    return n + binaryString;
+  }
+
+  const remainder = n % 2;
+  binaryString = remainder + binaryString;
+  return solution(parseInt(n / 2, 10), binaryString);
+};
+*/
+}
+
+//3. 꼬리 재귀 함수로 바꿔보세요.
+//4. 꼬리 재귀 최적화를 통해서 최적화해 보세요.
+const solution = (n) => {
+  let binaryString = "";
+  if (n <= 1) {
+    return n + binaryString;
+  }
+  while (n >= 1) {
+    const remainder = n % 2;
+    binaryString = remainder + binaryString;
+    n = parseInt(n / 2);
+  }
+  return binaryString;
 };
 
-test('이진수 문자열을 반환한다', () => {
-  expect(solution(0)).toBe('0');
-  expect(solution(1)).toBe('1');
-  expect(solution(2)).toBe('10');
-  expect(solution(3)).toBe('11');
-  expect(solution(4)).toBe('100');
-  expect(solution(5)).toBe('101');
-  expect(solution(6)).toBe('110');
-  expect(solution(7)).toBe('111');
-  expect(solution(8)).toBe('1000');
+test("이진수 문자열을 반환한다", () => {
+  expect(solution(0)).toBe("0");
+  expect(solution(1)).toBe("1");
+  expect(solution(2)).toBe("10");
+  expect(solution(3)).toBe("11");
+  expect(solution(4)).toBe("100");
+  expect(solution(5)).toBe("101");
+  expect(solution(6)).toBe("110");
+  expect(solution(7)).toBe("111");
+  expect(solution(8)).toBe("1000");
 });
 
-test('큰 입력이 주어져도 RangeError를 던지지 않는다', () => {
+test("큰 입력이 주어져도 RangeError를 던지지 않는다", () => {
   const input = Number.MAX_VALUE;
 
-  expect(() => solution(input))
-    .not.toThrowError(new RangeError('Maximum call stack size exceeded'));
+  expect(() => solution(input)).not.toThrowError(
+    new RangeError("Maximum call stack size exceeded")
+  );
 });

problem-4/problem-4.test.js

@@ -1,21 +1,70 @@
-const solution = () => {
+//1. 가장 익숙한 방법으로 문제를 해결해 주세요.
+{
+  /*
+const solution = (n) => {
+  let decimal = 0;
+  let exponent = 0;
+  if (n === "0" || n === "1") {
+    return parseInt(n, 10);
+  }
+  const length = n.length;
+  while (exponent <= length - 1) {
+    decimal += parseInt(n.charAt(n.length - 1), 10) * 2 ** exponent;
+
+    exponent++;
+    n = n.slice(0, -1);
+  }
+  return decimal;
+};*/
+}
+//2. 이번에는 재귀 함수로 문제를 해결해 주세요.
+{
+  /*
+const solution = (n, acc = 0, exponent = 0) => {
+  if (n.length === 1) {
+    return acc + parseInt(n, 10) * 2 ** exponent;
+  }
+  acc += parseInt(n.charAt(n.length - 1), 10) * 2 ** exponent;
+  return solution(n.slice(0, -1), acc, exponent + 1);
+};*/
+}
+
+//3. 꼬리 재귀 함수로 바꿔보세요.
+//4. 꼬리 재귀 최적화를 통해서 최적화해 보세요.
+const solution = (n) => {
+  let acc = 0;
+  let exponent = 0;
+
+  const length = n.length;
+  if (length === 1) {
+    return acc + parseInt(n, 10) * 2 ** exponent;
+  }
+
+  while (exponent <= length - 1) {
+    acc += parseInt(n.charAt(n.length - 1), 10) * 2 ** exponent;
+
+    exponent++;
+    n = n.slice(0, -1);
+  }
+  return acc;
 };
 
-test('10진수 숫자를 반환한다', () => {
-  expect(solution('0')).toBe(0);
-  expect(solution('1')).toBe(1);
-  expect(solution('10')).toBe(2);
-  expect(solution('11')).toBe(3);
-  expect(solution('100')).toBe(4);
-  expect(solution('101')).toBe(5);
-  expect(solution('110')).toBe(6);
-  expect(solution('111')).toBe(7);
-  expect(solution('1000')).toBe(8);
+test("10진수 숫자를 반환한다", () => {
+  expect(solution("0")).toBe(0);
+  expect(solution("1")).toBe(1);
+  expect(solution("10")).toBe(2);
+  expect(solution("11")).toBe(3);
+  expect(solution("100")).toBe(4);
+  expect(solution("101")).toBe(5);
+  expect(solution("110")).toBe(6);
+  expect(solution("111")).toBe(7);
+  expect(solution("1000")).toBe(8);
 });
 
-test('큰 입력이 주어져도 RangeError를 던지지 않는다', () => {
+test("큰 입력이 주어져도 RangeError를 던지지 않는다", () => {
   const input = Number.MAX_VALUE.toString(2);
 
-  expect(() => solution(input))
-    .not.toThrowError(new RangeError('Maximum call stack size exceeded'));
+  expect(() => solution(input)).not.toThrowError(
+    new RangeError("Maximum call stack size exceeded")
+  );
 });

problem-5/problem-5.test.js

@@ -1,17 +1,43 @@
-const solution = () => {
+//1. 가장 익숙한 방법으로 문제를 해결해 주세요.
+//2. 이번에는 재귀 함수로 문제를 해결해 주세요.
+{
+  /*
+const solution = (b, a) => {
+  if (a === 0) {
+    return b;
+  }
+  return solution(a, b % a);
 };
+*/
+}
 
-test('최대 공약수를 반환한다', () => {
+//3. 꼬리 재귀 함수로 바꿔보세요.
+//4. 꼬리 재귀 최적화를 통해서 최적화해 보세요.
+const solution = (b, a) => {
+  let temp;
+  while (true) {
+    if (a === 0) {
+      return b;
+    }
+    temp = a;
+    a = b % temp;
+    b = temp;
+    console.log(b + " " + a);
+  }
+};
+
+test("최대 공약수를 반환한다", () => {
   expect(solution(4, 12)).toBe(4);
   expect(solution(3, 7)).toBe(1);
   expect(solution(16, 72)).toBe(8);
   expect(solution(9, 12)).toBe(3);
 });
 
-test('큰 입력이 주어져도 RangeError를 던지지 않는다', () => {
+test("큰 입력이 주어져도 RangeError를 던지지 않는다", () => {
   const a = Number.MAX_VALUE;
   const b = 1213;
 
-  expect(() => solution(a, b))
-    .not.toThrowError(new RangeError('Maximum call stack size exceeded'));
+  expect(() => solution(a, b)).not.toThrowError(
+    new RangeError("Maximum call stack size exceeded")
+  );
 });

problem-6/problem-6.test.js

@@ -1,7 +1,45 @@
-const solution = (n) => {
+//1. 재귀 함수로 문제를 해결해 주세요.
+{
+  /*const solution = (n) => {
+  if (n === 1) {
+    return 1;
+  }
+
+  if (n === 2) {
+    return 2;
+  }
+
+  if (n === 3) {
+    return 4;
+  }
+
+  return solution(n - 1) + solution(n - 2) + solution(n - 3);
+};*/
+}
+
+//2. 다이나믹 프로그래밍으로 최적화 해주세요.
+const solution = (n, memo = []) => {
+  if (n === 1) {
+    return 1;
+  }
+
+  if (n === 2) {
+    return 2;
+  }
+
+  if (n === 3) {
+    return 4;
+  }
+
+  if (!memo[n]) {
+    memo[n] =
+      solution(n - 1, memo) + solution(n - 2, memo) + solution(n - 3, memo);
+  }
+
+  return memo[n];
 };
 
-test('계단에 오를 수 있는 가지 수를 반환한다', () => {
+test("계단에 오를 수 있는 가지 수를 반환한다", () => {
   expect(solution(1)).toBe(1);
   expect(solution(2)).toBe(2);
   expect(solution(3)).toBe(4);
@@ -14,6 +52,6 @@ test('계단에 오를 수 있는 가지 수를 반환한다', () => {
   expect(solution(10)).toBe(274);
 });
 
-test('큰 입력이 주어져도 시간안에 실행된다', async () => {
+test("큰 입력이 주어져도 시간안에 실행된다", async () => {
   expect(solution(40)).toBe(23837527729);
 });