728x90

https://www.acmicpc.net/problem/1152

Code

https://github.com/DasolPark/Algorithm_JavaScript/commit/c81908a96f908c3376e82072963d96e52bcfd077

😢 문제를 보자마자 '이게 왜 정답 비율이 25%지?' 라고 생각하고 바로 풀었는데 틀렸다.
알아보니 ' '(space)만 들어오는 Test Case가 있어서 틀렸던 것이었다. 문제의 '예시 입력'에서 알려줬으면 더 좋았을 것 같다.

😊 if 조건문으로 '' 예외처리를 하였더니, 바로 정답. ' '(space)가 아니고 ''라는 것이 중요하다!
split(' ')을 사용하면, separator가 ' '(space)이기 때문에 입력값으로 ' '만 들어왔을 때 split된 array에는 [ '' ]만 들어가게 된다.
이 함정에 빠져서 다들 문제를 패스한 것 같다.

윗 줄을 Test 하기 위해 출력해보았다.


다른 풀이도 봤는데, 흠.. 조금 돌아가는 방법들이 많았다. length를 못 쓰는 경우가 없진 않을텐데..
웬만하면 다른 코드들도 참고해서 풀어보겠지만, 여기서는 개인적으로 필요성을 느끼지 못해 패스. 조금 더 생각해보자.

Full Code

// For submit
 
// const fs = require('fs');
// const input = fs
// .readFileSync('/dev/stdin')
// .toString()
// .trim()
// .split(' ');
 
// For Local Test
 
const example = 'The Curious Case of Benjamin Button\n';
// const example = ' ';
const input = example.trim().split(' ');
 
if (input[0] === '') {
console.log(0);
} else {
console.log(input.length);
}
728x90

https://www.acmicpc.net/problem/1065

Code

최종 제출 코드 https://github.com/DasolPark/Algorithm_JavaScript/blob/b9164f18301aec45680c44eeb204a6500f53bcdd/Baekjoon/1065.js
기존 제출 코드https://github.com/DasolPark/Algorithm_JavaScript/commit/95a24f7f1c0887af6d8a7e1a55e8533f0850150e

 

😢 '어떤 양의 정수 X의 자리수가 등차수열을 이룬다면'???? 지금 보면 별 것 아니지만, 처음 문제를 볼 때는 비슷한 문제를 풀어보지 못해서 그런지 이해하기 힘들었다. 문제 이해하는 것에 시간을 많이 보냈다.

😊 즉, 100미만의 수두 자릿수 또는 한 자릿수여서 등차수열을 확인할 수 없기 때문에 모두 '한수'가 된다.
그리고 세 자릿수부터 연속된 등차수열을 확인할 수 있다.
예를 들어, 우리에게 주어진 숫자 111을 백의 자리 1, 십의 자리1, 일의 자리1 하나씩 분리했다고 치자.
백의자리 1 - 십의자리 1 = 0 그리고 십의자리 1 - 일의자리 1 = 0 ( 1-1=0 === 1-1=0, true )
위처럼 연속된 두 개의 수 차이가 0으로 같다. 그렇다면 이건 한수이다.
그리고 1000은 '한수'가 아니다.

Solution 1) 기존 제출 코드
for loop안에서 100미만은 모두 한수로 count,
1000미만은 각 자릿수를 분리하여 Array에 넣고 각 자릿수 순서대로 빼주어 등차수열을 확인하였다.
만약 그 값이 한수라면 한수를 count해주었다. 그리고 1000은 한수가 아니기 때문에 else{ break; }으로 작성해주었다.

Solution 2) Other Solution
이 해결 방법은 다른 정답자의 답안을 참고하였다. 다른 방식으로 접근하였기 때문에 꼭 학습해두고 싶었다.
이 해결 방법에서는, classic for loop을 이용해서 function을 반복 호출하고 true값을 이용해 한수를 count해주었다.
특히, 세 자릿수가 들어오면 toString().split('').map을 이용해 Array로 만들어주고 값을 빼주어서 등차를 확인하였다.

Solution 3) 최종 제출 코드
Solution 2)의 개선 버전이다. for loop을 2번 사용하지 않고, function 안에서 한 번만 for loop을 사용했다.

