주차장의 요금표와 차량이 들어오고(입차) 나간(출차) 기록이 주어졌을 때, 차량별로 주차 요금을 계산하려고 합니다. 아래는 하나의 예시를 나타냅니다.
요금표
기본 시간(분) | 기본 요금(원) | 단위 시간(분) | 단위 요금(원) |
---|---|---|---|
180 | 5000 | 10 | 600 |
시간(시:분) | 차량 번호 | 내역 |
---|---|---|
05:34 | 5961 | 입차 |
06:00 | 0000 | 입차 |
06:34 | 0000 | 출차 |
07:59 | 5961 | 출차 |
07:59 | 0148 | 입차 |
18:59 | 0000 | 입차 |
19:09 | 0148 | 출차 |
22:59 | 5961 | 입차 |
23:00 | 5961 | 출차 |
자동차 주차별 주차 요금
어떤 차량이 입차된 후에 출차된 내역이 없다면, 23:59에 출차된 것으로 간주합니다.
00:00부터 23:59까지의 입/출차 내역을 바탕으로 차량별 누적 주차 시간을 계산하여 요금을 일괄로 정산합니다.
누적 주차 시간이 기본 시간
이하라면, 기본 요금
을 청구합니다.
누적 주차 시간이 기본 시간
을 초과하면, 기본 요금
에 더해서, 초과한 시간에 대해서 단위 시간
마다 단위 요금
을 청구합니다.
단위 시간
으로 나누어 떨어지지 않으면, 올림
합니다.⌈
a⌉
: a보다 작지 않은 최소의 정수를 의미합니다. 즉, 올림
을 의미합니다.주차 요금을 나타내는 정수 배열 fees
, 자동차의 입/출차 내역을 나타내는 문자열 배열 records
가 매개변수로 주어집니다. 차량 번호가 작은 자동차부터 청구할 주차 요금을 차례대로 정수 배열에 담아서 return 하도록 solution 함수를 완성해주세요.
제한사항
fee
의 길이 = 4기본 시간(분)
기본 요금(원)
단위 시간(분)
단위 요금(원)
records
의 길이 ≤ 1,000records
의 각 원소는 "시각 차량번호 내역"
형식의 문자열입니다.시각
, 차량번호
, 내역
은 하나의 공백으로 구분되어 있습니다.시각
은 차량이 입차되거나 출차된 시각을 나타내며, HH:MM
형식의 길이 5인 문자열입니다.HH:MM
은 00:00부터 23:59까지 주어집니다.차량번호
는 자동차를 구분하기 위한, '0'~'9'로 구성된 길이 4인 문자열입니다.내역
은 길이 2 또는 3인 문자열로, IN
또는 OUT
입니다. IN
은 입차를, OUT
은 출차를 의미합니다.records
의 원소들은 시각을 기준으로 오름차순으로 정렬되어 주어집니다.records
는 하루 동안의 입/출차된 기록만 담고 있으며, 입차된 차량이 다음날 출차되는 경우는 입력으로 주어지지 않습니다.function solution(fees, records) {
let answer = [];
const carRecords = new Map();
const parkingTimes = new Map();
const getParkingTime = function(inTime, outTime) {
let [inHour, inMinute] = inTime.split(':').map((time) => +time);
let [outHour, outMinute] = outTime.split(':').map((time) => +time);
const totalInTime = inHour * 60 + inMinute;
const totalOutTime = outHour * 60 + outMinute;
const parkingTime = totalOutTime - totalInTime;
return parkingTime;
}
records.forEach((record) => {
const [time, car, sign] = record.split(' ');
const timeLog = carRecords.get(car);
if (timeLog) {
const parkingTime = getParkingTime(timeLog, time);
const parkLog = parkingTimes.get(car);
parkLog ? parkingTimes.set(car, parkLog + parkingTime) : parkingTimes.set(car, parkingTime);
carRecords.set(car, null);
} else {
carRecords.set(car, time);
}
});
for (const [car, time] of carRecords.entries()) {
if (time == null) continue;
const parkingTime = getParkingTime(time, "23:59");
const parkingLog = parkingTimes.get(car);
parkingLog ? parkingTimes.set(car, parkingLog + parkingTime) : parkingTimes.set(car, parkingTime);
}
const [baseTime, baseFee, unitTime, unitFee] = fees;
const timeArr = Array.from(parkingTimes.keys()).sort((a, b) => a - b);
timeArr.forEach((car) => {
const time = parkingTimes.get(car);
if (time <= baseTime) {
answer.push(baseFee);
return;
}
const overTime = Math.ceil((time - baseTime) / unitTime);
const totalFee = baseFee + overTime * unitFee;
answer.push(totalFee);
})
return answer;
}
개발자를 희망하는 죠르디가 카카오에 면접을 보러 왔습니다.
코로나 바이러스 감염 예방을 위해 응시자들은 거리를 둬서 대기를 해야하는데 개발 직군 면접인 만큼, 아래와 같은 규칙으로 대기실에 거리를 두고 앉도록 안내하고 있습니다.
5개의 대기실을 본 죠르디는 각 대기실에서 응시자들이 거리두기를 잘 기키고 있는지 알고 싶어졌습니다. 자리에 앉아있는 응시자들의 정보와 대기실 구조를 대기실별로 담은 2차원 문자열 배열 places
가 매개변수로 주어집니다. 각 대기실별로 거리두기를 지키고 있으면 1
을, 한 명이라도 지키지 않고 있으면 0
을 배열에 담아 return 하도록 solution 함수를 완성해 주세요.
제한사항
places
의 행 길이(대기실 개수) = 5places
의 각 행은 하나의 대기실 구조를 나타냅니다.places
의 열 길이(대기실 세로 길이) = 5places
의 원소는 P
,O
,X
로 이루어진 문자열입니다.places
원소의 길이(대기실 가로 길이) = 5P
는 응시자가 앉아있는 자리를 의미합니다.O
는 빈 테이블을 의미합니다.X
는 파티션을 의미합니다.places
에 담겨 있는 5개 대기실의 순서대로, 거리두기 준수 여부를 차례대로 배열에 담습니다.1
을, 한 명이라도 지키지 않고 있으면 0
을 담습니다.입출력 예
첫 번째 대기실
No. | 0 | 1 | 2 | 3 | 4 |
---|---|---|---|---|---|
0 | P | O | O | O | X |
1 | O | X | X | O | X |
2 | O | P | X | P | X |
3 | O | O | X | O | X |
4 | P | O | X | X | P |
No. | 0 | 1 | 2 | 3 | 4 |
---|---|---|---|---|---|
0 | P | O | O | P | X |
1 | O | X | P | X | P |
2 | P | X | X | X | O |
3 | O | X | X | X | O |
4 | O | O | O | P | P |
No. | 0 | 1 | 2 | 3 | 4 |
---|---|---|---|---|---|
0 | P | X | O | P | X |
1 | O | X | O | X | P |
2 | O | X | P | O | X |
3 | O | X | X | O | P |
4 | P | X | P | O | X |
No. | 0 | 1 | 2 | 3 | 4 |
---|---|---|---|---|---|
0 | O | O | O | X | X |
1 | X | O | O | O | X |
2 | O | O | O | X | X |
3 | O | X | O | O | X |
4 | O | O | O | O | O |
No. | 0 | 1 | 2 | 3 | 4 |
---|---|---|---|---|---|
0 | P | X | P | X | P |
1 | X | P | X | P | X |
2 | P | X | P | X | P |
3 | X | P | X | P | X |
4 | P | X | P | X | P |
function solution(places) {
let answer = [];
const size = 5;
const dx = [-1, 0, 1, 0];
const dy = [0, 1, 0, -1];
function isOutBoundary(x, y) {
return x < 0 || x >= size || y < 0 || y >= size;
}
function checkDistance(place) {
let placeArr = place.map((row) => row.split(''));
let queue = [];
for (let i = 0; i < size; i++) {
for (let j = 0; j < size; j++) {
if (placeArr[i][j] === 'P') {
queue.push([i, j]);
}
}
}
while (queue.length) {
const [x, y] = queue.shift();
for (let i = 0; i < size - 1; i++) {
let nx1 = x + dx[i];
let ny1 = y + dy[i];
if (isOutBoundary(nx1, ny1)) continue;
if (placeArr[nx1][ny1] === 'X') continue;
if (placeArr[nx1][ny1] === 'P') return 0;
for (let j = 0; j < size - 1; j++) {
let nx2 = nx1 + dx[j];
let ny2 = ny1 + dy[j];
if (isOutBoundary(nx2, ny2)) continue;
if (nx2 === x && ny2 === y) continue;
if (placeArr[nx2][ny2] === 'P') return 0;
}
}
}
return 1;
}
places.forEach((place) => {
answer.push(checkDistance(place));
});
return answer;
}
이 전화 키패드에서 왼손과 오른손의 엄지손가락만을 이용해서 숫자만을 입력하려고 합니다.
맨 처음 왼손 엄지손가락은 *
키패드에 오른손 엄지손가락은 #
키패드 위치에서 시작하며, 엄지손가락을 사용하는 규칙은 다음과 같습니다.
1. 엄지손가락은 상하좌우 4가지 방향으로만 이동할 수 있으며 키패드 이동 한 칸은 거리로 1에 해당합니다.
2. 왼쪽 열의 3개의 숫자 1
, 4
, 7
을 입력할 때는 왼손 엄지손가락을 사용합니다.
3. 오른쪽 열의 3개의 숫자 3
, 6
, 9
를 입력할 때는 오른손 엄지손가락을 사용합니다.
4. 가운데 열의 4개의 숫자 2
, 5
, 8
, 0
을 입력할 때는 두 엄지손가락의 현재 키패드의 위치에서 더 가까운 엄지손가락을 사용합니다.
4-1. 만약 두 엄지손가락의 거리가 같다면, 오른손잡이는 오른손 엄지손가락, 왼손잡이는 왼손 엄지손가락을 사용합니다.
순서대로 누를 번호가 담긴 배열 numbers
, 왼손잡이인지 오른손잡이인 지를 나타내는 문자열 hand
가 매개변수로 주어질 때, 각 번호를 누른 엄지손가락이 왼손인 지 오른손인 지를 나타내는 연속된 문자열 형태로 return 하도록 solution 함수를 완성해주세요.
제한사항
"left"
또는 "right"
입니다."left"
는 왼손잡이, "right"
는 오른손잡이를 의미합니다.L
, 오른손 엄지손가락을 사용한 경우는 R
을 순서대로 이어붙여 문자열 형태로 return 해주세요.입출력 예
- 입력 : numbers = [1, 3, 4, 5, 8, 2, 1, 4, 5, 9, 5], hand = "right"
입출력 설명
왼손 위치 | 오른손 위치 | 눌러야할 숫자 | 사용한 손 | 설명 |
---|---|---|---|---|
* | # | 1 | L | 1은 왼손으로 누름 |
1 | # | 3 | R | 3은 오른손으로 누름 |
1 | 3 | 4 | L | 4는 왼손으로 누름 |
4 | 3 | 5 | L | 왼손 거리는 1, 오른손 거리는 2이므로 왼손으로 5를 누름 |
5 | 3 | 8 | L | 왼손 거리는 1, 오른손 거리는 3이므로 왼손으로 8을 누름 |
8 | 3 | 2 | R | 왼손 거리는 2, 오른손 거리는 1이므로 오른손으로 2를 누름 |
8 | 2 | 1 | L | 1은 왼손으로 누름 |
1 | 2 | 4 | L | 4는 왼손으로 누름 |
4 | 2 | 5 | R | 왼손 거리와 오른손 거리가 1로 같으므로, 오른손으로 5를 누름 |
4 | 5 | 9 | R | 9는 오른손으로 누름 |
4 | 9 | 5 | L | 왼손 거리는 1, 오른손 거리는 2이므로 왼손으로 5를 누름 |
5 | 9 | - | - |
function solution(numbers, hand) {
let answer = '';
let left = 10;
let right = 12;
const lines = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]];
const getDistance = (start, end) => {
let startLineIndex, startNumIndex, endLineIndex, endNumIndex;
lines.forEach((line, lineIndex) => {
line.forEach((num, numIndex) => {
if (num === start) {
startLineIndex = lineIndex;
startNumIndex = numIndex;
}
if (num === end) {
endLineIndex = lineIndex;
endNumIndex = numIndex;
}
});
});
const distance = Math.abs(startLineIndex - endLineIndex) + Math.abs(startNumIndex - endNumIndex);
return distance;
}
numbers.forEach((num) => {
const moveLeft = () => {
answer += 'L';
left = num;
}
const moveRight = () => {
answer += 'R';
right = num;
}
if (num === 1 || num === 4 || num === 7) {
return moveLeft();
}
if (num === 3 || num === 6 || num === 9) {
return moveRight();
}
if (num === 2 || num === 5 || num === 8 || num === 0) {
if (num === 0) {
num = 11;
}
const leftDistance = getDistance(left, num);
const rightDistance = getDistance(right, num);
if (leftDistance < rightDistance) {
return moveLeft();
}
if (leftDistance > rightDistance) {
return moveRight();
}
if (leftDistance === rightDistance) {
return hand === 'left' ? moveLeft() : moveRight();
}
}
});
return answer;
}
info
, 2진 트리의 각 노드들의 연결 관계를 담은 2차원 배열 edges
가 매개변수로 주어질 때, 문제에 제시된 조건에 따라 각 노드를 방문하면서 모을 수 있는 양은 최대 몇 마리인지 return 하도록 solution 함수를 완성해주세요.info
의 길이 ≤ 17info
의 원소는 0
또는 1
입니다.info[i]
는 i번 노드에 있는 양 또는 늑대를 나타냅니다.0
은 양, 1
은 늑대를 의미합니다.info[0]
의 값은 항상 0
입니다. 즉, 0번 노드(루트 노드)에는 항상 양이 있습니다.edges
의 세로(행) 길이 = info의 길이 - 1edges
의 가로(열) 길이 = 2edges
의 각 행은 [부모 노드 번호, 자식 노드 번호] 형태로, 서로 연결된 두 노드를 나타냅니다.function solution(info, edges) {
let answer = 0;
const graph = Array.from({length: info.length}, () => []);
edges.forEach(([parent, child]) => {
graph[parent].push(child);
});
function dfs(currentNode, sheepCount, wolfCount, possible) {
let newPossibles = [...possible];
let currentIndex = newPossibles.indexOf(currentNode);
info[currentNode]? wolfCount++ : sheepCount++;
answer = Math.max(answer, sheepCount);
if (sheepCount === wolfCount) return;
newPossibles.push(...graph[currentNode]);
newPossibles.splice(currentIndex, 1);
for (const nextNode of newPossibles) {
dfs(nextNode, sheepCount, wolfCount, newPossibles);
}
}
dfs(0,0,0,[0]);
return answer;
}
어느 날 스트레스를 풀기 위해 보석 매장에 쇼핑을 하러 간 어피치는 이전처럼 진열대의 특정 범위의 보석을 모두 구매하되 특별히 아래 목적을 달성하고 싶었습니다.
진열대 번호 순서대로 보석들의 이름이 저장된 배열 gems
가 매개변수로 주어집니다. 이때 모든 보석을 하나 이상 포함하는 가장 짧은 구간을 찾아서 return 하도록 solution 함수를 완성해주세요.
가장 짧은 구간의 시작 진열대 번호와 끝 진열대 번호를 차례대로 배열에 담아서 return 하도록 하며, 만약 가장 짧은 구간이 여러 개라면 시작 진열대 번호가 가장 작은 구간을 return 합니다.
제한사항
gems
배열의 크기는 1 이상 100,000 이하입니다.gems
배열의 각 원소는 진열대에 나열된 보석을 나타냅니다.gems
배열에는 1번 진열대부터 진열대 번호 순서대로 보석이름이 차례대로 저장되어 있습니다.gems
배열의 각 원소는 길이가 1 이상 10 이하인 알파벳 대문자로만 구성된 문자열입니다.function solution(gems) {
let answer = [0, Infinity];
const gemCount = new Set(gems).size;
const gemMap = new Map();
for (let i = 0; i < gems.length; i++) {
gemMap.delete(gems[i]);
gemMap.set(gems[i], i);
if (gemMap.size === gemCount) {
const startIndex = gemMap.values().next().value;
const endIndex = i;
if (endIndex - startIndex < answer[1] - answer[0]) {
answer = [startIndex + 1, endIndex + 1];
}
gemMap.delete(gems[startIndex]);
}
}
return answer;
}
길이가 같은 두 개의 큐가 주어집니다. 하나의 큐를 골라 원소를 추출(pop)하고, 추출된 원소를 다른 큐에 집어넣는(insert) 작업을 통해 각 큐의 원소 합이 같도록 만들려고 합니다. 이때 필요한 작업의 최소 횟수를 구하고자 합니다. 한 번의 pop과 한 번의 insert를 합쳐서 작업을 1회 수행한 것으로 간주합니다.
큐는 먼저 집어넣은 원소가 먼저 나오는 구조입니다. 이 문제에서는 큐를 배열로 표현하며, 원소가 배열 앞쪽에 있을수록 먼저 집어넣은 원소임을 의미합니다. 즉, pop을 하면 배열의 첫 번째 원소가 추출되며, insert를 하면 배열의 끝에 원소가 추가됩니다. 예를 들어 큐 [1, 2, 3, 4]가 주어졌을 때, pop을 하면 맨 앞에 있는 원소 1이 추출되어 [2, 3, 4]가 되며, 이어서 5를 insert하면 [2, 3, 4, 5]가 됩니다.
두 큐에 담긴 모든 원소의 합은 30입니다. 따라서, 각 큐의 합을 15로 만들어야 합니다. 예를 들어, 다음과 같이 2가지 방법이 있습니다.
따라서 각 큐의 원소 합을 같게 만들기 위해 필요한 작업의 최소 횟수는 2입니다.
길이가 같은 두 개의 큐를 나타내는 정수 배열 queue1
, queue2
가 매개변수로 주어집니다. 각 큐의 원소 합을 같게 만들기 위해 필요한 작업의 최소 횟수를 return 하도록 solution 함수를 완성해주세요. 단, 어떤 방법으로도 각 큐의 원소 합을 같게 만들 수 없는 경우, -1
을 return 해주세요.
제한사항
queue1
의 길이 = queue2
의 길이 ≤ 300,000queue1
의 원소, queue2
의 원소 ≤ 10^9function solution(queue1, queue2) {
let answer = -1;
let sum1 = 0;
let sum2 = 0;
for (let i = 0; i < queue1.length; i++) {
sum1 += queue1[i];
sum2 += queue2[i];
}
const target = (sum1 + sum2) / 2;
const totalQueue = [...queue1, ...queue2];
let pointer1 = 0;
let pointer2 = queue1.length;
const end = queue1.length * 3;
for (let count = 0; count < end; count++) {
if (sum1 === target) {
return count;
}
if (sum1 > target) {
sum1 -= totalQueue[pointer1++];
} else {
sum1 += totalQueue[pointer2++];
}
}
return -1;
}
N
x M
크기의 행렬 모양의 게임 맵이 있습니다. 이 맵에는 내구도를 가진 건물이 각 칸마다 하나씩 있습니다. 적은 이 건물들을 공격하여 파괴하려고 합니다. 건물은 적의 공격을 받으면 내구도가 감소하고 내구도가 0이하가 되면 파괴됩니다. 반대로, 아군은 회복 스킬을 사용하여 건물들의 내구도를 높이려고 합니다.최종적으로 총 10개의 건물이 파괴되지 않았습니다.
건물의 내구도를 나타내는 2차원 정수 배열 board
와 적의 공격 혹은 아군의 회복 스킬을 나타내는 2차원 정수 배열 skill
이 매개변수로 주어집니다. 적의 공격 혹은 아군의 회복 스킬이 모두 끝난 뒤 파괴되지 않은 건물의 개수를 return하는 solution함수를 완성해 주세요.
제한사항
board
의 행의 길이 (= N
) ≤ 1,000board
의 열의 길이 (= M
) ≤ 1,000board
의 원소 (각 건물의 내구도) ≤ 1,000skill
의 행의 길이 ≤ 250,000skill
의 열의 길이 = 6skill
의 각 행은 [type, r1, c1, r2, c2, degree]
형태를 가지고 있습니다.board
의 행의 길이board
의 열의 길이정확성 테스트 케이스 제한 사항
board
의 행의 길이 (= N
) ≤ 100board
의 열의 길이 (= M
) ≤ 100board
의 원소 (각 건물의 내구도) ≤ 100skill
의 행의 길이 ≤ 100function solution(board, skill) {
skill.forEach(([type, r1, c1, r2, c2, degree]) => {
for (let r = r1; r <= r2; r++) {
for (let c = c1; c <= c2; c++) {
if (type === 1) {
board[r][c] -= degree;
continue;
}
board[r][c] += degree;
}
}
});
answer = board.reduce((totalRuinedBuildings, rowBuildings) => {
totalRuinedBuildings += rowBuildings.filter((durability) => durability > 0).length;
return totalRuinedBuildings;
}, 0);
return answer;
}
a번째부터 b번째 구간의 합
- sum_arr[b] = arr[0] + arr[1] + ... + arr[a-1] + arr[a] + arr[a+1] + ... + arr[b]
- sum_arr[a-1] = arr[0] + arr[1] + ... + arr[a-1]
- sum_arr[b] - sum_arr[a-1] = arr[a] + arr[a+1] + ... + arr[b]
1차원 누적합
1차원 누적합 예
a | -a | |||||
---|---|---|---|---|---|---|
a | a | a | a | a-a | ||
a | a | a | a |
a | b | c | -a | -b | -c | |
---|---|---|---|---|---|---|
a | a+b | a+b+c | a+b+c-a | b+c-b | c-c | |
a | a+b | a+b+c | b+c | c |
function solution(board, skill) {
let answer = 0;
const N = board.length;
const M = board[0].length;
const cumSum = Array.from({length: N + 1}, () => new Array(M + 1).fill(0));
skill.forEach((skillset) => {
const minRow = skillset[1];
const minCol = skillset[2];
const maxRow = skillset[3] + 1;
const maxCol = skillset[4] + 1;
const degree = skillset[0] === 1 ? skillset[5] * -1 : skillset[5];
const minusDegree = degree * -1;
cumSum[minRow][minCol] += degree;
cumSum[minRow][maxCol] += minusDegree;
cumSum[maxRow][minCol] += minusDegree;
cumSum[maxRow][maxCol] += degree;
});
// row cumulative sum
for (let row = 0; row <= N; row++) {
for (let col = 1; col <= M; col++) {
cumSum[row][col] += cumSum[row][col - 1];
}
}
// col cumulative sum
for (let col = 0; col <= M; col++) {
for (let row = 1; row <= N; row++) {
cumSum[row][col] += cumSum[row - 1][col];
}
}
for (let row = 0; row < N; row++) {
for (let col = 0; col < M; col++) {
board[row][col] += cumSum[row][col];
if (board[row][col] > 0) {
answer++;
}
}
}
return answer;
}
양의 정수 n
이 주어집니다. 이 숫자를 k
진수로 바꿨을 때, 변환된 수 안에 아래 조건에 맞는 소수(Prime number)가 몇 개인지 알아보려 합니다.
0P0
처럼 소수 양쪽에 0이 있는 경우P0
처럼 소수 오른쪽에만 0이 있고 왼쪽에는 아무것도 없는 경우0P
처럼 소수 왼쪽에만 0이 있고 오른쪽에는 아무것도 없는 경우P
처럼 소수 양쪽에 아무것도 없는 경우단, P
는 각 자릿수에 0을 포함하지 않는 소수입니다.
P
가 될 수 없습니다.예를 들어, 437674을 3진수로 바꾸면 211
02
0101011
입니다. 여기서 찾을 수 있는 조건에 맞는 소수는 왼쪽부터 순서대로 211, 2, 11이 있으며, 총 3개입니다. (211, 2, 11을 k
진법으로 보았을 때가 아닌, 10진법으로 보았을 때 소수여야 한다는 점에 주의합니다.) 211은 P0
형태에서 찾을 수 있으며, 2는 0P0
에서, 11은 0P
에서 찾을 수 있습니다.
정수 n
과 k
가 매개변수로 주어집니다. n
을 k
진수로 바꿨을 때, 변환된 수 안에서 찾을 수 있는 위 조건에 맞는 소수의 개수를 return 하도록 solution 함수를 완성해 주세요.
제한사항
n
≤ 1,000,000k
≤ 10function solution(n, k) {
let answer = 0;
const kNumber = n.toString(k);
const isPrime = (num) => {
if (num < 2) {
return false;
}
if (num === 2) {
return true;
}
for (let i = 2; i <= Math.sqrt(num); i++) {
if (num % i === 0) {
return false;
}
}
return true;
};
let candidate = '';
for (let i = 0; i < kNumber.length; i++) {
if (kNumber[i] === '0') {
if(isPrime(Number(candidate))) {
answer++;
}
candidate = '';
continue;
}
candidate += kNumber[i];
}
if (candidate.length) {
if(isPrime(Number(candidate))) {
answer++;
}
}
return answer;
}