Skip to content

Latest commit

 

History

History
1245 lines (1032 loc) · 39.8 KB

MOO-Language.md

File metadata and controls

1245 lines (1032 loc) · 39.8 KB

MOO Language

이 문서는 Solver와 Simulator가 공유하는 MOO Language를 정의합니다.

Operator definitions

  1. NEW_EQN()

  2. DONE()

  3. EQ

    EQ(x1: float, x2: float) -> bool
1) 목적/변화: 입력받은 두 인자가 같은지 비교
2) 인수값: 비교하려는 두 값
3) 반환값: 같으면 true, 다르면 false
4) 예시: 
R0: EQ(2, 2)

  4. ADD

    ADD(x1: float, x2: float) -> float
1) 목적/변화: 입력받은 두 값을 더해서 반환
2) 인수값: 더하려는 두 값
3) 반환값: x1 + x2, 두 인자를 더한 값
4) 예시: 
R0: ADD(3, 4)

  5. SUB

    SUB(x1: float, x2: float) -> float
1) 목적/변화: 입력받은 두 값의 차를 반환
2) 인수값: 차이를 알고 싶은 두 값
3) 반환값: x1 - x2, 두 인자의 차
4) 예시: 
R0: SUB(4, 3)

  6. MUL

    MUL(x1: float, x2: float) -> float
1) 목적/변화: 입력받은 두 값의 곱을 반환
2) 인수값: 곱하고 싶은 두 값
3) 반환값: x1 * x2, 두 인자를 곱한 값
4) 예시: 
R0: MUL(2, 3)

  7. DIV

    DIV(x1: float, x2: float) -> float
1) 목적/변화: 입력 받은 두 개의 인자 중 a(첫 번째 인자)를 b(두 번째 인자)로 나눠준다
2) 인수값: 나눠주고 싶은 두 값
3) 반환값: x1 / x2
4) 예시: 
R0: DIV(8,4)

  8. MOD

    MOD(x1: int, x2: int) -> int
1) 목적/변화: 입력 받은 두 개의 인자 중 a(첫 번째 인자)를 b(두 번째 인자)로 나눈 나머지를 반환
2) 인수값: 나누어 얻은 나머지를 얻고 싶은 두 값
3) 반환값: x1 % x2
4) 예시: 
R0: MOD(9,4)

  9. POW

    POW(x1: float, x2: float) -> float
1) 목적/변화: 입력 받은 두 개의 인자 중 x1(첫 번째 인자)를 x2(두 번째 인자)제곱을 구해준다
2) 인수값: base 값과 지수
3) 반환값: x1 ^ x2 (x1의 x2제곱)
4) 예시: 
R0: POW(2, 4)

  10. PRINT

    PRINT(value: Union[float, int, str])
1) 목적/변화: 입력받은 값 출력
2) 인수값: 출력하고 싶은 float, int 또는 str
3) 반환값: 없음
4) 예시:
R0: SUB(10,5)
R1: PRINT(R0)

  11. SUM

    SUM(ls1: List[float]) -> float
1) 목적/변화: 리스트 속 정수들을 모두 더해줌
2) 인수값: 정수로 이루어진 리스트
3) 반환값: 리스트의 원소들을 모두 더한 값
4) 예시: 
  R0: LIST()
  R1: APPEND(R0, 1) # APPEND(13.) 참고
  R2: APPEND(R1, 2)
  R3: APPEND(R2, 3)
  R4: APPEND(R3, 4)
  R5: APPEND(R4, 5)
  R6: SUM(ls)

  12. LIST

    LIST()  
1) 목적/변화: 리스트 객체를 만든다
2) 인수값: 없음
3) 반환값: 리스트 객체
4) 예시:
    R0: LIST()

  13. APPEND

    APPEND(ls1: List[Any], x1: Any) -> List[Any]
1) 목적/변화: 리스트 속에 정수, 실수, 문자열을 추가함. 리스트 속에 리스트가 들어갈 수 있음.
2) 인수값: 정수, 실수, 문자열, 다른 리스트
3) 반환값: 정수, 실수, 문자열, 다른 리스트가 들어있는 리스트
4) 예시:
    4-1) 정수형 리스트 만들기
        R0: LIST()
        R1: APPEND(R0, 3)
        R2: APPEND(R1, 4)
    4-2) 실수형 리스트 만들기
        R0: LIST()
        R1: APPEND(R0, 3.5)
        R2: APPEND(R1, 4.5)
    4-3) 문자형 리스트 만들기
        R0: LIST()
        R1: APPEND(R0, '(가)')
        R2: APPEND(R1, '(나)')

  14. COMB

    COMB(n: int, k:int) -> int
1) 목적/변화: n개 중 k개를 선택할 수 있는 경우의 수를 구한다(조합)
2) 인수값: 총 개수 n(정수), 선택할 개수 k(정수)
3) 반환값: 경우의 수
4) 예시: 
    R0: LIST()
    R1: APPEND(R0,'빨간')
    R2: APPEND(R1,'파랑')
    R3: APPEND(R2,'노랑')
    R4: COUNT(R0) # COUNT함수(29.) 참고
    R5: COMB(R4, 2)  (=3)
5) 제한 조건: n >= k (선택 할 수 있는 총 개수보다 선택할 수가 더 클 수 없다)

  15. PERM

    PERM(n: int, k:int) -> int
1) 목적/변화: n개 중 k개를 선택하여 나열할 수 있는 경우의 수를 구한다(순열)
2) 인수값: 총 개수 n(정수), 선택할 개수 k(정수)
3) 반환값: 경우의 수
4) 예시: 
    R0: LIST()
    R1: APPEND(R0,'빨간')
    R2: APPEND(R1,'파랑')
    R3: APPEND(R2,'노랑')
    R4: COUNT(R0) # COUNT함수(29.) 참고
    R5: PERM(R4, 2)    (=6)
5) 제한 조건: n >= k

  16. MIN

    MIN(ls1: List[Union[int,float]]) -> Union[int,float]
1) 목적/변화: 정수나 실수로 이루어진 리스트에서 가장 작은 값을 알려준다
2) 인수값: 정수나 실수로 이루어진 리스트
3) 반환값:
    정수 리스트인 경우: 정수
    실수 리스트인 경우: 실수
4) 예시:
    R0: LIST()
    R1: APPEND(R0, 4)
    R2: APPEND(R1, 5)
    R3: APPEND(R2, 8)
    R4: MIN(R3)    (=4)