자릿수를 다루는 문제와 직면할 때는, while을 이용하여 자릿수를 분리하거나
 문자열의 index를 이용하여 해결하곤 하는데, 항상 두 가지를 다 이용해보곤 한다.
프로그래밍은 한 가지 방법만 있지 않다는 게 가장 큰 매력인 것 같다.

Full Code

// Hansoo(category - function)
 
// 1st Solution
 
// For submit
 
// const fs = require('fs');
// const N = parseInt(fs.readFileSync('/dev/stdin').toString().trim());
 
function hansoo(N) {
const numArr = [];
let hansoo, digitCount;
let temp = 0;
 
for (let i = 1; i <= N; i++) {
if (i < 100) {
hansoo = i;
} else if (i < 1000) {
digitCount = 0;
temp = i;
while (temp > 0) {
numArr[digitCount] = temp % 10;
temp = parseInt(temp / 10);
digitCount++;
}
if (numArr[0] - numArr[1] === numArr[1] - numArr[2]) {
hansoo++;
}
} else {
break;
}
}
 
return hansoo;
}
 
// For Test
console.log(hansoo(110));
console.log(hansoo(1));
console.log(hansoo(210));
console.log(hansoo(1000));
 
// For submit
// console.log(hansoo(N));
 
// Other Solution(Solution 2)
 
// For submit
// const fs = require('fs');
// const N = parseInt(fs.readFileSync('/dev/stdin').toString().trim());
 
// For Test
// const N = 110;
 
// function findHansoo(N) {
// if (N < 100) {
// return true;
// } else {
// const numArr = N.toString()
// .split('')
// .map(num => {
// return parseInt(num);
// });
// if (numArr[0] - numArr[1] === numArr[1] - numArr[2]) {
// return true;
// }
// }
 
// return false;
// }
 
// let hansoo = 0;
// for (let i = 1; i <= N; i++) {
// if (findHansoo(i)) {
// hansoo++;
// }
// }
 
// console.log(hansoo);
 
// 2nd Solution
 
// For submit
 
// const fs = require('fs');
// const input = fs.readFileSync('/dev/stdin').toString().trim();
 
// For local test
// const input = '1000';
 
// function hanCheck(num) {
// num = parseInt(num);
// let counter = 0;
// for (let i = 1; i <= num; i++) {
// if (i < 100) {
// counter++;
// } else if (i < 1000) {
// let temp = i;
// let numArr = [];
// let index = 0;
// while (temp > 0) {
// numArr[index] = temp % 10;
// temp = parseInt(temp / 10);
// index++;
// }
// if (numArr[0] - numArr[1] === numArr[1] - numArr[2]) {
// counter++;
// }
// }
// }
// console.log(counter);
// }
 
// hanCheck(input);
 
// 3rd Solution(최종 제출 코드)
 
// For submit
 
// const fs = require('fs');
// const input = fs.readFileSync('/dev/stdin').toString().trim();
 
// For local test
// const input = '110';
// const N = parseInt(input);
 
// function hanCheck(N) {
// let hansoo = 0;
// for (let i = 1; i <= N; i++) {
// if (i < 100) {
// hansoo++;
// } else {
// const numArr = i
// .toString()
// .split('')
// .map(num => parseInt(num));
// if (numArr[0] - numArr[1] === numArr[1] - numArr[2]) {
// hansoo++;
// }
// }
// }
// console.log(hansoo);
// }
 
// hanCheck(N);
728x90

Q. 주어진 n만큼 1개씩 #(또는 *)을 계단모양으로 증가시켜라.
(n은 양수이며, 나머지 오른쪽 공백은 space로 입력)

--- Examples
steps(2)
'# '
'##'
steps(3)
'#  '
'## '
'###'
steps(4)
'#   '
'##  '
'### '
'####'

Code

https://github.com/DasolPark/Algorithm_DataStructure_JavaScript-Stephen-/blob/2d0c64627731b45be6d9e0dbc2492c894d2a5846/exercises/steps/index.js

😢 도형은 신기하다. 쉬워보이는데, 해보면 생각보다 쉽지는 않다. 특히, 재귀사용을 위해서는 재귀에 대한 높은 이해가 필요하다.

😊 Solution 1)
중첩 for loop을 이용해서 간단하게 해결이 가능하다.
직사각형 형태이기 때문에, 외부 for loop과 내부 for loop 모두 0부터 그리고 n보다 작을 때까지 index를 증가시키면 된다.
그리고 내부 for loop에서 column(열)이 row(행)보다 작거나 같으면 '#'을, 크다면 ' '을 대입해주면 된다.

