반응형

문제

세 개의 장대가 있고 첫 번째 장대에는 반경이 서로 다른 n개의 원판이 쌓여 있다. 각 원판은 반경이 큰 순서대로 쌓여있다. 이제 수도승들이 다음 규칙에 따라 첫 번째 장대에서 세 번째 장대로 옮기려 한다.

  1. 한 번에 한 개의 원판만을 다른 탑으로 옮길 수 있다.
  2. 쌓아 놓은 원판은 항상 위의 것이 아래의 것보다 작아야 한다.

이 작업을 수행하는데 필요한 이동 순서를 출력하는 프로그램을 작성하라. 단, 이동 횟수는 최소가 되어야 한다.

아래 그림은 원판이 5개인 경우의 예시이다.

입력

첫째 줄에 첫 번째 장대에 쌓인 원판의 개수 N (1 ≤ N ≤ 20)이 주어진다.

 

출력

첫째 줄에 옮긴 횟수 K를 출력한다.

두 번째 줄부터 수행 과정을 출력한다. 두 번째 줄부터 K개의 줄에 걸쳐 두 정수 A B를 빈칸을 사이에 두고 출력하는데, 이는 A번째 탑의 가장 위에 있는 원판을 B번째 탑의 가장 위로 옮긴다는 뜻이다.

 

해설

이 문제는 하오이의 타워 라는 이름으로 유명한 문제이다.

아마 컴퓨터 공학과를 나왔다면, 알고리즘 강의를 듣는 학기초에 한번쯤은 풀어봤을 문제라고 생각한다.

 

재귀로 풀기 위해서는

 

function(N)이 function(N-1)로 점점 작아지면서 Base case까지 작아져야한다.

 

이 문제의 Base Case는 function(1)이 될 것이고, 이 경우 1번에 있는 원판을 3번으로 옮기는 것이 된다.

 

function(2)인 경우를 생각해보면 아래와 같이 진행이 된다.

하오이 타워 원판이 2개일때

 

 

이 문제는 2번 타워를 이용해서 1번에 있는 원판을 3번으로 옮겨라. 라고 표현을 할 수 있다.

 

function moveVia(N, From, To, Via) 와 같은 함수를 만들어서 풀 수 있다.

 

그리고 실제로 원판을 옮기는 함수는

 

function Move(From, To)라는 함수로 정의를 해보자.

 

위에서 N == 1인 경우에는

Move(1, 3)으로 문제가 풀린다.

 

N==2인 경우에는

MoveVia(N:2, From:1, To:3, Via:2)  2개의 원판을 1번에서 3번까지 2번 타워를 이용해서 옮겨라

라는 함수를 실행 할 수 있다.

 

위 그림에서 두번재 단계를 생각해보자

 

 

첫번째로는 원판 1개를 From이 아닌 Via에 가져다 놓아야 한다.

왜냐하면, 더 큰 원판이 아래로 가야하기 때문에 작은 원판을 Via에 가져다 놓는 것이다.

 

즉 MoveVia(N-1, From, Via, To)가 된다. (From에서 Via까지 To를 경유해서 옮겨라.)

 

그 이후에는 Move(From, To)를 이용하여 실제 우리가 옮기는 원판 중 제일 큰 원판을 To로 옮겨 놓는다.

 

마지막으로

Via에 있는 1번 원판을 From을 이용하여 3까지 옮기면 되다.

 

해설에서는 N이 2인 경우만을 생각했지만,

 

N이 커지더라도 동일한 방법이 적용된다.

 

달라지는 점은 MoveVia함수가 하나의 원판을 움직이는데서 끝나지 않고,

여러개의 원판을 재귀를 통해서 계속해서 옮기는 작업을 하는 것만 달라진다.

 

코드로 보면 아래와 같다.

 

글로 설명하기가 어려워, 다른 분들 블로그를 참고했는데

수학이 싫지 않으신 분은 이분의 블로그를 참고해도 좋을 것 같다.

 

https://shoark7.github.io/programming/algorithm/tower-of-hanoi

 

'하노이의 탑' 이해하기

'하노이의 탑' 문제를 이해하고 문제 해결을 위한 핵심 통찰을 살핀 뒤 코드로 작성합니다. 이후 탑의 개수에 따른 총 이동 횟수를 구하는 일반항까지 수학적으로 유도합니다.

