프로그래머스 두 큐 합 같게 만들기

• 무지성 코딩...

def solution(queue1, queue2):
    answer = 0
    lenQ = len(queue1) * len(queue2)
    
    while answer < lenQ:
        if sum(queue1) > sum(queue2):
            queue2.append(queue1.pop(0))
        else:
            queue1.append(queue2.pop(0))
        answer += 1
        if sum(queue1) == sum(queue2):
            return answer
        
    return -1

• 테스트 케이스는 잘 되지만,

테스트 1
입력값 〉	[3, 2, 7, 2], [4, 6, 5, 1]
기댓값 〉	2
실행 결과 〉	테스트를 통과하였습니다.
테스트 2
입력값 〉	[1, 2, 1, 2], [1, 10, 1, 2]
기댓값 〉	7
실행 결과 〉	테스트를 통과하였습니다.
테스트 3
입력값 〉	[1, 1], [1, 5]
기댓값 〉	-1
실행 결과 〉	테스트를 통과하였습니다.

• 제출 후 채점하면 틀린다.

정확성  테스트
테스트 1 〉	통과 (0.01ms, 10.1MB)
테스트 2 〉	실패 (0.00ms, 10.3MB)
테스트 3 〉	통과 (0.00ms, 10.2MB)
테스트 4 〉	통과 (0.01ms, 10.2MB)
테스트 5 〉	통과 (0.18ms, 10.2MB)
테스트 6 〉	통과 (0.22ms, 10.1MB)
테스트 7 〉	통과 (0.49ms, 10.2MB)
테스트 8 〉	통과 (0.35ms, 10.3MB)
테스트 9 〉	통과 (2.85ms, 10.1MB)
테스트 10 〉	통과 (18.68ms, 10.2MB)
테스트 11 〉	실패 (시간 초과)
테스트 12 〉	실패 (시간 초과)
테스트 13 〉	통과 (470.15ms, 11.1MB)
테스트 14 〉	통과 (581.42ms, 11.4MB)
테스트 15 〉	실패 (시간 초과)
테스트 16 〉	통과 (3141.01ms, 17.5MB)
테스트 17 〉	통과 (466.77ms, 16.6MB)
테스트 18 〉	통과 (5542.90ms, 29.9MB)
테스트 19 〉	실패 (시간 초과)
테스트 20 〉	실패 (시간 초과)
테스트 21 〉	실패 (시간 초과)
테스트 22 〉	실패 (시간 초과)
테스트 23 〉	실패 (시간 초과)
테스트 24 〉	실패 (시간 초과)
테스트 25 〉	통과 (0.45ms, 10.2MB)
테스트 26 〉	통과 (0.21ms, 10.1MB)
테스트 27 〉	통과 (0.39ms, 10.2MB)
테스트 28 〉	실패 (시간 초과)
테스트 29 〉	실패 (3915.47ms, 10.8MB)
테스트 30 〉	실패 (시간 초과)

• 테스트 케이스 2는 처음부터 합이 같을 때, 조건문 순서만 바꾸면 맞음.

def solution(queue1, queue2):
    answer = 0
    lenQ = len(queue1) * len(queue2)
    
    while answer < lenQ:
        if sum(queue1) == sum(queue2):
            return answer
        if sum(queue1) > sum(queue2):
            queue2.append(queue1.pop(0))
        else:
            queue1.append(queue2.pop(0))
        answer += 1
        
    return -1

• 나머지 시간 초과는 어떻게 해결해야 하나...? sum 함수 때문에 느린건가?

def solution(queue1, queue2):
    answer = 0
    lenQ = len(queue1) * len(queue2)
    sum1 = sum(queue1)
    sum2 = sum(queue2)
    
    while answer < lenQ:
        if sum1 == sum2:
            return answer
        if sum1 > sum2:
            _tmp = queue1.pop(0)
            sum1 -= _tmp
            sum2 += _tmp
            queue2.append(_tmp)
        else:
            _tmp = queue2.pop(0)
            sum2 -= _tmp
            sum1 += _tmp
            queue1.append(_tmp)
        answer += 1
        
    return -1

• sum 함수 제거하니까 빨라졌다. 그래도 시간초과 발생.