Solution 2)
재귀적 용법으로 문제를 해결했다.

먼저 row=0, stair=''로 default를 선언해준다.
그리고 만약 n이 row(행)와 같다면 함수를 return;해준다.(n만큼 행을 출력했으니까 더 이상 출력할 필요 없음)
그리고 만약 값을 저장하는 stair의 길이가 n과 같으면 row(행)+1함수를 실행시켜준다.
(여기서 return을 필수적으로 해줘야한다. 해주지 않으면 밑으로 내려가 불필요한 재귀를 다시 실행해주기 때문이다)
그 밑으로는 Solution 1)과 마찬가지로 stair.length가 row보다 작거나 같으면 '#', 아니라면 ' '를 대입해준다.
(stair.length는 Solution 1)의 column을 대체한다) 그리고 steps(n, row, stair+add)를 재귀적으로 실행하면 된다.

Full Code

function steps(n, row = 0, stair = '') {
if (n === row) {
return;
}
 
if (n === stair.length) {
console.log(stair);
return steps(n, row + 1);
}
 
const add = stair.length <= row ? '#' : ' ';
steps(n, row, stair + add);
}
 
// function steps(n) {
// for (let row = 0; row < n; row++) {
// let stair = '';
 
// for (let column = 0; column < n; column++) {
// if (column <= row) {
// stair += '#';
// } else {
// stair += ' ';
// }
// }
 
// console.log(stair);
// }
// }
728x90

Q. 주어진 String(문장)에서 각 단어의 첫 알파벳을 대문자로 바꿔라.

--- Examples
capitalize('a short sentence') --> 'A Short Sentence'
capitalize('a lazy fox') --> 'A Lazy Fox'
capitalize('look, it is working!') --> 'Look, It Is Working!'

Code

https://github.com/DasolPark/Algorithm_DataStructure_JavaScript-Stephen-/blob/08ffc38c2f7b32b8baa35a6ecfc6c1d367559b1c/exercises/capitalize/index.js

😢 배열(Array)의 index을 이용해서 원초적 해결하려 했더니 조금 힘들었다.

😊 Solution 1)
입력받은 str을 split(' ')을 이용해 각 단어별로 나눠진 Array를 만들어주고,
for ... of loop 안에서 각 단어를 하나씩 가져와, 첫 번째 알파벳은 대문자로, 나머지 값은 slice(1)로 붙여주었다.
그리고 join(' ')을 이용해 다시 String(문장)으로 만들어 반환해주었다.

Solution 2)
classic for loop을 이용해 각 index의 앞(i-1)이 ' '(space)라면 해당 index(i)를 대문자로 변환하여 저장한다.
그게 아니라면, 해당 index(i)를 단순 저장해준다.

✔ toUpperCase()

소문자를 대문자로 변환해준다.

✔ split(' ')

String을 ' '(space)기준으로 나눠서 array에 저장해준다

✔ slice(1)

index 1부터 끝까지 모두 slice해준다

✔ for ... of

Array의 안에 있는 값을 index 순서대로 하나씩 가져온다

✔ join(' ')

' '(space)기준으로 Array를 String(문장)으로 합쳐준다

Full Code

function capitalize(str) {
let result = str[0].toUpperCase();
 
for (let i = 1; i < str.length; i++) {
if (str[i - 1] === ' ') {
result += str[i].toUpperCase();
} else {
result += str[i];
}
}
 
return result;
}
 
// function capitalize(str) {
// const words = [];
 
// for (let word of str.split(' ')) {
// words.push(word[0].toUpperCase() + word.slice(1));
// }
 
// return words.join(' ');
// }
728x90

Code

최종 제출 코드
기존 제출 코드

😢 무언가 원초적인 방법으로 풀었던 문제, 어떻게 풀어 나갈지에 대한 고민을 조금 했다.

😊 기존 제출 Solution) array를 선언하고, 모든 index 값을 0으로 초기화해준 후 Self Number가 아니라면 해당 index에 1을 넣어주었다.
그리고 마지막에 for loop의 i를 이용해 array[i]의 값이 1이 아니라면(=Self Number라면) Self Number인 i를 출력하도록 했다.