shoark7.github.io

 

코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
const fs = require('fs');
const input = fs.readFileSync('/dev/stdin').toString().split(' ');
const num = parseInt(input[0]);
 
var towers = [
  [],
  [],
  []
]
var moveCount = 0;
var output = []
 
const hanoi = (num) => {
  // init
  for(let i = 0; i < num; i++) {
    towers[0].push(i)
  }
 
  //num개를 0부터 2까지 옮겨라
  moveVia(num, 021)
 
  console.log(moveCount)
  console.log(output.join('\n'))
}
 
const move = (from, to) => {
  const tmp = towers[from].pop()
  towers[to].push(tmp)
  moveCount++;
  output.push(`${from+1} ${to+1}`)
  return;
}
 
const moveVia = (num, from, to, via) => {
  if(num == 1) {
    return move(from, to)
  }
 
  moveVia(num-1from, via, to);
  move(from, to)
  moveVia(num-1, via, to, from)
}
 
 
hanoi(num)
cs

 

반응형
반응형

문제

재귀적인 패턴으로 별을 찍어 보자. N이 3의 거듭제곱(3, 9, 27, ...)이라고 할 때, 크기 N의 패턴은 N×N 정사각형 모양이다.

크기 3의 패턴은 가운데에 공백이 있고, 가운데를 제외한 모든 칸에 별이 하나씩 있는 패턴이다.

***

* *

***

N이 3보다 클 경우, 크기 N의 패턴은 공백으로 채워진 가운데의 (N/3)×(N/3) 정사각형을 크기 N/3의 패턴으로 둘러싼 형태이다. 예를 들어 크기 27의 패턴은 예제 출력 1과 같다.

입력

첫째 줄에 N이 주어진다. N은 3의 거듭제곱이다. 즉 어떤 정수 k에 대해 N=3k이며, 이때 1 ≤ k < 8이다.

출력

첫째 줄부터 N번째 줄까지 별을 출력한다.

 

해설

이 문제는 그림을 그리면서 먼저 패턴을 파악하면 쉽게 풀 수 있을 것 같다.

입력값이 3 일때를 생각해보면

x x x
x   x
x x x

인데, 이 경우에 1,1이 공백을 출력해야 하는 위치인 것을 알 수 있고,

이 패턴이 반복되기 때문에 i, j의 1 % 3(1 나머지 3)의 값이 1인 곳은 공백으로 처리를 하면 첫번째 단계는 해결이 된다.

이 경우가 재귀에서 처리해는 최소범위의 값이다.

 

이 코드를 그래도 9로 넘어갈 경우

x x x x x x x x x
x   x x   x x   x
x x x x x x x x x
x x x x x x x x x
x   x x   x x   x
x x x x x x x x x
x x x x x x x x x
x   x x   x x   x
x x x x x x x x x

색칠된 부분이 정답과는 다른 부분이 된다.

즉, 첫번째 우리가 공백으로 처리한 부분 이외에 추가로 공백으로 처리해야하는 좌표는 아래와 같다.(좌표를 편의상 i, j로 작성합니다. for loop에서 자주 사용되는 변수입니다.)

 

(3,3) (3,4) (3,5)

(4,3) (4,4) (4,5)

(5,4) (5,4) (5,5)

 

여기서 i, j 의 범위는 모두

3^1 <= i,j < 3^1 + 3^1 이다.(^1은 1승, 제곱인 경우 ^2로 표현합니다.)

 

즉, 3^1부터 3^1 크기의 정 사각형이 빈 공백으로 표시가 된다.

 

입력값이 27이라면

3^2 부터 3^2+3^2까지 (9 ~ 17) 공백으로 표현이 된다.

 

이 규칙에서 나온 코드가 아래 코드에서 30번째 라인의 코드이다.

3~5까지는 모두 공백(n%3==1일때)으로 출력이 되도록 3으로 나눈 값의 몫만을 취해서 재귀로 호출한다.

그렇다면 9,9는 3,3이 되고, 다시 1,1이 되면서 빈 공백을 출력하게 된다.