정확성  테스트
테스트 1 〉	통과 (0.01ms, 10.1MB)
테스트 2 〉	통과 (0.00ms, 10.2MB)
테스트 3 〉	통과 (0.01ms, 10.2MB)
테스트 4 〉	통과 (0.01ms, 10.1MB)
테스트 5 〉	통과 (0.03ms, 10.3MB)
테스트 6 〉	통과 (0.04ms, 10.2MB)
테스트 7 〉	통과 (0.04ms, 10.2MB)
테스트 8 〉	통과 (0.03ms, 10.2MB)
테스트 9 〉	통과 (0.06ms, 10.3MB)
테스트 10 〉	통과 (0.12ms, 10.3MB)
테스트 11 〉	실패 (시간 초과)
테스트 12 〉	통과 (160.01ms, 14MB)
테스트 13 〉	통과 (4.91ms, 11.1MB)
테스트 14 〉	통과 (4.31ms, 11.3MB)
테스트 15 〉	통과 (235.36ms, 17MB)
테스트 16 〉	통과 (29.30ms, 17.5MB)
테스트 17 〉	통과 (7.37ms, 16.4MB)
테스트 18 〉	통과 (77.45ms, 29.9MB)
테스트 19 〉	통과 (863.07ms, 34.3MB)
테스트 20 〉	통과 (7243.30ms, 34.7MB)
테스트 21 〉	통과 (3127.62ms, 35MB)
테스트 22 〉	실패 (시간 초과)
테스트 23 〉	실패 (시간 초과)
테스트 24 〉	실패 (시간 초과)
테스트 25 〉	통과 (0.04ms, 10.2MB)
테스트 26 〉	통과 (0.02ms, 10MB)
테스트 27 〉	통과 (0.02ms, 10.4MB)
테스트 28 〉	실패 (시간 초과)
테스트 29 〉	통과 (0.10ms, 10.9MB)
테스트 30 〉	통과 (5550.23ms, 18.4MB)

• 혹시 lenQ가 너무 길었던 걸까나?
  • 답이 틀린게 1개
  • 시간 초과 3개

def solution(queue1, queue2):
    answer = 0
    lenQ = (len(queue1) + len(queue2)) * 1.3 # lenQ를 줄여보까?
    sum1 = sum(queue1)
    sum2 = sum(queue2)
    
    while answer < lenQ:
        if sum1 == sum2:
            return answer
        if sum1 > sum2:
            _tmp = queue1.pop(0)
            sum1 -= _tmp
            sum2 += _tmp
            queue2.append(_tmp)
        else:
            _tmp = queue2.pop(0)
            sum2 -= _tmp
            sum1 += _tmp
            queue1.append(_tmp)
        answer += 1
        
    return -1

• 테스트 케이스 22, 23, 24 시간 초과로 실패.

정확성  테스트
테스트 1 〉	통과 (0.01ms, 10.2MB)
테스트 2 〉	통과 (0.00ms, 10.1MB)
테스트 3 〉	통과 (0.00ms, 10.1MB)
테스트 4 〉	통과 (0.01ms, 10.3MB)
테스트 5 〉	통과 (0.03ms, 10.3MB)
테스트 6 〉	통과 (0.03ms, 10.2MB)
테스트 7 〉	통과 (0.02ms, 10.2MB)
테스트 8 〉	통과 (0.02ms, 10.3MB)
테스트 9 〉	통과 (0.06ms, 10.1MB)
테스트 10 〉	통과 (0.23ms, 10.2MB)
테스트 11 〉	통과 (952.51ms, 13.9MB)
테스트 12 〉	통과 (170.89ms, 13.9MB)
테스트 13 〉	통과 (4.26ms, 11.2MB)
테스트 14 〉	통과 (3.98ms, 11.4MB)
테스트 15 〉	통과 (223.09ms, 17.1MB)
테스트 16 〉	통과 (31.09ms, 17.6MB)
테스트 17 〉	통과 (6.57ms, 16.5MB)
테스트 18 〉	통과 (77.82ms, 29.8MB)
테스트 19 〉	통과 (868.39ms, 34.3MB)
테스트 20 〉	통과 (7123.35ms, 34.8MB)
테스트 21 〉	통과 (2941.93ms, 34.8MB)
테스트 22 〉	실패 (시간 초과)
테스트 23 〉	실패 (시간 초과)
테스트 24 〉	실패 (시간 초과)
테스트 25 〉	통과 (0.05ms, 10.2MB)
테스트 26 〉	통과 (0.03ms, 10.3MB)
테스트 27 〉	통과 (0.02ms, 10.3MB)
테스트 28 〉	통과 (7734.25ms, 18.3MB)
테스트 29 〉	통과 (0.11ms, 10.8MB)
테스트 30 〉	통과 (6124.55ms, 18.3MB)