5) 제한 조건: 문자열 리스트에는 사용할 수 없는 함수이다

  17. MAX

    MAX(ls1: List[Union[int,float]]) -> Union[int,float]
1) 목적/변화: 정수나 실수로 이루어진 리스트에서 가장 큰 값을 알려준다
2) 인수값: 정수나 실수로 이루어진 리스트
3) 반환값:
    정수 리스트인 경우: 정수
    실수 리스트인 경우: 실수
4) 예시:
    R0: LIST()
    R1: APPEND(R0, 4)
    R2: APPEND(R1, 5)
    R3: APPEND(R2, 8)
    R4: MAX(R3)    (=8)
5) 제한 조건: 문자열 리스트에는 사용할 수 없는 함수이다

  18. RANGE

    RANGE(start: int, end: int, step: int) -> List[int] 
1) 목적/변화: 시작하는 숫자(start)부터 끝나는 숫자보다 1이 더 큰 숫자(end)까지
정수로 이루어진 리스트를 만든다. 리스트 속의 숫자들은 step의 값만큼 차이가 난다.
리스트 속에 있는 정수들은 크기 순서대로 배열된다. (작은 수 -> 큰 수)
2) 인수값: 시작값, 끝값, 숫자 간 차이
3) 반환값: 정수로 구성된 리스트
4) 예시:
    4-1) 1부터 10까지 나열:
        R0: RANGE(1,11,1)
    4-2) 1부터 10까지 짝수만 나열:
        R0: RANGE(2,11,2)
    4-3) 1부터 9까지 홀수만 나열:
        R0: RANGE(1,10,2)
5) 제한 조건: 시작값과 끝값도 마찬가지만, step값도 무조건 입력해야 한다.

  19. LCM

    LCM(ls1: List[int]) -> int
1) 목적/변화: 리스트의 정수들의 최소공배수다를 구한다
2) 인수값: 정수로 구성된 리스트
3) 반환값: 최소공배수
4) 예시:
    R0: LIST()
    R1: APPEND(R0, 5)
    R2: APPEND(R1, 8)
    R3: APPEND(R2, 9)
    R4: LCM(R3)    (=360)
5) 제한 조건: 문자열, 실수형 리스트에는 사용할 수 없는 함수이다

  20. GCD

    GCD(ls1: List[int]) -> int
1) 목적/변화: 리스트의 정수들의 최대공약수를 구한다
2) 인수값: 정수로 구성된 리스트
3) 반환값: 최대공약수
4) 예시:
    R0: LIST()
    R1: APPEND(R0, 50)
    R2: APPEND(R1, 80)
    R3: APPEND(R2, 90)
    R4: GCD(R3)    (=10)
5) 제한 조건: 문자열, 실수형 리스트에는 사용할 수 없는 함수이다

  21. COUNT_MULTI

    COUNT_MULTI(ls1: List[int], ls2: List[int]) ->  int
1) 목적/변화: 13번 문제를 풀기 위한 특수 함수.. RANGE를 입력하면(ls1) 그 RANGE
속에 있는 숫자 중 ls2에 있는 숫자들 모두 나눠 떨어지는 숫자들의 개수를 출력한다
2) 인수값:
ls1: 찾고자 하는 RANGE
ls2: 나누어 떨어졌으면 하는 숫자들
3) 반환값: 개수
4) 예시:
    R0: RANGE(100,1000,1)
    R1: LIST()
    R2: APPEND(R1, 2)
    R3: APPEND(R2, 3)
    R4: APPEND(R2, 9)
    R5: COUNT_MULTI(R0, R4)
5) 제한 조건: ls1은 문제에서 제시하는 자리수 내에서 찾아야 하므로 다음과 같이 설정해야 한다.
한 자리수: RANGE(1,10,1)
두 자리수: RANGE(10,100,1)
세 자리수: RANGE(100,1000,1)
네 자리수: RANGE(1000,10000,1)
등등

  22. DIGIT

    DIGIT(x1: int, digit: int) -> int 
1) 목적/변화: 한 자리수 정수(x)가 주어지면 그 정수를 원하는 자리수의 숫자로 변환한다.
이는 그 정수에 필요한 개수(digit-1)의 0을 붙여서 생성한다.
2) 인수값: 한 자리수 정수, 
3) 반환값: 원하는 자리수의 정수
4) 예시:
    R0: DIGIT(7, 5)     (=70000)
    R1: DIGIT(2, 2)     (=20)
    R2: DIGIT(1, 3)     (=100)
    R3: DIGIT(8, 1)     (=8)
5) 제한 조건: x는 한 자리수의 정수다,(1~9) 절대로 다른 정수를 입력값으로 넣지 않는다.

  23. TO_INT

    TO_INT(x1: float) -> int
1) 목적/변화: 실수 x를 정수로 변환한다.
2) 인수값: 원본 실수
3) 반환값: 변환된 정수
4) 예시: 
 R0: TO_INT(3.0) = 3

  24. CALL_SYMPY

    CALL_SYMPY(prob: List, target: Any) -> Union[int, float] 
1) 목적/변화: Sympy에 prob들이 들어있는 을 넘겨서 문제를 해결한다.
2) 인수값: 
    prob: 문제 str들이 들어있는 list
  target: 구하고 싶은 인자 str
3) 반환값: 정답 결과가 들어있는 int or float
4) 예시: (문제 16)
 R0: LIST() 
 R1: APPEND(R0, "A+B=30")
 R2: APPEND(R1, "A=B+B+B+B")
 R3: CALL_SYMPY(R2, 'A')

  25. REVERSE_DIGIT

    REVERSE_DIGIT(x1: int) -> int
1) 목적/변화: x의 각 자리수를 역순으로 변환/배열한다.
2) 인자값: 원본 정수
3) 반환값: 자리수가 역순으로 재배열 된 정수
4) 예시: 
  R0: REVERSE_DIGIT(345)      (= 543)

  26. SEQ_TERM

    SEQ_TERM(seq: List, index: int) -> Union[int, float]
1) 목적/변화: 등차수열또는 계차수열을 입력받아 n번째 인덱스에 해당하는 값을 알아내는 함수
2) 인수값:
    sequence : 수열의 리스트
  n : 몇 번째 값을 가져올 지
3) 반환값: int 또는 float으로 된 n번째 값
4) 예시:
  R0: LIST()
  R1: APPEND(R0, 1)
  R2: APPEND(R1, 2)
  R3: APPEND(R2, 3)
  R4: SEQ_TERM(R3, 10)

  27. REP_SEQ_TERM

    REP_SEQ_TERM(seq: List, index: int) -> Union[int, float]
