function solution(num) {
if (num === 1)
return 0
let count = 0
for (let i=1; i<=500; i++) {
if (num%2 === 0) {
num = num/2
} else if (num%2 === 1) {
num = num*3 + 1
}
count++
if (num === 1) {
break
} else if (i === 500) {
return -1
}
}
return count;
}function solution(x) {
let answer = true;
let a = String(x)
let divisor = 0
for (let i=0; i<a.length; i++) {
divisor += Number(a[i])
}
if (x%divisor === 0) {
return true
} else {
return false
}
}배운 것
- join() 메소드를 쓰면 굳이 for loop을 돌리지 않아도 배열을 합친 문자열을 받을 수 있다.
- parseInt(value, 진수)는 value가 해당 진법 체계로 되어 있고, 이를 정수로 반환하라는 뜻이다
function solution(n) {
let num = n.toString(3).split('').reverse().join('')
return parseInt(num,3);
}function solution(sizes) {
for (let i=0; i<sizes.length; i++) {
if (sizes[i][0] < sizes[i][1]) {
sizes[i].reverse()
}
}
let w = sizes[0][0]
let h = sizes[0][1]
for (let i=1; i<sizes.length; i++) {
if (sizes[i][0] > w) {
w = sizes[i][0]
}
if (sizes[i][1] > h) {
h = sizes[i][1]
}
}
return w*h;
}구글링 후 답안
: 새 배열을 만들어서 조건을 충족하는 값만 배열에 추가하는게 배열의 숫자가 길어지고, 배열 내 같은 숫자가 많아질수록 효율적이다.
function solution(arr) {
let i = arr[0]
let answer = [i]
for (let j=1; j<arr.length; j++) {
if (i !== arr[j]) {
answer.push(arr[j])
i = arr[j]
}
}
return answer;
}구글링 전 답안
: 답은 제대로 나오는데 비교할때마다 배열을 수정하니까 효율성 측면에 문제가 있는지 채점기가 돌아가지 않았다.
function solution(arr) {
let answer = arr
let i = answer[0]
for (let j=1; j<answer.length; j++) {
if (i === answer[j]) {
answer.splice(j,1)
j--
} else {i = answer[j]}
}
return answer;
}function solution(numbers) {
let answer = []
for (let i=0; i<numbers.length-1; i++) {
for (let j=i+1; j<numbers.length; j++) {
if (answer.indexOf(numbers[i]+numbers[j]) === -1) {
answer.push(numbers[i]+numbers[j])
}
}
}
return answer.sort((a,b) => a-b)
} function solution(lottos, win_nums) {
let dangchum = 0
for (let i = 0; i < win_nums.length; i++) {
if (win_nums.indexOf(lottos[i]) !== -1) {
dangchum++
}
}
let min = dangchum
for (let i = 0; i < lottos.length; i++) {
if (lottos[i] === 0) {
for (let j = 0; j < win_nums.length; j++) {
if (lottos.indexOf(win_nums[j]) === -1) {
lottos[i] = win_nums[j]
dangchum++
break
}
}
}
}
let max = dangchum
let rank = [6,5,4,3,2,1]
let worst = rank.indexOf(min) + 1
if (worst === 0) {worst = 6}
let best = rank.indexOf(max) + 1
if (best === 0) {best = 6}
let answer = [best, worst]
return answer;
}내 답안
: 디버깅 하는 방법 배워서 오류 해결했더니 통과!! 모범 답안보다 효율성이 떨어지긴 하지만 효율성도 패스했다 ㅎㅎㅎ 테스트 환경의 중요성,, 으 근데 코드가 긴데 변수 이름도 기니까 나도 다시 읽기가 싫네,, 남들 코드 보면서 변수 이름 어떻게 쓰는지 좀 봐야겠당,,
: array of arrays를 sort 하는 방법을 배웠다!
function solution(answers) {
let num1 = [1, 2, 3, 4, 5]
let num2 = [2, 1, 2, 3, 2, 4, 2, 5,]
let num3 = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5]
let ans1 = []
let ans1_count = 0
for (let i = 0; i < answers.length; i++) {
let j = i
while (j >= num1.length) {
j = i % num1.length
}
ans1.push(num1[j])
if (ans1[i] === answers[i]) {
ans1_count++
}
}
let ans2 = []
let ans2_count = 0
for (let i = 0; i < answers.length; i++) {
let j = i
while (j >= num2.length) {
j = i % num2.length
}
ans2.push(num2[j])
if (ans2[i] === answers[i]) {
ans2_count++
}
}
let ans3 = []
let ans3_count = 0
for (let i = 0; i < answers.length; i++) {
let j = i
while (j >= num3.length) {
j = i % num3.length
}
ans3.push(num3[j])
if (ans3[i] === answers[i]) {
ans3_count++
}
}
let count_arr = [ans1_count, ans2_count, ans3_count]
let answer = [count_arr.indexOf(Math.max(ans1_count, ans2_count, ans3_count)) + 1]
let identical = []
let i = 0
for (let j = 1; j < count_arr.length; j++) {
let identical_score = [[1, ans1_count], [2, ans2_count], [3, ans3_count]]
identical_score.sort((a, b) => a[1] - b[1])
if (identical_score[i][1] !== 0) {
if (identical_score[i][1] === identical_score[j][1] && identical.indexOf(identical_score[i][0]) === -1) {
identical.push(identical_score[i][0])
identical.push(identical_score[j][0])
} else if (identical_score[i][1] === identical_score[j][1] && identical.indexOf(identical_score[i][0]) > -1) {
identical.push(identical_score[j][0])
}
}
i = j
}
if (identical.length === 0) {
return answer
} else {
return identical
}
}모범 답안
: 이 사람은 filter 메소드를 사용해 훨씬 짧게 했다! 콜백 function 내의 a는 element를 뜻하고, i는 element의 index를 뜻한다. answers의 해당 인덱스를 각 수포자 답안의 패턴 길이로 나눈 나머지를 활용해 따로 수포자 답안 배열을 만들지 않고 바로바로 비교하고, 필터링 된 것의 길이(정답수)만 저장했다. 이렇게 하면 메모리 측면에서 굉장히 효율적인듯,, ㄷㄷ 쩐다링
function solution(answers) {
let answer = [];
let a1 = [1, 2, 3, 4, 5];
let a2 = [2, 1, 2, 3, 2, 4, 2, 5]
let a3 = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5];
let a1c = answers.filter((a, i) => a === a1[i % a1.length]).length;
let a2c = answers.filter((a, i) => a === a2[i % a2.length]).length;
let a3c = answers.filter((a, i) => a === a3[i % a3.length]).length;
let max = Math.max(a1c, a2c, a3c);
if (a1c === max) {
answer.push(1)
}
;
if (a2c === max) {
answer.push(2)
}
;
if (a3c === max) {
answer.push(3)
}
;
return answer;
}