나머지는 제외한 몫만을 취급하기 때문에

(17,17, 27) => (5,5,9) => (1, 1, 3)이 되면서 num이 1이 되기전에 line 20에서 분기에 걸려 " " 빈 공백을 출력하게 된다.

코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
const fs = require('fs');
const input = fs.readFileSync('/dev/stdin').toString().split('\n');
const num = parseInt(input[0])
 
const lines = []
 
printStars(num);
console.log(lines.join(""))
 
function printStars(num) {
  for(let i = 0; i < num; i++) {
    for(let j = 0; j < num; j++) {
      star(i, j, num)
    }
    lines.push("\n")
  }
}
 
function star(i, j, num) {
  if(i % 3 == 1 && j % 3 == 1) {
    // (1,1), (1,4), (1,7)...
    lines.push(" ")
  } else {
    if(num == 1) {
      lines.push("*")
    } else {
      // (3,3) = (1,1)이 되고,
      // (3,4) = (1,1)이 된다.
      // (9,9), (27,27)도 동일한 방식으로 재귀 호출된다.
      star(parseInt(i/3), parseInt(j/3), parseInt(num/3))
    }
  }
}
cs

 

반응형
반응형

문제

피보나치 수는 0과 1로 시작한다. 0번째 피보나치 수는 0이고, 1번째 피보나치 수는 1이다. 그 다음 2번째 부터는 바로 앞 두 피보나치 수의 합이 된다.

이를 식으로 써보면 Fn = Fn-1 + Fn-2 (n ≥ 2)가 된다.

n=17일때 까지 피보나치 수를 써보면 다음과 같다.

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597

n이 주어졌을 때, n번째 피보나치 수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 n이 주어진다. n은 20보다 작거나 같은 자연수 또는 0이다.

출력

첫째 줄에 n번째 피보나치 수를 출력한다.

 

해설

피보나치 수를 구하는 함수를 작성하기 위해서는

최소케이스를 먼저 작성을 해야한다.

 

이 문제에서의 최소 케이스는 fibonacci(0) 은 0, fibonacci(1)은 1 을 리턴하도록 작성을 한다.

이후 2 부터는 는 fibonacci(n-1) + fibonacci(n-1)를 재귀를 통해 구해서 더하도록 작성하면 된다.

 

코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
const fs = require('fs');
const input = fs.readFileSync('/dev/stdin').toString().split('\n');
 
const num = input[0]
 
console.log(fibonacci(num))
 