• 시간 초과를 해결하기 위해 push, pop을 사용안하고 인덱스로 옮겨다니면서 합만 비교하는 방식으로 고쳤더니 테스트케이스 1, 11번 실패한다.

 

def solution(queue1, queue2):
    answer = 0
    ptr1, ptr2 = 0, 0
    sum1, sum2 = sum(queue1), sum(queue2)
    lenQ1, lenQ2 = len(queue1), len(queue2)
    lenQ = (lenQ1 + lenQ2) * 1.3 # LenQ를 줄여볼까?
    
    if (sum1 + sum2) % 2 != 0:
        return -1

    while answer < lenQ:
        if sum1 == sum2:
            return answer
        elif sum1 < sum2 and sum2 > 0:
            _tmp = queue2[ptr2]
            sum2 -= _tmp
            sum1 += _tmp
            ptr2 += 1
            if ptr2 == lenQ2:
                ptr2 = 0
        elif sum1 > sum2 and sum1 > 0:
            _tmp = queue1[ptr1]
            sum1 -= _tmp
            sum2 += _tmp
            ptr1 += 1
            if ptr1 == lenQ1:
                ptr1 = 0
        else:
            answer += lenQ
        answer += 1
        
    return -1

• 한참을 쳐다보니 문제점이 보였다. 실패하는 이유는 큐1에서 뽑아낸 값을 큐2로 넣어야 하는데, 아래 방식은 포인터만 이동하고 다니기 때문에 서로 섞이지 않아서 실패ㅋ
• 그래서 pop은 안하고, append만 하는걸로 반쪽만 사용하는 걸로 수정했더니 성공. 아쉬운 반쪽짜리 성공ㅋ

def solution(queue1, queue2):
    answer = 0
    lenQ = (len(queue1) + len(queue2)) * 1.3 # lenQ를 줄여보까?
    sum1 = sum(queue1)
    sum2 = sum(queue2)
    ptr1, ptr2 = 0, 0
    
    while answer < lenQ:
        if sum1 == sum2:
            return answer
        if sum1 > sum2:
            _tmp = queue1[ptr1]
            ptr1 += 1
            sum1 -= _tmp
            sum2 += _tmp
            queue2.append(_tmp)
        else:
            _tmp = queue2[ptr2]
            ptr2 += 1
            sum2 -= _tmp
            sum1 += _tmp
            queue1.append(_tmp)
        answer += 1
        
    return -1
    
정확성  테스트
테스트 1 〉	통과 (0.01ms, 10.2MB)
테스트 2 〉	통과 (0.00ms, 10.2MB)
테스트 3 〉	통과 (0.00ms, 10.2MB)
테스트 4 〉	통과 (0.01ms, 10.2MB)
테스트 5 〉	통과 (0.02ms, 10.2MB)
테스트 6 〉	통과 (0.02ms, 10.3MB)
테스트 7 〉	통과 (0.02ms, 10.3MB)
테스트 8 〉	통과 (0.01ms, 10.4MB)
테스트 9 〉	통과 (0.04ms, 10.2MB)
테스트 10 〉	통과 (0.09ms, 10.4MB)
테스트 11 〉	통과 (29.69ms, 14.9MB)
테스트 12 〉	통과 (11.30ms, 14MB)
테스트 13 〉	통과 (0.78ms, 11.1MB)
테스트 14 〉	통과 (0.85ms, 11.5MB)
테스트 15 〉	통과 (3.43ms, 17MB)
테스트 16 〉	통과 (1.29ms, 17.5MB)
테스트 17 〉	통과 (1.07ms, 16.6MB)
테스트 18 〉	통과 (3.25ms, 30MB)
테스트 19 〉	통과 (5.57ms, 34.3MB)
테스트 20 〉	통과 (22.14ms, 34.8MB)
테스트 21 〉	통과 (11.08ms, 35MB)
테스트 22 〉	통과 (52.15ms, 35.1MB)
테스트 23 〉	통과 (37.68ms, 36MB)
테스트 24 〉	통과 (61.73ms, 35.8MB)
테스트 25 〉	통과 (0.04ms, 10.3MB)
테스트 26 〉	통과 (0.02ms, 10.4MB)
테스트 27 〉	통과 (0.02ms, 10.2MB)
테스트 28 〉	통과 (80.32ms, 19.7MB)
테스트 29 〉	통과 (0.21ms, 10.9MB)
테스트 30 〉	통과 (47.23ms, 19.3MB)