[추가] 최종 제출 Solution)
while loop 안에서 각 자릿수 나눠주기 + 나눠준 값 더하기를 진행하여 코드의 복잡도를 줄여줬다. 또한 시간도 더 빨라졌다.
그리고  배열 10000개 만큼 false로 채워주고, 셀프 넘버가 아니라면 true로 변경시켜주었다. 따라서 false로 남아있다면 그건 셀프 넘버다.


각 자릿수를 구하는 것은 매우 원초적인 방법으로 진행했다.
54321인 다섯 자리를 기준으로 설명하자면,
parseInt( 54321/10000 )(=5.4321)은 5
parseInt( (54321%10000) / 1000 )(=4.321)은 4
parseInt( (54321%1000) / 100 )(=3.21)은 3
parseInt( (54321%100) / 10 )(=2.1)은 2
54321 % 10 은 1
아래 Full Code에는 위의 자릿수 나누는 방식을, 다른 방법으로 접근한 Code가 있다.

✔ while loop을 이용한 자릿수 나누고, 바로 더하기

let temp = 나눌값;
let sum = temp;

while( 0 > temp){
sum += temp%10;
temp = parseInt(temp/10); }

또한, 다른 사람들이 푼 풀이가 매우 흥미로워서 그 방법들도 함께 연습했다. 세상에는 대단한 사람들이 참 많다.

Full Code (https://github.com/DasolPark/Dasol_JS_Algorithm/tree/master/Baekjoon)

// Self Number
 
// 4th Solution
 
const n = 10000;
const isSelfNum = new Array(n + 1);
isSelfNum.fill(true);
 
function d(n) {
const N = n.toString().split('');
 
return n + N.reduce((acc, num) => (acc += +num), 0);
}
 
for (let i = 1; i <= n; i++) {
isSelfNum[d(i)] = false;
}
 
for (let i = 1; i <= n; i++) {
if (isSelfNum[i]) {
console.log(i);
}
}
 
// 3rd Solution
 
// function d(n) {
// let temp = n;
// let sum = temp;
 
// while (temp > 0) {
// sum += temp % 10;
// temp = parseInt(temp / 10);
// }
 
// return sum;
// }
 
// const N = 10000;
// const selfNumCheckArr = new Array(N);
// selfNumCheckArr.fill(false);
 
// for (let i = 1; i <= N; i++) {
// selfNumCheckArr[d(i)] = true;
// if (!selfNumCheckArr[i]) {
// console.log(i);
// }
// }
 
// 1st solution
 
// const N = 10000;
// let arr = [];
 
// for (let i = 0; i <= N; i++) {
// d(i);
// }
 
// function d(n) {
// if (n < 10) {
// arr[n + n] = 1;
// } else if (n < 100) {
// arr[n + parseInt(n / 10) + (n % 10)] = 1;
// } else if (n < 1000) {
// arr[n + parseInt(n / 100) + parseInt((n % 100) / 10) + (n % 10)] = 1;
// } else if (n < 10000) {
// arr[
// n +
// parseInt(n / 1000) +
// parseInt((n % 1000) / 100) +
// parseInt((n % 100) / 10) +
// (n % 10)
// ] = 1;
// } else {
// arr[
// n +
// parseInt(n / 10000) +
// parseInt((n % 10000) / 1000) +
// parseInt((n % 1000) / 100) +
// parseInt((n % 100) / 10) +
// (n % 10)
// ] = 1;
// }
// }
 
// for (let i = 1; i <= N; i++) {
// if (!(arr[i] === 1)) {
// console.log(i);
// }
// }
 
// 2nd solution(string - array[index])
 
// const N = 10000;
// const arr = [];
 
// for (let i = 0; i <= N; i++) {
// arr[i] = 0;
// }
 
// for (let i = 1; i <= N; i++) {
// d(i);
// }
 
// function d(n) {
// const str = n.toString();
 
// if (n < 10) {
// arr[n + n] = 1;
// } else if (n < 100) {
// arr[n + parseInt(str[0]) + parseInt(str[1])] = 1;
// } else if (n < 1000) {
// arr[n + parseInt(str[0]) + parseInt(str[1]) + parseInt(str[2])] = 1;
// } else if (n < 10000) {
// arr[
// n +
// parseInt(str[0]) +
// parseInt(str[1]) +
// parseInt(str[2]) +
// parseInt(str[3])
// ] = 1;
// } else {
// arr[
// n +
// parseInt(str[0]) +
// parseInt(str[1]) +
// parseInt(str[2]) +
// parseInt(str[3]) +
// parseInt(str[4])
// ];
// }
// }
 
// for (let i = 1; i <= N; i++) {
// if (arr[i] === 0) {
// console.log(i);
// }
// }
728x90

Q. 주어진 array를 주어진 size만큼 잘라서 sub array로 넣어라.

--- Examples
chunk([1, 2, 3, 4], 2) --> [[ 1, 2], [3, 4]]
chunk([1, 2, 3, 4, 5], 2) --> [[ 1, 2], [3, 4], [5]]
chunk([1, 2, 3, 4, 5, 6, 7, 8], 3) --> [[ 1, 2, 3], [4, 5, 6], [7, 8]]
chunk([1, 2, 3, 4, 5], 4) --> [[ 1, 2, 3, 4], [5]]
chunk([1, 2, 3, 4, 5], 10) --> [[ 1, 2, 3, 4, 5]]

Code

https://github.com/DasolPark/Algorithm_DataStructure_JavaScript-Stephen-/blob/master/completed_exercises/chunk/index.js

😢 undefined 개념, 배열의 마지막 index를 지정하는 방법 그리고 slice를 활용하는 방법을 몰라서 많이 고민했다.

😊 Solution 1)
주어진 array 값을 for ... of를 통해 element로 하나씩 가져오고, 새로운 chunk array가 비어(undefined)있거나 size만큼 꽉차면 새로운 sub array를 push하고, 그게 아니라면 chunk array의 마지막 index sub array에 element를 push하여 해결한다.

