Lv 1. ๋ชจ์๊ณ ์ฌ
๋ฌธ์
์ํฌ์๋ ์ํ์ ํฌ๊ธฐํ ์ฌ๋์ ์ค๋ง์ ๋๋ค. ์ํฌ์ ์ผ์ธ๋ฐฉ์ ๋ชจ์๊ณ ์ฌ์ ์ํ ๋ฌธ์ ๋ฅผ ์ ๋ถ ์ฐ์ผ๋ ค ํฉ๋๋ค. ์ํฌ์๋ 1๋ฒ ๋ฌธ์ ๋ถํฐ ๋ง์ง๋ง ๋ฌธ์ ๊น์ง ๋ค์๊ณผ ๊ฐ์ด ์ฐ์ต๋๋ค.
1๋ฒ ์ํฌ์๊ฐ ์ฐ๋ ๋ฐฉ์: 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ...
2๋ฒ ์ํฌ์๊ฐ ์ฐ๋ ๋ฐฉ์: 2, 1, 2, 3, 2, 4, 2, 5, 2, 1, 2, 3, 2, 4, 2, 5, ...
3๋ฒ ์ํฌ์๊ฐ ์ฐ๋ ๋ฐฉ์: 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, ...
1๋ฒ ๋ฌธ์ ๋ถํฐ ๋ง์ง๋ง ๋ฌธ์ ๊น์ง์ ์ ๋ต์ด ์์๋๋ก ๋ค์ ๋ฐฐ์ด answers๊ฐ ์ฃผ์ด์ก์ ๋, ๊ฐ์ฅ ๋ง์ ๋ฌธ์ ๋ฅผ ๋งํ ์ฌ๋์ด ๋๊ตฌ์ธ์ง ๋ฐฐ์ด์ ๋ด์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ ์กฐ๊ฑด
- ์ํ์ ์ต๋ 10,000 ๋ฌธ์ ๋ก ๊ตฌ์ฑ๋์ด์์ต๋๋ค.
- ๋ฌธ์ ์ ์ ๋ต์ 1, 2, 3, 4, 5์ค ํ๋์ ๋๋ค.
- ๊ฐ์ฅ ๋์ ์ ์๋ฅผ ๋ฐ์ ์ฌ๋์ด ์ฌ๋ฟ์ผ ๊ฒฝ์ฐ, returnํ๋ ๊ฐ์ ์ค๋ฆ์ฐจ์ ์ ๋ ฌํด์ฃผ์ธ์.
์ ๋ ฅ๊ฐ | ์ถ๋ ฅ๊ฐ |
[1, 2, 3, 4, 5] | [1] |
[1, 3, 2, 4, 2] | [1, 2, 3] |
(1) ๋์ ์ ๊ทผ ๋ฐฉ๋ฒ
function solution(answers) {
let answer = [];
let new_answer = [];
let count_1 = 0;
let count_2 = 0;
let count_3 = 0;
let max = 0;
// 1. 1๋ฒ, 2๋ฒ, 3๋ฒ ์ํฌ์ ์ฐ๋ ๋ฐฉ์ ๋ฐฐ์ด๋ก ์ ์ํ๋ค.
let first_arr = [1, 2, 3, 4, 5];
let second_arr = [2, 1, 2, 3 , 2, 4, 2, 5];
let third_arr = [3, 3, 1, 1, 2, 2 , 4, 4, 5, 5];
// 2. ์ฐ๋ ๋ฐฉ์ ๋ฐฐ์ด๊ณผ ์ ๋ต ๋ฐฐ์ด์ ๋น๊ตํ์ฌ ๋ง์ ๊ฐ์๋ฅผ ๋ฐํํ๋ค.
for (let i = 0; i < answers.length; i++) {
if (answers[i] == first_arr[i]) {
count_1++;
}
}
answer.push(count_1);
for (let i = 0; i < answers.length; i++) {
if (answers[i] == second_arr[i]) {
count_2++;
}
}
answer.push(count_2);
for (let i = 0; i < answers.length; i++) {
if (answers[i] == third_arr[i]) {
count_3++;
}
}
answer.push(count_3);
console.log(answer);
// 3. ๊ฐ์ฅ ๋์ ์ ์๋ฅผ ๋ฐ์ ์ฌ๋์ ๋ฐํํ๋ค.
for (let i = 0; i < answer.length; i++) {
if (max < answer[i]) {
max = answer[i];
}
}
console.log(max);
for (let i = 0; i < answer.length; i++) {
if (max == answer[i]) {
new_answer.push(i + 1);
}
}
new_answer.sort((a,b) => a - b);
return new_answer;
}
1. 1๋ฒ, 2๋ฒ, 3๋ฒ ์ํฌ์ ์ฐ๋ ๋ฐฉ์์ ๋ฐฐ์ด๋ก ์ ์ํ๋ค.
2. ์ฐ๋ ๋ฐฉ์ ๋ฐฐ์ด๊ณผ ์ ๋ต ๋ฐฐ์ด์ ๋น๊ตํ์ฌ ๋ง์ ๊ฐ์๋ฅผ ๋ฐํํ๋ค.
3. ์ต์ข ์ ์ผ๋ก ๊ฐ์ฅ ๋์ ์ ์๋ฅผ ๋ฐ์ ์ฌ๋์ ๋ฐํํ๋ค.
→ ํ ์คํธ์ผ์ด์ค๋ ๋ง์ท์ง๋ง ์ต์ข ์ ์ผ๋ก๋ 42.9/100 ์ด๋ผ๋ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ๊ฒ ๋์๋ค.
(2) ์ ๋ต ์ฝ๋ ๋ฐ ์ ๊ทผ ๋ฐฉ๋ฒ
function solution(answers) {
const answer = [];
// ์ํฌ์๋ค์ด ์ฐ๋ ๋ฐฉ์์ ํจํด(s1, s2, s3)๊ณผ ์ฑ์ ํ(score)๋ฅผ ๊ฐ๊ฐ ๋ฐฐ์ด๋ก ๋ณํ
const s1 = [1, 2, 3, 4, 5];
const s2 = [2, 1, 2, 3, 2, 4, 2, 5];
const s3 = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5];
const score = [0, 0, 0];
// ๋ฐฐ์ด answers๊ฐ ์ฃผ์ด์ก์ ๋, ๋ฌธ์ ๋ฅผ ๋งํ ํ์๋ฅผ ๊ฐ๊ฐ ์ฑ์ ํด score์ ์
๋ ฅ
for (let i = 0; i < answers.length; i++) {
if (s1[i % s1.length] === answers[i]) {
score[0]++;
}
if (s2[i % s2.length] === answers[i]) {
score[1]++;
}
if (s3[i % s3.length] === answers[i]) {
score[2]++;
}
}
// ์ฑ์ ๊ฒฐ๊ณผ, ๊ฐ์ฅ ๋ง์ ๋ฌธ์ ๋ฅผ ๋งํ ์ฌ๋์ ๋ฐฐ์ด์ ๋ด์ return
const max = Math.max(...score);
for (let j = 0; j < score.length; j++) {
if (score[j] === max) {
answer.push(j + 1);
}
}
return answer;
}
โ ๋ฐ๋ณต๋ฌธ์ i๋ฅผ ๊ฐ ๋ฐฐ์ด์ ๊ธธ์ด๋ก ๋๋ ๋๋จธ์ง๊ฐ answer ๋ฐฐ์ด๊ณผ ๊ฐ์ ๊ฒฝ์ฐ score ๋ฐฐ์ด์ ์ฆ๊ฐ์ํค๋ ๋ฐฉ๋ฒ์ผ๋ก ํ์ดํ์๋ค. ๊ทธ๋ฆฌ๊ณ ์ต์ข ์ ์ผ๋ก ์ต์ข ์ ์ผ๋ก ๊ฐ์ฅ ๋ง์ ๋ฌธ์ ๋ฅผ ๋ง์ถ ์ฌ๋์ score ๋ฐฐ์ด์ index๋ก answer ๋ฐฐ์ด์ push ํ๋ ๋ฐฉ๋ฒ์ผ๋ก ๊ฐ์ ๊ตฌํ๋ค.
(3) ๋ฌธ์ ๋ฅผ ํจ์จ์ ์ผ๋ก ํ์ง ๋ชปํ๋ ์ด์
โ ๋ฐฐ์ด๋ณ๋ก ๊ฐ๊ธฐ ๋ค๋ฅธ ๋ฐ๋ณต๋ฌธ์ผ๋ก ๋ง์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ค๊ณ ํ์๊ธฐ ๋๋ฌธ์ ํจ์จ์ฑ ์ธก๋ฉด์์ ๋ถ์กฑํ ์ ์ด ์์๋ค.
ํด๊ฒฐ ๋ฐฉ์
(1) ๋ฐ๋ณต๋ฌธ์ i ์ ๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ๋๋ ๋๋จธ์ง๋ก ํ ๋ฒ์ ๋ฐฐ์ด์ index ๋ฅผ ์ง์ ํ ์ ์์์ ๊ธฐ์ตํ๊ธฐ
(2) let score = [0, 0, 0]; ๊ณผ ๊ฐ์ด index์ ๊ฐ์๋ฅผ ๊ณ ์ ํ์ฌ ์์ฑํ๋ ๋น ๋ฐฐ์ด ์ ๊ทน์ ์ผ๋ก ํ์ฉํ๊ธฐ
(3) Math.max ์ ๋ํ ์ ํํ ์ดํด
โป Math.max
- ์ ๋ ฅ๊ฐ์ผ๋ก ๋ฐ์ 0๊ฐ ์ด์์ ์ซ์ ์ค ๊ฐ์ฅ ํฐ ์ซ์๋ฅผ ๋ฐํํ๋ค.
// ๋ฐฐ์ด ์ ์ธํ์ง ์๊ณ ์ง์ ์ซ์ ๋น๊ต
console.log(Math.max(1, 3, 2)); // output: 3
// ๋ฐฐ์ด ์ ์ธ ํ ๋น๊ต
arr = [23, 24, 25];
console.log(Math.max(...arr)); // output: 25