고수의 풀이

• 신박하다. 어떻게 푼 건지 모르겠네...

def solution(que1, que2):
    queSum = (sum(que1) + sum(que2))
    if queSum % 2:
        return -1
    target = queSum // 2

    n = len(que1)
    start = 0
    end = n - 1
    ans = 0

    cur = sum(que1)
    que3 = que1 + que2
    while cur != target:
        if cur < target:
            end += 1
            if end == n * 2:
                return -1
            cur += que3[end]
        else:
            cur -= que3[start]
            start += 1
        ans += 1
    return ans

정확성  테스트
테스트 1 〉	통과 (0.01ms, 10.1MB)
테스트 2 〉	통과 (0.00ms, 10.2MB)
테스트 3 〉	통과 (0.00ms, 10.2MB)
테스트 4 〉	통과 (0.01ms, 10.3MB)
테스트 5 〉	통과 (0.01ms, 10.2MB)
테스트 6 〉	통과 (0.02ms, 10.3MB)
테스트 7 〉	통과 (0.03ms, 10.3MB)
테스트 8 〉	통과 (0.02ms, 10.3MB)
테스트 9 〉	통과 (0.04ms, 10.4MB)
테스트 10 〉	통과 (0.09ms, 10.2MB)
테스트 11 〉	통과 (14.50ms, 14.5MB)
테스트 12 〉	통과 (4.48ms, 14.5MB)
테스트 13 〉	통과 (2.02ms, 12.2MB)
테스트 14 〉	통과 (2.24ms, 12.3MB)
테스트 15 〉	통과 (4.09ms, 18.1MB)
테스트 16 〉	통과 (2.99ms, 18.5MB)
테스트 17 〉	통과 (3.10ms, 17.5MB)
테스트 18 〉	통과 (10.80ms, 32.9MB)
테스트 19 〉	통과 (13.09ms, 37.2MB)
테스트 20 〉	통과 (21.46ms, 37.6MB)
테스트 21 〉	통과 (15.95ms, 37.6MB)
테스트 22 〉	통과 (40.42ms, 37.7MB)
테스트 23 〉	통과 (31.70ms, 37.6MB)
테스트 24 〉	통과 (48.96ms, 37.6MB)
테스트 25 〉	통과 (0.03ms, 10.3MB)
테스트 26 〉	통과 (0.02ms, 10.2MB)
테스트 27 〉	통과 (0.02ms, 10.2MB)
테스트 28 〉	통과 (29.33ms, 19.1MB)
테스트 29 〉	통과 (0.45ms, 10.8MB)
테스트 30 〉	통과 (30.97ms, 19MB)

 

def solution(queue1, queue2):
    indicator2=sum(queue1)-int(sum(queue1+queue2)/2)
    answer=0
    sub_list=(queue1+queue2+queue1)[::-1]
    add_list=(queue2+queue1+queue2)[::-1]
    while indicator2!=0:
        try:
            if indicator2>0:
                indicator2-=sub_list.pop()
            else:
                indicator2+=add_list.pop()
        except:
            return -1
        answer+=1
    return answer
    