Solution 2)
index를 size만큼 쌓아올리는 index 변수를 선언하여, slice(index, index + size); index += size; 를 while loop안에서 반복해준다. 그렇게하면 주어진 길이만큼 slice하여 sub array로 push할 수 있다.

✔ undefined 이용

!undefined는 true

✔ slice(begin, end)

시작부터 끝 전 index까지 array를 잘라준다.
(자세한 내용은 helper method 카테고리에서 확인 가능하다)

Full Code

function chunk(array, size) {
const chunked = [];
let index = 0;
 
while (index < array.length) {
chunked.push(array.slice(index, index + size));
index += size;
}
 
return chunked;
}
 
// function chunk(array, size) {
// const chunked = [];
//
// for (let element of array) {
// const last = chunked[chunked.length - 1];
//
// if (!last || last.length === size) {
// chunked.push([element]);
// } else {
// last.push(element);
// }
// }
//
// return chunked;
// }
728x90

https://www.acmicpc.net/problem/4344

Code

https://github.com/DasolPark/Algorithm_JavaScript/commit/54592b15a8664302e6d2c812440edabf9b417013

😢 5분 정도 고민하고, 코드로 하나씩 정리해 나가면서 금방 풀 수 있었던 문제

😊 전체 Test Case를 반복할 수 있는 for loop을 가장 바깥에서 돌리고, 중첩 첫 번째 for loop에서 점수를 모두 더해준 후 평균을 구한다. 그리고 중첩 두 번째 for loop에서 평균보다 높은 인원수를 구하고 비율을 계산해주고 출력한다.
평균을 어떻게 구할지, 평균을 넘는 인원은 몇명인지, 비율을 구하는 공식은 무엇인지 먼저 정리하고 풀어나가면 금방 해결할 수 있다.

Full Code

// 1st Solution
 
// For submit
// const fs = require('fs');
// const input = fs.readFileSync('/dev/stdin').toString().trim().split('\n');
 
// For local test
const input = [
'5',
'5 50 50 70 80 100',
'7 100 95 90 80 70 60 50',
'3 70 90 80',
'3 70 90 81',
'9 100 99 98 97 96 95 94 93 91'
];
 
const C = parseInt(input[0]);
 