1) 목적/변화: 반복되는 수열을 입력받아 n번째 인덱스에 해당하는 값을 알아내는 함수(이때 입력받는 수열은 두 번 반복되는 수열이다)
2) 인수값:
  sequence : 수열의 리스트
  n : 몇 번째 값을 가져올 지
3) 반환값: int 또는 float으로 된 n번째 값
4) 예시:
  R0: LIST()
  R1: APPEND(R0, 1)
  R2: APPEND(R1, 2)
  R3: APPEND(R2, 3)
  R4: APPEND(R3, 1)
  R5: APPEND(R4, 2)
  R6: APPEND(R5, 3)
  R7: REP_SEQ_TERM(R6, 10)

  28. MAKE_PAIR

    MAKE_PAIR(x1: str, x2:Union[str, int]) -> Tuple
1) 목적/변화: string 값에 대해 값을 쌍으로 묶어준다
2) 인수값: string과 int의 쌍 또는 string과 string의 쌍
3) 반환값: Tuple
4) 예시:
  4-1) string과 int pair
  R0: MAKE_PAIR("윤기", 4)
  4-2) string과 string pair
  R0: MAKE_PAIR("가", "나")

  29. COUNT

    COUNT(ls1: List) -> int
1) 목적/변화: ls의 인자 개수를 세어주는 함수
2) 인수값: list
3) 반환값: list에서의 인자 개수
4) 예시:
  R0: LIST()
  R1: APPEND(R0, 1)
  R2: APPEND(R1, 2)
  R3: APPEND(R2, 3)
  R4: COUNT(R3)           (= 3)

  30. LT

    LT(ls1 : List, x1: int)
1) 목적/변화: 
  리스트의 각 원소들을 입력받은 인자인 n과 비교하여 n보다 작으면 1,
  n보다 크거나 같으면 0으로 바꿔준다.
2) 인수값: 비교하고 싶은 list, 기준이 되는 int값
3) 반환값: 결과 list
4) 예시:
  R0: LIST()
  R1: APPEND(R0, 1)
  R2: APPEND(R1, 2)
  R3: APPEND(R2, 3)
  R4: APPEND(R3, 4)
  R5: APPEND(R4, 5)
  R6: APPEND(R5, 6)
  R7: LT(R6, 4)  (= [1,1,1,0,0,0])

  31. LE

    LE(ls1: List, x1: int)
1) 목적/변화:
  리스트의 각 원소들을 입력받은 인자인 n과 비교하여 n보다 작거나 같으면 1,
  n보다 크면 0으로 바꿔준다.
2) 인수값: 비교하고 싶은 list, 기준이 되는 int값
3) 반환값: 결과 list
4) 예시:
  R0: LIST()
  R1: APPEND(R0, 1)
  R2: APPEND(R1, 2)
  R3: APPEND(R2, 3)
  R4: APPEND(R3, 4)
  R5: APPEND(R4, 5)
  R6: APPEND(R5, 6)
  R7: LE(R6, 4)  (= [1,1,1,1,0,0])

  32. GT

    GT(ls1: List, x1: int)
1) 목적/변화:
  리스트의 각 원소들을 입력받은 인자인 n과 비교하여 n보다 크면 1,
  n보다 작거나 같으면 0으로 바꿔준다.
2) 인수값: 비교하고 싶은 list, 기준이 되는 int값
3) 반환값: 결과 list
4) 예시:
  R0: LIST()
  R1: APPEND(R0, 1)
  R2: APPEND(R1, 2)
  R3: APPEND(R2, 3)
  R4: APPEND(R3, 4)
  R5: APPEND(R4, 5)
  R6: APPEND(R5, 6)
  R7: GT(R6, 4)  (= [0,0,0,0,1,1])

  33. GE

    GE(ls1: List, x1: int)
1) 목적/변화:
  리스트의 각 원소들을 입력받은 인자인 n과 비교하여 n보다 크거나 같으면 1,
  n보다 작으면 0으로 바꿔준다
2) 인수값: 비교하고 싶은 list, 기준이 되는 int값
3) 반환값: 결과 list
4) 예시:
  R0: LIST()
  R1: APPEND(R0, 1)
  R2: APPEND(R1, 2)
  R3: APPEND(R2, 3)
  R4: APPEND(R3, 4)
  R5: APPEND(R4, 5)
  R6: APPEND(R5, 6)
  R7: GE(R6, 4)      (= [0,0,0,1,1,1])

  34. LIST_CONCAT

    LIST_CONCAT(ls1: List[Any], ls2: List[Any]) -> List[Any]
1) 목적/변화: 리스트 두 개를 붙여서 새로운 리스트를 만든다
2) 인수값: 리스트2개
3) 반환값: 리스트1개 [ls1, ls2]
4) 예시:
  R0: LIST()
  R1: APPEND(R0, 1)
  R2: APPEND(R1, 2)
  R3: APPEND(R2, 3)
  R4: LIST()
  R5: APPEND(R4, 4)
  R6: APPEND(R5, 5)
  R7: APPEND(R6, 6)
  R8: LIST_CONCAT(R3,R7)
5) 제한 조건: 리스트는 꼭 원하는 순서에 맞춰서 인수로 줘야한다

  35. LIST_INDEX

    LIST_INDEX(ls1: List[Union[int,float,str]],item: Union[str, int, float]) -> int
1) 목적/변화: 리스트와 원소가 주어지면 해당 원소의 인덱스를 반환한다
2) 인수값: 리스트, str 또는 int 또는 float 원소
3) 반환값: int
4) 예시:
  R0: LIST()
  R1: APPEND(R0, 1)
  R2: APPEND(R1, 2)
  R3: APPEND(R2, 3)
  R4: APPEND(R3, 4)
  R5: APPEND(R4, 5)
  R6: APPEND(R5, 6)
    R7: LIST_INDEX(R6, 3)

  36. LIST_REPLACE

    LIST_REPLACE(ls1: List[Union[int,float,str]], index: int, item: Union[int,float,str]) -> List[Union[int,float,str]]
1) 목적/변화: 리스트 속에 n번째 인덱스에 해당하는 값을 item으로 바꾼다.
2) 인수값: 리스트, 바꾸고자 하는 item, 바꾸고자 하는 위치
3) 반환값: 새로 바뀐 리스트
4) 예시:
    R0: LIST()
  R1: APPEND(R0, 1)
  R2: APPEND(R1, 2)
  R3: APPEND(R2, 3)
    R4: LIST_REPLACE(R3, 2, 4)        (=[1,2,4])