function fibonacci(n) {
  if(n == 0) {
    return 0
  } else if(n == 1) {
    return 1
  }
 
  return fibonacci(n-1+ fibonacci(n-2)
}
cs
반응형
반응형

문제

조규현과 백승환은 터렛에 근무하는 직원이다. 하지만 워낙 존재감이 없어서 인구수는 차지하지 않는다. 다음은 조규현과 백승환의 사진이다.

이석원은 조규현과 백승환에게 상대편 마린(류재명)의 위치를 계산하라는 명령을 내렸다. 조규현과 백승환은 각각 자신의 터렛 위치에서 현재 적까지의 거리를 계산했다.

조규현의 좌표 (x1, y1)와 백승환의 좌표 (x2, y2)가 주어지고, 조규현이 계산한 류재명과의 거리 r1과 백승환이 계산한 류재명과의 거리 r2가 주어졌을 때, 류재명이 있을 수 있는 좌표의 수를 출력하는 프로그램을 작성하시오.

입력

첫째 줄에 테스트 케이스의 개수 T가 주어진다. 각 테스트 케이스는 다음과 같이 이루어져 있다.

한 줄에 x1, y1, r1, x2, y2, r2가 주어진다. x1, y1, x2, y2는 -10,000보다 크거나 같고, 10,000보다 작거나 같은 정수이고, r1, r2는 10,000보다 작거나 같은 자연수이다.

출력

각 테스트 케이스마다 류재명이 있을 수 있는 위치의 수를 출력한다. 만약 류재명이 있을 수 있는 위치의 개수가 무한대일 경우에는 -1을 출력한다.

 

해설

이 문제는 테스트 케이스를 통과하더라도, 아래와 같은 이유로 틀리기가 쉽다.

 

1. 소수점 오차의 문제

2. 모든 케이스를 커버하지 못하는경우

 

특히 소수점 오차로 인하여 틀리는 경우가 많은 것 같은데, 이 문제는 제곱근을 취하지 않고

 

비교 대상을 제곱하여 비교연산을 한다면 정수형만으로 문제를 풀 수 있다.

 

문제를 푸는 핵심은 

 

* 두 점 사이의 거리와 r1, r2를 이용하여 두 원이 어떤 모양으로 접하는지를 파악

 

x1, y1과 x2,y2가 같은 점인 경우에는

 

r1, r2의 같다면 무수히 많은 점이 접하게 되고, 다른 경우 하나의 점도 만나지 않게 된다.

 

이 경우는 간단하기 때문에 그림으로 설명은 생략한다.

 

점이 다른 경우의  case들을 살펴보면 다음과 같다.

 

Case1 두 원이 외접하는 경우

 

두 원이 외접

 

외접하는 경우는 r1 + r1 가 두 점 사이의 거리와 같다.

 

Case2 두 원이 내접하는 경우

두 원이 내접하는 경우

두 원이 내접하는 경우에는 r2-r1의 값이 d와 같다.(단 여기서 r2는 r1, r2 중에 더 긴 값이다.)

하지만 코드상에서는 제곱을 하기때문에 r1, r2 중 누가 더 긴지 비교를 할 필요는 없다.

 

Case3 두 원이 두 점에서 만나는 경우

이 경우는 Case1과 Case2 사이에서 원이 존재라는 경우를 모두 포함하기 때문에 <, > 를 이용하여 구하면 된다.

 

Case4 두 원이 만나지 않는 경우

두 원이 만나지 않는 경우

 

위 Case 들을 고려하여 코드를 작성하면 아래와 같다.

 

단, 그림에서의 설명과는 다르게 거리의 제곱을 이용하여 비교를 하기 때문에 중간에 **2를 이용하여 제곱한 값을 사용한다.

코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
const fs = require('fs');
const input = fs.readFileSync('/dev/stdin').toString().split("\n");
// const input = ['7', '0 0 13 40 0 37', '0 0 3 0 7 4', '1 1 1 1 1 5', '40 0 37 0 0 13', '0 7 4 0 0 3', '1 1 5 1 1 1', '0 0 3000 4000 2500 2500']
 
 
const numOfInputs = parseInt(input[0]);
 
for(let i = 1; i <= numOfInputs; i++) {
  const [x1, y1, r1, x2, y2, r2] = input[i].split(" ").map(el => parseInt(el))
 
  const p1 = {x: x1, y: y1}
  const p2 = {x: x2, y: y2}
 
  // sqet(root)를 취하는 경우 소수점의 오차 때문에 비교가 힘들기 때문에 제곱된 값을 그대로 사용
  const squaredDistance = getSquaredDistance(p1, p2)
  console.log(findPointsCount(squaredDistance, r1, r2))
}
 
function getSquaredDistance(p1, p2) {
  return ((p1.x - p2.x) ** 2+ ((p1.y - p2.y) ** 2)
}
 
function findPointsCount(d, r1, r2) {
  const squaredSumR = (r1 + r2) ** 2
  const squaredDiffR = (r1 - r2) ** 2
 
  if(d == 0) {
    // 원점이 같을 때
    if(r1 == r2) return -1
    return 0
  } else {
    if(d > squaredSumR || d < squaredDiffR) {
      // Case4 : 0개일때
      return 0
    } else if(d == squaredDiffR || d == squaredSumR){
      // case 1,2: 1개일때(내접 또는 외접)
      return 1
    } else if(d < squaredSumR){
      // case 3: 2개일떄
      return 2
    }
  }
}
 
cs
반응형
반응형

문제

19세기 독일 수학자 헤르만 민코프스키는 비유클리드 기하학 중 택시 기하학을 고안했다.

택시 기하학에서 두 점 T1(x1,y1), T2(x2,y2) 사이의 거리는 다음과 같이 구할 수 있다.

D(T1,T2) = |x1-x2| + |y1-y2|

두 점 사이의 거리를 제외한 나머지 정의는 유클리드 기하학에서의 정의와 같다.

따라서 택시 기하학에서 원의 정의는 유클리드 기하학에서 원의 정의와 같다.

원: 평면 상의 어떤 점에서 거리가 일정한 점들의 집합

반지름 R이 주어졌을 때, 유클리드 기하학에서 원의 넓이와, 택시 기하학에서 원의 넓이를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 반지름 R이 주어진다. R은 10,000보다 작거나 같은 자연수이다.

출력

첫째 줄에는 유클리드 기하학에서 반지름이 R인 원의 넓이를, 둘째 줄에는 택시 기하학에서 반지름이 R인 원의 넓이를 출력한다. 정답과의 오차는 0.0001까지 허용한다.

 

해설

택시 기하학에서의 두 점 사이의 거리는

맨해튼 거리(Manhattan Distance)라고도 부른다.

맨해튼 거리의 원은 우리가 생각하는 동그라미 모양의 원이 아니다.

원의 정의를 이용하여 선을 그리면 기울어진 정 사각형 모양이 그려지는데, 원의 정의와는 일치한다.

원: 평면 상의 어떤 점에서 거리가 일정한 점들의 집합

즉, 거리의 정의가 달라지면서 원의 모양도 변하게 되는 것이다.

 

정리를 해보면

원의 넓이는 

유클리드계에서의 원의 넓이 = PI * r^2

맨해튼 거리를 이용한 원의 넓이 = 한변의 길이가 2 *r 인 직사각형의 넓이 = ( 2 *r)^2 = 2 * r ^2

이 된다.

 

코드

1
2
3
4
5
6
7
8
9
10
11
12
13
var fs = require('fs');
var input = fs.readFileSync('/dev/stdin').toString();
 
const PI = Math.PI
 
const r = parseInt(input);
 
// 원의 넓이
console.log((PI * r * r).toFixed(6))
 
// 택시 기하학, 맨하튼 거리 원의 넓이
console.log((2 * r * r).toFixed(6))
 
cs

 

반응형
반응형

https://chunghyup.tistory.com/50

 

[Pattern]Circuit Breaker Pattern - 회로 차단 패턴

MSA 방식의 아키텍쳐를 택한 서비스를 개발하는 중 아래와 같이 다른 MS(Micro Service)를 호출하는 경우는 상당히 많다. 1 2 const authService = new AuthService() authService.login(loginDto) cs 오류 처..

chunghyup.tistory.com

위 게시물과 연결되는 내용입니다.

 

JS를 이용하여 간다하게 Circuit Breaker를 구현해보았다.

 

몇번 실패를 하면 Open을 할 것인지, 몇 초 후 halfOpen으로 만들것인지 두가지 기능만 구현을 해 놓았다.

 

직접 사용하며 추가로 필요한 옵션이 필요하다면 기능을 추가 구현 하면 될 것 같다.

 

NPM에도 올려놓았는데, 사용 중 ISSUE가 발생해서 리포팅이 들어왔으면 좋겠다....

 

https://www.npmjs.com/package/super-simple-circuit-breaker

 

super-simple-circuit-breaker

Super Simple Circuit Breaker

www.npmjs.com

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
class SimpleCircuitBreaker {
 
  /**
   * 
   * @param {Object} options 
   * @param {number} options.retry number of retry count
   * @param {number} opeions.halfopenTime open time in millesec
   */
  constructor(options) {
    this[STATUS] = CIRCUIT_STATUS.CLOSED
    this[OPTIONS] = options
    this[FAILED_COUNT] = 0
  }
 
  getCurrentStatus() {
    return this[STATUS]
  }
 
  run = async (func) => {
    const isAsync = func.constructor.name === "AsyncFunction";
    if(!isAsync) {
      return Promise.reject(new Error('Function must be async function'));
    }
 
    if(this[STATUS] === CIRCUIT_STATUS.OPEN) {
      return Promise.reject(new Error('CIRCUIT OPEN'));
    }
 
    return new Promise(async (resolve, reject) => {
      try {
        const result = await func();
        this.handleSuccess();
        resolve(result);
      } catch (err) {
        this.handleFail();
        reject(err);
      }
    })
  }
 
  handleFail = () => {
    this[FAILED_COUNT]++;
    if (this[FAILED_COUNT] >= 3) {
      this[STATUS] = CIRCUIT_STATUS.OPEN;
      this.startTimer();
    }
  }
 
  handleSuccess = () => {
    if (this[STATUS] === CIRCUIT_STATUS.CLOSED) return
    
    this.reset()
  }
 
  startTimer () {
    this[HALFOPEN_TIMER] = setTimeout(() => {
      this[STATUS] = CIRCUIT_STATUS.HALFOPEN
    }, this[OPTIONS].halfopenTime);
  }
 
  reset() {
    clearTimeout(this[HALFOPEN_TIMER]);
    this[STATUS] = CIRCUIT_STATUS.CLOSED;
    this[FAILED_COUNT] = 0;
  }
 
}
cs
반응형
반응형

설명

RGB거리에 사는 사람들은 집을 빨강, 초록, 파랑중에 하나로 칠하려고 한다. 또한, 그들은 모든 이웃은 같은 색으로 칠할 수 없다는 규칙도 정했다. 집 i의 이웃은 집 i-1과 집 i+1이다.

각 집을 빨강으로 칠할 때 드는 비용, 초록으로 칠할 때 드는 비용, 파랑으로 드는 비용이 주어질 때, 모든 집을 칠할 때 드는 비용의 최솟값을 구하는 프로그램을 작성하시오.

 

입력

첫째 줄에 집의 수 N이 주어진다. N은 1,000보다 작거나 같다. 둘째 줄부터 N개의 줄에 각 집을 빨강으로 칠할 때, 초록으로 칠할 때, 파랑으로 칠할 때 드는 비용이 주어진다. 비용은 1,000보다 작거나 같은 자연수이다.

 

해설

 아래와 같이 집1, 집2, 집3인 경우의 R,G,B 페인트를 칠하는 비용이 있다고 가정한다.

Dynamic programming은 이전 계산값을 저장해서 다음 계산에 사용한다고 생각할 수 있다.

아래 그림을 보면 위에서 만든 자료구조를 가지고 같은 모양(열과 행이 같은) 자료구조를 만들어 자료를 업데이트 하는 것을 볼 수 있다.

업데이트를 하는 과정은 아래와 같다.

1. 각 샐은 현재 집을 해당 컬럼(R,G,B)로 칠했을때의 최소 비용이다.

2. 집2에 빨간색을 칠하는 경우 : 집2를 빨간색으로 칠하는 비용 + 최소값(집1을 초록색으로 칠하는 경우, 집 1을 파란색으로 칠하는 경우)

    집2에 파란색을 칠하는 경우 : 집2를 파란색으로 칠하는 비용 + 최소값(집1을 초록색으로 칠하는 경우, 집 1을 빨간으로 칠하는 경우)

위 2개의 규칙을 따라서 전체 셀을 업데이트 한다.

마지막까지의 최소비용을 구하면 해당 row에서 가장 최소인 값을 출력해주면된다.

 

코드

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
var fs = require('fs');
var input = fs.readFileSync('/dev/stdin').toString().split('\n');
 
// 입력값을 2중 배열로 저장해놓는다.
var numberOfHouses = parseInt(input[0]);
const costsForPainting = []
for(let i = 1; i <= numberOfHouses; i++) {
  costsForPainting.push(input[i].split(" ").map(el => parseInt(el)))
}
 
// 최솟값을 이용하여 계산하는 부분이 많이 때문에 최솟값을 구하는 함수를 미리 짜둔다
function min(list) {
  let min
  for(const num of list) {
    if(!min) {
      min = num
      continue
    }
    if(num < min) min = num
  }
  return min
}
 
// 그림에서 설명한것과 같이 2중 list를 만들어야 한다.
const minCostForPainting = []
for(let i = 0; i < numberOfHouses; i++) {
  // 첫번째 집에 경우 기존 입력값을 그대로 사용한다.
  if(i === 0) {
    minCostForPainting.push(costsForPainting[0])
    continue
  }
 
  // 현재 집(i)를 생상별로 칠할때의 최소 비용을 구한다.
  // 현재 집을 Red로 칠하는 경우 = 현재집을 red로 칠하는 비용 + 이전집을 green blue로 칠할때 비용 중 최소값.
  const currentHouseRedCost = costsForPainting[i][0+ min([minCostForPainting[i-1][1], minCostForPainting[i-1][2]])
  const currentHouseGreenCost = costsForPainting[i][1+ min([minCostForPainting[i-1][0], minCostForPainting[i-1][2]])
  const currentHouseBlueCost = costsForPainting[i][2+ min([minCostForPainting[i-1][0], minCostForPainting[i-1][1]])
 
  const currentMinCost = [currentHouseRedCost, currentHouseGreenCost, currentHouseBlueCost]
  minCostForPainting.push(currentMinCost)
}
console.log(min(minCostForPainting[minCostForPainting.length - 1]))
cs
반응형
반응형

문제

세 점이 주어졌을 때, 축에 평행한 직사각형을 만들기 위해서 필요한 네 번째 점을 찾는 프로그램을 작성하시오.

입력

세 점의 좌표가 한 줄에 하나씩 주어진다. 좌표는 1보다 크거나 같고, 1000보다 작거나 같은 정수이다.

출력

직사각형의 네 번째 점의 좌표를 출력한다.

해설

축에 평행한 직사각형을 만들기 위해서는 사실 두개의 점만 알고 있다면 직사각형을 그릴 수 있다.

 

직사각형의 시작점과 끝점 2개(그림에서 파란색 점 두개)만 안다면 직사각형을 그릴 수 있다.

 

(x1, y1) (x2,y2) 두개의 점을 안다고 하는 경우 아래와 같이 직사각형이 그려진다.

 

다시 문제로 넘어가면, 3개의 점을 알고 있다면 x1, y1, x2, y2 4개의 값을 모두 알 수 있다.

 

점 4개의 좌표값을 모으면 각자 2번씩 등장하기 때문에 우리는

 

3개의 점의 좌표값 중 1번만 등장하는 값을 찾으면 된다.

코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
var fs = require('fs');
var lines = fs.readFileSync('/dev/stdin').toString().split('\n');
var points = lines.map(lines => {
  const points = lines.split(" ").map(el => parseInt(el));
  return points
})
 
const xList = []
const yList = []
 
for(let point of points) {
  const xIndex = xList.findIndex(el => el === point[0])
  if(xIndex != -1) {
    xList.splice(xIndex, 1)
  } else {
    xList.push(point[0])
  }
 
  const yIndex = yList.findIndex(el => el === point[1])
  if(yIndex != -1) {
    yList.splice(yIndex, 1)
  } else {
    yList.push(point[1])
  }
}
 
console.log(`${xList[0]} ${yList[0]}`)
 
 
cs

 

 

반응형
반응형

문제

다음 소스는 N번째 피보나치 수를 구하는 C++ 함수이다.

1
2
3
4
5
6
7
8
9
10
11
int fibonacci(int n) {
    if (n == 0) {
        printf("0");
        return 0;
    } else if (n == 1) {
        printf("1");
        return 1;
    } else {
        return fibonacci(n‐1) + fibonacci(n‐2);
    }
}

fibonacci(3)을 호출하면 다음과 같은 일이 일어난다.

  • fibonacci(3)은 fibonacci(2)와 fibonacci(1) (첫 번째 호출)을 호출한다.
  • fibonacci(2)는 fibonacci(1) (두 번째 호출)과 fibonacci(0)을 호출한다.
  • 두 번째 호출한 fibonacci(1)은 1을 출력하고 1을 리턴한다.
  • fibonacci(0)은 0을 출력하고, 0을 리턴한다.
  • fibonacci(2)는 fibonacci(1)과 fibonacci(0)의 결과를 얻고, 1을 리턴한다.
  • 첫 번째 호출한 fibonacci(1)은 1을 출력하고, 1을 리턴한다.
  • fibonacci(3)은 fibonacci(2)와 fibonacci(1)의 결과를 얻고, 2를 리턴한다.

1은 2번 출력되고, 0은 1번 출력된다. N이 주어졌을 때, fibonacci(N)을 호출했을 때, 0과 1이 각각 몇 번 출력되는지 구하는 프로그램을 작성하시오.

 

입력

첫째 줄에 테스트 케이스의 개수 T가 주어진다.

각 테스트 케이스는 한 줄로 이루어져 있고, N이 주어진다. N은 40보다 작거나 같은 자연수 또는 0이다.

 

해설

문제는 재귀적으로 피보나치 수열 문제를 풀었을 때 f(n)은 f(1)과 f(0)을 각각 몇번씩 호출하게 되는가?로 해석이 가능하다.

f(2)는 f(1)을 1번, f(0)을 1번 호출한다.

f(3)은 f(2)를 1번, f(1)을 1번 호출한다. 따라서 f(2)각 f(1)과 f(0)을 각각 1번씩 호출하기 때문에 총 f(1) 2번 f(0) 1번 을 호출한다.

이러한 방식으로 f(1)을 호출하는 회수와  f(0)을 호출하는 회수를 위의 피보나치 코드와 매우 비슷한 형태로 풀 수 있다.

그림이 매우 별로이지만 zero라고 된 부분이 f(0)을 호출하는 회수이고 one 이 f(1)을 호출하는 회수이다.

이 각각은 zreo(n) = zero(n-1) + zero(n-2) 와 같이 풀면서 계속해서 더해간다면 f(n)에서의 f(0), f(1) 호출 회수를 구할 수 있다.

 

코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
var fs = require('fs');
var input = fs.readFileSync('/dev/stdin').toString().split('\n');
var cnt = input[0]
var inputlist = input.slice(1)
 
const countFibonacci = n => {
  const returnObj = {
    zeroCount: [10],
    oneCount: [0,1]
  }
 
  if (n <= 1) {
    return returnObj  
  }
 
  for (let i = 2; i < n+1; i++) {
    returnObj.zeroCount.push(returnObj.zeroCount[i-1+ returnObj.zeroCount[i-2])
    returnObj.oneCount.push(returnObj.oneCount[i-1+ returnObj.oneCount[i-2])
  }
 
  return returnObj
}
 
// 미리 40까지의 list를 생성
const cache = countFibonacci(40)
 
for(let i = 0; i < cnt; i++) {
  num = inputlist[i]
  console.log(`${cache.zeroCount[num]} ${cache.oneCount[num]}`)
}
cs

 

반응형
반응형

문제

한수는 지금 (x, y)에 있다. 직사각형은 각 변이 좌표축에 평행하고, 왼쪽 아래 꼭짓점은 (0, 0), 오른쪽 위 꼭짓점은 (w, h)에 있다. 직사각형의 경계선까지 가는 거리의 최솟값을 구하는 프로그램을 작성하시오.

 

첫째 줄에 x, y, w, h가 주어진다.

 

출력

첫째 줄에 문제의 정답을 출력한다.

제한

  • 1 ≤ w, h ≤ 1,000
  • 1 ≤ x ≤ w-1
  • 1 ≤ y ≤ h-1
  • x, y, w, h는 정수

 

해설

문제를 쉽게 풀어서 설명한다면

"직사각형 내부에 있는 점 (x,y)에서 직사각형의 변까지의 최소 거리" 를 구하는 문제이다.

결국 최솟값을 찾으면 되는 문제이다. 무엇중에 최소값을 구하는지만 생각하면 해결된다.

사각형이니까 변이 4개, 우리에게 주어진 점은 1개(x, y)

그렇다면 (x, y)에서 사각형 각 변까지의 거리 총 4개를 구하고 그중에 최솟값을 취하면 된다.

아래 코드는 4개의 거리값을 구하고, 정렬을 이용하여 최솟값을 구하는 코드이다.

 

코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var fs = require('fs');
var input = fs.readFileSync('/dev/stdin').toString().split(' ');
 
var [x, y, w, h] = input.map(el => parseInt(el));
 
 
//w, h 는 x, y보다 크기 떄문에 항상 양수
const xDiff = w-x
const yDiff = h-y
 
// 네개의 변수 중 최소값이 문제에서 하는 최소 거리이다.
const arr = [xDiff, yDiff, x, y]
// js의 기본 sort는 ascii 문자를 기준으로 정렬하기 때문에 반드시 비교함수를 넣어줘야한다.
arr.sort((a, b) => {
  return a - b
});
console.log(arr[0])
cs
반응형

+ Recent posts