for (let i = 1; i <= C; i++) {
const NAndGradeArr = input[i].trim().split(' ');
let totalGrade = 0;
let avg = 0;
let counter = 0;
let proportion = 0;
for (let j = 1; j <= parseInt(NAndGradeArr[0]); j++) {
totalGrade += parseInt(NAndGradeArr[j]);
}
 
avg = totalGrade / parseInt(NAndGradeArr[0]);
 
for (let k = 1; k <= parseInt(NAndGradeArr[0]); k++) {
if (parseInt(NAndGradeArr[k]) > avg) {
counter++;
}
}
 
proportion = (counter / parseInt(NAndGradeArr[0])) * 100;
console.log(proportion.toFixed(3) + '%');
}
// 비율 구하는 공식 : 비교량 / 기준량 * 100 (2 / 5 * 100)
 
// other solution (좀 특이해서 참고해보았다)
 
// var a = require('fs')
// .readFileSync('/dev/stdin')
// .toString()
// .match(/[^\r\n]+/g)
// .slice(1),
// b = a.map(function(x) {
// return x.split(' ');
// }),
// c = [],
// e = [];
// for (var i = 0; i <= b.length - 1; i++) {
// c.push(
// b[i].reduce(function(pre, cur) {
// return parseInt(pre) + parseInt(cur);
// }) /
// b[i][0] -
// 1
// );
 
// e.push(
// b[i].slice(1).filter(function(x) {
// return x > c[i];
// })
// );
 
// console.log(((e[i].length / b[i][0]) * 100).toFixed(3) + '%');
// }
728x90

Q. 주어진 2개의 String이 서로 Anagrams인지 확인하라 (Anagram - 철자 순서만 다르고, 같은 개수의 알파벳)
(단, 대문자, 공백 그리고 구두점은 제외한다)

--- Examples
anagrams('rail safety', 'fairy tales') --> True
anagrams('RAIL! SAFETY!', 'fairy tales') --> True
anagrams('Hi there', 'Bye there') --> False

Code

https://github.com/DasolPark/Algorithm_DataStructure_JavaScript-Stephen-/commit/2cf4631c1d09e038f0bf9827b710812d078c4023

😢 RegExp, Object.keys().length 스킬을 사용하게 될지 예상하기 힘들었다.

😊 Solution 1)
Map을 생성해주는 function을 만들고, Object.keys().length를 이용해 사용된 철자의 종류가 동일한지 확인하고, for ... in을 이용해 사용된 철자의 개수가 동일한지 확인하여 문제를 해결한다.
Solution 2)
순서를 정렬하는 function을 만들고, 그 결과가 서로 같은지 확인하는 방법을 이용해 문제를 해결한다.

위의 2가지 방법에서 가장 중요한 것은 replace(/[^\w]/g, '')을 이용해 대문자, 공백 그리고 구두점을 제거해주는 것이다.

✔ replace(/[^\w]/g, '')

알파벳 외 문자를 제거한다.

✔ toLowerCase()

대문자를 소문자로 바꿔준다

✔ split('')

String을 separator기준으로 Array로 나눠서 저장해준다

✔ sort()

Array의 순서를 UTF-16 기준으로 정렬해준다

✔ join()

Array를 separator기준으로 String으로 합쳐준다

✔ Object.keys()

Object의 key만 Array 형식으로 받아볼 수 있다. 따라서 옆에 .length를 사용해 길이를 받아볼 수 있다

 

Full Code

function anagrams(stringA, stringB) {
return cleanString(stringA) === cleanString(stringB);
}
 
function cleanString(str) {
return str
.replace(/[^\w]/g, '')
.toLowerCase()
.split('')
.sort()
.join('');
}
 
// function anagrams(stringA, stringB) {
// const aCharMap = buildCharMap(stringA);
// const bCharMap = buildCharMap(stringB);
//
// if (Object.keys(aCharMap).length !== Object.keys(bCharMap).length) {
// return false;
// }
//
// for (let char in aCharMap) {
// if (aCharMap[char] !== bCharMap[char]) {
// return false;
// }
// }
//
// return true;
// }
//
// function buildCharMap(str) {
// const charMap = {};
//
// for (let char of str.replace(/[^\w]/g, '').toLowerCase()) {
// charMap[char] = charMap[char] + 1 || 1;
// }
//
// return charMap;
// }
728x90

https://www.acmicpc.net/problem/8958

Code

https://github.com/DasolPark/Algorithm_JavaScript/commit/f1fa3910361f1978f2443cba1df1b851b055da38