5) 제한 조건: 리스트 안의 항목은 타입이 모두 통일되어야 한다.
(정수형이면 정수만, 실수형이면 실수만, 문자열이면 문자열)

  37. CEIL

    CEIL(x1: Union[int,float]) -> int
1) 목적/변화: 입력된 실수를 올림한다.
2) 인수값: 실수 (혹은 정수)
3) 반환값: 정수
4) 예시:
    R0: CEIL(5.5)     (= 6)

  38. LIST_MUL

    LIST_MUL(lst: List[Any], n: int) -> List[Any]
1) 목적/변화:
2) 인수값: Any 자료형으로 구성된 리스트, 리스트를 뿔리고 싶은 횟수
3) 반환값: 뿔어난 리스트
4) 예시:
    R0: List()
    R1: APPEND(R0, 1)
    R2: APPEND(R1, 2)
    R3: APPEND(R2, 3)
    R4: LIST_MUL(R3, 2)

  39. GET_DIGIT(original: int, place: int)

    1) 목적/변화: 숫자에서 원하는 자리수 추출
2) 인수값: original -> 원본 숫자 / place -> n번째 자리수 
3) 결과값: 숫자
4) 예시: 
    R0: GET_DIGIT(149, 2) --> 결과

  40. CHANGE_DIGIT(original: int, place: int, digit: int)

    1) 목적/변화: 자리수
2) 인수값: original -> 원본 숫자 / place -> 교체하고자 하는 자리수 / digit -> 교체 당하는 자리수
3) 결과값: 자리수가 교체된 숫자

  41. GET_ITEM(ls1: List[Any], item: Union[str, int, float]) -> int

    1) 목적/변화: 리스트 속에 있는 원소의 인덱스를 뽑는다
2) 인수값: lst -> 리스트 / item -> 인덱스를 알고자하는 원소
3) 결과값: 원소의 인덱스
4) 예시: 준석이가 선두로 재명, 준표 이 순서대로 뒤따라 달리고 있다. 준석은 몇 등인가?
    (LIST 구성됐다고 가정..)
    R0: GET_ITEM('준석')

  42. LIST_SORT(lst: List[Union[int, float]]) -> List[Union[int, float]]

    1) 목적/변화: 리스트를 ascending order로 정렬 (min -> max)
2) 인수값: 정렬하고자 하는 리스트
3) 결과값: 정렬된 리스트

  43. CIR_AREA(radius: Union[int, float]) -> float

    1) 목적/변화: 원의 넓이를 구한다
2) 인수값: 원의 반지름(정수 혹은 실수)
3) 결과값: 원의 넓이

  44. CIRCUM(radius: Union[int, float]) -> float

    1) 목적/변화: 원의 둘레를 구한다
2) 인수값: 원의 반지름(정수 혹은 실수)
3) 결과값: 원의 둘레

  45. SPHERE_SURFACE(radius: Union[int, float]) -> float

    1) 목적/변화: 구의 겉넓이를 구한다
2) 인수값: 구의 반지름(정수 혹은 실수)
3) 결과값: 구의 겉넓이

  46. SPHERE_VOLUME(radius: Union[int, float]) -> float

    1) 목적/변화: 구의 부피를 구한다
2) 인수값: 구의 반지름(정수 혹은 실수)
3) 결과값: 구의 부피

  47. TRI_AREA(a: Union[int, float], b: Union[int, float], c: Union[int, float]) -> Union[int, float]

    1) 목적/변화: 헤론의 공식을 이용하여 삼각형의 넓이
2) 인수값: 삼각형의 세 변의 길이 (정수 혹은 실수)
3) 결과값: 삼각형의 넓이
4) 예시: 삼각형의 변의 길이가 각각 1, 2, 3일 때 넓이를 구하여라
    R0: TRI_AREA(1,2,3)
    R1: PRINT(R0)

  48. POLY(polygon: str) -> int

    1) 목적/변화: 'n각형'을 입력하면 그에 맞는 각/변의 개수를 돌려준다.
2) 인수값: n각형
3) 결과값: 각/변의 개수
4) 예시: 
    R0: POLY('삼각형') --> 결과: 3

Examples

  1. 상자 안에 9개의 공이 있습니다. 석진이가 5개의 공을 상자 안에 더 넣었습니다. 상자 안에 있는 공은 모두 몇 개입니까?

    답: 14

 _00:상자 _01:안에 _02:9 _03:개의 _04:공이 _05:있습니다 _06:. 
 _07:석진 _08:이가 _09:5 _10:개의 _11:공을 _12:상자 _13:안에 _14:더 _15:넣었습니다 _16:. 
 _17:상자 _18:안에 _19:있는 _20:공은 _21:모두 _22:몇 _23:개입니까 _24:?

R0: ADD(_02, _09)  # 9와 5를 합함
R1: PRINT(R0)  # 합한 결과를 출력함

  1. 1부터 200까지의 홀수의 합을 구하시오.

    답: 10000

_00:1 _01:부터 _02:200 _03:까지의 _04:홀수의 _05:합을 _06:구하시오 _07:.

R0: ADD(_02, 1)  # 200과 1을 더함. 1은 상수
R1: RANGE(_00, R0, 2)  # 1부터 201미만까지 2 간격으로 리스트 생성. 2는 상수
R2: SUM(R1)  # 생성된 리스트의 총합 계산
R3: PRINT(R2)  # 합한 결과 출력

  1. 한 상자에는 감이 100개씩 들어있습니다. 6개의 상자 안에 있는 감은 모두 몇 개일까요?

    답: 600

_00:한 _01:상자에는 _02:감이 _03:100 _04:개씩 _05:들어있습니다 _06:.
_07:6 _08:개의 _09:상자 _10:안에 _11:있는 _12:감은 _13:모두 _14:몇 _15:개일까요 _16:?

R0: MUL(_03, _07)  # 100 곱하기 6
R1: PRINT(R0)  # 곱한 결과 출력

  1. 지민, 정국, 태형이의 수학 점수는 각각 94점, 82점, 88점입니다. 이 셋을 제외한 학급의 수학 점수 평균은 78점입니다. 지민이네 학급 인원수가 30명일 때, 학급 수학 평균 점수는 몇 점입니까?

    답: 79