정확성  테스트
테스트 1 〉	통과 (0.01ms, 10.3MB)
테스트 2 〉	통과 (0.00ms, 10.1MB)
테스트 3 〉	통과 (0.01ms, 10.3MB)
테스트 4 〉	통과 (0.01ms, 10.1MB)
테스트 5 〉	통과 (0.02ms, 10.3MB)
테스트 6 〉	통과 (0.02ms, 10.1MB)
테스트 7 〉	통과 (0.03ms, 10.1MB)
테스트 8 〉	통과 (0.04ms, 10.3MB)
테스트 9 〉	통과 (0.09ms, 10.2MB)
테스트 10 〉	통과 (0.22ms, 10.5MB)
테스트 11 〉	통과 (38.68ms, 17.9MB)
테스트 12 〉	통과 (9.16ms, 17.8MB)
테스트 13 〉	통과 (6.98ms, 16.9MB)
테스트 14 〉	통과 (8.44ms, 18MB)
테스트 15 〉	통과 (13.42ms, 23.9MB)
테스트 16 〉	통과 (13.06ms, 24.8MB)
테스트 17 〉	통과 (13.17ms, 24.3MB)
테스트 18 〉	통과 (41.66ms, 53.6MB)
테스트 19 〉	통과 (53.17ms, 57.8MB)
테스트 20 〉	통과 (60.49ms, 58.3MB)
테스트 21 〉	통과 (65.42ms, 58.3MB)
테스트 22 〉	통과 (81.41ms, 58.3MB)
테스트 23 〉	통과 (66.32ms, 58.3MB)
테스트 24 〉	통과 (76.20ms, 58.4MB)
테스트 25 〉	통과 (0.03ms, 10.2MB)
테스트 26 〉	통과 (0.02ms, 10.1MB)
테스트 27 〉	통과 (0.02ms, 10.2MB)
테스트 28 〉	통과 (74.54ms, 26MB)
테스트 29 〉	통과 (1.17ms, 11.6MB)
테스트 30 〉	통과 (34.34ms, 26MB)

from collections import deque
from itertools import combinations

def solution(queue1, queue2):

    # 1. 큐 자료형으로 변경
    q1 = deque(queue1); q2 = deque(queue2); totalq = q1 + q2
    sum1 = sum(q1); sum2 = sum(q2); total_sum = (sum1+sum2)
    target = total_sum/2
    # 2. 불가능한 상황 예외처리 : 정확히 절반으로 나눌수 없거나 절반 값보다 큰 원소가 존재하거나
    print(target)
    if target != int(target) or [i for i in totalq if i > target]:
        return -1
    # if not any()
    # 3. 자료 옮기기 구현
    # First in First Out : 앞에서 떼어 뒤에 붙인다
    # sum이 target보다 작으면 붙이고, sum이 target보다 크면 옮겨준다 두 경우에 대해 sum()을 쓰지 말고 추가요소만 더해주거나 뺸다
    cnt = 0

    _sum = sum1
    INF = 10000000
    for _ in range(INF):
        if _sum == target:
            return cnt
        elif _sum > target:
            _sum -= q1[0]
            q2.append(q1.popleft())
            cnt += 1
        elif _sum < target:
            _sum += q2[0]
            q1.append(q2.popleft())
            cnt += 1

    return -1
    
정확성  테스트
테스트 1 〉	통과 (0.02ms, 10.1MB)
테스트 2 〉	통과 (0.01ms, 10.2MB)
테스트 3 〉	통과 (0.02ms, 10.3MB)
테스트 4 〉	통과 (0.02ms, 10.2MB)
테스트 5 〉	통과 (0.06ms, 10.3MB)
테스트 6 〉	통과 (0.08ms, 10.2MB)
테스트 7 〉	통과 (0.05ms, 10.3MB)
테스트 8 〉	통과 (0.08ms, 10.2MB)
테스트 9 〉	통과 (0.16ms, 10.2MB)
테스트 10 〉	통과 (0.55ms, 10.3MB)
테스트 11 〉	통과 (2551.20ms, 15.4MB)
테스트 12 〉	통과 (12.22ms, 15.5MB)
테스트 13 〉	통과 (16.34ms, 13.2MB)
테스트 14 〉	통과 (10.68ms, 13.6MB)
테스트 15 〉	통과 (16.54ms, 19.5MB)
테스트 16 〉	통과 (20.22ms, 20.1MB)
테스트 17 〉	통과 (12.80ms, 19.3MB)
테스트 18 〉	통과 (61.55ms, 37.9MB)
테스트 19 〉	통과 (46.07ms, 42.2MB)
테스트 20 〉	통과 (67.96ms, 42.7MB)
테스트 21 〉	통과 (52.39ms, 42.7MB)
테스트 22 〉	통과 (115.27ms, 42.6MB)
테스트 23 〉	통과 (93.99ms, 42.7MB)
테스트 24 〉	통과 (114.76ms, 42.8MB)
테스트 25 〉	통과 (0.07ms, 10.2MB)
테스트 26 〉	통과 (0.05ms, 10.3MB)
테스트 27 〉	통과 (0.05ms, 10.2MB)
테스트 28 〉	통과 (2415.11ms, 20.9MB)
테스트 29 〉	통과 (1.29ms, 11MB)
테스트 30 〉	통과 (74.32ms, 20.7MB)