😢 이번 문제는 꽤나 고민을 했다. 첫 풀이 때는, 중첩 for loop을 2번이나 써서 '1. 점수를 얻어내고 2. 점수를 계산하여' 출력 하였다. 
하지만 2번째 풀이에서(위의 코드)는 중첩 for loop 한 번으로 점수를 얻음과 동시에 출력하였다. 중첩 for loop을 한 개나 없앴다는 것에 만족한다. 대략 30분 정도 걸렸던 것 같다. 혼자 못 풀 문제는 아니었다.

😊 첫 번째 for {}안에 점수를 표시할 counter와 점수를 더할 eachSum을 선언하였다. 그리고 두 번째 for {}안에서 배열의 해당 index가 O라면 counter를 증가하며 eachSum에 계속 더하였고, X라면 counter가 다시 1로 시작하도록 초기화하였다.
두 번째 for {}이 끝난 후 한 줄의 OX점수를 합한 eachSum을 출력해주었다.

Full Code

 

// 1st Solution (submitted)
 
// const fs = require('fs');
// const input = fs.readFileSync('/dev/stdin').toString().trim().split('\n');
 
// For local test
 
const input = [
'5',
'OOXXOXXOOO',
'OOXXOOXXOO',
'OXOXOXOXOXOXOX',
'OOOOOOOOOO',
'OOOOXOOOOXOOOOX'
];
 
// 2nd Solution
 
const N = parseInt(input[0]);
 
for (let i = 1; i <= N; i++) {
let counter = 1;
let eachSum = 0;
for (let j = 0; j < input[i].length; j++) {
if (input[i][j] === 'O') {
eachSum += counter;
counter++;
} else {
counter = 1;
}
}
console.log(eachSum);
}
 
// 1st Solution
 
// const N = parseInt(input[0]);
// const result = [];
// let idx = 0;
 
// for (let i = 1; i <= N; i++) {
// let counter = 0;
// for (let j = 0; j < input[i].length; j++) {
// if (input[i][j] === 'O') {
// counter++;
// result.push(counter);
// } else {
// counter = 0;
// result.push(counter);
// }
// }
// }
 
// for (let i = 1; i <= N; i++) {
// let eachSum = 0;
// for (let j = 0; j < input[i].length; j++) {
// eachSum += result[idx];
// idx++;
// }
// console.log(eachSum);
// }
 
// other solution
 
// const N = parseInt(input[0]);
 
// for (let i = 0; i < N; i++) {
// let eachO = String(input[i + 1]).split('X');
// let sum = 0;
// for (let j = 0; j < eachO.length; j++) {
// for (let k = 1; k <= String(eachO[j]).length; k++) {
// sum += k;
// }
// }
// console.log(sum);
// }
728x90

Q. 주어진 Number가 3의 배수일 때는 'fizz', 5의 배수일 때는 'buzz', 3과 5의 배수일 때는 'fizzbuzz'를 출력하라.
(그 외 경우는 숫자로 출력)

--- Example
fizzBuzz(5);
1
2
fizz
4
buzz

Code

https://github.com/DasolPark/Algorithm_DataStructure_JavaScript-Stephen-/commit/4bee15d5862145024c21049efb37aeddc7c4ebd0

😢 classic for loop, %연산, &&(and)연산, if else 제어문으로 쉽게 해결 가능하다.

😊 주어진 n까지 for문을 반복하고, 숫자가 증가할 때마다 if else 구문으로 배수를 파악하여 출력하면 된다.
if else구문으로 작성할 때는 해당 조건이 true일 때, 그 구문만 실행하고 다시 for문이 반복된다는 것을 명심하자.

✔ &&(and)연산

양쪽의 결과가 모두 true일 때, 결과는 true
(||(or)연산은 둘 중에 하나만 true여도, 결과는 true)

✔ %연산

나머지는 구하는 연산, 3%3의 결과는? 0(나머지가 없음)

Full Code

function fizzBuzz(n) {
for (let i = 1; i <= n; i++) {
// Is the number a multiple of 3 and 5?
if (i % 3 === 0 && i % 5 === 0) {
console.log('fizzbuzz');
// Is the number a multiple of 3?
} else if (i % 3 === 0) {
console.log('fizz');
// Is the number a multiple of 5?
} else if (i % 5 === 0) {
console.log('buzz');
} else {
console.log(i);
}
}
}

+ Recent posts