_00:지민 _01:, _02:정국 _03:, _04:태형 _05:이의 _06:수학 _07:점수는 _08:각각 _09:94 _10:점 _11:, _12:82 _13:점 _14:, _15:88 _16:점입니다 _17:. 
_18:이 _19:셋을 _20:제외한 _21:학급의 _22:수학 _23:점수 _24:평균은 _25:78 _26:점입니다 _27:. 
_28:지민 _29:이네 _30:학급 _31:인원수가 _32:30 _33:명일 _34:때 _35:, _36:학급 _37:수학 _38:평균 _39:점수는 _40:몇 _41:점입니까 _42:?

R0: LIST()  # 빈 리스트 초기화
R1: APPEND(R0, _09)  # 지민 점수 추가. [94]
R2: APPEND(R1, _12)  # 정국 점수 추가. [94, 82]
R3: APPEND(R2, _15)  # 태형 점수 추가. [94, 82, 88]
R4: SUM(R3)  # 세 사람 점수 합산.
R5: COUNT(R3)  # 제외된 사람 수 계산.
R6: SUB(_32, R5)  # 30명에서 3명 제외
R7: MUL(_25, R6)  # 3명 제외한 총점
R8: ADD(R4, R7)  # 학급 전체 총점
R9: DIV(R8, _32)  # 학급 전체 평균
R10: TO_INT(R9) # 결과를 정수로
R11: PRINT(R10)

  1. 20명의 학생들이 한 줄로 줄을 섰습니다. 윤기의 앞에 11명의 학생들이 서 있습니다. 윤기의 뒤에 서 있는 학생은 몇 명입니까?

    답: 8

_00:20 _01:명의 _02:학생들이 _03:한 _04:줄로 _05:줄을 _06:섰습니다 _07:. 
_08:윤기 _09:의 _10:앞에 _11:11 _12:명의 _13:학생들이 _14:서 _15:있습니다 _16:. 
_17:윤기 _18:의 _19:뒤에 _20:서 _21:있는 _22:학생은 _23:몇 _24:명입니까 _25:?

R0: SUB(_00, _11)  # 20 - 11
R1: SUB(R0, 1)  # 윤기도 제외
R2: PRINT(R1)

  1. 달리기 시합에서 남준이는 2등을 했고, 윤기는 4등을 했습니다. 호석이는 윤기보다 잘했지만 남준이보다는 못했습니다. 호석이의 등수는 몇 등입니까?

    답: 3

_00:달리기 _01:시합에서 _02:남준 _03:이는 _04:2 _05:등을 _06:했고 _07:, _08:윤기 _09:는 _10:4 _11:등을 _12:했습니다 _13:. 
_14:호석 _15:이는 _16:윤기 _17:보다 _18:잘했지만 _19:남준 _20:이보다는 _21:못했습니다 _22:. 
_23:호석 _24:이의 _25:등수는 _26:몇 _27:등입니까 _28:?

R0: LIST()
R1: APPEND(R0, _02)
R2: LIST()
R3: APPEND(R2, _08)
R4: LIST()
R5: APPEND(R4, _14)
R6: LIST_CONCAT(R5, R3)  # 호석이는 윤기보다 잘했지만
R7: LIST_CONCAT(R1, R6)  # 둘은 남준이보다 못했습니다.
R8: LIST_INDEX(R7, _14)  # 세사람 사이에서 호석이의 위치: 인덱스는 0부터 시작하므로 1
R9: ADD(_04, R8)
R10: PRINT(R9)

  1. 키가 작은 사람부터 순서대로 9명이 한 줄로 서 있습니다. 호석이가 앞에서부터 5번째에 서 있습니다. 키가 큰 사람부터 순서대로 다시 줄을 서면 호석이는 앞에서부터 몇 번째에 서게 됩니까?

    답: 5

_00:키가 _01:작은 _02:사람부터 _03:순서대로 _04:9 _05:명이 _06:한 _07:줄로 _08:서 _09:있습니다 _10:.
_11:호석 _12:이가 _13:앞에서부터 _14:5 _15:번째에 _16:서 _17:있습니다 _18:.
_19:키가 _20:큰 _21:사람부터 _22:순서대로 _23:다시 _24:줄을 _25:서면 _26:호석 _27:이는 _28:앞에서부터 _29:몇 _30:번째에 _31:서게 _32:됩니까 _33:?

R0: SUB(_04, _14)  # 9 - 5. 호석 뒤 사람 수
R1: ADD(R0, 1)  # 뒤에서부터 센 순위
R2: PRINT(R1)

  1. 사과 7개를 서로 다른 2마리의 원숭이에게 나누어 주려고 합니다. 원숭이는 적어도 사과 1개는 받습니다. 사과를 나누어 주는 방법은 모두 몇 가지입니까?

    답: 6

_00:사과 _01:7 _02:개를 _03:서로 _04:다른 _05:2 _06:마리의 _07:원숭이에게 _08:나누어 _09:주려고 _10:합니다 _11:. 
_12:원숭이는 _13:적어도 _14:사과 _15:1 _16:개는 _17:받습니다 _18:. 
_19:사과를 _20:나누어 _21:주는 _22:방법은 _23:모두 _24:몇 _25:가지입니까 _26:?

R0: SUB(_01, _05)  # 일단 사과 2개는 주인 확정
R1: SUB(_05, 1)  # 나머지 경우는 |*|*|*|*|*| 왼쪽의 파이프 중 (2-1)개 중복 조합이므로, r = 2-1.
R2: ADD(R0, 1)  # n은 파이프 개수이므로 사과 개수 + 1
R3: ADD(R2, R1)  # n+r
R4: SUB(R3, 1)  # n+r-1
R5: COMB(R4, R1)  # n+r-1Cr = nHr
R6: PRINT(R5)

  1. 4개의 숫자 7, 2, 5, 9를 한 번씩만 사용하여 네 자리 수를 만들려고 합니다. 만들 수 있는 네 자리 수는 모두 몇 개입니까?

    답: 24

_00:4 _01:개의 _02:숫자 _03:7 _04:, _05:2 _06:, _07:5 _08:, _09:9 _10:를 _11:한 _12:번씩만 _13:사용하여 _14:네 _15:자리 _16:수를 _17:만들려고 _18:합니다 _19:.
_20:만들 _21:수 _22:있는 _23:네 _24:자리 _25:수는 _26:모두 _27:몇 _28:개입니까 _29:?