• 큐를 합쳐서 좀 더 빠르게 할 수 있지 않을까?

def solution(queue1, queue2):
    answer = 0
    lenQ = (len(queue1) + len(queue2)) * 1.3 # lenQ를 줄여보까?
    
    sum1 = sum(queue1)
    sum2 = sum(queue2)
    
    if (sum1 + sum2) % 2 != 0:
        return -1
    ptr1, ptr2 = 0, 0
    
    # 큐를 미리 합쳐두면 index만 옮겨다닐 수 있지롱
    queue3 = queue1 + queue2 #+ queue1
    queue4 = queue2 + queue1 #+ queue2
    
    while answer < lenQ:
        if sum1 == sum2:
            return answer
        if sum1 > sum2:
            _tmp = queue3[ptr1]
            ptr1 += 1
            sum1 -= _tmp
            sum2 += _tmp
            answer += 1
        if sum1 < sum2:
            _tmp = queue4[ptr2]
            ptr2 += 1
            sum2 -= _tmp
            sum1 += _tmp
            answer += 1
        
    return -1
    
정확성  테스트
테스트 1 〉	통과 (0.01ms, 10.1MB)
테스트 2 〉	통과 (0.00ms, 10.1MB)
테스트 3 〉	통과 (0.01ms, 10.2MB)
테스트 4 〉	통과 (0.01ms, 10.3MB)
테스트 5 〉	통과 (0.02ms, 10.2MB)
테스트 6 〉	통과 (0.02ms, 10.1MB)
테스트 7 〉	통과 (0.02ms, 10.2MB)
테스트 8 〉	통과 (0.03ms, 10.2MB)
테스트 9 〉	통과 (0.08ms, 10.1MB)
테스트 10 〉	통과 (0.11ms, 10.3MB)
테스트 11 〉	통과 (24.07ms, 15.2MB)
테스트 12 〉	통과 (5.80ms, 15.1MB)
테스트 13 〉	통과 (3.68ms, 13.3MB)
테스트 14 〉	통과 (2.67ms, 13.7MB)
테스트 15 〉	통과 (5.99ms, 19.3MB)
테스트 16 〉	통과 (4.84ms, 20.1MB)
테스트 17 〉	통과 (3.90ms, 18.9MB)
테스트 18 〉	통과 (15.02ms, 37.4MB)
테스트 19 〉	통과 (17.16ms, 41.7MB)
테스트 20 〉	통과 (30.09ms, 42.1MB)
테스트 21 〉	통과 (22.29ms, 42.1MB)
테스트 22 〉	통과 (51.58ms, 42.1MB)
테스트 23 〉	통과 (38.58ms, 42.3MB)
테스트 24 〉	통과 (57.11ms, 42.2MB)
테스트 25 〉	통과 (0.03ms, 10.2MB)
테스트 26 〉	통과 (0.03ms, 10.2MB)
테스트 27 〉	통과 (0.02ms, 10.1MB)
테스트 28 〉	통과 (44.71ms, 20.5MB)
테스트 29 〉	통과 (0.36ms, 11.1MB)
테스트 30 〉	통과 (37.86ms, 20.6MB)

• 하지만 고수의 풀이가 더 빠르다.
• 큐 2개를 합쳐서 index로 이동하는게 메모리도 더 적게 소모하고 빠르다.
• 대신 내 코드는 보기 쉬워서 좋지 않아? ㅋㅋㅋ