R0: PERM(_00, _00)
R1: PRINT(R0)

  1. 사과, 복숭아, 배, 참외 중에서 2가지의 과일을 골라서 사는 경우는 모두 몇 가지입니까?

    답: 6

_00:사과 _01:, _02:복숭아 _03:, _04:배 _05:, _06:참외 _07:중에서 _08:2 _09:가지의 _10:과일을 _11:골라서 _12:사는 _13:경우는 _14:모두 _15:몇 _16:가지입니까 _17:?

R0: LIST()
R1: APPEND(R0, _00)
R2: APPEND(R1, _02)
R3: APPEND(R2, _04)
R4: APPEND(R3, _06)
R5: COUNT(R4)
R6: COMB(R5, _08)
R7: PRINT(R6)

  1. 4개의 수 53, 98, 69, 84가 있습니다. 그 중에서 가장 큰 수와 가장 작은 수의 차는 얼마입니까?

    답: 45

_00:4 _01:개의 _02:수 _03:53 _04:, _05:98 _06:, _07:69 _08:, _09:84 _10:가 _11:있습니다 _12:.
_13:그 _14:중에서 _15:가장 _16:큰 _17:수와 _18:가장 _19:작은 _20:수의 _21:차는 _22:얼마입니까 _23:?

R0: LIST()
R1: APPEND(R0, _03)  # [53]
R2: APPEND(R1, _05)  # [53, 98]
R3: APPEND(R2, _07)  # [53, 98, 69]
R4: APPEND(R3, _09)  # [53, 98, 69, 84]
R5: MAX(R4)
R6: MIN(R4)
R7: SUB(R5, R6)
R8: PRINT(R7)

  1. 어떤 소수의 소수점을 오른쪽으로 한 자리 옮기면 원래보다 2.7만큼 커집니다. 원래의 소수를 구하시오.

    답: 0.30

_00:어떤 _01:소수의 _02:소수점을 _03:오른쪽으로 _04:한 _05:자리 _06:옮기면 _07:원래보다 _08:2.7 _09:만큼 _10:커집니다 _11:.
_12:원래의 _13:소수를 _14:구하시오 _15:.

R0: SUB(10, 1)  # 10 - 1
R1: DIV(_08, R0)  # 2.7/(10-1)
R2: PRINT(R1)

  1. 3개의 수 2, 3, 9로 나누어 떨어질 수 있는 세 자리 수는 모두 몇 개 있습니까?

    답: 50

_00:3 _01:개의 _02:수 _03:2 _04:, _05:3 _06:, _07:9 _08:로 _09:나누어 _10:떨어질 _11:수 _12:있는 _13:세 _14:자리 _15:수는 _16:모두 _17:몇 _18:개 _19:있습니까 _20:?

R0: LIST()
R1: APPEND(R0, _03)  # [2]
R2: APPEND(R1, _05)  # [2, 3]
R3: APPEND(R2, _07)  # [2, 3, 9]
R4: DIGIT(1, 3)
R5: DIGIT(1, 4)
R6: RANGE(R4, R5, 1)  # 세 자리수 범위
R7: COUNT_MULTI(R6, R3)
R8: PRINT(R7)

  1. 두 자리 수의 덧셈식 A4+2B=69에서 A에 해당하는 숫자를 쓰시오.

    답: 4

_00:두 _01:자리 _02:수의 _03:덧셈식 _04:A4+2B=69 _05:에서 _06:A _07:에 _08:해당하는 _09:숫자를 _10:쓰시오 _11:.

R0: LIST()
R1: APPEND(R0, _04)
R2: CALL_SYMPY(R1, _06)
R3: PRINT(R2)

  1. A를 8로 나누면 몫은 B이고 나머지는 C가 됩니다. A, B, C는 자연수입니다. 이 식에서 몫과 나머지가 같습니다. 나누어지는 수 A 중 가장 큰 수를 구하시오.

    답: 63

_00:A _01:를 _02:8 _03:로 _04:나누면 _05:몫은 _06:B _07:이고 _08:나머지는 _09:C _10:가 _11:됩니다 _12:.
_13:A _14:, _15:B _16:, _17:C _18:는 _19:자연수입니다 _20:. 
_21:이 _22:식에서 _23:몫과 _24:나머지가 _25:같습니다 _26:. 
_27:나누어지는 _28:수 _29:A _30:중 _31:가장 _32:큰 _33:수를 _34:구하시오 _35:.

R0: RANGE(0, _02, 1)  # 나머지 범위
R1: MAX(R0)  # 가장 큰 나머지
R2: MUL(_02, R1)  # 나머지와 몫이 같아서, 몫으로 먼저 사용
R3: ADD(R2, R1)  # 나머지 합산
R4: PRINT(R3)

  1. 서로 다른 두 자연수 A, B가 있습니다. A+B=30, A=B+B+B+B일 때, A를 구하시오.

    답: 24

_00:서로 _01:다른 _02:두 _03:자연수 _04:A _05:, _06:B _07:가 _08:있습니다 _09:.
_10:A+B=30 _11:, _12:A=B+B+B+B _13:일 _14:때 _15:, _16:A _17:를 _18:구하시오 _19:.

R0: LIST()
R1: APPEND(R0, _10)
R2: APPEND(R1, _12)
R3: CALL_SYMPY(R2, _16)  # A에 대한 답 계산
R4: PRINT(R3)

  1. 어떤 수에서 36을 빼야 하는데 잘못하여 63을 뺀 결과가 8이 나왔습니다. 바르게 계산한 결과를 구하시오.

    답: 35

_00:어떤 _01:수에서 _02:36 _03:을 _04:빼야 _05:하는데 _06:잘못하여 _07:63 _08:을 _09:뺀 _10:결과가 _11:8 _12:이 _13:나왔습니다 _14:.
_15:바르게 _16:계산한 _17:결과를 _18:구하시오 _19:.

R0: ADD(_11, _07)  # 8 + 63
R1: SUB(R0, _02)  # 다시 제대로 36 뺌
R2: PRINT(R1)

  1. 윤기는 네 자리 수와 두 자리 수의 뺄셈을 하려 합니다. 윤기는 네 자리 수의 일의 자리 숫자 9를 6으로 잘못 보았고, 두 자리 수의 십의 자리 숫자와 일의 자리 숫자를 바꾸어 75라고 잘못 보았습니다. 윤기가 구한 차는 1821 일 때, 바르게 계산한 결과를 구하시오.

    답: 1842

_00:윤기 _01:는 _02:네 _03:자리 _04:수와 _05:두 _06:자리 _07:수의 _08:뺄셈을 _09:하려 _10:합니다 _11:. 
_12:윤기 _13:는 _14:네 _15:자리 _16:수의 _17:일의 _18:자리 _19:숫자 _20:9 _21:를 _22:6 _23:으로 _24:잘못 _25:보았고 _26:, _27:두 _28:자리 _29:수의 _30:십의 _31:자리 _32:숫자와 _33:일의 _34:자리 _35:숫자를 _36:바꾸어 _37:75 _38:라고 _39:잘못 _40:보았습니다 _41:. 
_42:윤기 _43:가 _44:구한 _45:차는 _46:1821 _47:일 _48:때 _49:, _50:바르게 _51:계산한 _52:결과를 _53:구하시오 _54:.

R0: ADD(_46, _37)  # 1821 + 75
R1: REVERSE_DIGIT(_37)  # 75 --> 57
R2: DIGIT(_20, 1)  # 1의 자리 9
R3: DIGIT(_22, 1)  # 1의 자리 6
R4: SUB(R0, R3)  # 잘못 본 일의자리 삭제
R5: ADD(R4, R2)  # 원래 숫자
R6: SUB(R5, R1)  # 계산해야 했던 차
R7: PRINT(R6)

  1. 어떤 수에서 46을 뺐더니 15가 되었습니다. 어떤 수에서 29를 빼면 얼마가 되는지 구하시오.

    답: 32

_00:어떤 _01:수에서 _02:46 _03:을 _04:뺐더니 _05:15 _06:가 _07:되었습니다 _08:. 
_09:어떤 _10:수에서 _11:29 _12:를 _13:빼면 _14:얼마가 _15:되는지 _16:구하시오 _17:.

R0: ADD(_05, _02)  # 15 + 46
R1: SUB(R0, _11)  # 29을 뺌
R2: PRINT(R1)

  1. 2에 어떤 수를 곱해야 할 것을 잘못하여 5에 어떤 수를 곱했더니 40이 되었습니다. 바르게 계산하면 얼마인지 구하시오.

    답: 16

_00:2 _01:에 _02:어떤 _03:수를 _04:곱해야 _05:할 _06:것을 _07:잘못하여 _08:5 _09:에 _10:어떤 _11:수를 _12:곱했더니 _13:40 _14:이 _15:되었습니다 _16:.
_17:바르게 _18:계산하면 _19:얼마인지 _20:구하시오.

R0: DIV(_13, _08)  # 40/5
R1: MUL(R0, _00)  # 2를 곱함
R2: TO_INT(R1)
R3: PRINT(R2)

  1. 1, 17, 33, 49, 65와 같은 규칙에서 25번째 놓일 수와 40번째 놓일 수를 각각 A와 B라 할 때, B-A를 구하시오.

    답: 240

_00:1 _01:, _02:17 _03:, _04:33 _05:, _06:49 _07:, _08:65 _09:와 _10:같은 _11:규칙에서 _12:25 _13:번째 _14:놓일 _15:수와 _16:40 _17:번째 _18:놓일 _19:수를 _20:각각 _21:A _22:와 _23:B _24:라 _25:할 _26:때 _27:, _28:B-A _29:를 _30:구하시오 _31:.

R0: LIST()
R1: APPEND(R0, _00)
R2: APPEND(R1, _02)
R3: APPEND(R2, _04)
R4: APPEND(R3, _06)
R5: APPEND(R4, _08)
R6: SEQ_TERM(R5, _12)  # 25번째 항
R7: SEQ_TERM(R5, _16)  # 40번째 항
R8: SUB(R7, R6)  # B-A
R9: TO_INT(R8)
R10: PRINT(R9)

  1. 자연수를 규칙에 따라 4, 7, 10, A, 16, 19로 배열하였습니다. A에 알맞은 수를 구하시오.

    답: 13

_00:자연수를 _01:규칙에 _02:따라 _03:4 _04:, _05:7 _06:, _07:10 _08:, _09:A _10:, _11:16 _12:, _13:19 _14:로 _15:배열하였습니다 _16:.
_17:A _18:에 _19:알맞은 _20:수를 _21:구하시오 _22:.

R0: LIST()
R1: APPEND(R0, _03)
R2: APPEND(R1, _05)
R3: APPEND(R2, _07)
R4: APPEND(R3, _09)
R5: APPEND(R4, _11)
R6: APPEND(R5, _13)
R7: LIST_INDEX(R6, _09)  # A의 위치 찾기
R8: ADD(R7, 1)
R9: SEQ_TERM(R6, R8)
R10: TO_INT(R9)
R11: PRINT(R10)

  1. 1, 5, 14, 30, 55, 91과 같은 규칙으로 수를 배열하고 있습니다. 9번째 수는 무엇입니까?

    답: 285

_00:1 _01:, _02:5 _03:, _04:14 _05:, _06:30 _07:, _08:55 _09:, _10:91 _11:과 _12:같은 _13:규칙으로 _14:수를 _15:배열하고 _16:있습니다 _17:.
_18:9 _19:번째 _20:수는 _21:무엇입니까 _22:?

R0: LIST()
R1: APPEND(R0, _00)
R2: APPEND(R1, _02)
R3: APPEND(R2, _04)
R4: APPEND(R3, _06)
R5: APPEND(R4, _08)
R6: APPEND(R5, _10)
R7: SEQ_TERM(R6, _18)  # 9번째 항
R8: TO_INT(R7)
R9: PRINT(R8)

  1. 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7과 같이 반복되는 수열이 있습니다. 왼쪽에서 57번째 숫자는 무엇입니까?

    답: 1

_00:1 _01:, _02:2 _03:, _04:3 _05:, _06:4 _07:, _08:5 _09:, _10:6 _11:, _12:7 _13:, _14:1 _15:, _16:2 _17:, _18:3 _19:, _20:4 _21:, _22:5 _23:, _24:6 _25:, _26:7 _27:과 _28:같이 _29:반복되는 _30:수열이 _31:있습니다 _32:.
_33:왼쪽에서 _34:57 _35:번째 _36:숫자는 _37:무엇입니까 _38:?