고수의 풀이

나의 코드

정확성  테스트 테스트 1 〉 통과 (0.01ms, 10.1MB) 테스트 2 〉 통과 (0.00ms, 10.2MB) 테스트 3 〉 통과 (0.00ms, 10.2MB) 테스트 4 〉 통과 (0.01ms, 10.3MB) 테스트 5 〉 통과 (0.01ms, 10.2MB) 테스트 6 〉 통과 (0.02ms, 10.3MB) 테스트 7 〉 통과 (0.03ms, 10.3MB) 테스트 8 〉 통과 (0.02ms, 10.3MB) 테스트 9 〉 통과 (0.04ms, 10.4MB) 테스트 10 〉 통과 (0.09ms, 10.2MB) 테스트 11 〉 통과 (14.50ms, 14.5MB) 테스트 12 〉 통과 (4.48ms, 14.5MB) 테스트 13 〉 통과 (2.02ms, 12.2MB) 테스트 14 〉 통과 (2.24ms, 12.3MB) 테스트 15 〉 통과 (4.09ms, 18.1MB) 테스트 16 〉 통과 (2.99ms, 18.5MB) 테스트 17 〉 통과 (3.10ms, 17.5MB) 테스트 18 〉 통과 (10.80ms, 32.9MB) 테스트 19 〉 통과 (13.09ms, 37.2MB) 테스트 20 〉 통과 (21.46ms, 37.6MB) 테스트 21 〉 통과 (15.95ms, 37.6MB) 테스트 22 〉 통과 (40.42ms, 37.7MB) 테스트 23 〉 통과 (31.70ms, 37.6MB) 테스트 24 〉 통과 (48.96ms, 37.6MB) 테스트 25 〉 통과 (0.03ms, 10.3MB) 테스트 26 〉 통과 (0.02ms, 10.2MB) 테스트 27 〉 통과 (0.02ms, 10.2MB) 테스트 28 〉 통과 (29.33ms, 19.1MB) 테스트 29 〉 통과 (0.45ms, 10.8MB) 테스트 30 〉 통과 (30.97ms, 19MB)

정확성  테스트 테스트 1 〉 통과 (0.01ms, 10.1MB) 테스트 2 〉 통과 (0.00ms, 10.1MB) 테스트 3 〉 통과 (0.01ms, 10.2MB) 테스트 4 〉 통과 (0.01ms, 10.3MB) 테스트 5 〉 통과 (0.02ms, 10.2MB) 테스트 6 〉 통과 (0.02ms, 10.1MB) 테스트 7 〉 통과 (0.02ms, 10.2MB) 테스트 8 〉 통과 (0.03ms, 10.2MB) 테스트 9 〉 통과 (0.08ms, 10.1MB) 테스트 10 〉 통과 (0.11ms, 10.3MB) 테스트 11 〉 통과 (24.07ms, 15.2MB) 테스트 12 〉 통과 (5.80ms, 15.1MB) 테스트 13 〉 통과 (3.68ms, 13.3MB) 테스트 14 〉 통과 (2.67ms, 13.7MB) 테스트 15 〉 통과 (5.99ms, 19.3MB) 테스트 16 〉 통과 (4.84ms, 20.1MB) 테스트 17 〉 통과 (3.90ms, 18.9MB) 테스트 18 〉 통과 (15.02ms, 37.4MB) 테스트 19 〉 통과 (17.16ms, 41.7MB) 테스트 20 〉 통과 (30.09ms, 42.1MB) 테스트 21 〉 통과 (22.29ms, 42.1MB) 테스트 22 〉 통과 (51.58ms, 42.1MB) 테스트 23 〉 통과 (38.58ms, 42.3MB) 테스트 24 〉 통과 (57.11ms, 42.2MB) 테스트 25 〉 통과 (0.03ms, 10.2MB) 테스트 26 〉 통과 (0.03ms, 10.2MB) 테스트 27 〉 통과 (0.02ms, 10.1MB) 테스트 28 〉 통과 (44.71ms, 20.5MB) 테스트 29 〉 통과 (0.36ms, 11.1MB) 테스트 30 〉 통과 (37.86ms, 20.6MB)