R0: LIST()
R1: APPEND(R0, _00)
R2: APPEND(R1, _02)
R3: APPEND(R2, _04)
R4: APPEND(R3, _06)
R5: APPEND(R4, _08)
R6: APPEND(R5, _10)
R7: APPEND(R6, _12)
R8: APPEND(R7, _14)
R9: APPEND(R8, _16)
R10: APPEND(R9, _18)
R11: APPEND(R10, _20)
R12: APPEND(R11, _22)
R13: APPEND(R12, _24)
R14: APPEND(R13, _26)
R15: REP_SEQ_TERM(R14, _34)  # 57번째 항
R16: PRINT(R15)

  1. 왼쪽부터 흰색 공 1개, 노란색 공 2개, 빨간색 공 3개가 반복되어 놓여 있습니다. 58번째 공의 색깔을 쓰시오.

    답: 빨간색

_00:왼쪽부터 _01:흰색 _02:공 _03:1 _04:개 _05:, _06:노란색 _07:공 _08:2 _09:개 _10:, _11:빨간색 _12:공 _13:3 _14:개가 _15:반복되어 _16:놓여 _17:있습니다 _18:.
_19:58 _20:번째 _21:공의 _22:색깔을 _23:쓰시오 _24:.

R0: LIST()
R1: APPEND(R0, _01)  # 흰색
R2: LIST_MUL(R1, _03)
R3: LIST()
R4: APPEND(R3, _06)  # 노란색
R5: LIST_MUL(R4, _08)
R6: LIST()
R7: APPEND(R6, _11)
R8: LIST_MUL(R7, _13)
R9: LIST_CONCAT(R2, R5)
R10: LIST_CONCAT(R9, R8)
R11: REP_SEQ_TERM(R10, _19)  # 58번째 항
R12: PRINT(R11)

  1. 100개의 사탕을 태형, 남준, 윤기 3명에게 순서대로 2개씩 나누어 줍니다. 91번째 사탕을 받는 사람은 누구입니까?

    답: 태형

_00:100 _01:개의 _02:사탕을 _03:태형 _04:, _05:남준 _06:, _07:윤기 _08:3 _09:명에게 _10:순서대로 _11:2 _12:개씩 _13:나누어 _14:줍니다 _15:.
_16:91 _17:번째 _18:사탕을 _19:받는 _20:사람은 _21:누구입니까 _22:?

R0: LIST()
R1: APPEND(R0, _03)  # 태형
R2: LIST_MUL(R1, _11)
R3: LIST()
R4: APPEND(R3, _05)  # 남준
R5: LIST_MUL(R4, _11)
R6: LIST()
R7: APPEND(R6, _07) # 윤기
R8: LIST_MUL(R7, _11)
R9: LIST_CONCAT(R2, R5)
R10: LIST_CONCAT(R9, R8)
R11: REP_SEQ_TERM(R10, _16)  # 91번째 항
R12: PRINT(R11)

  1. 정국이는 4와 4를 모았습니다. 지민이는 3과 6을 모았습니다. 누가 모은 수가 더 큽니까?

    답: 지민

_00:정국 _01:이는 _02:4 _03:와 _04:4 _05:를 _06:모았습니다 _07:. _08:지민 _09:이는 _10:3 _11:과 _12:6 _13:을 _14:모았습니다 _15:. 
_16:누가 _17:모은 _18:수가 _19:더 _20:큽니까 _21:?

R0: LIST()
R1: MAKE_PAIR(_00, _02)  # <정국, 4>
R2: APPEND(R0, R1)
R3: MAKE_PAIR(_00, _04)  # <정국, 4>
R4: APPEND(R2, R3)
R5: MAKE_PAIR(_08, _10)  # <지민, 3>
R6: APPEND(R4, R5)
R7: MAKE_PAIR(_08, _12)  # <지민, 6>
R8: APPEND(R6, R7)
R9: MAX(R8)  # 순서쌍 중 두번째 값이 최대인 순서쌍을 찾고, 그 순서쌍의 첫번째 값 반환
R10: PRINT(R9)  # '지민'

  1. (가), (나), (다), (라) 4개의 상자가 있습니다. (나) 상자는 (라) 상자보다 큽니다. (가) 상자는 (라) 상자보다 작습니다. (나) 상자는 (다) 상자보다 작습니다. 크기가 가장 작은 상자는 무엇입니까?

    답: 가

_00:(가) _01:, _02:(나) _03:, _04:(다) _05:, _06:(라) _07:4 _08:개의 _09:상자가 _10:있습니다 _11:. 
_12:(나) _13:상자는 _14:(라) _15:상자보다 _16:큽니다 _17:. 
_18:(가) _19:상자는 _20:(라) _21:상자보다 _22:작습니다 _23:. 
_24:(나) _25:상자는 _26:(다) _27:상자보다 _28:작습니다 _29:.
_30:크기가 _31:가장 _32:작은 _33:상자는 _34:무엇입니까 _35:?

R0: LIST()
R1: APPEND(R0, _18)
R2: APPEND(R1, _20)
R3: APPEND(R2, _24)
R4: APPEND(R3, _26)
R5: LIST()
R6: LIST_INDEX(R4, _18)
R7: MAKE_PAIR(_18, R6)
R8: APPEND(R5, R7)
R9: LIST_INDEX(R4, _20)
R10: MAKE_PAIR(_20, R9)
R11: APPEND(R8, R10)
R12: LIST_INDEX(R4, _24)
R13: MAKE_PAIR(_24, R12)
R14: APPEND(R11, R13)
R15: LIST_INDEX(R4, _26)
R16: MAKE_PAIR(_26, R15)
R17: APPEND(R14, R16)
R18: MIN(R17)
R19: PRINT(R18)

  1. 5개의 수 1.4, 9/10, 1.1, 0.5, 13/10이 있습니다. 이 중에서 0.9보다 큰 수는 모두 몇 개입니까?

    답: 3

_00:5 _01:개의 _02:수 _03:1.4 _04:, _05:9/10 _06:, _07:1.1 _08:, _09:0.5 _10:, _11:13/10 _12:이 _13:있습니다 _14:.
_15:이 _16:중에서 _17:0.9 _18:보다 _19:큰 _20:수는 _21:모두 _22:몇 _23:개입니까 _24:?

R0: LIST()
R1: APPEND(R0, _03)  # [1.4]
R2: APPEND(R1, _05)  # [1.4, 9/10]
R3: APPEND(R2, _07)  # [1.4, 9/10, 1.1]
R4: APPEND(R3, _09)  # [1.4, 9/10, 1.1, 0.5]
R5: APPEND(R4, _11)  # [1.4, 9/10, 1.1, 0.5, 13/10]
R6: GT(R5, _17)  # [1, 0, 1, 0, 1]
R7: SUM(R6)
R8: PRINT(R7)