Code.org분석

수탁연구 : 2015-02
Code.org 분석
“프로그래밍 언어는 제3외국어이다.
모든 학생들이 프로그래밍을 배울 필요는 없지만
배울 수 있는 기회는 반드시 주어져야 한다.”
과제책임자 : 정영식(전주교육대학교)
공동연구원 : 서진화(탄벌초등학교)
안형진(전주교육대학교)
안신영(전주교육대학교)
경규일(엔트리교육연구소)
전주교육대학교 컴퓨터교육과

- ii -
본 연구는 엔트리교육연구소의 ‘소프트웨어 교육 활성화를 위한 엔
트리 교육과정 개발 방안 연구’에 관한 연구비로 수행된 것으로서, 본
연구에서 제시된 정책 대안이나 의견 등은 엔트리교육연구소의 공식
의견이 아닌 본 연구진의 개인 견해임을 밝혀둡니다.

- iii -
차 례
I. 제 1 코스 Code.org 분석 ······················································································1
1. 스테이지1: 즐거운 맵(방향키 배열) ············································································1
2. 스테이지2: 움직여 움직여(공통적인 언어 이해하기) ··············································2
3. 스테이지 3: 퍼즐 맞추기 (드래그와 드롭 연습하기) ··············································4
4. 스테이지 4: 미로퍼즐 (순차) ························································································8
5. 스테이지5: 미로퍼즐 (디버깅) ····················································································16
6. 실시간 알고리즘: 씨앗 심기 ·······················································································23
7. 스테이지7: 꿀벌(순차) ··································································································25
8. 스테이지8: 예술가(순차) ······························································································33
9. 스테이지9: 건물 기초 만들기 ···················································································40
10. 스테이지10: 예술가(모양) ··························································································42
11. 말하는 꿀벌 ··················································································································47
12. 스테이지12: 반복적으로 하기 ···················································································54
13. 스테이지13: 미로 퍼즐(반복) ····················································································55
14. 스테이지14: 꿀벌(반복) ······························································································62
15. 스테이지15: 빅 이벤트 ·······························································································69
17. 스테이지17: 안전하게 자리잡기 ···············································································74
18. 스테이지18: 예술가(반복) ··························································································76
II. 제2코스 Code.org 분석 ·························································································81
1. 스테이지1: 모눈종이 프로그래밍 ···············································································81
2. 스테이지2: 실시간 알고리즘, 종이 비행기‘ ·························································83
3. 스테이지3: 미로퍼즐, 순차 ·························································································85
4. 스테이지4: 예술가, 순차 ·····························································································92
5. 스테이지5: 반복시키기 ·································································································98
6. 스테이지6: 미로퍼즐, 반복 ·························································································99

- iv -
7. 스테이지7: 예술가, 반복 ···························································································107
8. 스테이지8: 꿀벌, 반복 ·······························································································116
9. 스테이지9: 릴레이 프로그래밍 ·················································································124
10. 스테이지10: 꿀벌, 디버깅 ·······················································································126
11. 스테이지11: 예술가, 디버깅 ···················································································132
12. 스테이지12: 조건 ······································································································139
13. 스테이지13: 꿀벌, 조건선택 ···················································································140
14. 스테이지14: 2진 팔찌 ······························································································150
15. 스테이지15: 큰 이벤트 ····························································································152
16. 스테이지16: 플래피 버드 ························································································153
17. 스테이지17: PLAY LAB, 스토리 만들기 ······························································159
19. 스테이지19: 예술가, 중첩반복 ···············································································168
III. 제 3코스 code.org 분석 ····················································································175
1. 스테이지1: 컴퓨터 과학적 사고 ···············································································175
2. 스테이지2: Maze ·········································································································177
3. 스테이지3: 예술가 ·······································································································185
4. 스테이지4: 기능성 색유리 ·························································································193
5. 스테이지5: 예술가(함수) ····························································································195
6. 스테이지6: 꿀벌(함수) ································································································203
7. 스테이지7: 꿀벌(조건선택) ························································································210
8. 스테이지8: 미로 퍼즐(조건 선택) ············································································218
9. 스테이지9: 노래 만들기 ·····························································································225
10. 스테이지10: 주사위 경주 ························································································227
11. 스테이지11: 예술가(중첩반복) ················································································229
12. 스테이지12: 농부(~인동안 반복) ············································································236
13. 스테이지13: 꿀벌(중첩 반복) ··················································································242
14. 스테이지14: 꿀벌(디버깅) ························································································249
15. 스테이지15: 바운스 ··································································································256
16. 스테이지16: Play Lab(스토리 만들기) ··································································261
18. 스테이지18: 인터넷 ··································································································268
19. 스테이지19: 클라우드소싱 ······················································································270

- v -
20. 스테이지20: 디지털 시민의식 ···············································································272
21. 스테이지21: 예술가(패턴) ························································································273
IV. 제4코스(베타) Code.org 분석 ··········································································281
1. 스테이지1: 탱그램 ·······································································································281
2. 스테이지2: 미로와 꿀벌 ·····························································································282
3. 스테이지3: 예술가 ·······································································································289
4. 스테이지4: 변수들 묶기 ·····························································································297
5. 스테이지5: Madlibs(매들립) ·······················································································298
6. 스테이지6: 예술가, 변수 ···························································································299
7. 스테이지7: 플레이 랩, 변수 ·····················································································310
8. 스테이지8: 재미있는 반복 ·························································································315
9. 스테이지9: 꿀벌, 반복 ·······························································································316
10. 스테이지10: 예술가, 반복 ·······················································································322
11. 스테이지11: 플레이 랩, 반복 ·················································································329
12. 스테이지12: 예술가, 함수 ·······················································································332
13. 스테이지13: 매개변수를 사용한 노래 만들기 ·····················································341
14. 스테이지14: 예술가, 매개변수를 사용하는 함수 ···············································342
15. 스테이지15: 플레이 랩, 매개변수를 사용하는 함수 ·········································355
16. 스테이지16: 꿀벌, 매개변수를 사용하는 함수 ···················································362

- 1 -
I. 제 1 코스 Code.org 분석1)
1. 스테이지1: 즐거운 맵(방향키 배열)
◦ 개요 : 컴퓨터과학의 기초인 알고리즘의 기본적 개념과 관계를 이해시
킨다.
◦ 학습 목표
- 캐릭터를 맵 내에서 움직이게 하기 위한 단계를 작성한다.
- 예정된 목표에 도달하기 위해 방향키들을 배열한다.
- 주어진 단계의 목록을 보고 캐릭터가 어느 곳에 도착할지 예상한다.
◦ 활동
- 1/2단계 : 실제로 종이를 잘라 방향키 배열하기
주요 화면 1 주요 화면 2 설명
Ÿ 주어진 종이에 그려진 화살표를 잘라
캐릭터에 도달할 수 있도록 배열해보는
활동이다. 여러 명의 의견을 모아 결정
한다.
Ÿ 비어있는 칸을 그려주어 앞으로의 활동
을 대비한다.
주요 개념
알고리즘: 명령을 수행하기 위하여 따라야 할 단계의 목록
- 2/2단계: 온라인으로 옮겨와 방향키 배열하기
보기 화면 문제와 선택지 답
분석
Ÿ 언플러그드 활동과 마찬가지로 화살표를 배열하는 활동이다.
Ÿ 플러브를 보물로 보내기 위한 방향키를 배열하도록 한다.
1) https://studio.code.org

- 2 -
2. 스테이지2: 움직여 움직여(공통적인 언어 이해하기)
◦ 개요 : 주어진 명령을 실행하기 위해서는 공통적인 언어가 필요함을
인지하게 한다.
◦ 학습 목표
- 과제를 수행하기 위한 프로그램을 생성해야 하는 상황을 인지한다.
- 시작부터 끝까지 캐릭터의 움직임을 예측한다.
- 움직임을 상징적인 명령으로 전환시킨다.
- 알고리즘을 프로그램에 연관시킨다.
◦ 활동
- 1/2단계 : 몸짓 언어(공통된 언어)를 통한 명령 이해하기
Ÿ controller을 수행할 인원과 walking
machine을 수행할 인원을 나눈다.
Ÿ walking machine의 시작위치는 나침도
가 그려진 종이이다.
Ÿ controller는 walking machine에게 주요
화면 2에 주어진 몸 부호를 이용하여
이동해야할 방향을 알려준다.
Ÿ 지시한 방향대로 이동하다가 목표한 위
치에 도달하면 controller는 ‘stop’ 몸
부호를 보여준다.
Ÿ 뒤집어서 웃는 얼굴의 캐릭터가 보이면
성공한 것이다.
Ÿ 아이들이 주어진 명령을 수행하는 데에
있어서 몸 부호라는 공통적인 언어를
통하여 해결하도록 함.
주요 개념
프로그램: 기계에 의하여 실행될 수 있는 무엇인가로 암호화 된 알고리즘

- 3 -
- 2/2단계: 화살표(공통된 언어)를 이용한 명령 이해하기
분석
Ÿ 플러브를 꽃에 보낼 수 있는 프로그램을 화살표라는 공통적인 언어를 통하여 해결하도록 함.
Ÿ 스테이지 1에서 한 번을 움직여서 문제를 해결했다면, 스테이지 2에서는 두 번을 움직이도록 함.
Ÿ 스테이지 2의 목표는 공통적인 언어가 필요함을 인식시키는 것인데 그 전 스테이지와 언어가 다
르지 않아서(화살표) 아이들이 인식할 수 있을지 의문임.

- 4 -
Ÿ 스테이지 3은 드래그와 드롭을 연습하
는 스테이지로 웃는 얼굴의 캐릭터를
맞는 위치에 끌어 놓으면 해결된다.
Ÿ 처음 단계에서 하나의 그림을 그대로
지정된 위치에 드래그와 드롭을 이용하
여 옮겨놓았다면, 2단계에서는 분할된
그림을 반쪽의 퍼즐에 드래그와 드롭을
이용하여 맞춰 넣으면 된다.
Ÿ 2단계에서는 퍼즐을 아래에 옮겨놓았다
면 3단계에서는 퍼즐을 위에 옮겨놓으
면 된다.
3. 스테이지 3: 퍼즐 맞추기 (드래그와 드롭 연습하기)
◦ 소개: 드래그와 드롭에 대하여 알도록 하여 나중 스테이지의 블록 알
고리즘의 제작을 돕는다.
◦ 학습목표:
- 드래그를 통하여 퍼즐을 맞춘다.
- 퍼즐에서 더 나아가 블록 알고리즘의 형태를 인지하도록 한다.
- 블록 알고리즘의 사용 방법을 알도록 한다.
◦ 활동
- 1/12단계: 하나의 그림 드래그와 드롭하기
- 2/12단계: 반쪽의 그림 드래그와 드롭하기(아래 그림)
- 3/12단계: 반쪽의 그림 드래그와 드롭하기(위 그림)

- 5 -
- 4/12단계: 세 개로 나누어진 그림 드래그와 드롭하기
Ÿ 전 단계들보다 약간 심화되어 3개의 퍼
즐을 드래그와 드롭을 이용하여 맞는
자리에 옮겨놓으면 된다.
Ÿ 이 때부터 블록의 모양이 나중에 수행
하게 될 게임에서의 블록 알고리즘을
따라가게 된다.
- 5/12단계 : 세 개로 나누어진 그림 드래그와 드롭하기(순서를 뒤바꿔
놓음)
Ÿ 전 단계에서는 그림을 순서 그대로 배
열하여 보여주었다면 이 단계에서는 순
서를 뒤바꾸어 놓았다.
- 6/12단계: 세 개로 나누어진 그림 드래그와 드롭하기(순서 뒤바뀜)
Ÿ 이 단계는 전 단계와 같은 방식으로 문
제를 해결한다.
- 7/12단계: 세 개로 나누어진 그림 드래그와 드롭하기(순서 뒤바뀜)
Ÿ 이 단계도 마찬가지로 세 개의 블록을
드래그와 드롭을 이용하여 문제를 해결
하면 된다.
Ÿ 5~7 단계를 거쳐서 같은 문제를 여러
가지 그림으로 바꿔 놓아 연습할 수 있
도록 하였다.

- 6 -
- 8/12단계: 붙어있는 세 개의 그림 드래그와 드롭하기(순서 뒤바뀜)
Ÿ 전 단계들과 같이 드래그와 드롭을 이
용하여 그림을 완성한다.
Ÿ 그림이 서로 붙어있고 맨 위에 있는 조
각을 떼어내는 과정에서 단순히 맨 위
의 조각을 떼어내면 떨어지지 않고 아
래부터 차근차근 떼어내야 떨어지도록
설정해 놓았다. 앞으로의 활동에 있어서
이용할 블록 알고리즘을 사용한 것이다.
- 9/12단계: 붙어있는 세 개의 그림 드래그와 드롭하기(순서 뒤바뀜)
Ÿ 이 단계는 앞의 단계와 같은 과정을 통
하여 해결할 수 있다.
Ÿ 이 단계를 통하여 학생들이 블록 알고
리즘에 대하여 이해할 수 있게 된다.
- 10/12단계: 블록 알고리즘 블록 드래그 앤 드롭하기(1개만 옮김)
Ÿ 그림으로 이루어졌던 블록을 실제 블록
알고리즘 모양으로 바꾸어 놓아 직접적
으로 블록 알고리즘을 체험할 수 있도
록 함.
Ÿ 주요화면 2에서 아이들은 초록 블록을
청록색 블록 아래에 올려놓게 되면 자
주색 블록이 초록색 블록 또한 감싸게
된다는 것을 인지할 수 있을 것이다.
- 11/12단계: 블록 알고리즘 블록 드래그와 드롭하기(3개 옮김)
Ÿ 앞 단계에서의 활동을 여러 번 반복하
여 연습할 수 있도록 하였다.
Ÿ 이 단계를 통하여 아이들은 블록 알고
리즘에 대하여 더 알 수 있을 것이다.

- 7 -
- 12/12단계(평가): 붙어있는 세 개의 그림 드래그와 드롭하기(순서 뒤
바뀜)
Ÿ 마지막 12단계는 평가 단계이다.
Ÿ 앞에서 한 번 맞춰보았던 퍼즐을 블록
알고리즘대로 맞춰보도록 하여 알고리
즘과 퍼즐을 연관시켜 알고리즘에 대한
이해를 더욱 도와 앞으로 할 활동을 대
비시켰다.

- 8 -
4. 스테이지 4: 미로퍼즐 (순차)
◦ 동영상
주요 화면 1 설명
Ÿ 미로퍼즐 해결 방법에 대하여 설명한다.
Ÿ 도구상자에서 블록을 드래그 해 작업화면에 드롭하면 된다고
설명한다.
Ÿ 하나의 블록 아래에 올려놓을 것을 강조한다.
Ÿ 미로퍼즐을 다 해결했다고 생각할 때 Run을 누르면 된다고 설
명한다.
◦ 활동
- 1/15단계: 왼쪽으로 이동하기(방향 지시 있음)
실행 전 블록 입력 전 블록 입력 후
분석 스크립트
Ÿ [왼쪽]을 2번 반복하여 목표지점까지 이동
moveWest();
moveWest();

- 9 -
- 2/15단계: 오른쪽으로 이동하기(방향 지시 있음)
분석 스크립트
Ÿ [오른쪽]을 2번 반복하여 목표지점까지 이동
moveEast();
moveEast();
- 3/15단계: 아래쪽으로 이동하기(방향 지시 있음)
분석 스크립트
Ÿ [아래쪽]을 2번 반복하여 목표지점까지 이동
moveSouth();
moveSouth();

- 10 -
- 4/15단계: 위쪽으로 이동하기(방향 지시 있음)
분석 스크립트
Ÿ [위쪽]을 2번 반복하여 목표 지점으로 이동
moveNorth();
moveNorth();
- 5/15단계: 오른쪽으로 이동하기(방향 지시 없음)
분석 스크립트
Ÿ [오른쪽]을 3번 반복하여 목표지점까지 이동
moveEast();
moveEast();
moveEast();

- 11 -
- 6/15 단계: 왼쪽과 아래쪽으로 이동하기(상하 좌우 도입, 방향 지시
없음)
실행 전 블록 입력 전 실행 후
분석 스크립트
Ÿ [왼쪽] 1번과 [아래쪽] 2번을 이용하여 목표지점까지 이동
Ÿ 하나의 방향이 아니라 두 개의 방향을 순차적으로 이용할 수
있도록 함.(한 방향으로 갔다가 또 다른 방향으로 가라고 힌트
를 줌)
moveWest();
moveSouth();
moveSouth();
- 7/15 단계: 오른쪽과 위쪽으로 이동하기(상하 좌우 사용, 방향 지시
없음, 함정 만들어 놓음)
분석 스크립트
Ÿ [오른쪽] 1번, [왼쪽] 1번을 이용하여 목표지점까지 이동
Ÿ 답으로 가는 루트 외에 다른 루트 또한 포함시켜 헷갈릴 수 있
는 요소를 제공하였다.
moveEast();
moveNorth();

- 12 -
- 8/15 단계: 두 개의 방향의 블록 섞어 놓음
분석 스크립트
Ÿ [오른쪽] 1번 이동한 뒤 [왼쪽] 1번 이동하고 또 다시 [오른쪽]
1번 더 이동하여 목표한 지점까지 이동
Ÿ 방향을 순차적으로 배열하여 문제를 해결하도록 해 알고리즘
을 만드는 것을 이해 할 수 있게 한다.
moveEast();
moveNorth();
moveEast();
- 9/15 단계: 두 개의 방향 섞어 놓음
분석 스크립트
Ÿ [왼쪽] 으로 1번 움직이고 [아래쪽]으로 1번 움직인 다음 다시
[왼쪽]으로 1번 이동하여 목표지점까지 이동
Ÿ 순차배열을 연습할 수 있도록 한다.
moveWest();
moveSouth();
moveWest();

- 13 -
- 10/15 단계: 세 방향의 블록 섞어 놓음
분석 스크립트
Ÿ [위쪽]으로 1번 이동한 후 [오른쪽]으로 3번 이동하고, 그 후 [아
래쪽]으로 1번 이동하여 목표한 지점까지 이동
Ÿ 세 방향으로 순차적으로 이동하는 것을 연습하도록 한다.
moveNorth();
moveEast();
moveEast();
moveEast();
moveSouth();
- 11/15 단계: 세 방향의 블록 섞어 놓음
분석 스크립트
Ÿ [왼쪽] 2번 이동한 후 [아래쪽] 2번 이동한다. 그 후 [오른쪽] 2
번 이동한 후에 다시 [아래쪽] 1번 이동하여 목표지점까지 이동
한다.
Ÿ 복잡한 순차배열을 해보도록 하여 알고리즘을 이해하도록 하고
블록을 배열할 때 캐릭터가 어디에 도달할지 알도록 함.
moveWest();
moveWest();
moveSouth();
moveSouth();
moveEast();
moveEast();
moveSouth();

- 14 -
- 12/15 단계: 두 방향의 블록 사용하기(평가)
실행 전 블록 입력 전 사용 블록
분석 스크립트
Ÿ 12단계부터는 평가하는 문항으로 이루어져 있다.
Ÿ [오른쪽]으로 1번 이동 후 [아래쪽]으로 2번 이동하도록 순차적
으로 배열하여 문제를 해결한다.
moveEast();
moveSouth();
moveSouth();
- 13/15 단계: 세 방향의 블록 사용하기(평가)
분석 스크립트
Ÿ [아래쪽] 1번, [왼쪽] 2번 이동한 다음 [위쪽] 1번 이동한 후에
다시 [왼쪽]으로 1번 이동하여 목표지점까지 이동한다.
Ÿ 순차적 배열을 이해하여 문제를 해결한다.
moveSouth();
moveWest();
moveWest();
moveNorth();
moveWest();

- 15 -
분석
Ÿ 왼쪽, 아래쪽이라고 쓰여져 있던 언어를 w와 s로 대체했다.
Ÿ 알고리즘을 제대로 이해하고 있는지 확인한다.
- 14/15 단계: 두 방향의 블록 사용하기(평가)
- 15/15 단계: 한 방향이나 두 방향의 블록 사용하기 (평가)
문제와 선택지 답
분석
Ÿ 블록 짝 맞추기 활동을 이용하여 순차배열에 대해 평가한다.
Ÿ 각 미로 퍼즐로부터 각각의 블록 알고리즘을 작성해본 후 선택지와 맞춰보거나, 각 알고리즘이 의미
하는 위치 변화를 머릿속으로 그려 해결한다.

- 16 -
5. 스테이지5: 미로퍼즐 (디버깅)
◦ 동영상
Ÿ 디버깅에 대한 기본적인 이해를 돕기 위해 설명한다.
Ÿ 디버깅이란 오류를 발견하여 수정하는 것이며 디버깅의 가장
쉬운 방법은 행동을 차근차근 점검하는 것이라고 설명한다.
Ÿ 디버깅의 예시를 보여준다.
Ÿ 디버깅을 미로퍼즐에 적용시키는 방법을 알려준다.
◦ 활동
- 1/12 단계: 블록 추가하기 (1개)
실행 전 오류 수정 전 오류 수정 후
분석 스크립트
Ÿ [오른쪽]으로 2번 이동하는 기존의 오류를 수정하여 [오른쪽] 3
번 이동하여 목표지점까지 이동
Ÿ 알고리즘을 해석하여 오류를 파악할 수 있도록 한다.
moveEast();
moveEast();
moveEast();

- 17 -
- 2/12 단계: 블록 중간에 추가하기 (1개)
분석 스크립트
Ÿ 기존의 [왼쪽] 1번 이동, [위쪽] 2번 이동의 오류를 수정하여 [위
쪽] 1번을 추가
Ÿ 알고리즘을 파악하여 오류를 수정한다.
moveWest();
moveNorth();
moveNorth();
moveNorth();
- 3/12 단계: 중간의 오류 블록 제거하기(2개)
분석 스크립트
Ÿ 기존의 [오른쪽] 3번 , [위쪽] 1번 이동에서 [오른쪽] 2번을 제거
Ÿ 알고리즘을 파악하여 오류를 확인하고 오류 블록을 제거한다.
moveEast();
moveNorth();

- 18 -
- 4/12단계: 블록 순서 바꾸기
분석 스크립트
Ÿ 기존의 [왼쪽] 2번 이동 후 [아래쪽] 1번을 수정하여 [왼쪽] 1번,
[아래쪽] 1번 이동 후 [왼쪽] 1번 이동
Ÿ 알고리즘을 파악하여 오류를 확인하고 블록의 순서를 바꾼다.
moveWest();
moveSouth();
moveWest();
- 5/12단계: 좀 더 복잡한 알고리즘의 중간의 오류 블록 제거하기(1개)
분석 스크립트
Ÿ 기존의 [오른쪽] 2번 , [아래쪽] 3번 이동 후 [오른쪽] 2번 이동
에서 [아래쪽] 1번을 제거
Ÿ 알고리즘을 파악하여 오류를 확인하여 블록을 제거한다.
moveEast();
moveEast();
moveSouth();
moveSouth();
moveEast();
moveEast();

- 19 -
- 6/12단계: 좀 더 복잡한 알고리즘의 중간 오류 블록 제거하기(1개)
분석 스크립트
Ÿ 기존의 [오른쪽] 1번 , [위쪽] 1번, [오른쪽] 3번 이동 후 [아래
쪽] 1번 이동에서 [오른쪽] 1번을 제거
Ÿ 알고리즘을 파악하여 오류를 확인하고 오류 블록을 제거한다.
moveEast();
moveNorth();
moveEast();
moveEast();
moveSouth();
- 7/12단계: 좀 더 복잡한 알고리즘의 오류 블록 제거하기(3개 제거)
분석 스크립트
Ÿ 기존의 [왼쪽] 2번, [아래쪽] 2번, [오른쪽] 3번 이동 후 [아래
쪽] 1번 이동에서 [왼쪽] 1번과 [오른쪽] 2번 제거
Ÿ 알고리즘을 파악하여 오류를 확인하여 블록을 제거한다.
Ÿ 여러 개의 블록을 제거해야 하므로 조금 더 심화된 과정이다.
moveWest();
moveSouth();
moveSouth();
moveEast();
moveSouth();

- 20 -
- 8/12단계: 블록 추가하기(2개)
분석 스크립트
Ÿ 기존의 [아래쪽] 2번, [왼쪽] 1번 이동 후 [위쪽] 1번 이동에 [왼
쪽] 1번과 [위쪽] 1번 추가하기
Ÿ 알고리즘을 파악하여 오류를 확인하고 필요한 블록을 추가한다.
Ÿ 여러 개의 블록을 추가해야하기 때문에 좀 더 심화된 과정이다.
moveSouth();
moveSouth();
moveWest();
moveWest();
moveNorth();
moveNorth();
- 9/12단계: 블록 제거하고 추가하기(2개 제거 후 2개 추가)
분석 스크립트
Ÿ 기존의 [왼쪽] 2번, [아래쪽] 2번에서 [아래쪽] 2번 제거하고, [왼
쪽] 1번, [위쪽] 1번 추가
Ÿ 전 단계들보다 오류 블록이 많다.
Ÿ 또 하나의 길만이 아니라 여러 길을 선택할 수 있도록 공간을
열어 놓았다.
moveWest();
moveWest();
moveWest();
moveNorth();

- 21 -
- 10/12단계: 블록 제거하고 추가하기(2개 제거하고 2개 추가)
분석 스크립트
Ÿ 기존의 [왼쪽] 2번, [위쪽] 3번, [오른쪽] 1번, [아래쪽] 2번 이동
에서 [위쪽] 1번을 제거하고 [오른쪽] 2번을 추가하고 [아래쪽]
1번을 제거
Ÿ 전 단계와 마찬가지로 제거하기와 추가하기를 동시에 하여 보
다 심화된 과정이다.
moveWest();
moveNorth();
moveNorth();
moveEast();
moveEast();
moveEast();
moveSouth();
- 11/12단계: 블록 제거하기(1개)(평가)
분석 스크립트
Ÿ 기존의 [왼쪽] 1번, [위쪽] 1번 이동 후 [왼쪽] 2번, [위쪽] 1번
이동에서 나중의 [왼쪽] 1번을 제거
Ÿ 알고리즘을 파악하여 오류를 확인하고 제거할 수 있는 지를 평
가한다.
moveWest();
moveNorth();
moveWest();
moveNorth();
-

- 22 -
- 12/12단계: 미완성된 알고리즘 완성하기(평가)
분석
Ÿ 적절한 알고리즘을 구성할 수 있는지를 평가하는 단계이다.
Ÿ 알고리즘을 이해하여 새의 위치 변화를 파악하여 마지막 알고리즘을 결정한다.

- 23 -
6. 실시간 알고리즘: 씨앗 심기
◦ 개요: 학생들이 현실 세계 상황을 온라인 상의 알고리즘으로 옮길 수
있는 기술들을 얻을 수 있도록 한다. 또한 반대로 온라인 상의 알고리
즘을 현실 상황과 연관 시킬 수 있도록 한다.
◦ 학습목표
- 학생들의 하루를 구성하는 다양한 활동들을 이름 짓는다.
- 큰 활동을 일련의 작은 사건들로 나눈다.
- 잇따라 일어나는 사건들을 학생들의 논리적인 순서대로 정리한다.
◦ 활동
- 1/3단계: ‘씨앗 심기’의 알고리즘 만들기
Ÿ 나눠준 종이에서 씨앗을 심기위한 단계
들을 잘라낸 후 9개의 항목 중 적절한
6개 항목을 골라 순서대로 정렬하여 서
로 비교해 본 후 완성된 알고리즘을 씨
앗을 심는 데에 이용한다.
Ÿ 현실 세계의 상황인 씨앗심기를 알고리
즘을 이용하여 계획하도록 하여 현실
상황과 알고리즘 사이의 호환을 돕는다.
주요 개념
알고리즘: 명령을 수행하기 위하여 따라야 할 단계의 목록
- 2/3 단계: ‘이 닦기’의 미완성된 알고리즘 완성하기(처음 제거)
분석
Ÿ 이를 닦는 하나의 큰 활동을 여러 작은 사건들로 나누어 논리적인 순서대로 완성하도록 한다.
Ÿ 학생들은 이를 닦는 활동의 알고리즘을 완성하면서 현실 상황과 알고리즘을 더욱 잘 연관시키게
된다.

- 24 -
- 3/3단계: 씨앗 심기의 미완성된 알고리즘 완성하기(중간 제거)
분석
Ÿ 씨앗 심기라는 하나의 활동을 화분을 흙으로 채우기 등의 작은 사건들로 나누어 논리적인 순서대
로 완성하도록 한다.
Ÿ 씨앗 심기 활동의 알고리즘을 완성하면서 온라인 상에서 알고리즘을 제작할 수 있는 능력을 기른
다.

- 25 -
7. 스테이지7: 꿀벌(순차)
◦ 동영상
Ÿ 꿀벌 퍼즐에 대한 이해를 돕기 위하여 설명한다.
Ÿ 목표는 꿀벌이 꽃에 날아가 꽃꿀을 얻어 벌집으로 날아가 꿀을
만들 수 있도록 하는 것이라고 설명한다.
Ÿ 꽃에서 얻을 수 있는 꽃꿀의 수는 아래에 작게 쓰여 있으며 그
숫자만큼 꽃꿀을 얻어야 한다고 말한다. 또 벌집에서 얻을 수
있는 꿀도 마찬가지라고 설명한다.
Ÿ 최대로 얻을 수 있는 꿀을 다 얻으면 다음 단계로 넘어간다고
Ÿ 설명한다.
◦ 활동
- 1/15단계: 꽃꿀 1개를 얻어 꿀을 1개 만들기
실행 전 블록 추가 전 블록 추가 후
분석 스크립트
Ÿ [오른쪽]으로 1번 이동하여 꽃꿀을 하나 얻고 또 [오른쪽] 으로
2번 이동하여 꿀을 하나 만든다.
Ÿ 꿀벌이 꿀을 얻게 하는 블록의 사용(순차문)을 이해하도록 한
다.
moveEast();
getNectar();
moveEast();
moveEast();
makeHoney();

- 26 -
- 2/15단계: 꽃꿀 1개를 얻어 꿀을 1개 만들기(두 방향 이동)
분석 스크립트
Ÿ [아래쪽] 2번 이동하여 꽃꿀을 얻고 [오른쪽] 2번 이동하여 꿀을
하나 만든다.
Ÿ 이동과 꽃꿀을 얻거나 꿀을 만드는 활동의 순서를 알고 그에
따라 알고리즘을 만들 수 있도록 한다.
Ÿ 전 단계보다 위치의 이동이 다양하다.
moveSouth();
moveSouth();
getNectar();
moveEast();
moveEast();
makeHoney();
- 3/15단계: 꽃꿀을 1개를 얻어 꿀을 1개 만들기(두 방향 교차사용)
분석 스크립트
Ÿ [왼쪽] 1번, [위쪽] 2번 이동 후 꽃꿀을 얻고, [왼쪽] 1번, [위쪽]
1번 이동 후 꿀을 1개 만든다.
Ÿ 전 단계와 마찬가지로 꽃꿀을 하나 얻어 꿀을 만드는 과정의
순차적 진행을 이해하여 순차문을 만들도록 한다.
moveWest();
moveNorth();
getNectar();
moveWest();
moveNorth();
makeHoney();

- 27 -
- 4/15단계: 꽃꿀을 2개 얻어 꿀을 2개 만들기(세 방향 이동)
분석 스크립트
Ÿ [위쪽] 1번, [오른쪽] 1번 이동하여 꽃꿀을 2개 얻고, [오른쪽] 1
번 , [아래쪽] 1번 이동하여 꿀을 2개 만든다.
Ÿ 꽃꿀의 개수를 바꾸어 꽃꿀을 얻는 블록과 꿀을 만드는 블록을
2개씩 배열하도록 하여 한 단계 발전시켰다.
moveNorth();
moveEast();
getNectar();
getNectar();
moveEast();
moveSouth();
makeHoney();
makeHoney();
- 5/15단계: 꽃꿀을 3개 얻어 꿀을 3개 만들기(두 방향 이동, 꽃 2개로
나뉨)
분석 스크립트
Ÿ [아래쪽] 1번 이동하여 꽃꿀을 2개 얻고 [오른쪽] 1번 이동하여
꽃꿀을 1개 얻고 [오른쪽] 1번, [아래쪽] 1번 이동하여 꿀을 2개
만든다.
Ÿ 꽃꿀을 2개 얻고 이동하여 1개를 얻게 하여 순차문의 사용을
발전시켰다.
moveSouth();
getNectar();
getNectar();
moveEast();
getNectar();
moveEast();
moveSouth();
makeHoney();
makeHoney();
makeHoney();

- 28 -
- 6/15단계: 꽃꿀을 2개 얻어 꿀을 2개 만들기(두 방향 이동, 꿀 2개로
나뉨)
분석 스크립트
Ÿ [왼쪽] 1번 이동하여 꽃꿀을 2개 얻고 [왼쪽]으로 이동하여 꿀을
1개 만들고 [위쪽]으로 이동하여 꿀을 1개 만든다.
Ÿ 꿀을 1개 만든 후에 이동하여 꿀을 다시 만들게 하여 순차문의
사용을 발전시켰다.
moveWest();
getNectar();
getNectar();
moveWest();
makeHoney();
moveNorth();
moveNorth();
makeHoney();
나뉨)
분석 스크립트
Ÿ [아래쪽] 1번이동하여 꽃꿀을 1개 얻고, [왼쪽] 1번 이동하여 꽃
꿀을 1개 얻고, 또 [왼쪽] 1번 이동하여 꽃꿀을 얻은 후 [아래
쪽] 1번 이동하여 꿀을 2개 만든다.
Ÿ 꽃꿀을 3번으로 나누어 얻게 하여 순차문의 사용을 자유자재로
할 수 있도록 돕는다.
moveSouth();
getNectar();
moveWest();
getNectar();
moveWest();
getNectar();
moveSouth();
makeHoney();
makeHoney();

- 29 -
- 8/15단계: 꽃꿀을 2개 얻어 꿀을 2개 만들기(두 방향 이동, 이동 가능
범위 확장, 꽃 2개로 나뉨)
분석 스크립트
Ÿ [위쪽] 1번 이동하여 꽃꿀을 1개 얻고, [위쪽] 1번 이동하여 꽃
꿀을 1개 얻고 [오른쪽] 2번 이동하여 꿀을 2개 만든다.
Ÿ 꿀벌이 이동할 수 있는 범위를 확장시켜 자유로운 사고를 돕는
다. 그 중에서도 가장 효율적인 길을 생각해보는 기회도 갖는
다.
moveNorth();
getNectar();
moveNorth();
getNectar();
moveEast();
moveEast();
makeHoney();
makeHoney();
나뉨)
분석 스크립트
Ÿ [아래쪽] 1번 이동하여 꽃꿀을 2개 얻고, 왼쪽 2번 이동하여 꽃
꿀을 1개 얻고 [아래쪽] 1번 이동하여 꿀을 1개 얻는다.
Ÿ 꽃꿀을 얻고 이동한 후에 다시 꽃꿀을 얻게 하여 순차문의 연
습을 돕는다.
moveSouth();
getNectar();
getNectar();
moveWest();
moveWest();
getNectar();
moveSouth();
makeHoney();

- 30 -
- 10/15단계: 꽃꿀을 3개 얻어 꿀을 2개 만들기(두 방향 이동, 꽃 2개,
벌집 2개로 나뉨)
분석 스크립트
Ÿ [왼쪽] 1번 이동하여 꽃꿀을 2개 얻고 [왼쪽] 1번 이동하여 꽃꿀
을 1개 얻고 [아래쪽] 1번 이동하여 꿀을 만들고, 다시 [아래쪽]
으로 1번 이동하여 꿀을 만든다.
Ÿ 꽃꿀을 얻는 과정과 꿀을 만드는 과정을 나누어 만들게 하여
순차문의 연습을 돕는다.
moveWest();
getNectar();
getNectar();
moveWest();
getNectar();
moveSouth();
makeHoney();
moveSouth();
makeHoney();
- 11/15단계: 꽃꿀을 3개 얻어 꿀을 1개 만들기(이동 범위 확장, 꽃 2개
로 나뉨, 세 방향 이동)
분석 스크립트
Ÿ [아래쪽] 1번 이동하여 꽃꿀을 1개 얻고, [아래쪽] 1번, [오른쪽]
1번을 이동하여 꽃꿀을 2개 얻고 [오른쪽] 1번, [위쪽] 1번을 이
동하여 꿀을 만든다.
Ÿ 꿀벌이 이동할 수 있는 길을 더 만들어 최선의 알고리즘을 생
각할 수 있도록 돕고, 꽃꿀을 얻는 과정을 나누어 순차문의 연
습을 돕는다.
moveSouth();
getNectar();
moveSouth();
moveEast();
getNectar();
getNectar();
moveEast();
moveNorth();
makeHoney();

- 31 -
- 12/15단계: 꽃꿀을 1개 얻어 꿀을 1개 만들기(두 방향 이동)(평가)
분석 스크립트
Ÿ [왼쪽] 1번 이동하여 꽃꿀을 얻고 [위쪽] 3번 이동하여 꿀을 1개
만든다.
Ÿ 1개의 꽃꿀을 얻고 2개의 꿀을 만들도록 하여 지금까지 연습한
순차문을 제대로 사용하고 있는지 확인한다.
moveWest();
getNectar();
moveNorth();
moveNorth();
moveNorth();
makeHoney();
나뉨)(평가)
분석 스크립트
Ÿ [아래쪽] 1번 이동하여 꽃꿀을 1개 얻고, [아래쪽] 1번 이동하여
꽃꿀을 1개 얻고, [왼쪽] 2번 이동하여 꿀을 2개 만든다.
Ÿ 2개의 꽃꿀과 2개의 꿀을 얻는 과정의 블록 알고리즘을 만들
수 있는지 확인한다.
moveSouth();
getNectar();
moveSouth();
getNectar();
moveWest();
moveWest();
makeHoney();
makeHoney();

- 32 -
- 14/15단계: 꽃꿀의 개수 더하기
분석
Ÿ 꽃꿀의 개수를 맞추는 문항이다.
Ÿ 초등학교 1학년 학생들을 대상으로 하는 코스이기 때문에 학생들이 총 꽃꿀의 개수를 아는지 확
인한다.
Ÿ 학생들은 순차문에서 연습할 때 1개의 꽃꿀을 얻고 다시 1개의 꽃꿀을 얻었던 것을 떠올리며 문
제를 해결하게 된다.
- 15/15단계: 꽃꿀의 개수 더하기
분석
Ÿ 전단계와 마찬가지로 꽃꿀의 개수를 맞추는 문항이다.
Ÿ 학생들은 2개의 꽃꿀을 얻고 다시 2개의 꽃꿀을 얻었던 것을 떠올리며 문제를 해결한다.

- 33 -
8. 스테이지8: 예술가(순차)
◦ 동영상
Ÿ 예술가 퍼즐의 거리 이동 블록에 대하여 설명한다.
Ÿ 적절한 선을 그리기 위하여 적절한 방향의 거리 이동 블록을
선택하라고 설명한다.
Ÿ 예술가 퍼즐의 거리 점프 블록에 대하여 설명한다.
Ÿ 거리 점프 블록을 사용하면 예술가가 이동하지만 선을 그리지
않는다고 설명한다.
Ÿ 다른 선을 그리기 위하여 점프하고 싶을 때 사용하라고 설명한
다.
◦ 활동
- 1/12단계: 오른쪽 블록 1번 사용하기
분석 스크립트
Ÿ [오른쪽] 1번 사용
Ÿ 거리 이동 블록의 기능을 이해한다.
moveRight(50);

- 34 -
- 2/12단계: 오른쪽 블록 2개 사용하기
분석 스크립트
Ÿ 거리 이동 블록을 이용하여 순차문을 만들어낸다.
moveRight(50);
moveRight(50);
- 3/12단계: 두 방향의 블록 사용하기
분석 스크립트
Ÿ [오른쪽] 2번, [위쪽] 2번 사용
Ÿ 서로 다른 방향의 거리 이동 블록을 사용하여 목표 지점에 도
달한다.
moveRight(50);
moveRight(50);
moveUp(50);
moveUp(50);

- 35 -
- 4/12단계: 세 방향의 블록 사용하기
분석 스크립트
Ÿ [오른쪽] 1번 , [위쪽] 1번 이동 후 [오른쪽] 1번 이동 후 [아래
쪽] 1번 이동
Ÿ 3개의 서로 다른 방향 블록을 이용하여 목표 지점으로 도달하
기 위한 블록 알고리즘을 만들어낸다.
moveRight(50);
moveUp(50);
moveRight(50);
moveDown(50);
- 5/12단계: 한 방향의 블록 사용하기(꽃의 줄기 그리기)
분석 스크립트
Ÿ [위쪽] 2번 사용
Ÿ 블록 알고리즘(순차문)을 이용하여 꽃의 줄기를 그려보도록 한
다.
Ÿ 단순히 선이 아니라 그림이 될 수 있음을 이해한다.
moveUp(50);
moveUp(50);

- 36 -
- 6/12단계: 한 방향의 블록과 점프 이동 블록 사용하기
분석 스크립트
Ÿ [오른쪽] 2번 이동 후, [점프 오른쪽] 1번 이동 후 다시 [오른쪽]
2번 이동
Ÿ 점프 이동 블록을 포함한 순차문을 만들도록 한다.
moveRight(50);
moveRight(50);
jumpRight(50);
moveRight(50);
moveRight(50);
- 7/12단계: 한 방향의 블록과 점프 이동 블록 사용하기(여러 번 사용)
분석 스크립트
Ÿ [오른쪽] 1번 [점프 오른쪽] 1번 이동 후 다시 [오른쪽] 1번 ,[점
프 오른쪽] 1번 이동 후 다시 [오른쪽] 이동 후 다시 [점프 오른
쪽] 이동 후 [오른쪽] 1번 이동
Ÿ 여러 개의 점프 이동 블록과 거리 이동 블록을 이용하여 적절
한 순차문을 만들어낸다.
moveRight(50);
jumpRight(50);
moveRight(50);
jumpRight(50);
moveRight(50);
jumpRight(50);
moveRight(50);

- 37 -
- 8/12단계: 두 방향의 거리 이동 블록과 두 방향의 점프 이동 블록 사
용하기
분석 스크립트
Ÿ [오른쪽] 1번, [점프 오른쪽] 1번 이동 후 [오른쪽] 1번, [점프 오
른쪽] 1번 이동 후 [위쪽] 1번, [점프 위쪽] 1번 이동 후 [위쪽]
이동
Ÿ 서로 다른 방향의 거리 이동 블록과 점프 이동 블록을 이용하
여 순차문을 만들어낸다.
moveRight(50);
jumpRight(50);
moveRight(50);
jumpRight(50);
moveUp(50);
jumpUp(50);
moveUp(50);
- 9/12단계: 두 방향의 블록 사용하기(평가)
분석 스크립트
Ÿ [오른쪽] 2번 이동 후 [위쪽] 1번 이동
Ÿ 서로 다른 방향의 거리 이동 블록을 이용하여 적절한 순차문을
만들어 낼 수 있는지 평가한다.
moveRight(50);
moveRight(50);
moveUp(50);

- 38 -
- 10/12단계: 한 방향의 블록과 점프 이동 블록 사용하기(평가)
분석 스크립트
Ÿ [왼쪽] 1번, [점프 왼쪽] 1번 이동 후 [왼쪽] 1번, [점프 왼쪽] 1
번 이동 후 [왼쪽] 1번 이동
Ÿ 점프 이동 블록과 거리 이동 블록을 적절히 사용한 순차문을
만들어 낼 수 있는지 평가한다.
moveLeft(50);
jumpLeft(50);
moveLeft(50);
jumpLeft(50);
moveLeft(50);
- 11/12단계: 두 방향의 블록 사용하기(평가)
분석
Ÿ [오른쪽] 1번 이동 후 [아래쪽] 2번 이동
Ÿ 보기 화면에 맞는 알고리즘을 구성해보거나 선택지의 알고리즘을 머릿속으로 그려보아 적절한 답
을 선택한다.
Ÿ 서로 다른 방향의 거리 이동 블록을 적절히 사용한 순차문을 만들어 낼 수 있는지 평가한다.

- 39 -
- 12/12단계: 네 방향의 블록 사용하기(평가)
분석
Ÿ [위쪽] 1번, [오른쪽] 1번 이동 후 [아래쪽] 1번, [왼쪽] 1번 이동
Ÿ 전 단계와 마찬가지로 보기 화면에 맞는 알고리즘을 구성해보거나 선택지의 알고리즘을 머릿속으
로 그려보아 적절한 답을 선택한다.
Ÿ 여러 개의 서로 다른 방향의 거리 이동 블록을 적절히 사용한 순차문을 만들어 낼 수 있는지 평
가한다.

- 40 -
9. 스테이지9: 건물 기초 만들기
◦ 개요: 새롭고 풀리지 않은 문제를 풀기 위해서는 실패가 따르고 실패
는 끝이 아니라 성공하기 위한 힌트가 된다는 것을 인지시킨다.
◦ 학습목표
- 구조적인 공학 문제를 해결하기 위한 단계들의 윤곽을 그린다.
- 구조 만들기에서의 잠재적인 문제들에 대해서 예측하고 논의한다.
- 팀의 계획에 기초하여 구조를 만든다.
- 문제를 해결할 때까지 계획과 구조를 수정한다.
◦ 활동
- 1/2단계: 실패로부터 힌트 얻기
Ÿ 제공된 물건들을 사용하여 종이컵의 높
이 보다 높고 책의 무게를 10초 동안
견뎌낼 수 있는 타워를 세운다.
Ÿ 타워를 만들어 보는 동안 학생들이 실
패를 경험할 때 그 실패를 바탕으로 인
내심을 가지고 수정하도록 지도한다.
주요 개념
인내심: 어떤 것이 매우 어렵더라도 계속 다시 시도하는 것

- 41 -
- 2/2단계: 예술가 알고리즘을 만들며 실패에서 힌트 얻기
분석 스크립트
Ÿ [위쪽] 1번, [오른쪽] 1번, [위쪽] 1번, [오른쪽] 1번, [위쪽] 1번,
[오른쪽] 1번 이동 후 [아래쪽] 1번, [오른쪽] 1번, [아래쪽] 1번
이동 후 [오른쪽] 1번, [아래쪽] 1번 이동
Ÿ 문제를 해결하기 위하여 블록 알고리즘을 만드는 중에 실패를
경험하게 되고 그 실패에서 힌트를 얻어 문제를 해결하게 된다.
moveUp(50);
moveRight(50);
moveUp(50);
moveRight(50);
moveUp(50);
moveRight(50);
moveDown(50);
moveRight(50);
moveDown(50);
moveRight(50);
moveDown(50);

- 42 -
10. 스테이지10: 예술가(모양)
◦ 활동
- 1/10단계: 네 방향의 이동 블록을 사용하기
분석 스크립트
Ÿ [오른쪽] 2번, [아래쪽]2번 이동 후 [왼쪽] 2번 , [위쪽] 2번 이동
Ÿ 여러 방향의 거리 이동 블록을 이용하여 순차문을 만들어 삼각
형 아래에 정사각형을 만든다.
Ÿ 이 단계는 아래쪽 거리 이동 블록을 먼저 사용해도 답이 될 수
있다. 따라서 같은 단계더라도 여러 해결책이 있음을 인지시킬
수 있다.
moveRight(50);
moveRight(50);
moveDown(50);
moveDown(50);
moveLeft(50);
moveLeft(50);
moveUp(50);
moveUp(50);
- 2/10단계: 점프 이동 블록과 네 방향의 이동 블록 사용하기
분석 스크립트
Ÿ [점프 왼쪽] 1번, [왼쪽] 2번, [아래쪽] 2번, [오른쪽] 2번 이동
후 [위쪽] 2번 이동
Ÿ 점프 이동 블록을 포함한 순차문을 통하여 정사각형을 만든다.
jumpLeft(50);
moveLeft(50);
moveLeft(50);
moveDown(50);
moveDown(50);
moveRight(50);
moveRight(50);
moveUp(50);
moveUp(50);

- 43 -
- 3/10단계: 네 방향의 이동 블록 사용하기
분석 스크립트
Ÿ [오른쪽] 2번, [위쪽] 2번 이동 후 [왼쪽] 2번 이동 후 [아래쪽] 2
번 이동
Ÿ 거리 이동 블록을 이용한 알고리즘을 통하여 하나의 정사각형
위에 다른 정사각형을 만든다.
moveRight(50);
moveRight(50);
moveUp(50);
moveUp(50);
moveLeft(50);
moveLeft(50);
moveDown(50);
moveDown(50);
- 4/10단계: 네 방향의 이동블록 사용하여 직사각형 그리기
분석 스크립트
Ÿ [오른쪽] 2번, [위쪽] 1번, [왼쪽] 2번 이동 후 [아래쪽] 1번 이동
Ÿ 서로 다른 방향의 거리 이동 블록을 통한 순차문을 통하여 다
리를 완성하기 위한 직사각형을 만든다.
moveRight(50);
moveRight(50);
moveUp(50);
moveLeft(50);
moveLeft(50);
moveDown(50);

- 44 -
- 5/10단계: 네 방향의 이동 블록 사용하여 직사각형 그리기
분석 스크립트
Ÿ [위쪽] 2번, [왼쪽] 1번 이동 후 [아래쪽] 2번 이동 후 [오른쪽] 1
번 이동
Ÿ 서로 다른 거리 이동 블록을 적절히 구성하여 직사각형의 다리
기둥을 만든다.
moveUp(50);
moveUp(50);
moveLeft(50);
moveDown(50);
moveDown(50);
moveRight(50);
- 6/10단계: 네 방향의 이동 블록을 사용하여 정사각형 두 개를 그리기
(한 곳 두 번 지나가도 되는 것 이해하기)
분석 스크립트
Ÿ [오른쪽] 2번, [아래쪽] 1번 이동 후 [왼쪽] 1번, [위쪽] 1번, [아
래쪽] 1번, [왼쪽] 1번 이동 후 [위쪽] 1번 이동
Ÿ 여러 개의 거리 이동 블록을 이용하여 적절한 순차문을 만들어
두 개의 정사각형으로 구성된 직사각형을 만든다.
moveRight(50);
moveRight(50);
moveDown(50);
moveLeft(50);
moveUp(50);
moveDown(50);
moveLeft(50);
moveUp(50);

- 45 -
- 7/10단계: 네 방향의 이동 블록 사용하여 조금 더 긴 직사각형 그리기
분석 스크립트
Ÿ [오른쪽] 3번, [아래쪽] 1번 이동 후 [왼쪽] 3번, [위쪽] 1번 이동
Ÿ 서로 다른 방향의 거리 이동 블록을 사용하여 순차문을 만들어
직사각형 모양의 맨 위 서랍을 만든다.
moveRight(50);
moveRight(50);
moveRight(50);
moveDown(50);
moveLeft(50);
moveLeft(50);
moveLeft(50);
moveUp(50);
- 8/10단계: 네 방향의 이동블록과 점프 이동 블록 사용하기(평가)
분석 스크립트
Ÿ [점프 오른쪽] 1번, [오른쪽] 1번, [위쪽] 1번 이동 후 [왼쪽] 1번
, [아래쪽] 1번 이동
Ÿ 점프 이동 블록과 거리 이동 블록을 사용한 적절한 순차문을
통하여 정사각형 옆에 다른 정사각형을 만들 수 있는지를 평가
한다.
jumpRight(50);
moveRight(50);
moveUp(50);
moveLeft(50);
moveDown(50);
- 9/10단계: 동일한 형태 맞추기(평가)

- 46 -
분석
Ÿ 짝 맞추기 활동을 이용하여 모양에 따른 알고리즘에 대하여 이해하도록 한다.
Ÿ 같은 형태는 같은 알고리즘을 가짐을 이해한다.
- 10/10단계: 자유롭게 그리기(거리 이동 블록과 점프 이동 블록과 색
설정 블록 사용 가능)
사용할 수 있는 블록
분석
Ÿ 앞 단계에서 배운 내용을 사용하여 자신의 맘대로 그림을 그리도록 하여 프로그램에 흥미를 느
끼도록 하는 동시에 알고리즘에 대한 이해 또한 돕는다.
Ÿ 자신만의 알고리즘을 만들도록 하여 앞으로 더 나아가 프로그램을 만드는 데에 도움을 준다.
11. 말하는 꿀벌

- 47 -
◦ 동영상
Ÿ 말하는 꿀벌 레벨에 대하여 설명한다.
Ÿ 벌을 움직이게 하기 위하여 퍼즐 조각을 이용하라고 말한다.
Ÿ 움직이면서 글자를 모아서 퍼즐 아래에 있는 단어를 만든다고
설명한다.
Ÿ 벌이 움직이면서 글자를 모아서 퍼즐 아래에 있는 단어를 만든
다고 설명한다.
Ÿ 틀린 길로 갈 경우 원하지 않은 단어를 만들게 될 수 있다고
설명한다.
◦ 활동
- 1/12단계: 오른쪽으로 이동시키기(한 방향)
분석 스크립트
Ÿ [오른쪽] 4번 이동
Ÿ 오른쪽으로 이동하는 거리 이동 블록을 사용하여 알고리즘을
만들어 목표로 한 단어를 만든다.
moveEast();
moveEast();
moveEast();
moveEast();

- 48 -
- 2/12단계: 아래쪽으로 이동시키기(한 방향)
분석 스크립트
Ÿ [아래쪽] 5번 이동
Ÿ 아래쪽으로 이동하는 거리 이동 블록을 사용하여 알고리즘을
만들어 목표로 한 단어를 만든다.
moveSouth();
moveSouth();
moveSouth();
moveSouth();
moveSouth();
- 3/12단계: 왼쪽으로 이동시키기(한 방향)
분석 스크립트
Ÿ [왼쪽] 4번 이동
Ÿ 왼쪽으로 이동하는 거리 이동 블록을 사용하여 알고리즘을 만
들어 문제를 해결한다.
moveWest();
moveWest();
moveWest();
moveWest();

- 49 -
- 4/12단계: 위쪽으로 이동시키기 (한 방향)
분석 스크립트
Ÿ [위쪽] 5번 이동
Ÿ 위쪽으로 이동하는 거리 이동 블록을 사용하여 알고리즘을 만
들어 단어를 만든다.
moveNorth();
moveNorth();
moveNorth();
moveNorth();
moveNorth();
- 5/12단계: 오른쪽으로 이동한 후에 아래쪽으로 이동하기(두 방향)
분석 스크립트
Ÿ [오른쪽] 3번 이동 후 [아래쪽] 1번 이동
Ÿ 전 단계보다 발전해 오른쪽으로 이동했다가 아래쪽으로 이동하
는 알고리즘을 만들어 문제를 해결한다.
moveEast();
moveEast();
moveEast();
moveSouth();

- 50 -
- 6/12단계: 두 방향 이동시키기(방향이 주어지지 않음)
분석 스크립트
Ÿ [오른쪽] 2번, [위쪽] 1번 이동 후 [오른쪽] 1번 이동
Ÿ 전 단계와 다르게 팝업창에서 이동 방향에 대한 정보가 주어지
지 않는다.
Ÿ 주어진 단어를 만들기 위해 이동할 방향을 머릿속으로 그려내
어 알고리즘을 완성한다.
moveEast();
moveEast();
moveNorth();
moveEast();
분석 스크립트
Ÿ [오른쪽] 2번, [아래쪽] 2번 이동 후 [오른쪽] 1번 이동
Ÿ 전 단계와 마찬가지로 방향에 대한 정보가 주어지지 않았다.
Ÿ 단어를 만들기 위하여 적절한 거리 이동 블록을 사용하여 알고
리즘을 만든다.
moveEast();
moveEast();
moveSouth();
moveSouth();
moveEast();

- 51 -
분석 스크립트
Ÿ [아래쪽] 2번, [오른쪽] 1번 이동 후 [아래쪽] 1번, [오른쪽] 1번
이동
Ÿ 마찬가지로 방향이 주어지지 않았기 때문에 단어를 만들기 위
해 이동해야할 방향을 생각하여 블록 알고리즘을 완성한다.
moveSouth();
moveSouth();
moveEast();
moveSouth();
moveEast();
분석 스크립트
Ÿ [오른쪽] 1번, [위쪽] 1번, [오른쪽] 1번 이동 후 [위쪽] 2번 이동
Ÿ 마찬가지로 방향이 주어지지 않을 때 문제를 해결하기 위한 알
고리즘을 만들 수 있도록 연습시킨다.
moveEast();
moveNorth();
moveEast();
moveNorth();
moveNorth();

- 52 -
- 10/12단계: 두 방향 이동시키기(방향주어지지 않음)-평가
분석 스크립트
Ÿ [오른쪽] 2번, [아래쪽] 3번 이동
Ÿ 이동 방향이 주어지지 않았을 때 주어진 단어를 완성시키기 위
하여 이동해야 할 적절한 방향을 설정할 수 있는지 평가한다.
moveEast();
moveEast();
moveSouth();
moveSouth();
moveSouth();
- 11/12단계: 두 방향으로 이동시키기(평가)
분석
Ÿ ‘MOVE’라는 단어를 완성할 수 있는 적절한 알고리즘을 고르는 문제이다.
Ÿ 이동 방향이 주어지지 않았기 때문에 어떤 방향으로 이동해야 적절한 알고리즘을 구성할 수 있는
지 아는지를 평가한다.
Ÿ 학생들은 머릿속으로 꿀벌이 이동해야하는 방향을 그려보아 문제를 해결한다.

- 53 -
- 12/12단계: 알고리즘 파악하여 단어 찾기(평가)
분석
Ÿ 주어진 알고리즘을 통하여 완성될 단어를 찾는 문항이다.
Ÿ 블록 알고리즘을 통하여 이동했을 때 이동할 방향을 예상할 수 있는지를 평가한다.
Ÿ 학생들은 블록 알고리즘대로 순차적으로 꿀벌을 이동시켜 문제를 해결한다.

- 54 -
12. 스테이지12: 반복적으로 하기
◦ 개요: 여러 번의 행동을 하나의 루프로 바꾸는 연습을 한다.
◦ 학습목표
- 강사에 의해 접한 행동들을 반복한다.
- 사진으로 된 프로그램을 실제 행동으로 옮긴다.
- 여러 번의 행동을 하나의 루프로 바꾼다.
◦ 활동
- 1/2단계: 춤에서 반복되는 동작 파악하고 효율성 인지하기
Ÿ 일정한 반복패턴을 가진 춤이 그려진
종이를 나눠준다.
Ÿ 그 춤을 보여주고 따라하게 하며 무엇
이 반복되는지 파악하도록 지도한다.
Ÿ 학생들은 루프를 파악했을 때 더 효율
적으로 춤을 출 수 있음을 인지하게 된
다.
주요 개념
루프: 어떤 것을 계속 반복하는 행동
- 2/2단계: 루프 사용하기(평가)
분석
Ÿ 반복되는 블록을 파악하여 반복구조를 만들 수 있는지를 평가한다.
Ÿ 반복되는 행동을 하나의 루프로 바꿀 수 있음을 이해한다.
Ÿ [위쪽]으로 3번 이동하고 [꽃꿀얻기] 가 4번 반복되므로 이를 파악하여 문제를 해결한다.

- 55 -
13. 스테이지13: 미로 퍼즐(반복)
◦ 활동
- 1/14단계: 순차문 사용하기
분석 스크립트
Ÿ [오른쪽] 5번 이동
Ÿ 루프를 사용하기 전에 일정한 행동이 반복되고 있는 순차문을
이해한다.
moveEast();
moveEast();
moveEast();
moveEast();
moveEast();
- 2/14단계: 루프 사용하기(툴 박스에 미리 반복될 횟수 지정됨)
분석 스크립트
Ÿ [5번 반복] 1번, [오른쪽] 1번 사용
Ÿ 반복 횟수가 미리 지정되어 있어 이동해야할 방향을 파악
하여 지정하면 문제가 해결된다.
for (var count = 0; count < 5; count++) {
moveEast();
}

- 56 -
- 3/14단계: 루프 사용하기(반복 횟수 지정되지 않음)
분석 스크립트
Ÿ [3번 반복] 1번, [위쪽] 1번 사용
Ÿ 반복될 횟수가 지정되지 않아 몇 번 반복되어야 정확한
알고리즘이 만들어지는지 또한 파악하여야 한다.
moveNorth();
}
- 4/14단계: 두 개의 루프 사용하기(반복 횟수 작업 영역에 미리 지정)
분석 스크립트
Ÿ [3번 반복] 1번, [아래쪽] 1번, [4번 반복] 1번, [오른쪽]
1번 사용
Ÿ 루프를 2개 사용하는 것을 연습한다.
Ÿ 반복 횟수가 지정되어 있기 때문에 정확한 방향을 파
악하여 알고리즘을 완성한다.
moveSouth();
}
for (var count2 = 0; count2 < 4; count2++) {
moveEast();
}

- 57 -
- 5/14단계: 한 개의 거리 이동 블록과 두 개의 루프 함께 사용하기(반
복 횟수 지정 되지 않음)
분석 스크립트
Ÿ [왼쪽] 2번 , [3번 반복] 1번, [위쪽] 1번, [3번 반복] 1
번 사용
Ÿ 하나의 거리 이동 블록과 두 개의 루프를 사용한 알
고리즘이다.
Ÿ 반복 횟수와 이동 방향을 결정하여 알고리즘을 완성
한다.
moveWest();
moveNorth();
}
moveWest();
}
- 6/14단계: 세 개의 루프 사용하기(반복 횟수 지정 되지 않음)
분석 스크립트
Ÿ [4번 반복] 2번, [아래쪽] 1번, [3번 반복] 1번, [오른쪽]
1번 사용
Ÿ 3개의 루프를 사용하는 것을 연습한다.
Ÿ 이동 방향과 반복 횟수를 결정하여 알고리즘을 완성
한다.
moveSouth();
}
moveEast();
}
moveNorth();
}

- 58 -
- 7/14단계: 2개의 거리 이동 블록과 2개의 루프 사용하기(반복 횟수 지
정 되지 않음)
분석 스크립트
Ÿ [2번 반복] 1번, [5번 반복] 1번, [오른쪽] 1번, [왼쪽] 1
번, [위쪽] 1번, [아래쪽] 1번 사용
Ÿ 서로 다른 방향의 두 개의 거리 이동 블록과 루프 두
개를 사용한다.
Ÿ 이동방향과 반복 횟수를 결정하고 루프와 두 개의 거
리 이동 블록의 순차적인 이동을 고려하여 알고리즘
을 완성한다.
moveEast();
moveNorth();
}
moveWest();
}
moveSouth();
- 8/14단계: 하나의 루프 안에 두 개의 거리 이동 블록 포함시키기
분석 스크립트
Ÿ [3번 반복] 1번, [오른쪽] 1번, [위쪽] 1번 사용
Ÿ 하나의 루프 안에 두 개의 거리 이동 블록을 포함시킨
구조를 연습한다.
Ÿ 반복 횟수와 반복될 거리 이동을 파악하여 알고리즘을
완성한다.
moveEast();
moveNorth();
}

- 59 -
- 9/14단계: 하나의 루프 안에 두 개의 거리 이동 블록 포함시키기
분석 스크립트
Ÿ [3번 반복] 1번, [위쪽] 1번, [오른쪽] 1번 사용
Ÿ 전 단계와 마찬가지로 하나의 루프 안에 두 개의 서로
다른 방향의 거리 이동 블록이 포함되어 있다.
Ÿ 반복 횟수와 반복될 거리 이동을 파악하여 알고리즘을
완성한다.
moveNorth();
moveEast();
}
- 10/14단계: 하나의 블록 안에 두 개의 거리 이동 블록 포함시키기
분석 스크립트
Ÿ [5번 반복] 1번, [오른쪽] 1번, [아래쪽] 1번 사용
Ÿ 전 단계와 마찬가지로 하나의 루프 안에 두 개의 거리
이동 블록이 포함된 구조이다.
Ÿ 마찬가지로 반복 횟수와 반복될 거리 이동을 파악하여
문제를 해결한다.
moveEast();
moveSouth();
}

- 60 -
- 11/14단계: 하나의 거리 이동 블록과 루프 함께 사용하기(반복 횟수
지정 되지 않음)(평가)
분석 스크립트
Ÿ [위쪽] 1번, [5번 반복] 1번, [왼쪽] 1번 사용
Ÿ 거리 이동 블록과 하나의 루프를 사용한 반복구조
를 만들 수 있는지 평가한다.
Ÿ 반복될 횟수가 정해지지 않아 반복 횟수를 결정하
고 거리 이동블록과의 순차적 관계를 이해하여 알
고리즘을 완성한다.
moveNorth();
moveWest();
}
- 12/14단계: 두 개의 루프 사용하기(반복 횟수 지정 되지 않음)(평가)
분석 스크립트
Ÿ [3번 반복] 1번, [4번 반복] 1번, [오른쪽] 1번,
[아래쪽] 1번 사용
Ÿ 두 개의 루프로 이루어진 반복구조를 만들 수
있는지 평가한다.
Ÿ 반복 횟수를 결정하고 거리 이동 블록의 방향
을 정하여 알고리즘을 완성한다.
moveEast();
}
moveSouth();
}

- 61 -
- 13/14단계: 순차문을 하나의 루프로 만들기(평가)
분석
Ÿ 여러 번 반복되는 알고리즘을 보고 루프를 만들 수 있는지 확인하는 문항이다.
Ÿ [위쪽]으로 3번 이동하는 것을 파악하여 하나의 루프로 만든다.
- 14/14단계: 순차문을 두 개의 블록이 포함된 하나의 루프로 만들기(평
가)
분석
Ÿ 여러 번 반복되는 알고리즘을 보고 루프를 만들 수 있는지 확인하는 문항이다.
Ÿ [아래쪽] 1번, [오른쪽] 1번이 3번 반복되는 것을 파악하여 하나의 루프를 만든다.

- 62 -
14. 스테이지14: 꿀벌(반복)
◦ 활동
분석 스크립트
Ÿ [오른쪽] 5번, [꽃꿀 얻기] 1번, [꿀 만들기] 1번, [위쪽] 1번 사
용
Ÿ 루프를 사용을 연습하기 전에 꿀을 만들기 위한 순차문을 이해
시킨다.
moveEast();
moveEast();
moveEast();
moveEast();
moveEast();
getNectar();
moveNorth();
makeHoney();
◦ 동영상
Ÿ 벌집에서 꿀을 얻을 때 같은 활동을 반복한다는 것을 설명한
다.
Ÿ 이번 스테이지에서는 꽃꿀을 얻거나 꿀을 만들 때 루프를 사용
하여 만들어서 해결해야한다고 설명한다.

- 63 -
- 2/13단계: 루프를 사용하기
분석 스크립트
Ÿ [5번 반복] 1번, [오른쪽] 1번, [꽃꿀 얻기] 1번, [꿀
만들기] 1번, [위쪽] 1번
Ÿ 루프를 사용하여 꿀벌을 이동시킨다.
moveEast();
}
getNectar();
moveNorth();
makeHoney();
- 3/13단계: 세 개의 루프를 사용하기(루프 안에 다양한 블록 사용)
분석 스크립트
Ÿ [2번 반복] 1번, [3번 반복] 2번, [왼쪽] 2번, [꽃꿀
얻기] 1번, [꿀 만들기] 1번 사용
Ÿ 거리 이동 블록이 포함된 루프와 꽃꿀 얻기 블록
이 포함된 루프와 꿀 만들기 블록이 포함된 루프
를 통하여 알고리즘을 완성한다.
moveWest();
}
getNectar();
}
moveWest();
makeHoney();
}

- 64 -
- 4/13단계: 3개의 루프 사용하기(루프 안에 두 개의 블록 사용)
분석 스크립트
Ÿ [3번 반복] 3번, [왼쪽] 1번, [아래쪽] 1번, [오른
쪽] 1번, [꽃꿀 얻기] 1번, [꿀 만들기] 1번 사용
Ÿ 전 단계에서 발전하여 하나의 루프안에 두 개의
블록을 포함시킨다.
moveWest();
}
moveSouth();
getNectar();
}
moveEast();
makeHoney();
}
- 5/13단계: 2개의 루프 사용하기(루프 안에 세 개의 블록 사용)
분석 스크립트
Ÿ [2번 반복] 1번, [4번 반복] 1번, [오른쪽] 2번, [꽃
꿀 얻기] 2번, [꿀 만들기] 1번 사용
Ÿ 하나의 루프 안에 3개의 블록을 포함시킨다. 이
경우 꽃꿀 얻기 블록이 루프 안에서 반복 사용되
므로 이를 루프로 바꿀 수도 있다.
moveEast();
getNectar();
getNectar();
}
moveEast();
makeHoney();
}

- 65 -
- 6/13단계: 루프 안에 4개의 블록 사용
분석 스크립트
Ÿ [2번 반복] 1번, [오른쪽] 2번, [꽃꿀 얻기] 1번, [꿀
만들기] 1번 사용
Ÿ 하나의 루프 안에 4개의 블록이 포함되어 있다. 반
복되는 블록이 무엇인지 적절히 파악하여 알고리즘
을 만든다.
moveEast();
getNectar();
moveEast();
makeHoney();
}
- 7/13단계: 두 개의 루프 사용하고 하나의 루프 안에 4개의 블록 사용
분석 스크립트
Ÿ [3번 반복] 2번, [2번 반복] 1번, [왼쪽] 1번, [아
래쪽] 1번, [꽃꿀 얻기] 1번, [꿀 만들기] 1번 사
용
Ÿ 하나의 루프 안에 4개의 블록이 포함되어있는
알고리즘이다. 루프와 순차문을 적절히 이해하여
해결해야 한다. 이 단계 또한 반복되는 구간을
잘 파악하여 문제를 해결한다.
moveWest();
moveWest();
getNectar();
moveSouth();
}
moveSouth();
makeHoney();
}

- 66 -
- 8/13단계: 3개의 루프 사용하고 하나의 루프 안에 4개의 블록 사용
분석 스크립트
Ÿ [2번 반복] 2번, [4번 반복] 1번, [6번 반복] 1
번, [아래쪽] 1번, [오른쪽] 2번, [꽃꿀 얻기] 2
번, [꿀 만들기] 1번 사용
Ÿ 전 단계보다 복잡한 반복구조이다. 반복되는
횟수를 다양하게 설정해 놓았기 때문에 반복
횟수를 잘 파악하여 입력하여야 한다. 또 반복
되는 구간을 적절히 파악하여 문제를 해결한
다.
moveSouth();
moveSouth();
getNectar();
moveEast();
}
getNectar();
}
moveEast();
makeHoney();
}
- 9/13단계: 2개의 루프 사용하고 각각의 루프 안에 2개의 블록 사용(이
동 가능 범위 확장)
분석 스크립트
Ÿ [5번 반복] 2번, [왼쪽] 1번, [꽃꿀 얻기] 1번, [위
쪽] 1번, [꿀 만들기] 1번 사용
Ÿ 꿀벌이 이동할 수 있는 공간을 넓혀 주었다. 이
중 가장 효율적인 이동 방법을 생각하려는 노력
을 하게 된다.
Ÿ 반복되는 블록을 적절히 파악하여 알고리즘을 만
든다.
moveWest();
getNectar();
}
moveNorth();
makeHoney();
}

- 67 -
- 10/13단계: 4개의 루프 사용하기
분석 스크립트
Ÿ [2번 반복] 2번, [10번 반복] 2번, [위쪽] 2번,
[꽃꿀 얻기] 1번, [꿀 만들기] 1번 사용
Ÿ 숫자가 클 경우에 루프를 만드는 것이 효율
적임을 이해하게 된다.
Ÿ 반복되는 블록을 적절히 파악하여 문제를 해
결한다.
moveNorth();
getNectar();
}
moveNorth();
getNectar();
}
moveNorth();
makeHoney();
}
moveNorth();
makeHoney();
}
- 11/13단계: 하나의 루프 안에 4개의 블록 포함하기(평가)
분석 스크립트
Ÿ [3번 반복] 1번, [위쪽] 2번, [꽃꿀 얻기] 1번, [꿀
만들기] 1번 사용
Ÿ 반복되는 구간을 적절히 파악하여 루프를 만들어
낼 수 있는지 평가한다.
moveNorth();
getNectar();
moveNorth();
makeHoney();
}

- 68 -
- 12/13단계: 두 개의 루프 사용하고 하나의 루프 안에 세 개의 블록 사
용하기
분석 스크립트
Ÿ [3번 반복] 2번, [아래쪽] 2번, [왼쪽] 1번, [꽃꿀 얻
기] 1번, [꿀 만들기] 1번 사용
Ÿ 반복되는 구간을 잘 파악하여 두 개의 루프를 이
용한 반복구조를 만들 수 있는지 평가한다.
moveSouth();
moveWest();
getNectar();
}
moveSouth();
makeHoney();
}
- 13/13단계: 루프와 순차문 짝 맞추기(평가)
분석
Ÿ 순차문과 루프의 짝을 맞출 수 있는지 평가하는 문항이다.
Ÿ 학생들은 하나의 루프를 풀어 순차문을 만들어 선택지를 고르거나 순차문을 루프로 묶어서 답을 찾
을 수 있다.

- 69 -
15. 스테이지15: 빅 이벤트
◦ 개요: 프로그램의 다양하게 만들어주는 “이벤트”의 개념을 이해시킨
다.
◦ 학습 목표
- 학생들은 강사가 요구하는 것을 반복한다.
- 요구를 시행하기 위하여 강사의 행동을 신호로 인식한다.
- 미리 계획된 행동과 이벤트 기반의 행동을 구별할 수 있도록 한다.
◦ 활동
- 1/2단계: 버튼을 눌러 반응하게 하여 이벤트의 개념 이해시키기
Ÿ 각 버튼마다 해야 하는 행동을 지정해
놓고 버튼을 누르면 아이들이 반응하도
록 한다.
Ÿ 연속적으로 다른 버튼을 누르며 반응
하도록 하고 ‘숫자 10까지 세기’ 등
과 같이 미리 예정된 행동들을 하고 있
는 중에 버튼을 누르게 한다.
Ÿ 이 과정들을 통하여 ‘이벤트’의 개념
에 대하여 알게 되고, 미리 계획된 행동
과 이벤트 기반의 행동의 차이를 인식
하도록 한다.
주요 개념
이벤트: 어떤 것이 일어나도록 하는 행동
- 2/2단계: 블록에 따라 맞는 행동을 맞추어 이벤트 기반 행동 연습하
기
분석
Ÿ 버튼마다 다른 댄스를 지정해 놓아 이벤트를 통하여 프로그램을 다양하게 만들 수 있다는 것을 인식시킨
다.
Ÿ 연속적으로 다른 버튼을 눌러 이벤트 기반 행동을 연습시킨다.

- 70 -
16. 스테이지16: Play Lab(스토리 만들기)
◦ 동영상
Ÿ play lab을 통하여 이야기를 만드는 방법을 설명한다.
Ÿ 이동하기 블록을 통하여 캐릭터를 마음대로 이동시킬 수 있고,
말하기 블록을 통하여 우리가 입력하는 모든 말을 하도록 만들
수 있다고 설명한다.
Ÿ 화면 속의 블록을 이용하여 두 캐릭터를 연결시킬 수 있다고
설명한다.
Ÿ 이 블록에 다른 블록을 추가하여 두 캐릭터가 만날 때 다른 동
작들을 실행하도록 만들 수 있다고 설명한다.
◦ 활동
- 1/6단계: say 블록 사용하기
실행 전 블록 입력 전 분석
Ÿ 자신이 만든 알고리즘을 통하여
원하는 말을 하도록 시킬 수 있
음을 이해한다.
Ÿ 프로그래밍에 대한 이해를 돕는
다.
분석 블록 입력 후

- 71 -
- 2/6단계: 두 개의 블록 연결시키기
Ÿ 강아지 캐릭터 말하기 동작 블록
에 고양이 캐릭터 말하기 동작
블록을 연결하여 강아지가 말한
후 고양이가 말하도록 설정한다.
Ÿ 블록 알고리즘을 통하여 두 캐릭
터를 연결시킬 수 있음을 이해한
다.
- 3/6단계: move 블록 사용하기
Ÿ 강아지 캐릭터를 고양이 캐릭터
쪽인 오른쪽으로 이동시킨다.
Ÿ 자신이 만든 알고리즘을 통하여
캐릭터를 원하는 방향으로 이동
시킬 수 있음을 이해한다.

- 72 -
- 4/6단계: “~할 때”블록 사용하기
Ÿ 강아지 캐릭터를 이동시켜 고양
이 캐릭터와 만나게 될 때 고양
이 캐릭터가 말을 할 수 있도록
설정한다.
Ÿ 두 캐릭터가 만날 때 실행될 알
고리즘을 설정할 수 있다는 것을
이해한다.
- 5/6단계: 표정 설정하기
Ÿ 문어가 행복한 표정을 나타내도
록 설정한다.
Ÿ 블록 알고리즘을 통하여 감정 변
화 또한 표현할 수 있음을 이해
한다.
실행 후 블록 입력 후

- 73 -
- 6/6단계: 자신만의 이야기 만들어보기(강아지와 고양이기 돌아다니면
서 말하도록 하기)
사용 가능 블록 분석
Ÿ 마지막 단계에서는 전 단계에서
볼 수 없었던 [스피드] 블록과
[보이게 하기] 블록과 [소리 설
정] 블록과 [삭제하기] 블록이 추
가 되었다.
Ÿ 여러 블록들을 사용하여 자신만
의 이야기를 만들어본다.
Ÿ 이 단계를 통하여 전 단계까지
배워왔던 알고리즘을 연습하며
자신만의 프로그램을 만들기 위
한 연습을 하게 된다.

- 74 -
17. 스테이지17: 안전하게 자리잡기
◦ 개요: 많은 웹 사이트들이 사적인 정보들을 요구하는데 이에 어떻게
대처해야 하기 위하여 따라야 하는 룰에 대해서 알게 한다.
◦ 학습 목표
- 온라인에서의 안전은 실제 삶에서의 안전과 유사하다는 것을 인지한
다.
- 방문해도 되는 사이트들을 인지하는 방법을 배운다.
- 사적인 정보들의 종류에 대해서 안다.
- 자신의 사적인 정보를 보호하기 위하여 효과적인 사용자명을 만드는
방법을 배운다.
◦ 활동
- 1/2단계: 공유하지 말아야 할 정보 인식하기
Ÿ 아이들에게 주요화면 1,2와 같이 한 사
이트의 가입 페이지를 보여주고 수업을
시작한다.
Ÿ 학생들에게 사적인 정보에 대한 예를
들어보도록 하고 알려준 후 왜 정보를
사적으로 유지하는 것이 중요한지를 알
려준다.
Ÿ 그리고 다시 가입 페이지를 보여주어
자신의 사적인 정보를 담아야 하는지
물어본다.
Ÿ 그 후 실제로 사적인 정보를 담지 않은
사용자명을 만들도록 해본다.
주요 개념
사용자명: 웹 사이트에서 무엇을 보고, 무엇을 하기 위하여 구성하는 이름. 스크린 이름이라고도 함.

- 75 -
- 2/2단계: 공유하지 말아야 할 정보 인지하기(평가)
분석
Ÿ 온라인으로 공유하지 말아야 할 사적인 정보에 대해서 인지하게 한다.
Ÿ 나이, 생일 등의 사적인 정보에 대하여 정확하게 인지하고 안전한 사용자명을 만들 수 있도록 한다.

- 76 -
18. 스테이지18: 예술가(반복)
◦ 활동
분석 스크립트
Ÿ 루프 사용을 연습하기 전에 순차문에 대하여 이해시킨다.
moveRight(50);
moveRight(50);
moveRight(50);
moveRight(50);
분석 스크립트
Ÿ [4번 반복] 1번, [오른쪽] 1번 사용
Ÿ 전 단계에서의 [오른쪽] 4번 사용을 하나의 루프
를 통하여 표현한다.
Ÿ 반복될 횟수가 지정되어있다.
moveRight(50);
}

- 77 -
- 3/10단계: 루프 안에 점프 이동 블록 사용하기(반복 횟수 지정하기)
분석 스크립트
Ÿ [6번 반복] 1번, [오른쪽] 1번, [왼쪽] 1번, [점프 아
래쪽] 1번 사용
Ÿ 미리 반복될 블록에 대한 힌트를 작업 영역에 보
여준 뒤 이를 몇 번 반복해야할지 횟수를 생각해
보게 하여 루프 사용을 연습하게 한다.
moveRight(50);
moveLeft(50);
jumpDown(50);
}
- 4/10단계: 루프 안에 네 개의 블록 사용하기(반복 횟수 지정하기)
분석 스크립트
Ÿ [3번 반복] 1번, [오른쪽] 2번, [위쪽] 1번, [아래쪽] 1
번 사용
Ÿ 전 단계와 마찬가지로 미리 반복될 블록에 대한 힌
트를 작업영역에 준 뒤 몇 번 반복될 것인지 반복
횟수를 설정하도록 한다.
Ÿ 반복 횟수 설정에 대한 연습 과정이다.
moveRight(50);
moveUp(50);
moveRight(50);
moveDown(50);
}

- 78 -
- 5/10단계: 루프 안에 2개의 블록 사용하기(반복될 블록 넣기)
분석 스크립트
Ÿ [4번 반복] 1번, [왼쪽] 1번, [아래쪽] 1번 사용
Ÿ 전 단계까지는 반복횟수를 연습하게 하였다면 이번
단계에서는 루프 안에 들어갈 블록이 무엇인지를 결
정하는 연습을 하게 된다.
Ÿ 4번이라는 횟수에 맞추어 반복될 블록을 결정한다.
moveLeft(50);
moveDown(50);
}
- 6/10단계: 두 개(올라가는 루프와 내려가는 루프)의 루프를 이용하여
그리기(반복될 블록 넣기)
분석 스크립트
Ÿ [3번 반복] 2번, [오른쪽] 2번, [위쪽] 1번, [아래
쪽] 1번 사용
Ÿ 전 단계까지는 하나의 루프만을 이용했으나 이
단계는 올라가는 루프와 내려가는 루프 2개를 이
용하여 그리도록 한다.
Ÿ 반복되는 횟수가 주어져 있으므로 반복되는 블록
을 잘 파악하여 집어넣어 문제를 해결한다.
moveUp(50);
moveRight(50);
}
moveRight(50);
moveDown(50);
}

- 79 -
- 7/10단계: 두 개의 루프를 이용하여 그리기(반복될 블록 지정하기, 점
프 이동 블록 사용)
분석 스크립트
Ÿ [3번 반복] 2번, [오른쪽] 1번, [아래쪽] 1번, [점프
오른쪽] 1번, [점프 아래쪽] 1번 사용
Ÿ 전 단계와 달리 두 개의 루프 안에 각각 두 개의
블록이 들어가게 되고 점프 이동 블록 또한 추가
되었다.
Ÿ 반복횟수가 지정되어있으므로 캐릭터의 이동을 예
상하여 반복되는 블록이 무엇인지 잘 파악하여 해
결한다.
moveRight(50);
jumpRight(50);
}
moveDown(50);
jumpDown(50);
}
- 8/10단계: 루프 안에 3개의 블록 사용하기(미리 블록 주어지지 않음)
분석 스크립트
Ÿ [3번 반복] 1번, [위쪽] 1번, [오른쪽] 2번 사용
Ÿ 5단계에서 나왔던 계단과는 달리 계단 한 칸의 길
이가 좀 더 길다.
Ÿ 이 단계에서는 반복 횟수를 지정하는 것과 거리
이동 블록을 지정하는 것을 동시에 연습하게 된다.
moveUp(50);
moveRight(50);
moveRight(50);
}

- 80 -
- 9/10단계: 루프 안에 두 개의 블록 사용하기(미리 블록 주어지지 않
음)(평가)
분석 스크립트
Ÿ [4번 반복] 1번, [오른쪽] 1번, [아래쪽] 1번 사용
Ÿ 반복 횟수와 루프 안의 거리 이동 블록을 적절히
설정할 수 있는지를 평가한다.
moveRight(50);
moveDown(50);
}
- 10/10단계: 자유롭게 그리기
분석
Ÿ 전의 자유롭게 그리기와 달리 반복 블록이 추가되었다.
Ÿ 앞에 배운 루프를 사용하여 자신의 마음대로 그림을 그리도록 하여 프로그램에 흥미를 느끼도록 한
다.
Ÿ 자신만의 알고리즘을 만들도록 하여 앞으로 더 나아가 프로그램을 만드는 데에 도움을 준다.

- 81 -
II. 제2코스 Code.org 분석
1. 스테이지1: 모눈종이 프로그래밍
◦ 개요 : 모눈종이에 그림을 그리는 순서 프로그래밍을 통해 학생들이
프로그래밍의 기본적인 개념과 의미를 이해할 수 있다.
◦ 학습 목표
- 실제 문제를 프로그램으로 전환시키는 것의 어려움을 이해한다.
- 직관적으로는 명확해 보이지만 컴퓨터는 잘못 해석할 수 있음을 배
운다.
- 암호와 기호를 통해 개념들에 대한 의사소통 과정을 연습한다.
◦ 활동
- 1/3단계 : 언플러그드 활동(글로 표현된 명령을 기호로 표현해보기)
Ÿ 4*4의 모눈종이에서 내가 작성한 알고
리즘을 보고 친구가 격자의 빈칸에 색
칠할 수 있도록 한다.
Ÿ 알고리즘의 각 명령을 화살표로 대치하
여 쉽게 색칠할 수 있도록 한다.
Ÿ 이 때, 화살표 기호가 알고리즘의 ‘암
호’이고, 각각의 명령들은 알고리즘 조
각들이다.
주요 개념
알고리즘 : 과제를 마치기 위해 따라야 하는 단계들의 모음
프로그램 : 기계에 의해 운영되기 위해 암호화된 알고리즘

- 82 -
- 2/3단계 : 모눈종이의 격자그림에 알맞은 기호 알고리즘 선택하기
분석
Ÿ 처음 빈칸 색칠, 오른쪽으로 두 칸 이동 후 색칠, 아래로 두 칸 이동 후 색칠, 왼쪽으로 두 칸 이
동 후 색칠
Ÿ 학생들이 명령들을 화살표로 대치한 것을 이해하고, 알고리즘과 프로그래밍의 개념을 알게 한다.
- 3/3단계 : 각 격자무늬에 알맞은 기호 알고리즘 맞추기
분석
Ÿ 각 격자무늬 이미지로부터 각각의 알고리즘을 작성해본 후 선택지와 맞춰보거나, 각 알고리즘 선
택지로부터 격자무늬를 색칠해본 후 맞춰보는 방법 중 선택하여 학생들이 알고리즘에 대한 이해
를 확장시키도록 한다.

- 83 -
2. 스테이지2: 실시간 알고리즘, 종이 비행기‘
◦ 개요 : 알고리즘의 개념을 종이 비행기 만들기와 같은 일상생활 속의
활동들과 연관시켜 일상생활 속의 상황을 알고리즘으로 전환시킬 수
있게 한다.
◦ 학습 목표
- 일상생활 속에서 일어나는 다양한 활동들을 명명한다.
- 큰 활동들을 일련의 작은 사건들로 분해한다.
- 순차적인 사건들을 논리적인 명령 구조로 배열한다.
◦ 활동
- 1/3단계 : 언플러그드 활동(생활 속의 알고리즘 작성하기)
Ÿ 종이 비행기를 접는 과정을 설명서로
만들어 본다.
Ÿ 설명서의 각 지시들에 따라 종이 비행
기를 직접 만들어본다.
Ÿ 이 때, 종이 비행기를 만드는 과정의 각
지시들이 논리적으로 배열되어있음을
알게 한다.
주요 개념

- 84 -
- 2/3 단계 : 제시된 그림을 보고 알맞은 문장 알고리즘 선택하기
분석
Ÿ 사각형에서 시작, 사각형의 오른쪽에 삼각형 그리기, 사각형 아래에 평행사변형 그리기, 평행사변
형 오른쪽에 삼각형 그리기
Ÿ 선택지가 한글과 영어, 이어진 문장과 나열된 문장 등으로 다양하게 구성되었다.
Ÿ 학생들이 지시를 따라가며 순서대로 모양을 그릴 수 있도록 한다.
- 3/3 단계 : 제시된 문장 알고리즘을 보고 만들 수 없는 그림 선택하기
분석
Ÿ 각 선택지의 삼각형, 사각형의 크기와 모양에 관계없이 나타내는 도형의 이름만 추상화시킨다.
Ÿ 추상화된 각 도형의 위치를 비교해보며 알고리즘으로 전환시켜 본다.

- 85 -
3. 스테이지3: 미로퍼즐, 순차
◦ 동영상
Ÿ 미로퍼즐의 기본적인 이해를 돕기 위해 설명한다.
Ÿ 캐릭터가 돼지를 향해 이동해가는 모습을 나타낸다.
Ÿ 미로퍼즐 활동의 화면 구성에 대해 세 부분(실행화면, 도구
상자, 작업화면)으로 나누어 하나하나 설명한다.
◦ 활동
- 1/11단계 : 앞으로 두 번 이동하기
분석 스크립트
Ÿ [앞으로 이동] 2번 사용
Ÿ 방향 이동 블록(순차문)의 사용을 이해한다.
moveForward();
moveForward();

- 86 -
- 2/11단계 : 앞으로 세 번 이동하기
분석 스크립트
moveForward();
moveForward();
moveForward();
- 3/11단계 : 앞으로 이동과 오른쪽으로 회전하기
분석 스크립트
Ÿ [앞으로 이동] 3번 사용, [오른쪽으로 회전] 1번 사용
Ÿ 방향 이동 블록과 방향 회전 블록(순차문)의 사용을 이해한
다.
moveForward();
moveForward();
turnRight();
moveForward();

- 87 -
- 4/11단계 : 앞으로 이동과 왼쪽, 오른쪽으로 회전하기
분석 스크립트
Ÿ [앞으로 이동] 3번 사용, [왼쪽으로 회전] 1번 사용, [오른쪽
으로 회전] 1번 사용
다.
moveForward();
turnLeft();
moveForward();
turnRight();
moveForward();
- 5/11단계 : 앞으로 이동과 오른쪽 한 번, 왼쪽 두 번 회전하기
분석 스크립트
Ÿ [앞으로 이동] 5번 사용, [오른쪽으로 회전] 1번 사용, [왼쪽
Ÿ 방향 이동 블록과 방향 회전 블록(순차문)의 반복 사용을 이
해한다.
turnRight();
moveForward();
turnLeft();
moveForward();
moveForward();
moveForward();
turnLeft();
moveForward();

- 88 -
- 6/11단계 : 앞으로 이동과 세 번 회전하여 오른쪽으로 가기
분석 스크립트
해한다.
moveForward();
moveForward();
turnLeft();
moveForward();
moveForward();
turnRight();
moveForward();
moveForward();
turnRight();
moveForward();
moveForward();
- 7/11단계 : 앞으로 이동과 두 번 회전하여 밑으로 가기
분석 스크립트
다.
moveForward();
moveForward();
turnRight();
moveForward();
moveForward();
moveForward();
turnLeft();
moveForward();
moveForward();

- 89 -
- 8/11단계 : 앞으로 이동과 세 번 회전하여 밑으로 가기
분석 스크립트
해한다.
moveForward();
moveForward();
moveForward();
turnRight();
moveForward();
turnLeft();
moveForward();
moveForward();
turnRight();
moveForward();

- 90 -
- 9/11단계 : 앞으로 이동과 여러 번 회전하여 왼쪽으로 가기
분석 스크립트
해한다.
moveForward();
turnRight();
moveForward();
turnLeft();
moveForward();
moveForward();
turnLeft();
moveForward();
moveForward();
turnRight();
moveForward();
moveForward();
turnRight();
moveForward();
moveForward();
moveForward();
turnRight();
moveForward();

- 91 -
- 10/11단계 : 평가(화면의 도착점에 도달하기 위한 알고리즘 선택하기)
분석
Ÿ 보기 화면의 캐릭터가 이동해야하는 과정을 블록 순서도로 작성해보고 선택지와 비교하여 본다.
- 11/11단계 : 평가(각 화면에 알맞은 알고리즘 맞추기)
분석
Ÿ 각 화면에서 캐릭터가 이동해야 하는 과정을 블록 순서도로 작성해본 후, 세 가지 보기 블록 순
서도와 비교해본다.

- 92 -
4. 스테이지4: 예술가, 순차
◦ 개요 : 캐릭터가 경로를 이동하며 선을 그리는 활동을 통해 순차문을
이해시킨다.
◦ 학습 목표
- 문제에 따라 거리와 각도를 조절하며 경로를 설정해 이동할 수 있다.
- 순차문을 이해하고 블록 알고리즘 작성을 통한 문제해결능력을 신장
시킨다.
◦ 활동
- 1/12단계 : 거리이동 블록과 각도회전 블록으로 정사각형 절반 그리기
분석 스크립트
Ÿ [앞으로 100 이동] 2번 사용, [오른쪽으로 90°돌기] 1번 사용
Ÿ 거리 이동 블록과 각도 회전 블록(순차문)의 사용을 이해한다.
moveForward(100);
turnRight(90);
moveForward(100);
- 2/12단계 : 각도회전 블록과 거리이동 블록으로 정사각형의 나머지 부분 그리기
분석 스크립트
Ÿ [왼쪽으로 90°돌기] 1번 사용, [앞으로 50 이동] 1번 사용
Ÿ 거리 이동 블록을 원하는 거리만큼 조절하여 이동할 수 있다.
turnLeft(90);
moveForward(50);

- 93 -
- 3/12단계 : 각도회전 블록과 거리이동 블록(힌트로 길이 설정)으로 직사각
형 나머지 부분 그리기
분석 스크립트
Ÿ [왼쪽으로 90°돌기] 1번 사용, [앞으로 30 이동] 2번 사용, [오른
쪽으로 90°돌기] 2번 사용, [앞으로 50 이동] 1번 사용,
Ÿ 거리 이동 블록을 원하는 거리만큼 계산하여 이동할 수 있다.
turnLeft(90);
moveForward(30);
turnRight(90);
moveForward(50);
turnRight(90);
moveForward(30);
- 4/12단계 : 앞으로 점프 블록과 왼쪽으로 회전 블록으로 선 그리기
분석 스크립트
Ÿ [앞으로 50 이동] 4번 사용, [앞으로 50 점프] 3번 사용, [왼
쪽으로 90°돌기] 1번 사용
Ÿ 거리 이동 블록과 거리 점프 블록, 각도 회전 블록을 필요에
따라 순차적으로 사용할 수 있다.
moveForward(50);
jumpForward(50);
moveForward(50);
jumpForward(50);
turnLeft(90);
moveForward(50);
jumpForward(50);
moveForward(50);

- 94 -
- 5/12단계 : 거리이동 블록과 각도회전 블록으로 정사각형 전체 그리기
분석 스크립트
Ÿ [앞으로 100 이동] 4번 사용, [왼쪽으로 90°돌기] 3번 사용
Ÿ 거리 이동 블록과 각도 회전 블록을 번갈아가며 사용할 수
있다.
moveForward(100);
turnLeft(90);
moveForward(100);
turnLeft(90);
moveForward(100);
turnLeft(90);
moveForward(100);
- 6/12단계 : 거리이동 블록과 각도회전 블록(120°선택)으로 정삼각형 전체 그리기
분석 스크립트
Ÿ 정삼각형의 내부 각이 모두 60°인 것을 고려해 왼쪽으로
120°회전해야 함을 인식하게 한다.
Ÿ 원하는 만큼 각도를 조절하여 회전할 수 있다.
moveForward(100);
turnLeft(120);
moveForward(100);
turnLeft(120);
moveForward(100);

- 95 -
- 7/12단계 : 각도회전 블록(45°선택)과 거리이동 블록으로 정사각형 전체 그리기
분석 스크립트
Ÿ [왼쪽으로 45°돌기] 1번 사용, [앞으로 100 이동] 4번 사용,
[왼쪽으로 90°돌기] 3번 사용
Ÿ 정사각형의 내부 각이 모두 90°인 것을 고려해 원하는 만큼
각도를 조절해가며 회전할 수 있다.
turnLeft(45);
moveForward(100);
turnLeft(90);
moveForward(100);
turnLeft(90);
moveForward(100);
turnLeft(90);
moveForward(100);
- 8/12단계 : 거리이동 블록(힌트로 길이 설정)과 왼쪽으로 회전으로 정사각형 두 개 그리기
분석 스크립트
Ÿ 창문 그림을 완성하기 위해서 거쳐야 하는 길의 경로를 탐색
한 후, 그 경로에 맞게 거리 이동 블록과 각도 회전 블록을
사용할 수 있다.
moveForward(25);
turnLeft(90);
moveForward(25);
turnLeft(90);
moveForward(25);
turnLeft(90);
moveForward(50);
turnLeft(90);
moveForward(25);
turnLeft(90);
moveForward(25);

- 96 -
- 9/12단계 : 거리이동 블록(힌트로 길이 설정)과 왼쪽으로 회전으로 정사각형 두 개 그리기
분석 스크립트
Ÿ [앞으로 200 이동] 2번 사용, [왼쪽으로 90°사용] 5번 사용,
[앞으로 100 이동] 4번 사용
Ÿ 두 개의 정사각형 모양의 방을 그리기 위해 거쳐야 하는 길
의 경로를 탐색한 후, 그 경로에 맞게 거리 이동 블록의 거
리를 조절해가며 사용할 수 있다.
Ÿ 경로를 탐색할 때, 보다 효율적이고 짧은 경로를 파악한다.
moveForward(200);
turnLeft(90);
moveForward(100);
turnLeft(90);
moveForward(200);
turnLeft(90);
moveForward(100);
turnLeft(90);
moveForward(100);
turnLeft(90);
moveForward(100);
- 10/12단계 : 자유 시간
사용할 수 있는 블록들
분석
Ÿ 학생들이 그리고 싶은 것을 마음대로 그리게 한다.
Ÿ 이 때, 각도 회전 블록이 45, 60, 90, 120, 180°만 회전할 수 있도록 지원하기 때문에 학생들이
이를 인식하여 그릴 경로를 정하도록 한다.
Ÿ 이를 통해 정해진 문제뿐만 아니라 스스로 문제를 설정하여 알고리즘으로 나타낼 수 있음을 알
게 한다.

- 97 -
- 11/12단계 : 평가, 거리이동 블록(힌트로 길이 설정)과 왼쪽으로 회전으로
정사각형 절반 그리기
분석 스크립트
Ÿ 거리 이동 블록과 각도 회전 블록의 사용을 복습한다.
moveForward(25);
turnLeft(90);
moveForward(25);
- 12/12단계 : 평가, 각 다각형을 그리기 위한 알맞은 알고리즘 맞추기
분석
Ÿ 각 화면의 경로를 거리 이동 블록과 각도 회전 블록을 사용해 알고리즘으로 작성해 본 후, 선택
지와 비교해 본다.

- 98 -
5. 스테이지5: 반복시키기
◦ 개요 : 특정 행동들의 반복을 간단한 루프로 바꾸어본다.
◦ 학습 목표
- 교사가 발화한 행동들을 반복한다.
- 그림에 나와 있는 행동들을 실제 춤으로 전환시켜본다.
- 일련의 다수 행동들을 간단한 루프로 바꾸어본다.
◦ 활동
- 1/2단계 : 언플러그드 활동(일상생활의 반복구조를 활용하는 예시)
Ÿ 학습지의 동작들을 하나하나 따라해보
게 한 후, 그 중 반복되는 행동들을
‘몇 번 반복’이라는 구조로 만들었을
때의 효과를 생각해보게 한다.
Ÿ 동작들을 ‘몇 번 반복’이라는 루프로
만들면 더 짧고 쉽게 표현할 수 있다.
주요 개념
루프 : 어떠한 행동을 계속적으로 반복하는 구조
- 2/2단계 : 제시된 알고리즘을 반복문을 사용한 알고리즘으로 알맞게 바꾼 것을 선택하기
분석
Ÿ [앞으로 이동] 또는 [꿀 획득] 등의 블록 몇 개를 일일이 나열하는 것보다 ‘몇 번 반복’이라는
루프 속에 블록을 넣어 반복하는 것이 효율적임을 인식한다.

- 99 -
6. 스테이지6: 미로퍼즐, 반복
◦ 활동
- 1/14단계 : 앞으로 다섯 번 이동하여 오른쪽으로 가기
분석 스크립트
Ÿ 루프를 사용하기 전에 먼저 블록을 여러 번 중첩하여 사용해
보게 함으로써 루프 사용의 필요성을 느끼게 한다.
moveForward();
moveForward();
moveForward();
moveForward();
moveForward();
◦ 동영상
Ÿ 반복문(루프)을 소개하며 반복되는 행동을 나열하는 대신 그 행
동을 루프 속에 넣어 단순화시킬 수 있음을 이해시킨다.
Ÿ 반복문 내에 한 개 이상의 명령들이 연결되어 들어갈 수 있음
을 보여준다.

- 100 -
- 2/14단계 : 1단계를 반복문을 사용하여 알고리즘 작성하기
분석 스크립트
Ÿ [5번 반복] 1번 사용, [앞으로 이동] 1번 사용
Ÿ 이번에는 반복문(루프) 안에 방향 이동 블록을 넣어
간단하게 만들어 본다.
moveForward();
}
- 3/14단계 : 앞으로 이동을 다섯 번 반복하여 밑으로 가기
분석 스크립트
Ÿ 반복 블록과 명령 블록의 사용 방법을 이해시킨다.
moveForward();
}

- 101 -
- 4/14단계 : 반복문 사용 후 오른쪽으로 회전하여 반복문 사용하기
분석 스크립트
Ÿ [4번 반복] 1번 사용, [5번 반복] 1번 사용, [앞으
로 이동] 2번 사용, [오른쪽으로 회전] 1번 사용
Ÿ 반복문을 여러 번 사용하여 이동할 수 있음을 알
게 한다.
moveForward();
}
turnRight();
moveForward();
}
- 5/14단계 : 오른쪽으로 회전한 후 반복문 사용하기
분석 스크립트
Ÿ [앞으로 이동] 2번 사용, [오른쪽으로 회전] 1번 사용,
[5번 반복] 1번 사용
Ÿ 반복문이 필요한 경우와 필요하지 않은 경우를 구분
하여 반복문을 효율적으로 사용할 수 있다.
moveForward();
turnRight();
moveForward();
}

- 102 -
- 6/14단계 : 오른쪽으로 회전과 앞으로 이동을 반복시키기
분석 스크립트
Ÿ [3번 반복] 1번 사용, [오른쪽으로 회전] 1번 사용, [앞
으로 이동] 2번 사용
Ÿ 어떤 행동들을 연결하여 반복시키면 알고리즘을 가장
단순화시킬 수 있을지 생각해본다.
Ÿ 반복문이 몇 번 반복되어야 도착지점까지 갈 수 있을
지 생각해본다.
turnRight();
moveForward();
moveForward();
}
- 7/14단계 : 앞으로 이동과 오른쪽, 왼쪽으로 회전을 반복시키기
분석 스크립트
Ÿ [5번 반복] 1번 사용, [앞으로 이동] 2번 사용, [오른쪽
으로 회전] 1번 사용, [왼쪽으로 회전] 1번 사용
Ÿ 알고리즘을 단순화시키기 위해 어디서부터 어디까지
의 이동경로를 반복하면 좋을지 생각해본다.
Ÿ 반복문이 끝난 후의 위치와 방향을 고려하여 도착지
점까지의 나머지 경로는 어떻게 갈지 판단한다.
moveForward();
turnRight();
moveForward();
turnLeft();
}

- 103 -
- 8/14단계 : 앞으로 이동 세 번 후 오른쪽으로 회전을 반복시키기
분석 스크립트
Ÿ 반복블록과 이동블록, 회전블록을 이용하여 시작부터
루프를 직접 형성한다.
moveForward();
moveForward();
moveForward();
turnRight();
}
- 9/14단계 : 반복문을 여러 번 사용하기, 중첩하여 사용하기
분석 스크립트
Ÿ [3번 반복] 2번 사용, [5번 반복] 1번 사용, [2번 반복] 1
번 사용, [앞으로 이동] 2번 사용, [왼쪽으로 회전] 2번
사용
Ÿ 반복해야 할 명령들이 무엇일지 생각해보고, 반복블록
을 중첩하여 사용할 수 있음을 인식한다.
Ÿ 각각의 반복문이 몇 번 반복해야 할지 판단한다.
Ÿ 반복문을 최대한 많이 활용할수록 알고리즘이 단순해진
다는 것을 인지한다.
moveForward();
}
turnLeft();
moveForward();
}
turnLeft();
moveForward();
}
turnLeft();
moveForward();
}

- 104 -
- 10/14단계 : 앞으로 이동과 왼쪽으로 회전, 오른쪽으로 회전을 두 번 반복하기
분석 스크립트
Ÿ [2번 반복] 1번 사용, [앞으로 이동] 4번 사용, [왼쪽으
로 회전] 1번 사용, [오른쪽으로 회전] 1번 사용
Ÿ 왼쪽과 오른쪽의 방향 회전에 유의하여 반복해야할
구간의 설정을 선택한다.
moveForward();
moveForward();
turnLeft();
moveForward();
moveForward();
turnRight();
}
- 11/14단계 : 앞으로 이동과 왼쪽으로 회전, 오른쪽으로 회전을 세 번 반복하기
분석 스크립트
로 회전] 1번 사용, [오른쪽으로 회전] 1번 사용
Ÿ 왼쪽과 오른쪽의 방향 회전에 유의하여 반복해야할
구간의 설정을 선택한다.
Ÿ 반복문을 실행하는 도중에 도착지점을 만나더라도 상
관없음을 학생들이 인식하게 한다.
moveForward();
moveForward();
turnLeft();
moveForward();
turnRight();
}

- 105 -
- 12/14단계 : 평가(앞으로 이동과 왼쪽으로 회전을 두 번 반복하기)
분석 스크립트
로 회전] 1번 사용
Ÿ 반복블록과 명령블록의 사용을 복습한다.
Ÿ 반복문을 실행하는 도중에 도착지점을 만나더라도 상
관없음을 학생들이 인식하게 한다.
moveForward();
moveForward();
turnLeft();
}
- 13/14단계 : 평가(제시된 경로에 알맞은 반복문 알고리즘을 선택하기)
분석
Ÿ 보기 화면의 캐릭터가 이동해야하는 과정을 반복문(루프)을 이용하여 알고리즘으로 작성해보고
선택지와 비교해본다.

- 106 -
- 14/14단계 : 평가(반복문이 포함된 알고리즘들 중 각 화면의 경로에 알맞은 것끼리 맞추기)
분석
Ÿ 각 화면의 이동해야 할 경로를 반복문(루프)를 이용하여 알고리즘으로 작성해보고 선택지와 비교
해본다.

- 107 -
7. 스테이지7: 예술가, 반복
◦ 활동
- 1/16단계 : 거리이동 블록과 오른쪽으로 회전 블록으로 정사각형 그리기
분석 스크립트
Ÿ 거리 이동 블록과 각도 회전 블록의 사용을 복습한다.
moveForward(100);
turnRight(90);
moveForward(100);
turnRight(90);
moveForward(100);
turnRight(90);
moveForward(100);
◦ 동영상
Ÿ 반복문(루프)을 다시 한 번 소개하며 루프의 개념을 이해시킨
다.
Ÿ 실제 블록들을 조작하는 모습을 보여주며 반복문(루프)의 사
용을 권장하고 있다.

- 108 -
분석 스크립트
Ÿ [4번 반복] 1번 사용, [앞으로 100 이동] 1번 사용, [오
른쪽으로 90°돌기] 1번 사용
Ÿ 1단계의 문제를 반복문을 사용해 단순화시켜 해결할
수 있음을 알게 한다.
moveForward(100);
turnRight(90);
}
- 3/16단계 : 랜덤 색 설정과 각도회전 블록(45°선택)을 반복하여 선 8개 그리기
분석 스크립트
Ÿ [8번 반복] 1번 사용, [랜덤 색 설정] 1번 사용, [앞으
로 100 이동] 1번 사용, [뒤로 100 이동] 1번 사용,
[오른쪽으로 45°돌기] 1번 사용
Ÿ 주어진 명령 블록들을 반복시키기 위해 루프를 사용
한다.
Ÿ 루프를 몇 번 반복시켜야 모든 색을 칠할 수 있는지
생각한다.
penColour(colour_random());
moveForward(100);
moveBackward(100);
turnRight(45);
}

- 109 -
- 4/16단계 : 1°씩 회전하며 그리는 선들로 원을 그리기 위한 반복횟수 설정하기
분석 스크립트
Ÿ [360번 반복] 1번 사용, [랜덤 색 설정] 1번 사용,
[앞으로 100 이동] 1번 사용, [뒤로 100 이동] 1번
사용, [오른쪽으로 1°돌기] 1번 사용
Ÿ 오른쪽으로 1°씩 돌며 색칠을 할 때, 원 모양을
모두 색칠하기 위해서는 주어진 명령을 몇 번 반
복해야하는지 생각한다.
Ÿ 원의 내각의 합이 360°임을 고려한다.
moveForward(100);
moveBackward(100);
turnRight(1);
}
- 5/16단계 : 반복문을 사용하여 정팔각형을 그리기 위한 알고리즘 작성하기
분석 스크립트
Ÿ 8각형의 경계선을 돌며 색칠을 할 때, 이동과 회전을
몇 번 반복하면 시작 지점으로 돌아올 수 있는지 생
각한다.
Ÿ 오른쪽으로 몇 도 회전해야 하는지 판단한다.
moveForward(100);
turnRight(45);
}

- 110 -
- 6/16단계 : 오른쪽으로 1°씩 회전하며 원을 그리기 위한 반복문 사용하기
분석 스크립트
Ÿ [360번 반복] 1번 사용, [앞으로 1 이동] 1번 사용,
Ÿ 원을 그리기 위해서는 1°씩 몇 번 회전해야 하는
지 판단한다.
moveForward(1);
turnRight(1);
}
- 7/16단계 : 거리이동 블록(힌트로 거리 설정)과 각도회전 블록으로 이등변삼각형 그리기
분석 스크립트
Ÿ [오른쪽으로 45°돌기] 1번 사용, [앞으로 50 이동] 2번 사용,
Ÿ 필요에 따라 각도를 조절해가며 경로를 이동할 수 있다.
turnRight(45);
moveForward(50);
turnLeft(90);
moveForward(50);

- 111 -
- 8/16단계 : 7단계를 여덟 번 반복하여 그림 그리기
분석 스크립트
Ÿ [8번 반복] 1번 사용, [랜덤 색 설정] 1번 사용, [오른
쪽으로 45°돌기] 1번 사용, [앞으로 50 이동] 2번 사
용, [왼쪽으로 90°돌기] 1번 사용
Ÿ 7단계의 경로를 반복하며 응용할 수 있다.
turnRight(45);
moveForward(50);
turnLeft(90);
moveForward(50);
}
- 9/16단계 : 8단계를 응용하여 제시된 그림을 그리기 위한 반복문 만들기
분석 스크립트
Ÿ [24번 반복] 1번 사용, [랜덤 색 설정] 1번 사용, [오
른쪽으로 45°돌기] 1번 사용, [앞으로 50 이동] 2번
사용, [왼쪽으로 90°돌기] 1번 사용, [왼쪽으로 30°
돌기] 1번 사용
Ÿ 문제에서 왼쪽으로 30°회전 블록을 추가하여 24번
반복하라는 힌트를 주고 있다.
Ÿ 위 명령을 반복하면 내부에 원 모양이 생긴다는 것
을 이해한다.
turnRight(45);
moveForward(50);
turnLeft(90);
moveForward(50);
turnLeft(30);
}

- 112 -
- 10/16단계 : 반복문을 사용하여 마름모를 그리기 위한 알고리즘 작성하기
분석 스크립트
Ÿ [2번 반복] 1번 사용, [왼쪽으로 60°돌기] 1번 사용,
[앞으로 100 이동] 2번 사용, [오른쪽으로 120°사용]
2번 사용
Ÿ 반복문을 사용하지 않고 경로를 이동할 수 있지만,
반복문을 사용하면 더 적은 명령 블록들로 문제를 해
결할 수 있음을 알게 한다.
Ÿ 루프 내의 마지막 명령 블록을 실행한 후, 루프 내의
첫 번째 명령이 바로 실행된다는 것에 유의하여 회전
각도를 설정한다.
turnLeft(60);
moveForward(100);
turnRight(120);
moveForward(100);
turnRight(120);
}
- 11/16단계 : 반복문을 사용하여 정육면체를 그리기 위한 알고리즘 완성하기
분석 스크립트
Ÿ [3번 반복] 1번 사용, [랜덤 색 설정] 1번 사용, [왼쪽으로
60°돌기] 1번 사용, [앞으로 100 이동] 4번 사용, [오른쪽으
로 120°돌기] 2번 사용, [오른쪽으로 60°돌기] 1번 사용
Ÿ 주어진 명령 블록들을 따라가보며 루프의 마지막 명령 블록
을 실행하고 난 후의 방향과 루프의 첫 번째 명령 블록 실
행 전의 방향이 일치하는지 확인한다.
turnLeft(60);
moveForward(100);
turnRight(120);
moveForward(100);
turnRight(60);
moveForward(100);
turnRight(120);
moveForward(100);
}

- 113 -
- 12/16단계 : 반복문을 사용하여 다이아몬드모양 그리기 위한 알고리즘 완성하기
분석 스크립트
Ÿ [10번 반복] 1번 사용, [랜덤 색 설정] 1번 사용, [왼쪽으로
60°돌기] 1번 사용, [앞으로 100 이동] 4번 사용, [오른쪽으
로 120°돌기] 2번 사용, [오른쪽으로 60°돌기] 1번 사용,
Ÿ 문제에서 90°회전 블록을 추가하여 10번 반복하라는 힌트가
주어져 있다.
Ÿ 실행할 명령 블록들을 따라가보며 루프의 마지막 명령 블록
을 실행하고 난 후의 방향과 루프의 첫 번째 명령 블록 실행
전의 방향이 일치하는지 확인한다.
turnLeft(60);
moveForward(100);
turnRight(120);
moveForward(100);
turnRight(60);
moveForward(100);
turnRight(120);
moveForward(100);
turnRight(90);
}
- 13/16단계 : 자유 시간
분석
Ÿ 학생들이 그리고 싶은 것을 마음대로 그리게 한다.
Ÿ 각도 회전 블록이 직접 설정할 수 있도록 지원하고 있기 때문에 학생들이 원하는 대로 각도를
설정할 수 있다.
Ÿ 펜의 색깔뿐만 아니라 두께까지 변경할 수 있어 다양한 표현이 가능하다.
Ÿ 이를 통해 정해진 문제뿐만 아니라 스스로 문제를 설정하여 알고리즘으로 나타낼 수 있음을 알
게 한다.

- 114 -
- 14/16단계 : 평가(여러 다각형을 그리기 위한 적절한 반복문 알고리즘을 맞추기)
분석
Ÿ 각 화면의 이동해야 할 경로를 반복문(루프)를 이용하여 알고리즘으로 작성해보거나 제시된 알고
리즘에 따라 직접 그려본 후 비교해본다.
- 15/16단계 : 평가(제시된 알고리즘으로 그릴 수 있는 그림 선택하기)
분석
Ÿ 제시된 알고리즘에 따라 그림을 그려가며 선택지와 비교해본다.

- 115 -
- 16/16단계 : 평가(반복문을 사용한 알고리즘을 보고 그릴 수 있는 그림 선택하기)
분석
Ÿ 제시된 알고리즘에 따라 그림을 그려가며 선택지와 비교해본다.

- 116 -
8. 스테이지8: 꿀벌, 반복
◦ 활동
- 1/14단계 : 앞으로 이동과 꽃꿀 얻기 블록 반복하여 사용하기
분석 스크립트
Ÿ [앞으로 이동] 4번 사용, [꽃꿀 얻기] 2번 사용
Ÿ [꽃꿀 얻기]라는 이벤트를 이해한다.
moveForward();
moveForward();
getNectar();
moveForward();
moveForward();
getNectar();
◦ 동영상
Ÿ 루프(Loop)란 같은 활동이나 행동을 여러 번 반복하는 구조라
는 개념을 이해시킨다.
Ÿ 실제 블록들을 조작하여 루프(반복문)을 실행하는 과정을 보
여준다.

- 117 -
분석 스크립트
Ÿ [2번 반복] 1번 사용, [앞으로 이동] 2번 사용, [꽃꿀
얻기] 1번 사용
Ÿ 1단계의 과정을 반복문을 사용하여 단순화시킨다.
moveForward();
moveForward();
getNectar();
}
- 3/14단계 : 꽃꿀 얻기 블록을 반복문으로 만들기
분석 스크립트
Ÿ [앞으로 이동] 2번 사용, [4번 반복] 1번 사용, [꽃꿀
얻기] 1번 사용
Ÿ [꽃꿀 얻기]라는 이벤트를 반복할 수 있다.
moveForward();
moveForward();
getNectar();
}

- 118 -
- 4/14단계 : 꽃꿀 얻기 블록과 꿀 만들기 블록을 반복문으로 만들기
분석 스크립트
Ÿ [앞으로 이동] 2번 사용, [4번 반복] 2번 사용, [꽃
꿀 얻기] 1번 사용, [꿀 만들기] 1번 사용
Ÿ [꽃꿀 얻기]와 [꿀 만들기]라는 이벤트를 반복하여
사용할 수 있다.
moveForward();
getNectar();
}
moveForward();
makeHoney();
}
- 5/14단계 : 회전, 앞으로 이동, 꽃꿀 얻기를 반복문을 사용하여 알고리즘 완성하기
분석 스크립트
Ÿ [3번 반복] 1번 사용, [왼쪽으로 회전] 1번 사용, [앞으
로 이동] 2번 사용, [꽃꿀 얻기] 2번 사용
Ÿ 회전, 이동, 이벤트가 포함된 명령 블록들을 루프를
통해 반복하여 실행할 수 있다.
turnLeft();
moveForward();
getNectar();
moveForward();
getNectar();
}

- 119 -
- 6/14단계 : 주어진 블록들을 반복문으로 묶고 반복문을 추가하여 사용하기
분석 스크립트
Ÿ [3번 반복] 2번 사용, [왼쪽으로 회전] 1번 사용, [앞으
로 이동] 4번 사용, [꽃꿀 얻기] 1번 사용, [꿀 만들기]
1번 사용
Ÿ 필요에 따라 적절하게 시퀀스(명령 블록들의 집합)를
반복할 수 있다.
turnLeft();
moveForward();
moveForward();
moveForward();
getNectar();
}
moveForward();
makeHoney();
}
- 7/14단계 : 앞으로 이동, 꽃꿀 얻기, 회전 블록을 반복문으로 만들어 알고리즘 작성하기
분석 스크립트
Ÿ [3번 반복] 1번 사용, [앞으로 이동] 2번 사용, [꽃꿀 얻기]
1번 사용, [오른쪽으로 회전] 1번 사용
Ÿ 시퀀스(명령 블록들의 집합)를 적절하게 배열하여 반복문
(루프)으로 실행할 수 있다.
moveForward();
moveForward();
getNectar();
turnRight();
}

- 120 -
- 8/14단계 : 앞으로 이동, 꽃꿀 얻기, 꿀 만들기 블록을 반복문으로 만들어 알고리즘 작성하기
분석 스크립트
얻기] 1번 사용, [꿀 만들기] 1번 사용
Ÿ 시퀀스(명령 블록들의 집합)를 적절하게 배열하여 반
복문(루프)으로 실행할 수 있다.
moveForward();
getNectar();
moveForward();
makeHoney();
}
- 9/14단계 : 꽃꿀 얻기와 꿀 만들기를 두 번씩 실행하는 반복문 작성하기
분석 스크립트
얻기] 2번 사용, [꿀 만들기] 2번 사용
moveForward();
getNectar();
getNectar();
moveForward();
makeHoney();
makeHoney();
}

- 121 -
- 10/14단계 : 앞으로 이동, 꽃꿀 얻기, 꿀 만들기, 회전 등 복합적인 반복문 작성하기
분석 스크립트
얻기] 1번 사용, [꿀 만들기] 1번 사용, [왼쪽으로 회
전] 1번 사용
Ÿ 시퀀스(명령 블록들의 집합)를 적절하게 배열하여
반복문(루프)으로 실행할 수 있다.
moveForward();
getNectar();
moveForward();
makeHoney();
turnLeft();
}
- 11/14단계 : 꽃꿀을 얻는 규칙적인 경로 이동을 반복문으로 작성하기
분석 스크립트
으로 회전] 1번 사용, [꽃꿀 얻기] 1번 사용, [왼쪽으
moveForward();
turnRight();
moveForward();
getNectar();
turnLeft();
}

- 122 -
- 12/14단계 : 꽃꿀을 얻고 꿀을 만드는 경로 이동을 반복문으로 작성하기
분석 스크립트
얻기] 1번 사용, [왼쪽으로 회전] 1번 사용, [꿀 만들
기] 1번 사용, [오른쪽으로 회전] 1번 사용
moveForward();
getNectar();
turnLeft();
moveForward();
makeHoney();
turnRight();
}
- 13/14단계 : 평가(앞으로 이동하며 꽃꿀을 얻는 반복문 작성하기)
분석 스크립트
얻기] 2번 사용
Ÿ 위 단계들에서 학습한 것을 복습한다.
moveForward();
getNectar();
getNectar();
}

- 123 -
- 14/14단계 : 평가(화면의 꽃꿀을 얻기 위한 올바른 알고리즘 선택하기)
분석
Ÿ 시퀀스와 루프를 활용하여 알고리즘을 작성하고 선택지와 비교해본다.

- 124 -
9. 스테이지9: 릴레이 프로그래밍
◦ 개요 : 모눈종이 프로그래밍을 복습하고, 친구들과 팀을 만들어 프로
그램을 만드는 릴레이 시합을 한다.
◦ 학습 목표
- 암호와 기호를 통해 개념들에 대한 의사소통 과정을 연습한다.
- 협동심을 발휘하여 과제를 수행한다.
- 성공적인 결과를 위해 친구들의 작업을 확인한다.
◦ 활동
- 1/3단계 : 언플러그드 활동(친구들의 프로그램 오류 발견 및 수정하기; 디버깅)
Ÿ 지난 시간에 배웠던 모눈종이 프로그래
밍을 친구들과 릴레이 시합 형식으로
활동한다.
Ÿ 각 팀에서 한명씩 문제로 뛰어가 이미
지를 나타내기 위한 자신의 기호(화살
표)를 그린 후 다시 팀으로 돌아온다.
Ÿ 앞의 친구들이 작성한 기호나 프로그램
에 문제나 오류가 있을 경우 수정(디버
깅)한 후 돌아온다.
주요 개념
디버깅 : 알고리즘이나 프로그램에서 문제나 오류를 발견하고 수정하는 것
- 2/3단계 : 격자무늬를 프로그램으로 작성해보고 오류 발견하기

- 125 -
분석
Ÿ 보기 화면의 그림을 그리기 위한 다양한 프로그램이 있을 수 있음을 인지한다.
Ÿ 학생들 스스로 그림을 그리기 위한 프로그램을 작성해보고, 친구들과 비교해본다.
Ÿ 선택지의 프로그램에 따라 그림을 그려보고 보기 화면과 비교해본다.
- 3/3단계 : 격자무늬를 프로그램으로 작성한 것을 보고 오류 발견하기
분석
Ÿ 각 선택지마다 그림과 프로그램을 비교해보며 오류를 발견할 수 있다.

- 126 -
10. 스테이지10: 꿀벌, 디버깅
◦ 동영상
Ÿ 디버깅(Debugging)이란 알고리즘이나 프로그램에서 문제나 오
류를 발견하고 수정하는 것이라는 개념을 이해시킨다.
Ÿ Step이란 버튼을 누를 때마다 각 명령 블록들이 하나씩 실행
된다는 것을 보여주고, 주어진 블록들을 올바르게 수정하여
다시 Step버튼을 통해 하나씩 실행하면 미션을 완료할 수 있
다는 것을 이해시킨다.
◦ 활동
- 1/11단계 : 반복횟수 수정하기
분석 스크립트
Ÿ [앞으로 이동]을 3번 실행에서 4번 실행으로 수정
Ÿ 학생들이 먼저 주어진 시퀀스를 [단계] 버튼을 통해
실행해 본 후 오류를 발견하게 한다.
Ÿ 오류를 수정하기 위해서 반복문을 어떻게 바꾸면 좋
을지 생각한다.
moveForward();
}
getNectar();

- 127 -
- 2/11단계 : 앞으로 이동 블록 1개 제거하기
분석 스크립트
Ÿ [앞으로 이동]을 1개 제거
Ÿ 오류를 수정하기 위해서 어떤 블록을 제거해야할지 생각한
다.
moveForward();
getNectar();
moveForward();
getNectar();
- 3/11단계 : 오른쪽으로 회전을 왼쪽으로 회전으로 수정하기
분석 스크립트
Ÿ [오른쪽으로 회전]을 [왼쪽으로 회전]으로 변경
Ÿ 꿀벌이 이동하는 경로의 방향에 유의하여 어떤 블록을 어떻
게 변경해야할지 생각한다.
moveForward();
getNectar();
turnRight();
moveForward();
turnLeft();
moveForward();
getNectar();

- 128 -
- 4/11단계 : 꽃꿀 얻기 1개 추가하고 회전방향 수정하기
분석 스크립트
Ÿ [꽃꿀 얻기]를 1개 추가, [왼쪽으로 회전]을 [오른쪽으로 회
전]으로 변경
Ÿ 이벤트와 꿀벌이 이동하는 경로의 방향에 유의하여 어떤 블
록을 추가하거나 변경해야할지 생각한다.
moveForward();
moveForward();
turnLeft();
moveForward();
getNectar();
getNectar();
turnRight();
moveForward();
getNectar();
- 5/11단계 : 반복횟수 수정하기
분석 스크립트
Ÿ [5번 반복]을 [4번 반복]으로 변경
Ÿ 이동 블록을 반복해야 하는 횟수를 생각해본다.
moveForward();
}
getNectar();

- 129 -
- 6/11단계 : 앞으로 이동 1개 추가하고 반복횟수 수정하기
분석 스크립트
Ÿ [앞으로 이동]을 1개 추가, [4번 반복]을 [5번 반복]으로
변경
Ÿ 꿀벌이 이동해야하는 경로를 살펴보고 누락된 명령 블록
이나 변경해야할 명령 블록을 파악한다.
moveForward();
moveForward();
moveForward();
turnRight();
moveForward();
}
getNectar();
- 7/11단계 : 반복횟수 2번 수정하고 앞으로 이동 1개 추가하기
분석 스크립트
Ÿ [4번 반복]을 [5번 반복]으로 변경, [앞으로 이동]을 1개 추
가
Ÿ 꿀벌이 이동해야하는 경로를 살펴보고 누락된 명령 블록이
나 변경해야할 명령 블록을 파악한다.
moveForward();
moveForward();
getNectar();
}
moveForward();
makeHoney();
}

- 130 -
- 8/11단계 : 앞으로 이동 2개 제거하기
분석 스크립트
Ÿ [앞으로 이동]을 2개 제거
Ÿ 시퀀스를 단순화시키기 위해 반복문을 사용한 것에
유의하여 제거해야할 명령 블록이 무엇인지 생각한
다.
moveForward();
getNectar();
}
- 9/11단계 : 꿀 만들기를 꽃꿀 얻기로 수정하고 반복횟수 수정하기
분석 스크립트
Ÿ [꿀 만들기]를 [꽃꿀 얻기]로 변경, [4번 반복]을 [3
번 반복]으로 변경
Ÿ 이벤트나 반복문 등에서 오류를 발견하고 수정할
수 있다.
moveForward();
getNectar();
}
turnLeft();
moveForward();
makeHoney();
}

- 131 -
- 10/11단계 : 꿀 만들기 블록 순서 이동하기
분석 스크립트
Ÿ [꿀 만들기]를 마지막 반복문 내에 포함
Ÿ 알고리즘에서 오류를 발견하여 적절하게 수정할 수 있
다.
moveForward();
getNectar();
}
turnRight();
moveForward();
getNectar();
}
turnRight();
moveForward();
makeHoney();
}
- 11/11단계 : 평가(반복횟수 수정과 회전방향 수정하기)
분석 스크립트
Ÿ [3번 반복]을 [4번 반복]으로 변경, [오른쪽으로 회전]을 [왼
쪽으로 회전]으로 변경
Ÿ 알고리즘에서 오류를 발견하여 적절하게 수정할 수 있다.
moveForward();
}
turnLeft();
moveForward();
getNectar();
}

- 132 -
11. 스테이지11: 예술가, 디버깅
◦ 동영상
Ÿ 주어진 시퀀스를 그대로 실행했을 때 문제가 있음을 발견한다.
Ÿ 문제가 생기는 이유가 무엇인지 파악하고 문제를 해결하기 위
해 노력한다.
Ÿ 오류를 수정하여 다시 실행해본다.
Ÿ 다시 실행했을 때의 결과를 예측해본다.
◦ 활동
- 1/12단계 : 이동거리 수정하기
분석 스크립트
Ÿ [앞으로 50 이동]을 [앞으로 100 이동]으로 변경
Ÿ 문제 상황에서 알고리즘의 오류를 발견하여 적절하게 수정할
수 있다.
moveForward(20);
turnLeft(90);
moveForward(50);
turnRight(90);
moveForward(100);
turnRight(90);
moveForward(50);
turnLeft(90);
moveForward(20);

- 133 -
- 2/12단계 : 회전각도 2번 수정과 이동거리 1번 수정하기
분석 스크립트
Ÿ [왼쪽으로 90°돌기]를 [왼쪽으로 45°돌기]로 변경, [오른쪽
으로 45°돌기]를 [왼쪽으로 45°돌기]로 변경, [앞으로 25 이
동]을 [앞으로 75 이동]으로 변경
Ÿ 문제 상황에서 알고리즘의 오류를 발견하여 적절하게 수정할
수 있다.
Ÿ 오류가 많을 경우 세심한 주의로 살펴보며 오류들을 발견할
수 있다.
turnRight(45);
moveForward(75);
moveBackward(75);
turnLeft(45);
moveForward(75);
moveBackward(75);
turnLeft(45);
moveForward(75);
- 3/12단계 : 회전각도를 파악하여 수정하기
분석 스크립트
Ÿ [오른쪽으로 115°돌기]를 [오른쪽으로 130°돌기]로 변경
Ÿ 경로의 방향과 각도를 변경해가며 이동할 수 있다.
Ÿ 문제 경로의 각도를 알 수 없으므로 먼저 주어진 시퀀스를
실행해보며 경로의 이동을 확인해본다.
Ÿ 주어진 힌트(15°차이가 난다)를 이용하여 문제를 해결할 수
있다.
moveForward(70);
turnRight(50);
moveForward(100);
turnRight(130);
moveForward(200);
turnRight(130);
moveForward(100);

- 134 -
- 4/12단계 : 거리이동 블록 1개 제거하기
분석 스크립트
Ÿ [앞으로 40 이동] 1개를 제거
Ÿ 알고리즘의 실행에서 문제가 생기는 이유를 발견하여 수정할
수 있다.
turnRight(70);
moveForward(80);
turnLeft(70);
moveForward(40);
- 5/12단계 : 거리이동 블록을 거리점프 블록으로 변경하고 이동거리 수정하기
분석 스크립트
Ÿ [앞으로 150 이동]을 [앞으로 150 점프]로 변경, [앞으로 150
이동]을 [앞으로 300 이동]으로 변경
Ÿ 각 명령 블록들에 대한 이해를 바탕으로 필요한 명령 블록을
선택하여 적절하게 사용할 수 있다.
moveForward(150);
turnLeft(90);
moveForward(150);
turnRight(90);
jumpForward(150);
turnRight(180);
moveForward(300);

- 135 -
- 6/12단계 : 거리점프 블록 추가와 앞으로 이동을 뒤로 이동으로 변경, 회전각도 수정하기
분석 스크립트
Ÿ [앞으로 50 점프]를 1개 추가, [앞으로 50 이동]을 [뒤로 50
이동]으로 변경, [오른쪽으로 90°돌기]를 [왼쪽으로 90°돌
기]로 변경
Ÿ 점프와 뒤로 이동의 명령에 대한 이해를 바탕으로 명령 블록
을 추가하거나 변경하여 사용한다.
jumpForward(50);
moveBackward(50);
turnRight(90);
moveForward(100);
turnLeft(90);
moveForward(50);
- 7/12단계 : 중첩 반복문의 반복횟수 수정하기
분석 스크립트
Ÿ 반복문을 중첩하여 사용할 수 있다.
Ÿ [2번 반복] 안에 포함된 시퀀스를 실행했을 때 꽃잎모
양 하나가 그려진다는 것을 인식하고 그 꽃잎을 몇 번
그려야하는지 파악한다.
penColour('#843179');
turnRight(90);
moveForward(60);
turnRight(45);
moveForward(20);
turnRight(45);
moveForward(60);
}
turnRight(60);
}

- 136 -
- 8/12단계 : 회전각도를 파악하여 수정하기
분석 스크립트
Ÿ [왼쪽으로 30°돌기]를 [왼쪽으로 90°돌기]로 변경
Ÿ 알고리즘에서 오류를 발견하여 적절하게 수정한다.
penColour('#228b22');
turnLeft(90);
moveForward(200);
turnRight(40);
moveForward(80);
turnLeft(130);
- 9/12단계 : 이동거리를 파악하여 수정하기
분석 스크립트
Ÿ 이동해야 할 경로의 길이를 먼저 파악한 뒤, 거리 이
동 블록의 숫자가 적절한지 판단한다.
moveForward(60);
turnRight(90);
moveForward(30);
turnRight(90);
moveForward(60);
turnRight(90);
}

- 137 -
- 10/12단계 : 반복횟수를 파악하여 수정하기
분석 스크립트
Ÿ 시퀀스를 몇 번 실행해야하는지 파악한다.
penColour('#7fffd4');
moveForward(50);
turnRight(90);
moveForward(25);
turnRight(90);
penColour('#0000cd');
moveForward(25);
turnRight(90);
moveForward(50);
turnRight(45);
}
- 11/12단계 : 평가(이동거리 수정하기)
분석 스크립트
Ÿ 각 모서리가 75 더 길어야 한다는 힌트를 이용한다.
Ÿ 알고리즘을 실행시켜보며 이동 거리를 확인한다.
moveForward(150);
turnLeft(90);
}

- 138 -
- 12/12단계 : 평가(원을 그리기 위한 프로그램에서 오류 부분 발견하기)
분석
Ÿ 보기 화면의 그림을 그리기 위한 제시된 알고리즘에서 잘못된 부분이 무엇인지 파악한다.
Ÿ 원의 내부 각도가 360°임에 유의한다.
Ÿ 왼쪽으로 18°씩 회전하며 10픽셀씩 뒤로 이동하는데, 이 시퀀스를 10번 반복했을 때 어디까지
그려지는지 예상해본다.

- 139 -
12. 스테이지12: 조건
◦ 개요 : 프로그램을 특정한 정보에 따라 맞춰서 행동하게 하는 조건문
의 사용을 보여주고 이해시킨다.
◦ 학습 목표
- 프로그램의 특정 부분들이 언제 실행되어야하고 언제 실행되어서는
안 되는지 상황을 규정한다.
- 기준에 따라 조건문의 실행 여부를 결정한다.
- 주어진 입력값의 집합으로부터 프로그램의 실행과정을 파악하고 결
과값을 예측한다.
◦ 활동
- 1/2단계 : 언플러그드 활동(게임에서 조건문이 사용되는 예시로 설명하기)
Ÿ 친구들과 카드의 숫자나 색 등을 맞추
며 점수를 주거나 빼는 게임을 한다.
Ÿ 이를 알고리즘, 코드 등의 프로그램으로
만들어 볼 수 있다.
Ÿ 조건에 맞을 경우 +1점을 주고 조건에
해당하지 않을 경우 –1점을 주는 등의
게임을 통해 if와 else문의 개념을 이해
시킨다.
주요 개념
조건문 : 특정한 조건 아래에서만 실행되는 진술문
- 2/2단계 : 제시된 조건문 프로그램에 따른 올바른 결과값 선택하기
분석
Ÿ 보기 화면의 If, Else문을 읽어보며 선택지의 점수를 계산해본다.
Ÿ 조건이 중첩되어 있을 때 위 조건을 고려하며 아래 조건을 생각한다.
Ÿ Else문이 위 If문의 반대라는 것을 생각한다.

- 140 -
13. 스테이지13: 꿀벌, 조건선택
◦ 활동
- 1/15단계 : 반복문을 2번 사용하여 꽃꿀을 얻는 알고리즘 작성하기
분석 스크립트
Ÿ [5번 반복] 1번 사용, [앞으로 이동] 2번 사용, [꽃
꿀 얻기] 2번 사용, [오른쪽으로 회전] 1번 사용,
[3번 반복] 1번 사용
Ÿ 반복문의 사용을 복습한다.
moveForward();
}
getNectar();
turnRight();
moveForward();
getNectar();
}

- 141 -
- 2/15단계 : 반복문을 5번 사용하여 꽃꿀을 얻고 꿀을 만드는 알고리즘 작성하기
분석 스크립트
Ÿ [3번 반복] 3번 사용, [앞으로 이동] 3번 반복, [왼
쪽으로 회전] 2번 사용, [꽃꿀 얻기] 1번 사용, [4
번 반복] 2번 사용, [꿀 만들기] 1번 사용
Ÿ 반복문을 여러 번 사용하여 문제를 해결할 수 있
다.
moveForward();
}
turnLeft();
moveForward();
}
getNectar();
}
turnLeft();
moveForward();
}
makeHoney();
}

- 142 -
◦ 동영상
Ÿ 다음 단계부터 사용될 조건문 블록에 대한 이해를 위해 실제
사용하는 모습을 화면으로 보여준다.
Ÿ 조건문 블록에서 선택할 수 있는 조건들이 무엇이 있는지 보
여준다.
Ÿ 조건문 블록에서 조건을 충족할 경우 실행할 명령 블록을 붙
이는 모습을 화면으로 보여준다.
Ÿ 문제를 해결하는 데 필요한 블록들의 구성과 순서 등을 어떻
게 정해야 하는지 생각해본다.
- 3/15단계 : 조건문으로 꽃꿀이 1개일 때 꽃꿀을 얻도록 만들기
분석 스크립트
Ÿ [3번 반복] 1번 사용, [앞으로 이동] 1번 사용, [만약~
실행~] 1번 사용, [꽃꿀 얻기] 1번 사용
Ÿ 꽃꿀의 양이 1일 때 실행할 행동이 무엇인지 생각해
본다.
Ÿ 아래에서 꽃꿀의 양이 1 또는 0이라는 힌트가 주어져
있기 때문에 조건문의 조건(대소 비교)을 어떤 것으로
선택해야 하는지 알 수 있다.
moveForward();
}
if (nectarRemaining() == 1) {
getNectar();
}

- 143 -
- 4/15단계 : 조건문을 사용하여 꽃꿀이 1개일 때 꽃꿀을 얻는 알고리즘 작성하기
분석 스크립트
Ÿ [앞으로 이동] 1번 사용, [만약~실행~] 1번 사용, [꽃꿀 얻기]
1번 사용
Ÿ 조건문 블록을 가져와 사용할 수 있다.
Ÿ 꽃꿀의 양이 1일 때 실행할 행동이 무엇인지 생각해본다.
moveForward();
getNectar();
}
- 5/15단계 : 꽃꿀을 얻는 조건문을 2번 사용하여 알고리즘 작성하기
분석 스크립트
Ÿ [앞으로 이동] 3번 사용, [만약~실행~] 2번 사용, [꽃꿀 얻기]
2번 사용, [오른쪽으로 회전] 1번 사용
Ÿ 조건문 블록을 사용하여 알고리즘을 작성할 수 있다.
moveForward();
getNectar();
}
turnRight();
moveForward();
moveForward();
getNectar();
}

- 144 -
- 6/15단계 : 꽃꿀의 개수가 정해져 있을 때와 없을 때를 구분하여 조건문을
사용해 알고리즘 작성하기
분석 스크립트
Ÿ [앞으로 이동] 4번 사용, [꽃꿀 얻기] 2번 사용, [왼쪽으로 회
전] 1번 사용, [만약~실행~] 1번 사용,
Ÿ 조건문 블록을 필요에 따라 적절히 사용하여 알고리즘을 작
성할 수 있다.
moveForward();
getNectar();
moveForward();
turnLeft();
moveForward();
moveForward();
getNectar();
}
- 7/15단계 : 반복문과 조건문을 사용하여 꽃꿀을 얻는 알고리즘 작성하기
분석 스크립트
Ÿ [앞으로 이동] 3번 사용, [4번 반복] 1번 사용, [꽃꿀 얻
기] 2번 사용, [오른쪽으로 회전] 1번 사용, [만약~실행~]
1번 사용,
Ÿ 조건문 블록을 필요에 따라 적절히 사용하여 알고리즘
을 작성할 수 있다.
moveForward();
getNectar();
}
turnRight();
moveForward();
moveForward();
getNectar();
}

- 145 -
- 8/15단계 : 반복문과 조건문을 여러 번 사용하여 꽃꿀을 얻는 알고리즘 작성하기
분석 스크립트
Ÿ [4번 반복] 1번 사용, [앞으로 이동] 3번 사용, [만
약~실행~] 3번 사용, [꽃꿀 얻기] 3번 사용, [왼쪽
으로 회전] 2번 사용, [3번 반복] 2번 사용
Ÿ 이동해야할 경로를 파악하여 반복문과 조건문을
적절히 사용할 수 있다.
moveForward();
}
getNectar();
}
turnLeft();
moveForward();
}
getNectar();
}
turnLeft();
moveForward();
}
getNectar();
}

- 146 -
- 9/15단계 : 반복문 안에 조건문을 포함시켜 알고리즘 작성하기
분석 스크립트
Ÿ [5번 반복] 1번 사용, [앞으로 이동] 1번 사용, [만약~실
행~] 1번 사용, [꽃꿀 얻기] 1번 사용
Ÿ 반복문 내에 조건문을 포함시켜 알고리즘을 작성할 수 있
다.
Ÿ 논리적 사고를 통해 블록들을 배열한다.
moveForward();
getNectar();
}
- 10/15단계 : 조건문을 포함하는 반복문과 단순한 반복문을 사용해 알고리즘 작성하기
분석 스크립트
행~] 1번 사용, [꽃꿀 얻기] 1번 사용, [오른쪽으로 회
전] 1번 사용, [3번 반복] 1번 사용, [꿀 만들기] 1번 사
용
Ÿ 반복문 내에 조건문을 포함시켜 알고리즘을 작성할 수
있다.
Ÿ 정해져 있는 상황도 조건으로 포함시켜 행동을 실행할
수 있다.
Ÿ 조건문을 알 수 없는 상황에서만 활용하는 것이 아니
라는 것을 인식한다.
moveForward();
moveForward();
getNectar();
}
turnRight();
}
moveForward();
}
makeHoney();

- 147 -
- 11/15단계 : 반복문과 조건문을 여러 번 사용하여 꽃꿀을 얻고 꿀을 만드는
알고리즘 작성하기
분석 스크립트
행~] 2번 사용, [꽃꿀 얻기] 4번 사용, [왼쪽으로 회전]
3번 사용, [2번 반복] 1번 사용, [꿀 만들기] 1번 사용
Ÿ 정해져 있는 상황도 조건으로 포함시켜 행동을 실행할
수 있다.
Ÿ 조건문을 알 수 없는 상황에서만 활용하는 것이 아니
라는 것을 인식한다.
Ÿ 여러 블록들을 적절히 중첩하여 알고리즘을 단순화시
킬 수 있다.
moveForward();
}
getNectar();
turnLeft();
moveForward();
}
getNectar();
}
turnLeft();
moveForward();
}
getNectar();
}
turnLeft();
moveForward();
for (var count4 =

- 148 -
- 12/15단계 : 조건문에 따라 꽃꿀을 얻는 규칙적인 이동을 반복문을 사용해
알고리즘으로 작성하기
분석 스크립트
Ÿ [4번 반복] 1번 사용, [앞으로 이동] 2번 사용, [왼쪽으로
회전] 1번 사용, [만약~실행~] 1번 사용, [꽃꿀 얻기] 1번
사용, [오른쪽으로 회전] 1번 사용
Ÿ 반복문과 조건문을 사용하여 알고리즘을 작성한다.
moveForward();
turnLeft();
moveForward();
getNectar();
}
turnRight();
}
- 13/15단계 : 평가(조건문을 사용해 꽃꿀을 3번 얻고 단순히 꽃꿀 1번 얻기)
분석 스크립트
Ÿ [앞으로 이동] 3번 사용, [3번 반복] 1번 사용, [만약~실
행~] 1번 사용, [꽃꿀 얻기] 2번 사용, [4번 반복] 1번
사용
Ÿ 반복문과 조건문을 활용하여 알고리즘을 작성한다.
moveForward();
moveForward();
getNectar();
}
}
moveForward();
getNectar();
}

- 149 -
- 14/15단계 : 평가(조건문에서 꽃꿀의 개수를 조건의 숫자 비교로 추상화시키기)
분석
Ÿ 조건문에서 조건의 선택(대소 비교)이 의미하는 것을 이해한다.
- 15/15단계 : 평가(반복문과 조건문을 사용한 알고리즘들 중 화면의 꽃꿀을 얻기
위한 올바른 것 선택하기)
분석
Ÿ 보기 화면의 이동 경로를 파악한 후, 반복문과 조건문을 사용하여 알고리즘으로 작성하여 선택
지와 비교해본다.

- 150 -
14. 스테이지14: 2진 팔찌
◦ 개요 : 우리가 일련의 ‘켜짐-꺼짐’ 형태로 정보를 받아들이고 전달
하는 것이 가능한 방법을 보여준다.
◦ 학습 목표
- 문자를 2진법 형태로 암호화한다.
- 2진법을 다시 문자의 형태로 해독한다.
- 팔찌에 첫글자들을 저장하는 개념과 컴퓨터가 정보를 저장하는 개념
을 관련시켜 이해한다.
◦ 활동
- 1/3단계 : 언플러그드 활동(일상생활의 예들을 2진법 체계로 설명하기)
Ÿ 학습지, 로봇 눈 깜빡임 등을 통해 2진
법의 의미를 이해시킨 다음, 컴퓨터가
이 2진법을 바탕으로 작동한다는 것을
알게 한다.
Ÿ 2진법이‘켜짐-꺼짐’,‘위-아래’,‘안
-밖’등의 반대되는 개념의 선택으로
이루어져있다는 것을 알게 한다.
Ÿ 사각형들의 패턴들로 이루어진 팔찌를
활용하여 문자와 2진법을 번갈아 바꾸
어본다.
주요 개념
2진법 : 두 가지의 선택만을 이용하여 정보를 나타내는 방법

- 151 -
- 2/3단계 : 제시된 그림을 보고 각 문자를 올바르게 2진법 표기로 바꾼 것끼리 맞추기
분석
Ÿ 보기 화면을 보고 각 문자를 2진법 암호로 나타내보거나 2진법 암호를 문자로 바꾸어본다.
- 3/3단계 : 화살표와 색칠하기가 각각 2진법의 두 가지 선택조건임을 알고
격자무늬를 프로그램으로 작성하기
분석
Ÿ 모눈종이 프로그램에서 사용하였던 알고리즘이 2진법을 바탕으로 하고 있다는 것을 알게 한다.
Ÿ 이처럼 컴퓨터의 알고리즘은 2진법 구조를 바탕으로 하고 있음을 인지한다.

- 152 -
15. 스테이지15: 큰 이벤트
◦ 개요 : 사용자가 원할 때 지시한 반응을 하도록 프로그램을 구성하고
알고리즘을 작성한다.
◦ 학습 목표
- 교사가 제시한 명령들을 반복한다.
- 교사의 행동을 명령들을 시작하라는 신호로 인지한다.
- 사전에 정의된 행동들과 이벤트 반응형 행동들을 구분하는 연습을 한다.
◦ 활동
- 1/2단계 : 언플러그드 활동(코스1과 동일)
Ÿ 프로그램을 제어하고 실행되는 방법을
변화시키기 위해 버튼을 누르거나 마우
스를 클릭하는 등의 행동을 하는 원리를
이해한다.
Ÿ 이벤트를 비디오 게임과 같은 프로그램
에 응용할 수 있음을 알게 한다.
Ÿ 사전에 어떤 행동이 입력될지 모르는 상
태에서 이벤트 제어장치를 통해 원하는
결과를 이끌어낼 수 있음을 알게 한다.
주요 개념
이벤트 : 특정 사건이 발생하도록 유발하는 행동
- 2/2단계(코스1과 동일)
분석
Ÿ 보기 화면을 보고 각 신호가 의미하는 행동이 무엇인지 파악한다.
Ÿ 선택지의 각 신호를 행동으로 해석한 후 맞춰본다.
Ÿ 각 신호를 행동으로 읽어내는 과정이 이벤트와 어떠한 관련이 있을지 생각해본다.

- 153 -
16. 스테이지16: 플래피 버드
◦ 동영상
Ÿ 컴퓨터 프로그램과 사람이 서로 대화할 수 있음을 알게 한다.
Ÿ 그 의사소통이 다양한 형태로 입력된 이벤트 암호들로 나타난
다는 것을 인식한다.
Ÿ 사용자가 어떤 동작을 실행했을 때 컴퓨터가 어떤 이벤트를 실
행할지 이벤트 핸들러와 실행문을 통해 프로그램을 작성한다.
Ÿ 간단한 드래그 앤 드롭 형식으로 자신의 플래피 버드 게임을
만들 수 있음을 알게 한다.
Ÿ 이렇게 어렵지 않은 코드 작성을 통해 게임을 프로그래밍 할
수 있다는 것을 인식하여 학생들에게 학습의 동기를 부여한다.
Ÿ 블록(이벤트 핸들러)들의 내부에는 실제로 스크립트와 같은 프
로그래밍 코드가 존재함을 인식한다.
◦ 활동
- 1/10단계 : 초기 설정하기
분석
Ÿ 플래피 버드 게임은 정해진 블록들을 사용하여 미션을 완료하는 것이 아니라, 다양한 이벤트 핸
들러들을 이용하여 자유롭게 게임을 구성할 수 있다.
Ÿ 프로그램을 작성 후, 실행 버튼을 누르거나 화면을 클릭하면 게임이 시작된다.
Ÿ 게임을 시작한 후 화면을 마우스로 클릭하여 ‘펄럭인다’동작을 실행시켜 도착지점까지 도달하
게 한다.
Ÿ 프로그램을 작성한 후 실행만으로 활동이 완료되는 것이 아니라, 사용자가 설정한 동작을 실행하
여야 활동이 완료된다는 사실을 통해 이벤트의 성격을 파악한다.

- 154 -
- 2/10단계 : 게임 종료 설정하기
분석
Ÿ 실행 버튼을 누르거나 화면을 클릭하면 게임이 시작되고, 캐릭터가 땅에 떨어져 도착지점에 도달
했을 때 게임이 끝나도록 조작한다.
- 3/10단계 : 캐릭터 스피드 설정하기
분석
Ÿ 화면을 마우스로 클릭할 때마다 캐릭터가 보통 스피드로 펄럭이며 날개소리를 출력하는 다양한
효과를 줄 수 있다.

- 155 -
- 4/10단계 : 캐릭터 소리 출력 추가와 게임 종료 설정하기
분석
Ÿ 화면을 마우스로 클릭할 때마다 다양한 효과를 줄 수 있으며, 장애물에 의해 게임이 종료되는 효
과도 설정할 수 있다.
며 게임을 진행해야 활동이 완료된다는 사실을 통해 이벤트의 성격을 파악한다.
- 5/10단계 : 캐릭터 소리 출력과 점수 획득 설정하기
분석
Ÿ 화면을 마우스로 클릭할 때마다 다양한 효과를 줄 수 있으며, 장애물에 의해 게임이 종료되거나
포인트를 얻는 효과도 설정할 수 있다.

- 156 -
- 6/10단계 : 캐릭터 초기 설정 후 점수 획득 확인하기
분석
Ÿ 화면을 마우스로 클릭할 때마다 다양한 효과를 줄 수 있으며, 다양한 형식으로 포인트를 얻게 설
정할 수 있다.
- 7/10단계 : 캐릭터 소리 출력과 랜덤 배경 설정하기
분석
Ÿ 여러 가지 이벤트들을 각각 설정할 수 있고, 게임을 시작했을 때 배경을 바꾸도록 설정할 수 있
다.

- 157 -
- 8/10단계 : 캐릭터 랜덤 설정과 랜덤 배경 설정하기
분석
Ÿ 여러 가지 이벤트들을 각각 설정할 수 있고, 게임을 시작했을 때 캐릭터를 바꾸거나 물체를 통과
했을 때 랜덤으로 배경이 바뀌도록 설정할 수 있다.
- 9/10단계 : 물체에 부딪쳤을 때 점수가 0이 되도록 설정하기
분석
Ÿ 여러 가지 이벤트들을 각각 설정할 수 있고, 물체에 부딪칠 때마다 점수가 0이 되도록 하는 효과
를 설정할 수 있다.

- 158 -
- 10/10단계 : 자유롭게 게임 만들기
분석
Ÿ 지금까지의 단계들에서 배운 효과들을 활용하여 자신만의 이야기를 구성할 수 있다.
Ÿ 물체 설정, 바닥 설정, 중력 설정 등의 화면 구성 요소들을 추가적으로 구성할 수 있다.
Ÿ 자신이 만든 게임을 친구들과 스마트폰에서 해볼 수 있도록 공유할 수 있음을 인지한다.

- 159 -
17. 스테이지17: PLAY LAB, 스토리 만들기
◦ 동영상
Ÿ 방향키 블록과 캐릭터 이동 블록을 함께 조작하여 실제 게임에
사용되는 이벤트를 구성할 수 있다.
Ÿ 캐릭터가 다른 캐릭터나 어떤 물체를 만났을 때, 혹은 마우스
로 캐릭터를 클릭했을 때 설정할 수 있는 효과들이 있다는 것
을 인식한다.
◦ 활동
- 1/11단계 : 실행했을 때 캐릭터가 문장을 말하도록 설정하기
분석
Ÿ 프로그램을 실행했을 때 캐릭터가‘hello world’라는 문장을 말하도록 작성할 수 있다.

- 160 -
- 2/11단계 : 실행했을 때 캐릭터1과 캐릭터2가 대화 주고받게 설정하기
분석
Ÿ 캐릭터1이 말한 다음, 캐릭터 2가 말하게 설정할 수 있다.
Ÿ 말하는 내용은 자유롭게 작성할 수 있다.
- 3/11단계 : 실행했을 때 캐릭터1이 오른쪽으로 이동하여 캐릭터2를 만나게 설정하기
분석
Ÿ 강아지가 오른쪽으로 이동하여 고양이까지 움직이게 설정할 수 있다.
- 4/11단계 : 캐릭터1이 오른쪽으로 랜덤하게 이동할 때 캐릭터2에 닿으면 말을 하도록 설정하기
분석
Ÿ 강아지가 오른쪽으로 이동하여 고양이에게 닿으면 ‘hello’라고 말하도록 설정할 수 있다.
Ÿ 강아지가 이동하는 거리를 랜덤으로 설정하여 고양이에게 닿았을 때만 말을 하도록 한다.

- 161 -
- 5/11단계 : 캐릭터를 클릭했을 때 말을 하도록 설정하기
분석
Ÿ 캐릭터를 클릭했을 때 ‘hello’라고 말하도록 설정한다.
Ÿ 프로그램을 실행한 후 마우스로 화면을 클릭해야 명령이 실행됨을 인식한다.
- 6/11단계 : 각 방향키를 눌렀을 때 그 방향으로 움직이도록 설정하기
분석
Ÿ 방향키를 움직여 캐릭터가 깃발들을 지나가도록 프로그램을 작성한다.

- 162 -
- 7/11단계 : 캐릭터2가 위아래로 무한반복 움직이도록 설정하기
분석
Ÿ 공룡이 위 아래를 반복적으로 움직이며 깃발을 지나도록 프로그램을 작성한다.
Ÿ 방향키를 움직였을 때 이동하는 것은 펭귄이지만, 깃발을 지나야하는 대상은 공룡임을 명확히 한다.

- 163 -
- 8/11단계 : 캐릭터1이 위아래로 무한반복 움직이는 캐릭터2에 닿았을 때
소리를 내며 말하도록 설정하기
분석
Ÿ 공룡이 위 아래를 반복적으로 움직이도록 알고리즘을 작성한 다음, 펭귄이 움직이는 공룡에 닿았
을 때 어떤 효과들을 설정해야할지 생각해본다.
Ÿ 방향키를 움직여 이동시키는 대상은 펭귄임을 명확히 한다.

- 164 -
- 9/11단계 : 캐릭터1이 캐릭터2를 피해 캐릭터3에 닿았을 때 점수가 올라가도록
설정하기
분석
Ÿ 펭귄이 위 아래로 움직이는 공룡을 피해 문어에 닿았을 때 점수가 올라가도록 프로그램을 작성
한 다음, 실제로 프로그램을 실행시켜 펭귄이 문어와 만났을 때 점수가 올라가는지 확인해본다.

- 165 -
- 10/11단계 : 배경을 랜덤으로 설정하고 캐릭터1이 랜덤한 속도로 움직이도록 설정하기
분석
Ÿ 펭귄이 위 아래로 움직이는 공룡을 피해 문어에 닿았을 때 점수가 올라가도록 프로그램을 작성
한 다음, 실제로 프로그램을 실행시켜 펭귄이 문어와 만났을 때 점수가 올라가는지 확인해본다.
Ÿ 화면의 배경과 펭귄의 스피드가 바뀌도록 프로그램을 작성할 수 있다.
- 11/11단계 : 자신만의 이야기 만들기
분석
Ÿ 지금까지의 단계들에서 배운 효과들을 활용하여 자신만의 이야기를 구성할 수 있다.
Ÿ 자신이 만든 이야기를 스마트폰에서 살펴볼 수 있음을 인지한다.

- 166 -
18. 스테이지18: 디지털 개인정보 흔적
◦ 개요 : 학생들이 실제 세계에서 안전하게 생활하는 것과 웹사이트를
방문했을 때 안전성을 확보하는 것 사이의 유사성을 인식하고, 온라인
상의 정보가 흔적을 남긴다는 것을 인지하여 이에 유의하여 디지털
매체를 다루도록 한다.
◦ 학습 목표
- 웹사이트를 방문했을 때 안전성을 확보하는 것이 실제 세계에서 안
전하게 생활하는 것과 유사하다는 것을 이해한다.
- 방문한 웹사이트가 그들에게 올바른지 인식하는 연습을 한다.
- 학생들이 특정 웹사이트를 방문할 때 그들이 신뢰하는 어른에게 물
어보고 접속해야할지 인식한다.
- 어떤 정보가 온라인 상에 게시하기 적절한지 설명한다.
◦ 활동
- 1/2단계 : 언플러그드 활동(‘Follow the digital trail’을 읽고 디지털 흔적에
대한 개념 알기)
Ÿ 하이퍼링크로 연결된‘Follow the digital
trail’를 정독해보고, 그 중‘Animal
tracks chart’를 학생들이 실제로 활동
으로 해볼 수 있도록 한다.
Ÿ 온라인 상에 자신에 대한 구체적이고
상세한 정보들을 많이 남길수록 부적절
한 디지털 흔적이 많아진다는 것을 알
게 한다.
주요 개념
디지털 흔적 : 인터넷 상에서 누군가에 대한 정보

- 167 -
- 2/2단계 : 디지털 흔적을 많이 남긴다는 것의 의미 알기
분석
Ÿ 문제에 오류가 있음 (디지털 흔적을 가장 적게 남기는 동물은? → 디지털 흔적을 가장 많이 남기
는 동물은?)
Ÿ 구체적이고 상세한 정보를 많이 남길수록 디지털 흔적이 많아진다.

- 168 -
19. 스테이지19: 예술가, 중첩반복
◦ 활동
- 1/13단계 : 반복문을 세 번 실행하는 중첩 반복문을 만들기
분석 스크립트
Ÿ [3번 반복] 추가
Ÿ 삼각형 하나를 그리기 위한 알고리즘이 제시되어 있기
때문에 삼각형을 3개 그리기 위해서는 이를 몇 번 반
복해야 하는지 생각한다.
moveForward(100);
turnRight(120);
}
turnRight(120);
}
- 2/13단계 : 반복문을 여섯 번 실행하는 중첩 반복문 만들기
분석 스크립트
Ÿ 작은 삼각형 하나를 그리기 위한 알고리즘이 제시되어
있기 때문에 이를 6개 그리기 위해서는 몇 번 반복해
야 하는지 생각한다.
moveForward(100);
turnRight(120);
}
turnRight(60);
}

- 169 -
- 3/13단계 : 반복문을 한 번 실행 후 각도를 회전하여 다음 실행을 하는 중첩 반복문 만들기
분석 스크립트
Ÿ [12번 반복] 추가, [오른쪽으로 30°돌기] 추가
Ÿ 작은 삼각형 하나를 그리기 위한 알고리즘이 제시되
어 있기 때문에 이를 12개 그리기 위해서는 몇 번 반
Ÿ 작은 삼각형 하나를 그린 후의 방향을 고려하여 그
다음 삼각형을 그리기 위해서는 어느 방향으로 얼마
나 각도를 회전해야 하는지 생각한다.
moveForward(100);
turnRight(120);
}
turnRight(30);
}
분석 스크립트
Ÿ 작은 사각형 하나를 그리기 위한 알고리즘이 제시되
Ÿ 작은 사각형 하나를 그린 후의 방향을 고려하여 그
다음 사각형을 그리기 위해서는 어느 방향으로 얼마
나 각도를 회전해야 하는지 생각한다.
moveForward(100);
turnRight(60);
moveForward(100);
turnRight(120);
}
turnRight(30);
}

- 170 -
- 5/13단계 : 반복문을 한 번 실행 후 앞으로 점프하여 다음 실행을 하는 반복문 만들기
분석 스크립트
Ÿ [8번 반복] 추가, [앞으로 40 점프] 추가
Ÿ 작은 창문 하나를 그리기 위한 알고리즘이 제시되어
있기 때문에 창문 8개를 그리기 위해서는 몇 번 반복
해야 하는지 생각한다.
Ÿ 창문 하나를 그린 후 다음 창문을 그리기 위해서는 캐
릭터가 어떻게, 얼마나 이동해야하는지 생각한다.
moveForward(20);
turnLeft(90);
}
jumpForward(40);
}
분석 스크립트
Ÿ 작은 삼각형 하나를 그리기 위한 알고리즘이 제시되어
있기 때문에 이를 8개 그리기 위해서는 몇 번 반복해
야 하는지 생각한다.
Ÿ 삼각형 하나를 그린 후 다음 삼각형을 그리기 위해서
는 캐릭터가 어떻게, 얼마나 이동해야하는지 생각한다.
moveForward(30);
turnLeft(120);
}
jumpForward(30);
}

- 171 -
- 7/13단계 : 반복문을 한 번 실행 후 앞으로 점프하고 각도를 회전하여 다음 실행을 하는
중첩 반복문 만들기
분석 스크립트
Ÿ [10번 반복] 추가, [앞으로 30 점프] 추가, [오른쪽으로
36°돌기] 추가
Ÿ 작은 삼각형 하나를 그리기 위한 알고리즘이 제시되
Ÿ 삼각형 하나를 그린 후 다음 삼각형을 그리기 위해서
는 캐릭터가 어떻게 해야 하는지 거리와 각도를 계산
한다.
moveForward(30);
turnLeft(120);
}
jumpForward(30);
turnRight(36);
}
분석 스크립트
Ÿ 그림 하나를 그리기 위한 알고리즘이 제시되어 있기
때문에 이를 8개 그리기 위해서는 몇 번 반복해야 하
는지 생각한다.
Ÿ 각 그림이 50만큼 떨어져 있다는 힌트를 이용해 알고
리즘을 완성한다.
turnLeft(120);
moveForward(40);
moveBackward(40);
turnRight(30);
}
turnRight(30);
jumpForward(50);
}

- 172 -
분석 스크립트
Ÿ 4단계와 동일
moveForward(40);
turnRight(60);
moveForward(40);
turnRight(120);
}
turnRight(30);
}
- 10/13단계 : 매우 복잡한 그림에서 중첩 반복문의 반복횟수 설정하기
분석 스크립트
Ÿ 제시된 루프를 몇 번 반복하면 그림을 그릴 수 있는
지 파악하여 알고리즘을 완성한다.
moveForward(100);
turnRight(100);
}
turnRight(30);
}

- 173 -
분석 스크립트
Ÿ 반복해야 할 횟수와 회전 각도에 유의하여 알고리즘
을 완성한다.
moveForward(1);
turnRight(1);
}
turnRight(90);
}
- 12/13단계 : 반복문을 두 개 포함하는 중첩 반복문 만들기
분석 스크립트
Ÿ 반복해야 할 횟수에 유의하여 나선 모양을 그리기
위한 알고리즘을 완성한다.
moveForward(1);
turnRight(2);
}
moveForward(3);
turnRight(2);
}
}

- 174 -
- 13/13단계 : 자유 시간
분석
Ÿ 지금까지 배운 내용들을 떠올리며 자신이 그리고 싶은 그림을 그린다.

- 175 -
III. 제 3코스 code.org 분석
1. 스테이지1: 컴퓨터 과학적 사고
◦ 개요: 하나의 활동에서 컴퓨터 과학적 사고 단계들(분석, 패턴 맞추기,
추상화, 알고리즘)을 연습할 수 있도록 한다.
◦ 학습목표
- 결론을 내기 위하여 정보를 분석한다.
- 패턴을 맞추기 위하여 유사한 어구들의 동일한 부분을 파악한다.
- 유사한 어구에서 다른 점들을 파악하여 그것들을 추상화한다.
◦ 활동
- 1/3단계: 컴퓨터 과학적 사고(분석, 패턴 맞추기, 추상화) 연습하기
Ÿ 아이들을 그룹으로 나누어 교사의 가르
침 없이 스스로 게임을 실행하는 법을
알아보도록 한다.
Ÿ 아이들에게 사용자들이 자신의 경험에
대하여 서술해놓은 것을 읽고 공통점에
는 동그라미 표시하여 패턴 맞추기를
하고 차이점에는 줄을 그어 추상화하도
록 한 후 종이를 나눠주어 게임을 실행
하기 위한 지침(알고리즘)을 적어보라고
지도한다.
Ÿ 이 활동을 통하여 컴퓨터 과학적 사고
를 연습할 수 있다.
주요 개념
분석: 하나의 문제를 작은 조각들로 나누는 것
패턴 맞추기: 사물들 간의 유사성을 발견하는 것
추상화: 하나의 해결책이 여러 문제에 작용하도록 하기 위하여 특수한 차이점을 제거하는 것

- 176 -
- 1/2단계: 분석, 패턴 맞추기, 추상화하여 알고리즘 만들기(평가)
분석
Ÿ 분석하고 패턴 맞추기를 한 후 추상화를 통하여 알고리즘을 찾아내는 문항이다.
Ÿ 학생들에게 컴퓨터과학적 사고를 연습할 수 있도록 도와준다.
Ÿ 아이들은 [은], [도시]가 공통적으로 포함된다는 것을 발견하여 패턴 맞추기를 하고, 도시 이름과 도
시의 크기가 들어가는(차이점) 공간을 추상화하여 알고리즘을 완성하게 된다.
- 2/2단계: 패턴 맞추기와 추상화 하기(평가)
분석
Ÿ 패턴 맞추기와 추상화 과정을 준비하기 위하여 분석하는 과정이다.
Ÿ 이 과정을 통하여 컴퓨터과학적 사고의 단계 중 분석하기를 연습할 수 있다.
Ÿ 학생들은 바퀴의 수와 창문의 개수 부분으로 나누어 개수를 분석하여 답을 내게 된다.

- 177 -
2. 스테이지2: Maze
◦ 활동
분석 스크립트
Ÿ [move forward] 3번 사용
Ÿ 순차문을 사용하여 문제를 해결할 수 있도록 한다.
moveForward();
moveForward();
moveForward();
- 2/15단계: 방향 회전 블록을 포함한 순차문 만들기
분석 스크립트
Ÿ [move forward] 3번, [왼쪽으로 회전] 1번, [오른쪽으로 회전] 1
번 사용
Ÿ 회전 블록이 포함된 순차문을 만들어 문제를 해결하도록 한다.
moveForward();
turnLeft();
moveForward();
turnRight();
moveForward();

- 178 -
- 3/15단계: 방향 회전 블록을 포함한 순차문 만들기
분석 스크립트
Ÿ [move forward] 6번 사용, [오른쪽으로 회전] 1번, [왼쪽으로 회
전] 1번 사용
Ÿ 전 단계와 마찬가지로 회전 블록이 포함된 순차문이다.
Ÿ 다음 단계에 반복문을 연습하도록 하기 위하여 같은 블록을 여
러 번 쓰도록 하였다.
moveForward();
turnRight();
moveForward();
moveForward();
moveForward();
turnLeft();
moveForward();
moveForward();
◦ 동영상
Ÿ 미로 퍼즐의 목적은 좀비를 해바라기에게 데려다주는 것이라고
말한다.
Ÿ 반복 블록을 사용하여 행동을 반복할 수 있다고 말한다.
Ÿ 블록을 사용하여 반복하는 방법을 알려준다.
Ÿ 반복 블록 안에 블록을 넣으면 된다고 설명한다.

- 179 -
- 4/15단계: 루프 사용하기(반복 횟수 직접 입력)
분석 스크립트
Ÿ [5번 반복] 1번, [move forward] 1번 사용
Ÿ 루프를 사용하여 문제를 해결하도록 한다.
Ÿ 이 단계에서는 반복되는 횟수를 미리 도구 박스에서
알려준다.
moveForward();
}
- 5/15단계: 두 개의 루프와 방향 회전 블록 사용하기
분석 스크립트
Ÿ [4번 반복] 1번, [5번 반복] 1번, [move
forward] 2번, [오른쪽으로 회전] 1번 사용
Ÿ 두 개의 루프를 사용하여 해결하는 단계이다.
Ÿ 이 단계부터는 반복되는 횟수를 알려주지 않는
다.
moveForward();
}
turnRight();
moveForward();
}

- 180 -
- 6/15단계: 하나의 루프 안에 3개의 블록 사용하기
분석 스크립트
Ÿ [3번 반복] 1번, [move forward] 2번, [오른쪽으
Ÿ 하나의 루프안에 여러 개의 블록이 포함되는
단계이다.
Ÿ 반복되는 구간과 반복횟수를 잘 지정하여 해결
한다.
moveForward();
moveForward();
turnRight();
}
분석 스크립트
forward] 3번, [오른쪽으로 회전] 1번, [왼쪽으
Ÿ 세 개의 루프와 방향 이동 블록을 적절히 사용
하는 단계이다.
moveForward();
turnRight();
moveForward();
}
turnLeft();
moveForward();
}
}

- 181 -
분석 스크립트
forward] 5번, [왼쪽으로 회전] 2번, [오른쪽으
Ÿ 반복구조와 순차문을 적절히 이해하여 해결한
다.
moveForward();
}
turnLeft();
moveForward();
}
turnRight();
moveForward();
}
turnRight();
moveForward();
- 9/15단계: ‘~할 때까지 반복’블록 사용하기
분석 스크립트
Ÿ [~할 때까지 반복] 1번, [move forward] 1번 사
용
Ÿ 해바라기를 만날 때까지 반복 실행되는 블록을
사용하여 해결하도록 한다.
while (notFinished()) {
moveForward();
}

- 182 -
- 10/15단계: ‘~할 때까지 반복’ 블록 안에 방향 회전 블록 사용하기
분석 스크립트
Ÿ [~할 때까지 반복] 1번, [왼쪽으로 회전] 1번,
[move forward] 2번 사용
Ÿ [~할 때까지 반복] 블록 안에 여러 개의 블록이
포함된 단계이다.
Ÿ 계속해서 반복 실행될 구간이 어디인지 파악하
여 해결한다.
turnLeft();
moveForward();
moveForward();
}
- 11/15단계: ‘~할 때가지 반복’ 블록 안에 4개의 블록 사용하기
분석 스크립트
Ÿ [~할 때까지 반복] 1번, [move forward] 2번,
[왼쪽으로 회전] 1번, [오른쪽으로 회전] 1번
사용
Ÿ 전 단계와 마찬가지로 [~할 때까지 반복] 블록
안에 여러 블록이 포함되어있다.
Ÿ 반복되는 블록이 무엇인지 잘 파악하여 해결한
다.
moveForward();
turnLeft();
moveForward();
turnRight();
}

- 183 -
- 12/15단계: ‘~할 때까지 반복’ 블록 안에 4개의 블록 사용하기
분석 스크립트
Ÿ [~할 때까지 반복] 1번, [오른쪽으로 회전] 1번,
[왼쪽으로 회전] 1번, [move forward] 2번 사용
Ÿ 전 단계를 한 번 더 연습한다.
turnRight();
moveForward();
turnLeft();
moveForward();
}
- 13/15단계: ‘~할 때까지 반복’ 블록 안에 블록 4개 사용하기(평가)
분석 스크립트
Ÿ [~할 때까지 반복] 1번, [오른쪽으로 회전] 1번,
Ÿ [~할 때까지 반복] 블록을 적절히 사용할 수 있
는지 평가한다.
Ÿ 반복되는 블록이 무엇인지 적절히 파악하여 문
제를 해결한다.
turnRight();
moveForward();
moveForward();
moveForward();
}

- 184 -
- 14/15단계: 순차문, 반복구조 등 미로에 맞는 알고리즘 선택하기(평
가)
분석
Ÿ 미로 퍼즐을 해결하기 위한 적절한 알고리즘이 무엇인지 파악하여 짝을 맞추는 문항이다.
Ÿ 순차문과 반복문과 [~할 때까지 반복] 블록을 적절히 사용할 수 있는지 파악한다.
Ÿ 각각의 미로퍼즐에 맞는 알고리즘을 머릿속으로 그려보거나 각각의 알고리즘을 보고 이동방향을 예
측하여 적절한 미로퍼즐을 찾아 해결한다.
- 15/15단계: 미로에 맞는 알고리즘 선택하기(평가)
분석
Ÿ 미로 퍼즐을 해결할 수 있는 적절한 알고리즘을 선택하는 문항이다.
Ÿ 주어진 미로퍼즐에 맞는 알고리즘을 알고 있는지 평가한다.
Ÿ 주어진 미로퍼즐의 알고리즘을 만들어보거나 선택지에 있는 알고리즘들의 이동을 예측하여 적절
한 알고리즘을 찾는다.

- 185 -
3. 스테이지3: 예술가
◦ 활동
- 1/15단계: 순차문 사용하기(각도 미리 지정되어 있음)
분석 스크립트
Ÿ 순차문을 사용하여 문제를 해결하도록 한다.
moveForward(300);
turnRight(90);
moveForward(300);
turnRight(90);
moveForward(300);
turnRight(90);
moveForward(300);
- 2/15단계: 루프 사용하기(반복될 블록 주어짐, 반복 횟수 직접 입력)
분석 스크립트
Ÿ [4번 반복] 1번, [앞으로 300 이동] 1번, [오른쪽
으로 90°돌기] 1번 사용
Ÿ 루프를 사용하여 해결하는 단계이다.
Ÿ 반복될 블록을 미리 지정해준 뒤 반복될 횟수
를 지정하도록 한다.
moveForward(300);
turnRight(90);
}

- 186 -
- 3/15단계: 루프 사용하기(반복될 블록 주어지지 않음, 각도가 툴 박스
에 지정되어 있음, 둘레의 길이를 통해 길이 유추하기)
분석 스크립트
Ÿ [2번 반복] 1번, [앞으로 200 이동] 1번, [앞으로
100 이동] 1번, [왼쪽으로 90°돌기] 2번 사용
Ÿ 전 단계와 마찬가지로 루프를 사용하는 단계이
다.
Ÿ 하나의 루프 안에 많은 블록이 포함되어 있어
반복되는 블록을 잘 파악하여 해결해야한다.
moveForward(200);
turnLeft(90);
moveForward(100);
turnLeft(90);
}
- 4/15단계: 반복 횟수 정하기
분석 스크립트
Ÿ [8번 반복] 1번, [색 설정] 1번, [앞으로 100 이
동] 1번, [뒤로 100 이동] 1번, [오른쪽으로
45°돌기] 1번 사용
Ÿ 반복될 블록을 미리 지정해주어 반복될 횟수만
을 지정하도록 한다.
Ÿ 이 단계부터는 한번 앞으로 이동한 후 다음 그
림을 그리기 위하여 준비하기 위해 뒤로 이동
하여 각도를 돌린다.
moveForward(100);
moveBackward(100);
turnRight(45);
}

- 187 -
- 5/15단계: 반복 횟수 정하기
분석 스크립트
Ÿ [색 설정] 1번, [앞으로 100 이동] 1번, [뒤로
100 이동] 1번, [오른쪽으로 1°돌기] 1번, [359
번 반복] 1번 사용
Ÿ 반복되는 블록은 정해져 있게 되고 반복될 횟
수만을 지정하도록 하는 단계이다.
Ÿ [오른쪽으로 1°돌기]라는 블록이 있기 때문에
이 블록이 힌트가 되어 문제를 해결한다.
Ÿ 359 이상의 숫자는 모두 답이 된다.
moveForward(100);
moveBackward(100);
turnRight(1);
}
- 6/15단계: 회전 방향과 각도 정하기
분석 스크립트
Ÿ [3번 반복] 1번, [색 설정] 1번, [오른쪽으로
30°돌기] 1번, [앞으로 100 이동] 1번, [뒤로
100 이동] 1번 사용
Ÿ 회전할 방향과 각도를 지정하도록 하는 단계이
다.
turnLeft(30);
moveForward(100);
moveBackward(100);
}

- 188 -
- 7/15단계: 회전 방향과 각도, 이동할 거리 지정하기(팝업창으로 회전
할 각도와 각 변의 길이 알려줌)
분석 스크립트
Ÿ [왼쪽으로 60°돌기] 1번, [앞으로 200 이동] 1번 사용
Ÿ 바라보고 있는 방향을 파악하여 회전 방향과 각도를 지정하고
이동방향과 거리 또한 지정하여 해결한다.
turnLeft(60);
moveForward(200);
- 8/15단계: 회전 방향과 각도, 이동할 거리 지정하기(팝업창에서 직각
삼각형의 세 각을 알려주고 이동할 거리 100의 2배라고 알려줌)
분석 스크립트
Ÿ [왼쪽으로 30°돌기] 1번, [앞으로 200 이동] 1번 사용
Ÿ 전 단계를 한 번 더 연습한다.
turnLeft(30);
moveForward(200);

- 189 -
- 9/15단계: 루프를 사용하기(팝업창에서 한 변과 둘레의 길이를 알려
줌)
분석 스크립트
Ÿ [2번 반복] 1번, [앞으로 240 이동] 1번, [앞으
로 160 이동] 2번, [앞으로 120 이동] 1번, [왼
Ÿ 둘레의 길이와 한 변의 길이만이 주어져있어
변의 길이를 계산하여 해결하는 단계이다.
Ÿ 반복되는 구간을 지정하고 중간의 선을 그리기
위한 알고리즘 또한 추가하여 해결한다.
moveForward(240);
turnLeft(90);
moveForward(160);
turnLeft(90);
}
moveForward(120);
turnLeft(90);
moveForward(160);
- 10/15단계: 미리 주어진 블록(하나의 정삼각형)에 거리 이동 블록을
추가한 뒤 다시 한 번 루프 사용하기(길이 주어짐, 대칭 구조)
분석 스크립트
Ÿ 하나의 삼각형을 그릴 알고리즘이 주어지고 그
것을 사용하여 3개의 삼각형을 그릴 알고리즘
을 만드는 단계이다.
Ÿ 다음 삼각형을 그리기 위하여 앞으로 50 pixels
를 움직여야한다는 것을 파악하여 해결한다.
moveForward(50);
turnRight(120);
}
moveForward(50);
}

- 190 -
- 11/15단계: 루프 사용하기(점프 이동 블록 사용하기, 팝업창에서 길이
주어짐)
분석 스크립트
Ÿ [앞으로 300 이동] 2번, [왼쪽으로 90°돌기] 2번,
[오른쪽으로 90°돌기] 2번, [앞으로 15 점프] 2번
사용
Ÿ 점프 블록을 사용하도록 한 단계이다.
Ÿ 반복되어야 할 블록이 무엇인지 파악하여 정확히
횟수를 지정하여 해결한다.
moveForward(300);
turnLeft(90);
jumpForward(15);
turnLeft(90);
moveForward(300);
turnRight(90);
jumpForward(15);
turnRight(90);
}
- 12/15단계: 루프 사용하기(팝업창에서 정삼각형이라는 것과 길이 주
어짐) (평가)
분석 스크립트
Ÿ [3번 반복] 1번, [앞으로 300 이동] 1번, [왼쪽으
로 120°돌기] 1번 사용
Ÿ 삼각형을 그리기 위해 반복되어야할 블록을 파
악하여 반복 횟수를 지정하여 해결할 수 있는
지 평가한다.
moveForward(300);
turnLeft(120);
}

- 191 -
- 13/15단계: 주어진 조건에 맞는 알고리즘 선택하기(평가)
분석
Ÿ 둘레의 길이가 100인 사각형을 그리는 알고리즘이 무엇인지 아는지 확인하는 문항이다.
Ÿ 알고리즘에 따라 그려질 도형을 예측할 수 있는지를 평가한다.
Ÿ 각각의 선택지의 알고리즘에 따라 그려질 도형을 예측하여 적절한 선택지를 선택한다.
- 14/15단계: 대칭인 도형 선택하기(평가)
분석
Ÿ 대칭의 개념에 대하여 파악하고 있는지 묻는 문항이다.
Ÿ 대칭인 도형을 찾아 답하면 된다.

- 192 -
- 15/15단계
분석
Ÿ 자신의 맘대로 그림을 그리도록 하여 프로그램에 흥미를 느끼도록 하는 동시에 알고리즘에 대한 이
해 또한 돕는다.
Ÿ 이제까지 배운 루프를 이용하여 그리고 싶은 것을 그리도록 한다.

- 193 -
4. 스테이지4: 기능성 색유리
◦ 개요: 아이들이 선캐처를 만들면서 반복되는 일련의 기술을 파악하여
종이에 적고 또한 개개인의 특정한 재료의 세부사항을 추상화하여 용
어를 만들 수 있도록 한다.
◦ 학습목표
- 과정들에서 패턴을 찾아내는 것을 배운다.
- 예술적인 일을 다른 방식으로 생각해 본다.
- 상징들을 물리적인 교구들로 연관시켜 해석한다.
◦ 활동
- 1/3단계: 선캐쳐를 만드는 활동을 묶어 함수를 만들고 함수를 이용하
여 프로그램 만들기
Ÿ 선캐쳐를 어떻게 만드는지 설명한다.
Ÿ 그 과정이 몇 개의 단계를 거쳐서 일어
난다는 것을 이해시키고 그 순서를 기
억하도록 하기 위하여 노래가사처럼 과
정을 간단히 하여 말해준다.
Ÿ 아이들이 무슨 선캐쳐를 만들기 위한
단계들이 무엇이 있었는지 생각하고 적
도록 한다.
Ÿ 반복되는 여러 개의 스텝을 묶어 하나
의 함수가 되고 그 함수를 이용하여 만
든 전체의 과정이 프로그램이 되며 다
른 도구들을 이용하여 선캐쳐를 만들
때 어떤 재료를 사용하든지 하나 하나
의 스텝들이 플레이스 홀더가 되주며
그것이 변수라고 설명한다.
주요 개념
함수: 쉽게 불러내고 다시 불러낼 수 있는 하나의 암호
변수: 바뀔 수 있는 하나의 정보를 위한 플레이스 홀더

- 194 -
- 2/3단계: 함수를 이해하고 동일한 프로그램 파악하기(평가)
분석
Ÿ 프로그램 1과 동일한 시퀀스를 가지지 않는 프로그램을 선택하는 문항이다.
Ÿ 함수로 이루어진 하나의 프로그램을 파악하여 같은 프로그램을 찾아낼 수 있는지 평가한다.
- 3/3단계: 함수를 파악하여 프로그램이 나타내는 내용파악하기(평가)
문제와 보기 화면 선택지 답
분석
Ÿ 보기 화면의 함수를 파악하여 각각의 프로그램에 맞는 단어를 맞추는 문항이다.
Ÿ 각각의 함수를 파악하고 또 전체의 프로그램을 파악하여 맞는 단어를 찾아낸다.
Ÿ 이 과정을 통해 학생들은 함수와 프로그램의 개념에 대하여 이해하게 된다.

- 195 -
5. 스테이지5: 예술가(함수)
◦ 활동
분석 스크립트
Ÿ [4번 반복] 2번, [앞으로 100 이동] 2번, [오른쪽으
로 90°돌기] 2번, [앞으로 175 이동] 1번 사용
Ÿ 두 개의 루프를 적절히 사용하여 해결한다.
Ÿ 반복되는 구간을 파악하여 루프 사이에 이동할
거리를 설정한다.
moveForward(100);
turnRight(90);
}
moveForward(175);
moveForward(100);
turnRight(90);
}
◦ 동영상
Ÿ 함수에 이름을 지어 원할 때는 언제든 불러내어 사용할 수 있
다고 설명한다.
Ÿ 정사각형을 그리는 것을 예로 들어 설명한다.
Ÿ 하나의 함수에 ‘정사각형 그리기’라고 이름을 지어준 뒤 원
할 때는 언제든 자신의 프로그램에 추가하여 사용할 수 있다고
설명한다.

- 196 -
- 2/10단계: 주어진 함수를 사용하여 알고리즘 만들기
분석 스크립트
Ÿ [draw a square] 1번, [앞으로 175 이동] 1번 사
용
Ÿ 함수를 이용한 순차문을 만든다.
Ÿ 정사각형을 그리는 함수를 파악하여 함수 사이
의 이동거리를 적절히 설정한다.
function draw_a_square() {
moveForward(100);
turnRight(90);
}
}
draw_a_square();
moveForward(175);
draw_a_square();
- 3/10단계: 함수 수정하여 알고리즘 만들기(사각형)
분석 스크립트
Ÿ [draw a square] 1번, [앞으로 160 이동] 1번 사
용, [앞으로 100 이동] 1번 제거 후 [앞으로
115°이동] 1번 사용
Ÿ 함수를 수정하는 단계이다.
Ÿ 더 큰 정사각형을 만들기 위해서 함수를 수정한
다. 또한 함수 블록 사이에 있는 거리 이동 블
록의 거리를 적절히 설정한다.
moveForward(115);
turnRight(90);
}
}
draw_a_square();
moveForward(160);
draw_a_square();

- 197 -
- 4/10단계: 루프 안에 함수 사용하기(사각형)
분석 스크립트
Ÿ [3번 반복] 1번, [오른쪽으로 120°돌기] 1번
사용
Ÿ 함수와 루프를 함께 사용하는 단계이다.
Ÿ 세 개의 삼각형을 만들기 위하여 세 번 반복하
고 하나의 정사각형을 그린 후 다음 정사각형
을 그리기 위하여 회전할 각도 또한 지정해야
한다.
moveForward(100);
turnRight(90);
}
}
draw_a_square();
turnRight(120);
}
- 5/10단계: 함수를 수정하기(육각형)
분석 스크립트
Ÿ [4번 반복] 제거 후, [6번 반복] 1번 사용, [앞
으로 100 이동] 제거 후 [앞으로 50 이동] 사
용, [오른쪽으로 90°돌기] 제거 후, [오른쪽으
Ÿ 사각형을 만드는 함수로 되어있는 육각형 만들
기 함수를 육각형을 만드는 함수로 수정한다.
function draw_a_hexagon() {
moveForward(50);
turnRight(60);
}
}
draw_a_hexagon();
turnRight(120);
}

- 198 -
- 6/10단계: 루프 안에 함수 사용하기(육각형)
분석 스크립트
Ÿ [6번 반복] 1번, [왼쪽으로 60°돌기] 1번 사용
Ÿ 미리 루프 안에서 60°만을 회전하라고 팝업창
에 주어진다.
Ÿ 6개의 정사각형을 파악하여 육각형 그리기 함수
와 60°회전 블록을 루프로 6번 반복시킨다.
function draw_a_hexagon() {
moveForward(50);
turnRight(60);
}
}
draw_a_hexagon();
turnLeft(60);
}

- 199 -
- 7/10단계: 루프 안에 함수 사용하기
분석 스크립트
Ÿ [3번 반복] 1번, [왼쪽으로 90°돌기] 1번, [오른
쪽으로 90°돌기] 1번, [앞으로 100 점프] 1번,
[draw a flower] 1번 사용
Ÿ 꽃 사이의 거리가 100이라고 주어졌다.
Ÿ 꽃 그리기 함수를 파악하여 ‘꽃 그리기’함수
시행 전에 회전각도를 설정하고 2번째 꽃을 그
리기위해 회전할 각도와 이동해야할 거리를 적
절히 설정한다.
function draw_a_flower() {
penColour('#228b22');
moveForward(100);
turnLeft(36);
moveForward(25);
turnLeft(36);
moveForward(25);
turnLeft(144);
moveForward(25);
turnLeft(36);
moveForward(25);
turnLeft(144);
}
jumpBackward(100);
}
turnLeft(90);
draw_a_flower();
turnRight(90);
jumpForward(100);
}

- 200 -
- 8/10단계: 주어진 함수 사용하여 알고리즘 만들기(자유놀이단계)
실행 후 블록 입력 전 블록 입력 후
분석 스크립트
Ÿ [draw a snowflake] 1번 사용
Ÿ 미리 설정되어있는 함수를 파악하여 자유롭게
새로운 그림을 그리는 단계이다.
function draw_a_snowflake() {
penColour('#7fffd4');
moveForward(30);
turnRight(90);
moveForward(15);
turnRight(90);
moveForward(15);
turnRight(90);
moveForward(30);
turnRight(45);
}
}
draw_a_snowflake();

- 201 -
- 9/10단계: 두 개의 함수 이용하여 알고리즘 만들기
실행 후 블록 입력 전 블록 입력 후
분석 스크립트
Ÿ [big gear] 1번, [small gear] 2번, [오른쪽 90°
돌기] 1번, [왼쪽 90°돌기] 1번 사용
Ÿ 전 단계와 마찬가지로 미리 설정되어있는 함
수를 파악하여 자유롭게 그림을 그려보는 단
계이다.
function big_gear() {
moveForward(20);
turnLeft(75);
moveForward(10);
turnRight(90);
moveForward(20);
turnRight(90);
moveForward(10);
turnLeft(75);
}
}
function small_gear() {
}
big_gear();
turnRight(90);
small_gear();
turnLeft(90);
small_gear();
moveForward(20);
turnLeft(60);
moveForward(10);
turnRight(90);
moveForward(20);
turnRight(90);
moveForward(10);
turnLeft(60);
}

- 202 -
- 10/10단계: 주어진 함수를 사용하여 알고리즘 만들기(평가)
분석
Ÿ [draw a rectangle] 함수를 파악하여 두 개의 직사각형을 그리는 알고리즘을 선택하는 문항이다.
Ÿ 함수의 기능을 적절히 사용할 수 있는지 평가하는 문항이다.
Ÿ 각각의 선택지의 블록 알고리즘을 이용한 그림을 그려보아 적절한 선택지를 선택한다.

- 203 -
6. 스테이지6: 꿀벌(함수)
◦ 함수
- 1/11단계: 루프 사용하기
분석 스크립트
Ÿ [3번 반복] 3번, [move forward] 4번, [오른쪽 회
전] 2번, [꽃꿀 얻기] 2번 사용
Ÿ 루프를 사용하여 모든 꽃꿀을 얻는 단계이다.
Ÿ 반복문을 사용하여 효율적으로 꽃꿀을 얻는다.
moveForward();
}
getNectar();
}
turnRight();
moveForward();
turnRight();
moveForward();
moveForward();
getNectar();
}
◦ 동영상
Ÿ 농구에 빗대어 함수를 설명한다.
Ÿ 농구에서 레이업 슛과 드리블 등을 배워 더 복잡한 기술을 구
사할 수 있듯이 컴퓨터 프로그래밍에서도 여러 블록들을 합쳐
더 복잡한 기술을 만들 수 있는데 이것을 함수라고 한다고 설
명한다.
Ÿ 꿀벌이 꽃꿀을 얻는 과정에서 함수를 사용하는 방법을 설명한
다.
Ÿ 현재 ‘꽃꿀 얻기’ 함수는 꽃꿀을 1번 얻고 또 다시 1번 더
얻는 것이라고 설명하며, 이 함수를 파악하여 문제를 해결해야
한다고 설명한다.

- 204 -
- 2/11단계: 함수 사용하여 알고리즘 만들기
분석 스크립트
Ÿ [move forward] 2번, [get 2 nectar] 1번 사용
Ÿ 꽃꿀을 두 번 얻는 함수를 파악하여 함수를 이
용해 알고리즘을 완성한다.
function get_2_nectar() {
getNectar();
getNectar();
}
moveForward();
get_2_nectar();
moveForward();
get_2_nectar();
- 3/11단계: 루프 안에 함수 사용하기
분석 스크립트
Ÿ [move forward] 2번, [오른쪽으로 회전] 1번, [3
번 반복] 1번 사용
Ÿ 루프와 함수를 적절히 사용하는 단계이다.
Ÿ 꽃꿀을 5개 얻는 함수와 반복되는 블록이 무엇
인지를 적절히 파악하여 블록 알고리즘을 완성
한다.
function get_5() {
getNectar();
}
}
moveForward();
turnRight();
get_5();
moveForward();
}

- 205 -
- 4/11단계: 루프 안에 함수 사용하기 (함수가 더 복잡)
분석 스크립트
Ÿ [2번 반복], [move forward] 3번, [move and get
nectar] 2번 사용
Ÿ 전 단계와 마찬가지로 루프와 함수를 적절히 사
용하는 단계이다.
Ÿ 이동 후 꽃꿀을 얻는 함수와 반복되는 블록을
적절히 파악하여 해결한다.
function move_and_get_nectar() {
turnRight();
moveForward();
getNectar();
moveBackward();
turnLeft();
}
moveForward();
move_and_get_nectar();
}
moveForward();
moveForward();
move_and_get_nectar();
- 5/11단계: 함수를 수정하기
분석 스크립트
Ÿ [4번 반복] 1번 사용
Ÿ 함수를 수정하는 단계이다.
Ÿ 4개의 꽃꿀을 얻는 함수인데 1개의 꽃꿀만을
얻고 있다는 것을 발견하여 루프를 사용하여
반복시켜준다.
function move_and_get_4() {
turnRight();
moveForward();
getNectar();
moveBackward();
turnLeft();
}
}
moveForward();
moveForward();
move_and_get_4();

- 206 -
- 6/11단계: 함수를 수정하고 알고리즘 완성하기
분석 스크립트
Ÿ [move forward] 2번, [move and get 4] 3번 사
용
Ÿ 함수를 수정하고 블록 알고리즘 또한 완성시키
는 단계이다.
Ÿ 함수안에서 반복되어야할 블록이 빠진 것을 확
인하여 수정하고, 이를 이용하여 효율적인 알고
리즘을 구성한다.
function move_and_get_4() {
moveForward();
turnRight();
moveForward();
getNectar();
}
moveBackward();
turnLeft();
}
move_and_get_4();
moveForward();
move_and_get_4();
move_and_get_4();
- 7/11단계: 함수 구성하기
분석 스크립트
Ÿ [7번 반복] 2번, [꽃꿀 얻기] 2번, [move
forward] 1번 사용
Ÿ 완성된 알고리즘을 보고 함수가 무엇인지 파악
function get_7_nectar_make_7_honey() {
getNectar();
}
moveForward();
makeHoney();
}
}
moveForward();
get_7_nectar_make_7_honey();
moveForward();
moveForward();
get_7_nectar_make_7_honey();

- 207 -
- 8/11단계: 함수 구성하기
분석 스크립트
Ÿ [7번 반복] 2번, [꽃꿀 얻기] 1번, [꿀 만들기] 1
번, [뒤로 이동하기] 2번, [move forward] 2번,
[오른쪽으로 회전] 1번, [왼쪽으로 회전] 1번 사
용
Ÿ 전 단계와 마찬가지로 미리 구성된 블록 알고리
즘을 보고 함수를 구성하는 단계이다.
function get_7_make_7() {
turnRight();
moveForward();
getNectar();
}
moveForward();
makeHoney();
}
moveBackward();
moveBackward();
turnLeft();
}
moveForward();
get_7_make_7();
moveForward();
}
get_7_make_7();

- 208 -
- 9/11단계: 함수를 구성하고 블록 알고리즘 완성하기
분석 스크립트
Ÿ [3번 반복] 1번, [collect purple nectar] 1번,
[move forward] 2번, [오른쪽으로 회전] 1번, [왼
쪽으로 회전] 1번, [만약 꽃꿀의 양〉0 실행] 1
번, [꽃꿀 얻기] 1번 사용
Ÿ 보라색 꽃의 꿀의 숫자는 미리 알 수 없다. 꽃
꿀의 양이 1개 이상일 때 꽃꿀을 얻도록 하는
함수를 구성해야한다.
Ÿ 함수를 구성하여 그 함수를 이용한 블록 알고리
즘을 만든다.
function collect_purple_nectar() {
moveForward();
turnRight();
moveForward();
if (nectarRemaining() > 0) {
getNectar();
}
turnLeft();
}
collect_purple_nectar();
}
- 10/11단계: 주어진 함수를 사용하여 알고리즘 만들기(평가)
분석 스크립트
Ÿ [move forward] 3번, [오른쪽으로 회전] 1번,
[get 7] 2번 사용
Ÿ 미리 설정된 함수를 이용하여 블록 알고리즘을
구성할 수 있는지 평가한다.
function get_7() {
getNectar();
}
}
moveForward();
get_7();
turnRight();
moveForward();
moveForward();
get_7();

- 209 -
- 11/11단계: 함수를 구성하고 알고리즘을 완성하기(평가)
분석 스크립트
Ÿ [make 3] 3번, [move forward] 4번, [3번 반복]
2번, [오른쪽으로 회전] 1번, [왼쪽으로 회전] 1
번, [꿀 만들기] 1번, [뒤로 이동하기] 1번 사용
Ÿ 함수를 구성하고 그 함수를 이용하여 블록 알
고리즘을 완성할 수 있는지 평가한다.
function make_3() {
turnRight();
moveForward();
makeHoney();
}
moveBackward();
turnLeft();
}
make_3();
moveForward();
}
make_3();
moveForward();
moveForward();
make_3();

- 210 -
7. 스테이지7: 꿀벌(조건선택)
◦ 동영상
Ÿ 조건문을 이용한 스테이지라고 설명한다.
Ÿ 꽃꿀의 수가 0과 같거나, 적거나, 많을 때 어떤 행동을 하도록
만들 수 있다고 설명한다.
Ÿ 꽃꿀의 수가 몇 개인지 파악할 수 없을 때 사용한다고 말한다.
Ÿ 이 문제를 해결하기 위해서는 0보다 꽃꿀의 수가 많을 경우 꽃
꿀을 얻기를 실행하라고 설정해야한다고 설명한다.
◦ 활동
- 1/10단계: 조건문 사용하여 꽃꿀 얻기
분석 스크립트
Ÿ [3번 반복] 1번, [move forward] 1번, [만약 꽃에
서 실행] 1번, [꽃꿀 얻기] 1번 사용
Ÿ 조건문을 처음 사용하는 단계이다.
Ÿ 이 단계에서는 만약 물음표가 꽃이라면 꽃꿀을
얻으라는 조건문을 설정하면 된다.
moveForward();
}
if (atFlower()) {
getNectar();
}

- 211 -
- 2/10단계: 루프 안에 조건문 사용하여 꽃꿀 얻기
분석 스크립트
Ÿ [move forward] 3번, [오른쪽으로 회전] 1번, [2
번 반복] 1번, [만약 꽃에서 실행] 1번, [꽃꿀 얻
기] 1번 사용
Ÿ 팝업창에서 꽃꿀만을 얻으라고 정보를 주었기
때문에 만약 꽃이라면 꽃꿀 얻기를 실행하라는
조건문을 만들어야한다.
Ÿ 조건문과 루프를 사용하여 문제를 해결한다.
moveForward();
moveForward();
turnRight();
moveForward();
if (atFlower()) {
getNectar();
}
}
- 3/10단계: 루프 안에 조건문 사용하여 꿀 만들기
분석 스크립트
Ÿ [2번 반복], [move forward] 2번, [만약 벌집에
서 실행] 1번, [꿀 만들기] 1번, [왼쪽으로 회전]
1번 사용
Ÿ 팝업창에서 꿀을 만들라고 주어졌기 때문에 만
약 벌집이라면 꿀 만들기를 실행하라는 조건문
을 만들어야 한다.
Ÿ 반복되는 구간 또한 적절히 파악하여 루프를
이용하여 알고리즘을 완성한다.
moveForward();
moveForward();
if (atHoneycomb()) {
makeHoney();
}
turnLeft();
}

- 212 -
- 4/10단계: if/else 블록 사용하기
분석 스크립트
Ÿ [move forward] 2번, [만약 꽃에서 실행 아니면]
1번 사용, [꽃꿀 얻기] 1번, [꽃 만들기] 1번 사
용
Ÿ if 블록 뿐만 아니라 else 블록도 사용하도록 하
는 단계이다.
Ÿ 꽃이라면 꽃꿀 얻기를 실행하고 아니면 꿀 만들
기를 실행하도록 설정한다.
moveForward();
moveForward();
if (atFlower()) {
getNectar();
} else {
makeHoney();
}
- 5/10단계: 루프 안에 if/else 블록 사용한 알고리즘 만들기
분석 스크립트
Ÿ [move forward] 2번, [3번 반복] 1번, [4번 반복]
1번, [만약 꽃에서 실행 아니면] 1번, [꽃꿀 얻
기] 1번, [꿀 만들기] 1번, [오른쪽 회전] 1번 사
용
Ÿ if/else 블록을 사용하여 블록 알고리즘을 만드
는 단계이다.
Ÿ 반복되는 구간을 파악하고 꽃꿀인지 꿀인지를
확인하여 꽃꿀이나 꿀을 얻도록 설정하여 알고
리즘을 완성한다.
moveForward();
if (atFlower()) {
getNectar();
} else {
makeHoney();
}
moveForward();
}
turnRight();
}

- 213 -
- 6/10단계: else 블록 안에 if/else 블록 포함 시키기
분석 스크립트
Ÿ [2번 반복] 1번, [꽃꿀 얻기] 2번 사용
Ÿ 이번 단계는 1,2,3개로 정해져 있는 꽃꿀을 모
두 얻기 위한 알고리즘을 만드는 단계이다.
Ÿ 꽃꿀이 3개일 경우의 알고리즘이 짜져있고 아
닐 경우의 블록은 짜져있지 않다.
Ÿ 3개가 아니면 2개이거나 1개가 되므로 만약 2
개일 경우에는 꽃꿀얻기를 2번 반복하도록 해
야하고, 1개일 경우에는 꽃꿀 얻기를 한번 시행
하도로고 설정해야한다.
Ÿ if/else문을 이해하고 사용하도록 한다.
moveForward();
getNectar();
}
} else {
getNectar();
}
} else {
getNectar();
}
}

- 214 -
- 7/10단계: if/else 블록이 포함된 함수와 블록 알고리즘 완성하기(꽃꿀
얻기)
분석 스크립트
Ÿ [2번 반복] 1번, [3번 반복] 2번, [move forward]
1번, [check purple flower] 1번, [꽃꿀 얻기] 3
번, [만약 꽃꿀의 양=3 실행 아니면] 1번, [만약
꽃꿀의 양=2 실행 아니면] 1번 사용
Ÿ 보라색 꽃의 모든 꽃꿀을 얻는 함수를 만들고
이 함수를 이용하여 블록 알고리즘을 완성한다.
function check_purple_flower() {
getNectar();
}
} else {
getNectar();
}
} else {
getNectar();
}
}
}
moveForward();
check_purple_flower();
}

- 215 -
- 8/10단계: if/else 블록을 사용한 함수 구성하기(꽃꿀 얻기와 꿀 만들
기)
분석 스크립트
Ÿ [만약 꽃꿀의 양=3 실행 아니면] 1번, [만약
꽃꿀의 양=2 실행 아니면] 1번, [3번 반복] 1
번, [2번 반복] 1번, [꽃꿀 얻기] 3번, [move
forward] 1번, [꿀 만들기] 1번 사용
Ÿ 보라색 꽃의 꽃꿀을 모두 얻고 움직여 꿀을
만드는 함수를 만드는 단계이다. 미리 완성된
알고리즘을 파악하여 꽃꿀을 모두 얻는 함수
에 꿀을 만들기 위한 블록을 추가한다.
function check_flower_make_honey() {
getNectar();
}
} else {
getNectar();
}
} else {
getNectar();
}
}
moveForward();
makeHoney();
}
moveForward();
turnRight();
moveForward();
turnLeft();
check_flower_make_honey();
turnRight();
moveForward();
turnLeft();
}

- 216 -
- 9/10단계: 미완성된 함수 완성하기(평가)
분석 스크립트
Ÿ [3번 반복] 1번, [꽃꿀 얻기] 3번 사용
Ÿ 꽃일 경우 꽃꿀을 얻고, 벌집일 경우 꿀을 만
드는 함수를 만들기 위하여 벌집이 아닌 경우
에 꽃꿀을 얻기 위한 알고리즘을 완성한다.
Ÿ if/else 블록을 적절히 사용할 수 있는지 평가
한다.
function get_nectar_or_make_honey() {
makeHoney();
} else {
getNectar();
}
} else {
getNectar();
getNectar();
} else {
getNectar();
}
}
}
}
moveForward();
get_nectar_or_make_honey();

- 217 -
- 10/10단계: 개수가 정확히 주어지지 않은(1개 또는 2개 또는 3개) 꽃
의 꽃꿀 얻는 알고리즘 만들기(평가)
분석
Ÿ 보라색 꽃의 경우 꽃꿀의 개수가 나와 있지 않은데 이 경우 모든 꽃꿀을 얻기 위해 만들어야할
알고리즘을 알고 있는지 평가하는 문항이다.
Ÿ 선택지를 보고 머릿속으로 예측하여 적절한 알고리즘을 선택한다.

- 218 -
8. 스테이지8: 미로 퍼즐(조건 선택)
◦ 활동
- 1/12단계: ‘~할때까지 반복’ 블록 사용하기
분석 스크립트
Ÿ [~할 때까지 반복] 1번, [move forward] 1번 사용
Ÿ [~할 때까지 반복] 블록에 [move forward] 블록을 집어
넣어 좀비를 해바라기에 도착하도록 만든다.
moveForward();
}
- 2/12단계: ‘~할 때까지 반복’ 블록 사용하기(미로가 더 복잡)
분석 스크립트
Ÿ [~할 때까지 반복] 1번, [move forward] 1번 사용
Ÿ 전 단계를 조금 더 복잡해진 미로에서 연습한다.
moveForward();
}

- 219 -
◦ 동영상
Ÿ if 블록에 대하여 설명하고 있다.
Ÿ if 블록은 블록 안에 주어진 것을 확인하도록 한다고 말한다.
확인하여 맞다면 그 블록을 실행하도록 한다고 말한다.
Ÿ 다른 블록과 합쳐진 블록 알고리즘에서 if블록이 하는 일을 말
한다.
Ÿ if 서술은 컴퓨터 프로그래밍의 가장 기초적인 개념이라고 말
한다.
Ÿ 자신도 프로그램을 만들 때 if 서술을 사용했다고 말하고 있다.
- 3/12단계: 반복구조 안에 if 블록 사용을 이해하기(블록 한 개만 추가
하면 됨)
분석 스크립트
Ÿ [왼쪽으로 회전] 1번 사용
Ÿ if 블록을 사용하고 한 개의 블록만 추가하면 해결된
다고 힌트가 주어졌다.
Ÿ 이 단계를 통하여 if 블록이 어떻게 실행되는지 학습
한다.
moveForward();
if (isPathLeft()) {
turnLeft();
}
}

- 220 -
- 4/12단계: 반복구조 안에 if 블록 사용하기
분석 스크립트
Ÿ [~할 때까지 반복] 1번, [move forward] 1번, [만약, 오
른쪽에 길이 있으면 실행] 1번, [오른쪽으로 회전] 1번
실행
Ÿ if 블록과 반복 블록을 적절히 조합하여 알고리즘을 완
성한다.
moveForward();
if (isPathRight()) {
turnRight();
}
}
분석 스크립트
Ÿ [~할 때까지 반복] 1번, [move forward] 1번, [만약 왼쪽
에 길이 있으면] 1번, [왼쪽으로 회전] 1번 사용
Ÿ 전 단계를 한번 더 연습하는 단계이다.
moveForward();
if (isPathLeft()) {
turnLeft();
}
}

- 221 -
분석 스크립트
Ÿ [~할 때까지 반복] 1번, [move forward] 1번, [만약, 왼
쪽에 길이 있으면] 1번, [왼쪽으로 회전] 1번 사용
Ÿ 전 단계를 한 번 더 연습하는 단계이다.
moveForward();
if (isPathLeft()) {
turnLeft();
}
}
분석 스크립트
Ÿ [~할 때까지 반복] 1번, [move forward] 1번, [만약, 오
른쪽에 길이 있으면 실행] 1번, [오른쪽으로 회전] 1번
사용
Ÿ 전 단계를 한 번 더 연습하는 단계이다.
moveForward();
turnRight();
}
}

- 222 -
- 8/12단계: 반복구조 안에 if/else 블록 사용 이해하기(두 개의 블록만
추가하면 됨)
분석 스크립트
Ÿ [move forward] 1번, [왼쪽으로 회전] 1번 사용
Ÿ 전 단계까지는 if 블록만 사용했다면 이제는 길이 없
다면 왼쪽으로 회전하라는 else 블록 또한 사용하게
된다.
if (isPathForward()) {
moveForward();
} else {
turnLeft();
}
}
- 9/12단계: 반복구조 안에 if/else 블록 사용하기
분석 스크립트
Ÿ [~할 때까지 반복] 1번, [만약 앞에 길이 있으면 실행]
1번, [move forward] 1번, [오른쪽으로 회전] 1번 사용
Ÿ 반복문과 if/else 블록을 적절히 사용하여 알고리즘을
완성한다.
moveForward();
} else {
turnRight();
}
}

- 223 -
- 10/12단계: 반복구조 안의 else블록 안에 if/else블록 추가하기
분석 스크립트
Ÿ [move forward] 1번, [오른쪽으로 회전] 1번, [왼쪽으로
회전] 1번 사용
Ÿ else블록 안에 if/else 블록을 사용하도록 하는 단계이
다.
Ÿ else 블록은 오른쪽에 길이 없고, 왼쪽에 길이 있을
때 따로 블록을 사용하지 않고도 문제를 해결할 수
있도록 해준다.
moveForward();
} else {
turnRight();
} else {
turnLeft();
}
}
}
- 11/12단계: 반복구조 안에 if블록 사용하기(평가)
분석 스크립트
Ÿ [~할 때까지 반복] 1번, [만약 앞에 길이 있으면 실행
아니면] 1번, [move forward] 1번, [오른쪽으로 회전]
1번 사용
Ÿ 반복 블록과 if/else 블록을 적절히 사용하여 알고리
즘을 완성할 수 있는지 평가하는 단계이다.
moveForward();
} else {
turnRight();
}
}

- 224 -
- 12/12단계: 반복구조 안에 if블록 사용하기(평가)
분석
Ÿ if블록과 반복 블록을 적절히 사용하여 좀비를 해바라기로 이동시킬 수 있는지 평가하는 문항이다.
Ÿ 보기 화면을 보고 직접 알고리즘을 구성해보거나 선택지의 알고리즘을 예측하여 적절한지 판단하
여 문제를 해결한다.

- 225 -
9. 스테이지9: 노래 만들기
◦ 개요: 학생들이 왜 암호들을 하나의 함수로 합치는 것이 도움이 되는
지를 직관적으로 이해하도록 돕는다.
◦ 학습 목표
- 노래가사 안에 반복되는 어구를 넣는다.
- 함수(코러스)를 만들기 위해 노래의 부분들을 파악한다.
- 함수가 얼마나 프로그램을 만드는 것을 용이하게 하는지를 묘사한다.
◦ 활동
- 1/2단계: 노래에서의 코러스를 통해 함수를 이해하기
Ÿ 학생들을 그룹으로 나누어 코러스 부분
이 명백한 노래를 들려주고 코러스부분
을 찾아보도록 한다.
Ÿ 학생들이 코러스를 찾는데 어려움을 느
낄 때까지 반복한다. 또 학생들이 코러
스 부분 노래를 부르도록 지도한다.
Ÿ 이 활동을 통하여 계속 반복해 실행되
는 것을 노래에서 코러스라고 한다는
것을 알게 되고, 코러스의 개념을 통해
서 함수의 개념을 이해하게 된다. 따라
서 함수를 사용하는 것의 장점을 알게
된다.

- 226 -
- 2/2단계: 노래에서 코러스 부분 찾아내기(함수 구별하기)
분석
Ÿ 노래의 코러스 부분을 찾는 문항이다.
Ÿ 학생들은 노래의 구조를 파악하여 계속 반복되는 코러스 부분을 찾아낸다.
Ÿ 코러스를 찾아내는 연습은 프로그램에서 함수를 만들어 처리하면 용이한 부분을 파악하는 데에
도움을 준다.

- 227 -
10. 스테이지10: 주사위 경주
◦ 개요: 학생들은 현실 상황과 온라인 시나리오를 호환하는 기술들을 쌓
기 시작하게 된다.
◦ 학습 목표
- 그들의 하루를 구성하는 다양한 활동들의 이름을 짓는다.
- 큰 활동들을 일련의 작은 사건들로 나눈다.
- 순차적인 사건들을 논리적인 순서로 배열한다.
◦ 활동
- 1/3단계: 주사위 게임의 작은 단계들을 알고리즘으로 만들어 보기
주요 화면 설명
Ÿ 주사위 게임을 해보고 묘사하며 알고리즘을 만들어 본다.
Ÿ 컴퓨터의 관점에서는 주사위 놀이가 어떻게 보일지를 생각해보며
현실 상황을 온라인 상의 알고리즘으로 바꿔보는 연습을 한다.
- 2/3단계: 주사위 게임에서의 단계를 논리적인 순서대로 배열하기(평
가)
분석
Ÿ 순차적으로 일어난 사건들을 논리적인 순서로 배열하는 문항이다.
Ÿ 주사위 게임은 순차적으로 사건들이 일어나는데 이 사건들을 올바른 순서대로 배열할 수 있는지를
평가한다.

- 228 -
- 3/3단계: 알고리즘으로 만들기 적절한 대상 알기(평가)
분석
Ÿ 알고리즘의 의미를 잘 파악하고 있는지 평가하는 문항이다.
Ÿ 알고리즘이란 일을 끝내기 위하여 따를 수 있는 단계들의 목록을 말하는데 바나나라는 하나의 단어
는 단계들의 목록을 말하고 있지 않으므로 알고리즘으로 표현하기가 어렵다.

- 229 -
11. 스테이지11: 예술가(중첩반복)
◦ 활동
- 1/12단계: 주어진 루프가 포함된 알고리즘을 다시 루프에 넣기(3개의
삼각형이라고 힌트가 주어짐)
분석 스크립트
Ÿ [3번 반복] 1번, [오른쪽으로 120°돌기] 1번 사
용
Ÿ 삼각형 1개를 그리는 알고리즘이 주어지고 3개
를 그리기 위한 알고리즘을 내포된 루프를 사
용하여 만드는 단계이다.
Ÿ 1개의 삼각형을 그린 후 각도를 바꾸는 알고리
즘을 3번 반복시킨다.
moveForward(100);
turnLeft(120);
}
turnRight(120);
}
◦ 동영상
Ÿ 내포된 루프의 개념에 대하여 설명한다.
Ÿ 하나의 루프 안에 다른 루프를 넣으려고 할 때 이것을 내포된
루프라고 한다고 말한다.
Ÿ 내포된 루프를 사용할 상황을 예를 들어 설명하고 블록 알고리
즘을 어떻게 배열해야하는지에 대하여 설명한다.
Ÿ 삼각형을 6개 그리고자할 때 사용하고 3번 반복되는 루프를 6
번 반복되는 루프 안에 넣는다고 설명한다.

- 230 -
- 2/12단계: 주어진 루프가 포함된 알고리즘을 루프에 넣기(10개의 삼
각형이라는 힌트가 주어짐)
분석 스크립트
Ÿ 내포된 루프를 사용하여 10개의 삼각형을 그리
는 단계이다.
Ÿ 반복되는 횟수만을 결정하면 된다.
Ÿ 360°를 36°로 나누어 10번 반복이라는 해답을
구한다.
moveForward(100);
turnLeft(120);
}
turnRight(36);
}
- 3/12단계: 주어진 루프가 포함된 알고리즘에 각도 변경 블록 추가하
여 루프 안에 넣기(반복 횟수와 각도 힌트 없음)
분석 스크립트
Ÿ [6번 반복] 1번, [왼쪽으로 60°돌기] 1번 사용
Ÿ 6개의 삼각형을 그리기 위하여 내포된 루프를
사용하는 단계이다.
Ÿ 전 단계와는 달리 각도를 바꾸는 알고리즘까지
추가시켜야한다.
moveForward(100);
turnLeft(120);
}
turnLeft(60);
}

- 231 -
- 4/12단계: 주어진 루프가 포함된 알고리즘에 거리 이동 블록 추가하
여 루프 안에 넣기(이동 거리는 주어진 알고리즘 보고 파악해야함)
분석 스크립트
Ÿ [6번 반복] 1번, [앞으로 20 이동] 1번 사용
는 단계이다.
Ÿ 전 단계와 달리 거리 이동 블록을 추가시켜야
한다.
Ÿ 하나의 삼각형을 그린 후 다음 삼각형을 그리
기 위하여 앞으로 20 이동하여야 한다.
moveForward(20);
turnLeft(120);
}
moveForward(20);
}
- 5/12단계: 주어진 루프가 포함된 알고리즘에 블록을 2개(각도 변경 블
록, 거리 이동 블록) 추가하여 루프 안에 넣기(각도, 이동거리 힌트
없음)
분석 스크립트
는 단계이다.
Ÿ 거리 이동 블록과 각도를 변경하는 블록을 둘
다 포함시켜야 한다.
moveForward(50);
turnLeft(120);
}
moveForward(50);
turnRight(30);
}

- 232 -
- 6/12단계: 주어진 루프가 포함된 알고리즘을 루프 안에 넣기(반복 횟
수 힌트 없음)
분석 스크립트
Ÿ 미리 주어진 알고리즘을 반복시키라는 팝업창
이 있었다.
Ÿ 주어진 알고리즘을 이해하여 몇 번 반복시켜야
하는지 결정하여야 하는 단계이다.
moveForward(50);
moveForward(50);
turnRight(120);
}
moveBackward(50);
turnRight(40);
}
- 7/12단계: 미리 주어진 알고리즘에 각도 변경 블록 추가하여 루프 안
에 넣기(반복 횟수 힌트와 함께 각도 힌트 있음)
분석 스크립트
용
Ÿ 미리 주어진 알고리즘을 10번 반복하고 각도를
변경(전 단계와 의 차이점)하라는 팝업창이 있
었다.
Ÿ 각도에 대한 힌트(360°를 36°으로 나누면 몇
이냐)가 있었다.
Ÿ 10번 반복에 전체가 360°이므로 36°를 돌아
야한다고 계산하여야 한다.
moveForward(100);
turnRight(60);
moveForward(50);
turnRight(120);
}
turnRight(36);
}

- 233 -
- 8/12단계: 미리 주어진 알고리즘에 거리 이동 블록 추가하여 루프 안
에 넣기(10개의 정사각형인 것과 한 변의 길이 주어짐)
분석 스크립트
Ÿ 10개의 정사각형을 그리라는 팝업창이 주어졌
다.
Ÿ 주어진 알고리즘이 하나의 정사각형을 그리는
알고리즘임을 파악하여야 한다.
Ÿ 전 단계와 달리 거리 이동 블록을 추가하여야
한다.
Ÿ 하나를 그린 후 다음 정사각형을 그리기 위하
여 거리 이동 블록을 사용하고 이를 10번 반복
시킨다.
moveForward(30);
turnLeft(90);
}
moveForward(30);
}
- 9/12단계: 주어진 알고리즘에 각도 변경 블록 추가하여 루프 안에 넣
기(반복횟수 주어지고 각도에 대한 힌트 주어짐)
분석 스크립트
Ÿ [6번 반복] 1번, [오른쪽 60°돌기] 1번 사용
Ÿ 주어진 알고리즘을 6번 반복시키라는 팝업창이
있다. 각도 또한 변경하여야 한다.
Ÿ 주어진 알고리즘이 그리는 도형이 무엇인지를
파악하여 각도 변경 블록을 추가하여 이를 내
포된 루프를 사용하여 반복시킨다.
Ÿ 360°를 6으로 나누면 무엇이냐는 각도에 대
한 힌트가 주어졌다.
Ÿ 갈수록 도형이 복잡해진다.
penColour('#843179');
moveForward(100);
turnRight(60);
moveForward(50);
turnRight(60);
}
turnRight(60);
}

- 234 -
- 10/12단계: 주어진 알고리즘에 각도 변경 블록을 추가하여 루프 안에
넣기(36개의 삼각형이라는 힌트가 주어짐)
분석 스크립트
Ÿ [오른쪽 60°돌기] 1번, [36번 돌기] 1번 사용
Ÿ 내포된 블록을 사용하여 36개의 삼각형을 그리
라는 팝업창이 주어졌다. 따라서 미리 주어진
알고리즘이 각도 변경 블록을 포함하지 않기
때문에 추가하여야 한다.
Ÿ 36개의 삼각형을 그리기 위하여 360°를 36으
로 나누어 10°이라는 변경 각도를 구한다. 그
후 알고리즘을 36번 반복시킨다.
moveForward(100);
turnRight(120);
}
turnRight(10);
}
- 11/12단계: 주어진 알고리즘에 각도 변경 블록을 추가하여 루프 안에
넣기(힌트 없음)(평가)
분석 스크립트
용
Ÿ 하나의 원을 그리는 알고리즘을 내포된 루프
를 사용하여 4번 반복시킬 수 있는지 평가하
는 단계이다.
Ÿ 하나의 원을 그린 후 다음 원을 그리기 위하
여 각도를 변경하는 블록을 추가하여 4번 반
복한다.
moveForward(5);
turnRight(4);
}
turnRight(90);
}

- 235 -
- 12/12단계: 주어진 그림을 그릴 중첩 반복된 알고리즘 선택하기(평가)
분석
Ÿ 4개의 삼각형으로 이루어진 모양을 만드는 블록 알고리즘을 선택하는 문항이다.
Ÿ 각각의 선택지의 알고리즘으로 그려질 모양을 예측하여 답을 선택하거나 내포된 블록을 사용하여
하나의 삼각형을 그리는 알고리즘을 반복시키는 알고리즘을 만들어 답을 선택한다.

- 236 -
12. 스테이지12: 농부(~인동안 반복)
◦ 활동
분석 스크립트
Ÿ [move forward] 1번, [메우기 1번] 2번 사용
Ÿ 구덩이를 메우는 순차문을 만드는 단계이다.
moveForward();
fill();
fill();
분석 스크립트
Ÿ [move forward] 1번, [5번 반복] 1번, [치우기 1
번] 1번 사용
Ÿ 루프를 사용하여 흙더미를 치우도록 하는 단계
이다.
moveForward();
dig();
}

- 237 -
◦ 동영상
Ÿ while loop를 설명하기 위하여 세차를 예로 든다.
Ÿ 세차를 할 때 차가 깨끗해질 때가지 계속 청소하듯이 while
loop도 그러하다고 설명한다.
Ÿ while loop에 대하여 설명한다.
Ÿ 제일 위의 문장이 참이라면 무엇인가를 실행하도록 하는 블록
이라고 설명한다.
- 3/9단계: 루프 안에 ‘~인 동안 반복’ 블록 사용하기(흙더미와 구덩
이의 수가 주어짐)
분석
Ÿ [2번 반복] 1번, [3번 반복] 1번, [move forward] 1번 [치우기 1번] 1번, [메우기 1번] 1번, [반복(~인
동안): 흙더미가 있으면 실행] 1번, [반복(~인 동안): 구덩이가 있으면 실행] 1번 사용
Ÿ 최소한의 블록을 사용하여 문제를 사용하기 위하여 내포된 루프를 사용한다. 또한 이 단계에서는 여
러 개의 흙더미와 구덩이를 해결하기 위하여‘~인동안 반복’블록을 사용하게 된다.
스크립트
moveForward();
}
while (pilePresent()) {
dig();
}
turnLeft();
while (holePresent()) {
executionInfo.checkTimeout(); if (executionInfo.isTerminated()){return;}
fill();
}

- 238 -
- 4/9단계: ‘~인 동안 반복’ 블록 사용하기(구덩이 메울 횟수가 주어
지지 않음)
분석 스크립트
Ÿ [move forward] 2번, [왼쪽으로 회전] 1번, [반복
(~인 동안): 구덩이가 있으면 실행] 1번, [메우기
1번] 1번 사용
Ÿ 구덩이를 메워야하는 횟수가 정해져있지 않은
단계이다. 따라서 ‘~인 동안 반복’블록을 사
용하여 해결하여야 한다.
moveForward();
turnLeft();
moveForward();
fill();
}
- 5/9단계: 루프 안에 ‘~인 동안 반복’ 블록 사용하기(구덩이 메울 횟
수 주어지지 않음)
분석 스크립트
Ÿ [2번 반복] 1번, [move forward] 2번, [왼쪽으로
회전] 1번, [오른쪽으로 회전] 1번, [반복(~인
동안): 구덩이가 있으면 실행] 1번, [메우기 1
번] 1번 사용
Ÿ ‘~인 동안 반복’블록을 루프를 이용하여 반
복시키는 단계이다. 반복되는 블록이 무엇인지
파악하여 알고리즘을 완성한다.
moveForward();
turnLeft();
moveForward();
fill();
}
turnRight();
}

- 239 -
- 6/9단계: ‘~인 동안 반복’ 블록 사용하기(흙더미 치울 횟수 주어지
지 않음)
분석 스크립트
Ÿ [move forward] 2번, [왼쪽으로 회전] 1번, [반복(~인 동안): 흙더
미가 있으면 실행] 1번, [치우기 1번] 1번 사용
Ÿ 이번엔 흙더미를 치워야하는 횟수가 정해져있지 않은 단계이다.
Ÿ ‘~인 동안 반복’블록을 사용하여 해결하여야 한다.
moveForward();
turnLeft();
moveForward();
dig();
}
- 7/9단계: 루프 안에 ‘~인 동안 반복’ 블록 사용하기(흙더미 치울 횟
수 주어지지 않음)
분석 스크립트
회전] 1번, [오른쪽으로 회전] 1번, [반복(~인 동
안): 흙더미가 있으면 실행] 1번, [치우기 1번] 1
번 사용
Ÿ 5단계와 마찬가지로‘~인 동안 반복’블록을 루
프를 사용하여 반복시키는 단계이다. 구덩이를
흙더미로 바꾸었다. 마찬가지로 반복되는 구간을
파악하여 문제를 해결한다.
moveForward();
turnLeft();
moveForward();
turnRight();
dig();
}
}

- 240 -
- 8/9단계: ‘~인 동안 반복’ 블록 2개 사용하기(횟수가 주어지지 않은
구덩이와 흙더미가 동시에 주어짐)
분석
Ÿ [move forward] 4번, [반복(~인 동안): 구덩이가 있으면 실행] 1번, [메우기 1번] 1번, [오른쪽으로 회
전] 1번, [반복(~인 동안): 흙더미가 있으면 실행] 1번, [치우기 1번] 1번 사용
Ÿ 최소의 개수의 블록으로 횟수가 정해져있지 않은 메우기와 치우기를 수행하여야하는 단계이다.
스크립트
moveForward();
moveForward();
fill();
}
moveForward();
turnRight();
moveForward();
dig();
}

- 241 -
- 9/9단계: 루프 안에 ‘~인 동안 반복’ 블록 사용하기(횟수가 주어진
것과 안주어진 것이 함께 있음)(평가)
분석
Ÿ [move forward] 3번, [2번 반복] 1번, [반복(~인 동안): 구덩이가 있으면 실행] 1번, [메우기 1번] 1번,
[반복(~인 동안): 흙더미가 있으면 실행] 1번, [치우기 1번] 1번, [오른쪽으로 회전] 1번 사용
Ÿ 횟수가 정해져있는 일과 정해져있지 않은 일을 같은 ‘~인 동안 반복’블록을 루프로 반복하여 해결
할 수 있다는 것을 이해하고 해결해야하는 단계이다.
Ÿ 횟수가 정해져있든 정해져있지 않든 해결될 때까지 반복하는 블록이 ‘~인 동안 반복’블록이라는
것을 이해하고 이용하여 문제를 해결할 수 있는지 평가한다.
스크립트
moveForward();
moveForward();
fill();
}
moveForward();
dig();
}

- 242 -
13. 스테이지13: 꿀벌(중첩 반복)
◦ 활동
분석 스크립트
Ÿ [5번 반복] 1번, [move forward] 1번, [꽃꿀 얻기]
1번 사용
Ÿ 루프를 사용하여 꽃꿀을 얻는 일을 반복한다.
moveForward();
getNectar();
}
◦ 동영상
Ÿ 내포된 루프를 꿀벌 퍼즐에서 사용해보자고 말한다.
Ÿ 다른 반복 루프 안에 루프를 포함한 블록들을 넣으면 문제가
해결된다고 말한다.

- 243 -
- 2/13단계: 중첩 반복 사용하기
분석 스크립트
Ÿ [5번 반복] 1번, [3번 반복] 1번, [move forward]
1번, [꽃꿀 얻기] 1번 사용
Ÿ 전 단계와 달리 꽃 하나 당 3개의 꽃꿀을 얻는
단계이다.
Ÿ 내포된 루프를 사용하여 문제를 해결한다.
moveForward();
getNectar();
}
}
- 3/13단계: 주어진 알고리즘의 반복 횟수 지정하기
분석 스크립트
Ÿ [3번 반복] 1번
Ÿ 미리 반복될 알고리즘이 주어지고 이를 반복할
횟수를 지정하여 중첩반복을 만드는 단계이다.
Ÿ 미리 주어진 알고리즘을 보고 이해하여 반복횟
수를 정한다.
moveForward();
getNectar();
}
turnRight();
}

- 244 -
- 4/13단계: 루프 안에 두 개의 루프 넣기
분석 스크립트
forward] 1번, [왼쪽으로 회전] 1번, [꽃꿀 얻
기] 1번 사용
Ÿ 하나의 루프 안에 두 개의 루프가 들어가게 되
는 단계이다.
Ÿ 반복되는 블록을 파악하여 문제를 해결한다.
moveForward();
}
getNectar();
}
turnLeft();
}
- 5/13단계: 두 개의 루프 사용하고 하나의 루프 안에 루프 넣기
분석 스크립트
forward] 2번, [꽃꿀 얻기] 1번, [꿀 만들기] 1
번 사용
Ÿ 중첩 반복에 다른 루프도 추가된 단계이다.
Ÿ 어디까지가 반복이 되는지를 파악하여 알고리
즘을 만들고 뒤에 덧붙여서 해결한다.
moveForward();
getNectar();
}
}
moveForward();
makeHoney();
}

- 245 -
- 6/13단계: 루프와 ‘~인 동안 반복’ 블록 사용하기
분석 스크립트
Ÿ [3번 반복] 1번, [move forward] 1번, [반복(~인
동안): 꽃꿀의 양 > 0 실행] 1번, [꽃꿀 얻기] 1
번 사용
Ÿ 꽃꿀의 개수가 정해져있지 않은 보라색 꽃에서
꽃꿀을 얻기 위하여 ‘~인 동안 반복’블록을
이용하는 단계이다. (이 단계에서는 꽃꿀의 양
이 0보다 클 때로 지정해야한다고 힌트를 주었
다.)
moveForward();
}
while (nectarRemaining() > 0) {
getNectar();
}
- 7/13단계: 주어진 알고리즘의 반복 횟수 지정하기
분석 스크립트
Ÿ 하나의 보라색 꽃에서 모든 꽃꿀을 얻는 알고
리즘은 주어져있고 이를 중첩 반복을 사용하여
한 번 더 반복시키는 단계이다.
Ÿ 미리 주어진 알고리즘을 파악하여 몇 번 반복
되어야 하는지 파악하여 해결한다.
moveForward();
moveForward();
getNectar();
}
}

- 246 -
- 8/13단계: ‘~인 동안 반복’ 블록을 루프 안에 넣고 또 다시 한번 루
프를 사용하기
분석 스크립트
Ÿ [move forward] 2번, [4번 반복] 1번, [3번 반복]
1번, [반복(~인 동안): 꽃꿀의 양 > 0 실행] 1번,
[꽃꿀 얻기] 1번 [오른쪽으로 회전] 1번 사용
Ÿ 두 개의 루프 안에 ‘~인 동안 반복’블록을
사용하는 단계이다.
Ÿ 반복되는 구간을 잘 파악하여 해결한다.
moveForward();
getNectar();
}
moveForward();
}
turnRight();
}
- 9/13단계: 루프 안에 ‘~인 동안 반복’ 블록 사용하기
분석 스크립트
회전] 1번, [오른쪽으로 회전] 1번, [반복(~인 동
안): 꽃꿀의 양 > 0 실행] 1번, [꽃꿀 얻기] 1번
사용
Ÿ 반복되는 구간을 잘 파악하고 꽃꿀의 양이 정
해져있지 않기 때문에 ‘~인 동안 반복’블록
을 사용하여 해결한다.
moveForward();
turnLeft();
moveForward();
turnRight();
getNectar();
}
}

- 247 -
- 10/13단계: 루프 안에 ‘~인 동안 반복’ 루프 사용 후 다시 한 번 루
프 사용하기
분석 스크립트
forward] 2번, [반복(~인 동안): 꽃꿀의 양 >
0 실행] 1번, [꽃꿀 얻기] 1번, [왼쪽으로 회
전] 2번 사용
Ÿ 두 개의 루프 안에 ‘~인 동안 반복’이 들
어가게 되는 단계이다.
Ÿ 최소한의 블록을 사용하기 위하여 루프를 사
용하는데 이때 실제로 문제 해결 시에 꼭 필
요하지 않지만 반복되는 블록들이 있게 된
다.
moveForward();
getNectar();
}
}
turnLeft();
moveForward();
turnLeft();
}
- 11/13단계: 루프 안에 ‘~인 동안 반복’ 블록 사용하기(평가)
분석 스크립트
Ÿ [7번 반복] 1번, [move forward] 1번, [반복(~인
동안): 꽃꿀의 양 > 0 실행] 1번, [꽃꿀 얻기] 1번
사용
Ÿ 루프 안에 ‘~인 동안 반복’을 사용하는 단계
이다.
moveForward();
getNectar();
}
}

- 248 -
- 12/13단계: 루프 안에 두 개의 루프 사용하기(평가)
분석 스크립트
Ÿ [3번 반복] 3번, [move forward] 2번, [꽃꿀 얻
기] 1번, [꿀 만들기] 1번 사용
Ÿ 내포된 루프를 사용하여 중첩반복을 수행할 수
있는지 평가하는 단계이다.
moveForward();
getNectar();
}
moveForward();
makeHoney();
}
}
- 13/13단계: 루프 안에 ‘~인 동안 반복’ 블록과 루프 사용하기(평가)
분석
Ÿ 중첩 반복이 수행되는 꿀벌 퍼즐을 해결할 수 있는 알고리즘을 선택하는 문항이다.
Ÿ 내포된 블록을 사용하여 문제를 해결할 수 있는지 평가하는 문항이다.
Ÿ 직접 보기 화면의 알고리즘을 만들어보거나 선택지의 알고리즘을 예측하여 답을 선택한다.

- 249 -
14. 스테이지14: 꿀벌(디버깅)
◦ 동영상
Ÿ 디버깅에 대하여 설명한다.
Ÿ 디버깅이란 잘 작동하지 않는 부분, 즉 에러를 찾아내어 그것
을 제거하는 것이라고 말한다.
Ÿ 단계 버튼을 이용하여 단계마다 차근차근 실행한 후 에러를 찾
아내어 그것을 수정하면 된다고 설명한다.
◦ 활동
- 1/13단계: 블록 하나 제거 후 추가하기
분석 스크립트
Ÿ [꽃꿀 얻기] 1번 제거 후 [꿀 만들기] 1번 사용
Ÿ 벌집을 꽃으로 본 에러를 파악하여 수정하는 단계이다.
moveForward();
moveForward();
getNectar();
moveForward();
moveForward();
makeHoney();

- 250 -
- 2/13단계: 블록 제거하기
분석 스크립트
Ÿ [move forward] 1번 제거
Ÿ 잘못된 거리 이동 블록을 파악하여 제거하는 단계이다.
Ÿ 차근차근 단계를 따라가다 보면 오류를 찾아낼 수 있다.
moveForward();
getNectar();
moveForward();
turnRight();
moveForward();
getNectar();
moveForward();
makeHoney();
makeHoney();
- 3/13단계: 반복 횟수 수정하기
분석 스크립트
Ÿ [4번 반복] 2번 제거 후, [3번 반복] 2번 사용
Ÿ 반복되는 횟수 오류를 파악하여 수정하는 단계이
다.
Ÿ 꽃 3개, 벌집 또한 3개이므로 3번으로 수정한다.
moveForward();
getNectar();
}
moveForward();
makeHoney();
}
- 4/13단계: 회전 방향 수정하기

- 251 -
분석 스크립트
Ÿ [오른쪽으로 회전] 2번 제거 후 [왼쪽으로 회전]
2번 사용
Ÿ 회전 방향의 오류를 파악하여 수정하는 단계이
다.
moveForward();
getNectar();
turnLeft();
moveForward();
makeHoney();
turnRight();
}
- 5/13단계: if문 조건 수정하기
분석 스크립트
Ÿ [만약 꽃에서 실행 아니면] 1번 제거 후 [만약 벌
집에서 실행 아니면] 1번 사용
Ÿ if/else 블록에서의 오류를 발견하여 수정하는 단
계이다.
Ÿ 벌집에서 꿀을 만들어야한다.
moveForward();
}
makeHoney();
} else {
getNectar();
}

- 252 -
- 6/13단계: ‘~인 동안 반복’ 블록의 조건 수정하기
분석 스크립트
Ÿ [반복(~인 동안): 꽃꿀의 양 = 0 실행] 1번 제거 후
[반복(~인 동안): 꽃꿀의 양 > 0 실행] 1번 사용
Ÿ 꽃꿀이 없을 때 꽃꿀을 얻게하는 오류를 수정하여 꽃
꿀이 개수가 1개 이상일 때 얻게 하도록 하는 단계이
다.
moveForward();
turnRight();
moveForward();
getNectar();
}
- 7/13단계: 함수 수정하기
분석 스크립트
Ÿ [오른쪽으로 회전] 1번 사용
Ÿ 3개의 꿀을 만드는 함수를 수정하는 단계이다.
Ÿ 미리 구성된 함수를 차근차근 실행해보면 ‘오
른쪽으로 회전’1번이 빠져있다는 것을 알 수
있다.
function make_3_honey() {
turnRight();
moveForward();
makeHoney();
}
turnRight();
turnRight();
moveForward();
turnRight();
}
moveForward();
make_3_honey();
moveForward();
moveForward();
make_3_honey();
moveForward();
}

- 253 -
- 8/13단계: 주어진 함수 파악하여 알고리즘 수정하기
분석 스크립트
Ÿ [get 5 nectar] 2번 사용
Ÿ 미리 구성된 알고리즘에 꽃꿀을 얻는 함수가 빠져
있어 넣어주어야 한다. 구성된 함수를 파악하여
끼워 넣는다.
getNectar();
}
}
moveForward();
get_5_nectar();
moveForward();
turnLeft();
moveForward();
get_5_nectar();
- 9/13단계: 함수의 ‘~인 동안 반복’ 블록의 조건 수정하기
분석 스크립트
Ÿ [반복(~인 동안): 꿀 > 1 실행] 1번 제거 후 [반복(~인 동안):
꿀 > 0 실행] 1번 사용
Ÿ 서로 다른 개수의 꿀을 모두 얻기 위하여 ‘~인 동안 반복’
블록을 사용하였는데 1 초과의 꿀을 얻는다면 남은 1개의 꿀
을 얻지 않고 지나가게 되므로 이를 0 초과로 수정하여야 한
다.
function make_all_honey() {
while (honeyAvailable() > 0) {
makeHoney();
}
}
moveForward();
make_all_honey();
moveForward();
moveForward();
make_all_honey();
turnRight();
moveForward();
moveForward();

- 254 -
- 10/13단계: 반복 횟수 수정하고 앞으로 이동 블록 추가하기
분석 스크립트
Ÿ [3번 반복] 1번 제거 후 [4번 반복] 1번 사용,
Ÿ 반복 횟수의 오류와 거리 이동 블록이 빠져있
는 오류를 수정하는 단계이다.
Ÿ 앞으로 이동하는 블록이 빠져있어 추가해야하
고 꽃이 4개이므로 중첩 반복을 사용하여 4번
반복시켜주어야 한다.
moveForward();
getNectar();
}
}
- 11/13단계: 반복 횟수 수정하기
분석 스크립트
Ÿ [2번 반복]과 [5번 반복] 위치 바꾸기
Ÿ 반복 횟수의 오류를 수정하는 단계이다.
Ÿ 꽃 하나 당 꽃꿀이 2개이므로 2번 반복시켜준
후 꽃이 5개이므로 다시 5번 반복시켜야 한다.
moveForward();
getNectar();
}
}

- 255 -
- 12/13단계: 반복횟수와 루프의 개수와 반복되는 블록 수정하기(평가)
분석 스크립트
Ÿ [5번 반복] 1번 제거 후 [3번 반복] 2번 사용,
Ÿ 꽃꿀과 꿀을 한 루프 안에서 얻도록 한 오류를
수정하여야 한다. 루프를 나누어야하고 이에
따라 두 개의 루프 밖의 루프의 반복횟수 또한
수정하여야 한다.
moveForward();
getNectar();
}
moveForward();
makeHoney();
}
}
- 13/13단계: 함수 구성하기(평가)
분석
Ÿ 꿀벌 퍼즐의 함수를 예측하도록 하는 문항이다.
Ÿ 주어진 블록 알고리즘을 보고 함수를 파악할 수 있는지 평가한다.
Ÿ 직접 함수를 만들거나 각 선택지의 함수를 알고리즘에 대입하여 예측해보아 답을 선택한다.

- 256 -
15. 스테이지15: 바운스
◦ 활동
- 1/10단계: 방향키 연결하기
분석
Ÿ [왼쪽으로 움직이기] 1번 사용
Ÿ 왼쪽 방향키를 누르면 왼쪽으로 움직이도록 알고리즘을 짜는 단계이다.
Ÿ 알고리즘을 짠 후 단계를 해결하기 위하여 방향키를 눌러 목표지점까지 이동시켜야 한다.
Ÿ 이번 스테이지는 모두 if문을 연습하게 된다.
- 2/10단계: 방향키 연결하기(두 방향)
분석
Ÿ [왼쪽으로 움직이기] 1번, [오른쪽으로 움직이기] 1번 사용
Ÿ 왼쪽 방향키를 누르면 왼쪽으로 움직이도록 블록을 연결하고, 오른쪽 방향키를 누르면 오른쪽으로
움직이도록 블록을 연결하여 if문 사용을 연습하도록 한다.
Ÿ 전 단계와 마찬가지로 블록 알고리즘 완성 후 실행하여 목표 지점까지 이동시켜야 한다.

- 257 -
- 3/10단계: 방향키 연결하기(상하 방향)
분석
Ÿ [위로 올리기] 1번 사용
Ÿ 전 두 단계와 마찬가지로 위쪽 방향키를 누르면 위로 올라가도록 두 블록을 연결시키도록 하여 if문
사용을 연습한다.
Ÿ 블록 알고리즘 완성 후 마찬가지로 목표 지점까지 이동시켜야 한다.
- 4/10단계: 방향키 연결하기(상하좌우 방향)
분석
Ÿ [왼쪽으로 움직이기] 1번, [오른쪽으로 움직이기] 1번, [위로 올리기] 1번, [아래로 움직이기] 1번 사용
Ÿ 전 단계와 달리 4개의 방향이동을 설정하도록 하였다.
Ÿ 방향키마다 그 방향으로 이동하도록 블록을 연결하여 알고리즘을 완성한 후 목표지점을 모두 통과하
여 해결한다.

- 258 -
- 5/10단계: 라켓에 공이 부딪히면 넘기도록 블록 연결하기
분석
Ÿ [공 넘기기] 1번, [때리는 소리 출력] 1번 사용
Ÿ 라켓에 공이 부딪치면 공이 목표지점에 도달하도록 공 넘기기 블록을 연결해야한다. if문에 적절한
블록을 연결하는 것을 연습한다.
Ÿ 때리는 소리가 출력되도록 블록을 연결할 수 있음을 안다.
- 6/10단계: 공이 벽에 부딪히면 공이 넘어가도록 블록 연결하기
분석
Ÿ [공 넘기기] 2번 사용
Ÿ 이번 단계부터는 빨간색으로 벽이 설정되었다. [벽에 부딪치면] 이라는 블록이 새로 생겨나 [공 넘기
기] 블록을 연결시키면 공이 벽에 부딪칠 때 공이 다른 곳으로 넘겨지게 된다.
Ÿ 두 개의 if문을 이용하여 공을 목표지점으로 이동시키는 것을 연습한다.

- 259 -
- 7/10단계: 방향키와 공 넘기기는 블록 함께 연결하기
분석
Ÿ [왼쪽으로 움직이기] 1번, [오른쪽으로 움직이기] 1번, [공 넘기기] 2번 사용
Ÿ 이번 단계부터는 다시 방향키를 이용하여 라켓을 이동시킬 수 있게 된다. 공이 벽이 없는 부분으로
나가 사라지면 게임은 끝나게 된다. 따라서 방향키를 이용하여 라켓으로 공을 막아야 한다.
Ÿ 다음 단계의 게임을 위하여 라켓과 벽을 이용하여 공을 이동시키는 것을 연습한다.
- 8/10단계: 점수 올라가도록 블록 연결하기
분석
Ÿ [왼쪽으로 움직이기] 1번, [오른쪽으로 움직이기] 1번, [공 넘기기] 2번, [점수 올리기] 1번, [상대방 점
수 올리기] 1번 사용
Ÿ 전 단계에는 없던 골대가 생겨 골대에 공을 넣으면 되는 단계이다.
Ÿ 공이 들어가면 점수가 올라가고 라켓이 공을 놓치면 상대방 점수를 올리도록 블록을 연결하여 실행
하여 방향키를 눌러 라켓을 이용하여 공을 넘겨 상대방 점수가 내 점수의 2배가 되지 않도록 하면
해결된다.
Ÿ if문을 사용하여 게임을 나와 상대방의 점수를 올리는 게임을 만들 수 있다는 것을 이해한다.

- 260 -
- 9/10단계: 스피드 수정하고 배경을 바꾸고 새 공 만드는 블록 추가하
기
분석
Ÿ [새 공 준비] 3번, [빠른 공 설정] 1번, [왼쪽으로 움직이기] 1번, [오른쪽으로 움직이기] 1번, [공 넘기
기] 2번, [점수 올리기] 1번, [상대방 점수 올리기] 1번, [랜덤 배경 설정] 1번, [매우 빠른 라켓 설정]
1번 사용
Ÿ 상대방의 점수가 나의 점수의 2배가 되지 않도록 스피드를 수정하고 배경을 바꾸고 새 공 만들기 블
록을 추가하라고 팝업창이 정보를 주었다.
Ÿ 게임이 실행될 때 공이 나오도록 하기위하여 [실행하기] 블록에 [새 공 준비] 블록을 연결하고 배경
설정 블록을 원하는 곳에 연결하고 공이 들어가거나 놓쳐서 사라졌을 때 새 공을 준비하도록 하기
위하여 [공이 들어가면] 블록과 [상대방 점수 올리기] 블록에 [새 공 준비] 블록을 연결한다. 캐릭
터의 스피드를 바꾸기 위하여 [실행하기] 블록에 있는 [새 공 준비] 블록에 [빠른 공 설정] 블록을 연
결한다.
Ÿ 전 단계보다 심층적으로 공이 나오는 것부터 설정하도록 하였다.
- 10/10단계: 자신의 게임 만들어 공유하기
분석
Ÿ [새 공 준비] 3번, [빠른 공 설정] 2번, [왼쪽으로 움직이기] 1번, [오른쪽으로 움직이기] 1번, [공 넘기
기] 2번, [점수 올리기] 1번, [상대방 점수 올리기] 1번, [보통 빠르기 공 설정] 1번, [랜덤 공 설정] 1
번, [랜덤 배경 설정] 1번 사용
Ÿ 자신만의 게임을 만들어 보는 단계이다.
Ÿ 이전 단계들에서 배운 내용들로 자신의 게임을 만들어보면서 프로그래밍에 대하여 이해하게 되고 if
문을 사용하여 게임을 만드는 것을 연습하게 된다.

- 261 -
16. 스테이지16: Play Lab(스토리 만들기)
◦ 활동
- 1/6단계: say블록 사용하기
Ÿ 말하기 동작 블록을 연결하여 실
행하면 말하도록 설정한다.
Ÿ 말하기 동작 블록을 사용하여 캐
릭터가 말하도록 설정할 수 있다
는 것을 안다.
- 2/6단계: 두 개의 블록 연결하기
Ÿ 강아지가 말한 후 고양이가 말하
도록 설정하는 단계이다.
Ÿ 블록 두 개를 연결하여 한 캐릭
터가 말한 후 다른 캐릭터가 말
하도록 연결할 수 있다는 것을
안다.

- 262 -
- 3/6단계: 거리 이동 블록 사용하기
쪽으로 이동시키는 단계이다.
Ÿ 캐릭터 움직이기 블록을 설정하
여 캐릭터를 이동시킬 수 있다는
것을 안다.
- 4/6단계: 캐릭터가 만날 경우 동작 수행하도록 하기
로 이동시켜 두 캐릭터가 닿으면
고양이가 말을 하도록 하는 단계
이다.
Ÿ 캐릭터가 서로 만날 때 동작을
수행하도록 하는 블록을 설정할
수 있다는 것을 안다.

- 263 -
- 5/6단계: 문어 표정 설정하기
Ÿ 문어의 표정을 행복한 표정으로
바꾸는 단계이다.
Ÿ 블록을 이용하여 문어의 표정을
변화시킬 수 있다는 것을 안다.
- 6/6단계: 자신만의 스토리 만들어 공유하기
사용할 수 있는 블록 분석
Ÿ 자신만의 스토리를 만드는 단계
이다.
Ÿ 제목화면을 만들 수 있는 블록과
배경 설정 블록 속도 설정 블록
등 여러 가지 블록을 사용할 수
있었다.
Ÿ 이 단계를 통하여 다양한 블록으
로 프로그래밍을 연습하게 된다.

- 264 -
17. 스테이지17: Play Lab(게임 만들기)
◦ 동영상
Ÿ 이제까지는 클릭하면 항상 같은 것이 실행되었다면 이제부터는
상호적인 게임을 만들 수 있다고 말한다.
Ÿ “when arrow" 블록과 "move actor" 블록이 있다고 말한다.
두 블록을 함께 놓아 화살표 키를 누르면 방향대로 이동할 수
있다고 말한다.
Ÿ 캐릭터가 충돌하거나 클릭될 때 실행되도록 하는 블록이 있다
고 설명한다.
◦ 활동
- 1/7단계: ‘클릭하면’ 블록에 say블록 연결하기
Ÿ 이번 단계는 전 스테이지보다 발
전되어 캐릭터를 클릭하면 실행
되는 블록이 추가되었다.
Ÿ 캐릭터를 클릭하면 말하도록 설
정하는 단계이다.

- 265 -
- 2/7단계: 방향 키 연결하기
Ÿ 스테이지 15에서 연습했던 if문을
사용하여 캐릭터를 이동시켜 문
제를 해결하는 단계이다.
Ÿ 방향마다 적절한 블록을 연결시
키는 것이 중요하다.
- 3/7단계: 무한반복 블록 안에 블록 추가하기
Ÿ [무한 반복] 블록이 추가되었다.
이 블록을 사용하면 안에 있는
블록들이 무한대로 반복된다.
Ÿ 공룡이 계속 위 아래로 움직이도
록 하기 위하여 무한 반복 블록
안에 위로 400픽셀 아래로 400픽
셀 이동 블록을 추가한다.

- 266 -
- 4/7단계: 캐릭터들이 만날 때 블록을 실행시키도록 하는 블록과 say
블록 연결하기
Ÿ 전 단계에 두 캐릭터가 닿게 되
면 실행되도록 하는 블록이 추가
되었다. 캐릭터가 말하도록 설정
하고 충돌 소리 또한 설정하도록
하였다.
Ÿ 이를 통해 여러 실행 블록들을
한번에 사용하도록 하여 더 복잡
한 프로그래밍을 연습하도록 한
다.
- 5/7단계: 캐릭터들이 만날 때 실행되도록 하는 블록에 점수 올리기
블록 연결하기
Ÿ 전 단계에 캐릭터가 닿으면 점수
가 올라가도록 설정하는 블록이
추가되었다.
Ÿ 단계마다 블록들을 추가하여 게
임을 만드는 법을 연습하도록 한
다.

- 267 -
- 6/7단계: 화면 배경과 펭귄의 이동 스피드 바꾸기
Ÿ 배경설정과 이동 스피드를 바꾸
도록 한 단계이다.
Ÿ 더 재밌고 흥미로운 게임을 만들
수 있도록 하기 위하여 배경 설
정과 이동 스피드를 바꾸도록 하
였다.
- 7/7단계: 자신만의 게임 만들어 공유하기
사용할 수 있는 블록 블록 입력 후
Ÿ 이제까지 연습한 것을 실행해보
고 자신이 원하는 블록을 선택하
여 프로그래밍 해보는 단계이다.

- 268 -
18. 스테이지18: 인터넷
◦ 개요: 학생들은 인터넷 연결과 URL과 IP 주소와 DNS 등에 대해서
배우며 인터넷에 대하여 알게 된다.
◦ 학습목표
- 인터넷을 통하여 메시지를 보내는 것의 복잡성에 대하여 배운다.
- URL을 IP주소로 번역한다.
- 창의적인 문제 해결을 연습한다.
◦ 활동
- 1/3단계: 인터넷을 통하여 메시지를 보내는 과정을 이해하고 행동으
로 표현해보기
Ÿ 학생들에게 주요 화면1과 같은 DNS 테
이블을 보여주어 URL마다 IP주소를 알
려준(URL을 IP주소로 바꿔주는 것이
DNS라는 것을 알려줌) 후에 그룹을 나
누어 그룹마다 IP주소를 정해주고 각 구
성원마다 Message writer, 서버, 인터넷
등으로 역할을 정해준다. 정보를 전달하
는 방법은 Wi-fi, Cable/DSL, 광섬유 케
이블로 나뉘며(전달 방식마다 특유의 특
징에 따라서 해야 하는 행동이 정해져
있다. ex: 선이 필요한 광섬유 케이블은
벽에 손을 대며 전달해야한다.) 각 구
성원마다 패킷을 전달하는 등의 역할을
수행하여 서버, 인터넷 등의 개념에 대
하여 알게 한다.
Ÿ 주요 화면2는 학생들이 게임동안 이동
하게 될 가상의 설계도이다.
주요 개념
Ÿ IP 주소: 인터넷에 연결되어 있는 모든 항목에 부여된 숫자
Ÿ DNS(Domain Name Service): URL을 IP주소로 번역하는 서비스
Ÿ URL: 웹페이지를 부르기 위한 기억하기 쉬운 주소
Ÿ 인터넷: 서로에게 연결되어있는 컴퓨터와 서버들의 그룹
Ÿ 서버: 다른 컴퓨터들을 위하여 오직 무엇인가를 제공하기 위하여 존재하는 컴퓨터들
Ÿ 광섬유 케이블: 정보를 전달하기 위하여 빛을 사용하는 연결
Ÿ 와이 파이: 라디오파를 이용하여 정보를 보내는 무선의 방법
Ÿ DSL/Cable: 전화기나 텔레비전 케이블을 이용하여 정보를 보내는 방법
Ÿ 패킷: 정보의 큰 덩어리들로부터 조심스럽게 형성되어온 정보의 작은 덩어리들

- 269 -
- 2/3단계: URL과 IP주소의 호환성 이해하고 주어진 URL의 IP주소 선
택하기(평가)
분석
Ÿ code.org 라는 URL에 맞는 IP주소를 선택하는 문항이다.
Ÿ URL을 IP주소로 바꿀 수 있다는 사실을 알고 URL에 맞는 적절한 IP주소를 선택할 수 있는지 평
가한다.
- 3/3단계: URL과 IP주소의 호환성 이해하고 주어진 IP주소의 URL 선
택하기 (평가)
분석
Ÿ 100.42.50.110 이라는 IP주소에 맞는 URL을 선택하는 문항이다.
Ÿ IP를 URL로 바꿀 수 있다는 것을 알고 IP주소에 맞는 적절한 URL을 선택할 수 있는지 평가하는
문항이다.

- 270 -
19. 스테이지19: 클라우드소싱
◦ 개요: 해결하기 어려운 일에 있어 팀워크의 필요성에 대하여 알게 된
다.
◦ 학습목표
- 수행되어야 하는 큰 일에 대해 알게 된다.
- 큰 일을 여러 개의 작은 일로 재배열한다.
- 여러 개의 작은 해결책들로부터 완벽한 해결책을 얻는다.
◦ 활동
- 1/3단계: 함께 협동하여 활동하여 클라우드소싱 개념알고 연습하기
Ÿ 그룹을 나누어 한 팩의 카드를 섞어 모
든 구성원들이 보는 곳에 내려놓아 분
담을 하여 카드를 분류한다. 여러 번 반
복하여 가장 빠른 클라우드소싱 방법을
찾는다.
Ÿ 이 활동을 통하여 학생들은 클라우드소
싱의 개념을 알게 되고 연습하게 된다.
주요 개념
클라우드소싱: 일을 빨리 끝내기 위하여 큰 그룹의 사람들로부터 도움을 받는 것
- 2/3단계: 클라우드소싱을 이해하고 잘 표현하는 그림 선택하기(평가)
분석
Ÿ 클라우드소싱을 가장 잘 표현한 그림을 선택하는 문항이다.
Ÿ 클라우드소싱의 개념을 잘 이해하고 있는지를 평가한다.
Ÿ 클라우드소싱은 일을 빨리 끝내기 위하여 큰 그룹의 사람들로부터 도움을 받는 것을 알고 해결한다.

- 271 -
- 3/3단계: 클라우드소싱 하기에 좋은 활동 선택하기(평가)
분석
Ÿ 클라우드소싱을 연습하기에 가장 좋은 활동을 고르는 문항이다.
Ÿ 전 단계와 마찬가지로 클라우드소싱의 개념을 알고 있는지를 평가한다.
Ÿ 클라우드 소싱은 큰 그룹의 사람들로부터 도움을 받는 것을 말하므로 도움을 받아 분담할 만한 일을
생각하여 해결한다.

- 272 -
20. 스테이지20: 디지털 시민의식
◦ 개요: 사적인 정보와 개인적인 정보의 차이점을 알고 온라인에서 공유
하기에 무엇이 안전하고 안전하지 않은지 구별할 수 있게 된다. 또한
좋은 디지털 시민이 되는 방법을 배우면서 책임감있고 존경할만한 행
동에 대하여 알게 된다.
◦ 학습목표
- 온라인과 오프라인의 공동체에서의 그들의 책임감을 비교하고 대조한다.
- 어떤 유형의 정보가 그들을 신용사기나 신원도용의 위험에 빠뜨리는
지를 안다.
- 정직한 시민의 특징을 생각해본다.
- 디지털 딜레마의 해법을 고안한다.
◦ 활동
- 1/2단계: 바람직한 디지털 시민의 특징 알기
Ÿ 학생들에게 우리가 온라인에서 하는 행동이 영향력이 세다는 것을
알려주고 우리가 남기는 부정적인 코멘트들도 모든 세대에 빨리 퍼진
다는 것을 알려준다. 그리고 'safe', 'responsible', 'respectful' 단어에
어울리는 단어나 어구를 말하고 종이에 적도록 지도한다. 그 후에 각
각의 학생들의 종이의 답변을 조합하고 그룹을 나누어 슈퍼 디지털
시민을 만들어서 무대에서 연기를 하도록 시킨다. 바람직하지 못한 디
지털 시민을 보고 슈퍼 히어로가 이를 고쳐주는 내용으로 만들도록 한다.
Ÿ 이 활동을 통하여 학생들은 바람직한 디지털 시민의 특징을 알게 되
고 어떻게 행동해야하는지 깨닫게 된다.
주요 개념
디지털 시민: 온라인 상에서 안전하고 책임감있고 존경스럽게 행동하는 사람.
- 2/2단계: 인터넷 통해 공유하기 적당한 정보 선택하기(평가)
분석
Ÿ 인터넷 상에 공유하기 적당한 정보가 무엇인지 선택하는 문항이다.
Ÿ 인터넷에 공유해도 안전한 정보에 대하여 알고 있는지 평가한다.

- 273 -
21. 스테이지21: 예술가(패턴)
◦ 활동
- 1/15단계: 루프 안에 들어갈 블록 지정하기(변의 길이 알려줌)(스테이
지 21부터 각도 보기 중에서 선택하는 것이 아니라 직접 입력)
분석 스크립트
Ÿ [앞으로 20 이동] 1번, [오른쪽으로 90°돌기]
1번 사용
Ÿ 반복될 횟수는 미리 지정되어있고 정사각형을
만들기 위하여 무엇을 반복시켜야하는지 지정
moveForward(20);
turnRight(90);
}
- 2/15단계: 주어진 알고리즘에 거리 이동 블록 추가하여 루프 안에 넣
기(길이에 대한 힌트는 주어진 알고리즘에서 얻음)
분석 스크립트
Ÿ 내포된 루프를 사용하여 15개의 정사각형을 그
리도록 하는 단계이다.
Ÿ 미리 주어진 알고리즘에 다음 정사각형을 그리
기 위한 거리 이동 블록을 추가하여 이를 다시
반복시켜 해결한다.
moveForward(20);
turnRight(90);
}
moveForward(20);
}

- 274 -
- 3/15단계: 주어진 알고리즘에 툴 박스에 있는 보기 중에 적절한 블록
모음을 선택하여 넣기
분석 스크립트
Ÿ [오른쪽으로 90°돌기] 1번, [앞으로 20 이동]
1번, [왼쪽으로 90°돌기] 1번, [뒤로 300 이동]
1번 사용
Ÿ 225개의 정사각형을 그리기 위하여 추가되어
야할 블록을 선택하는 단계이다.
Ÿ 이 세 개가 보기로 주어졌
다.
moveForward(20);
turnRight(90);
}
moveForward(20);
}
turnRight(90);
moveForward(20);
turnLeft(90);
moveBackward(300);
- 4/15단계: 루프 안에 들어갈 블록 지정하기(도형의 각도와 변의 길이
주어짐)
분석 스크립트
Ÿ [앞으로 20 이동] 2번, [오른쪽으로 60°돌기]
1번, [오른쪽으로 120°돌기] 1번 사용
Ÿ 다이아몬드를 그리기 위하여 2번 반복되어야할
블록을 선택하는 단계이다.
moveForward(50);
turnRight(120);
moveForward(50);
turnRight(60);
}

- 275 -
- 5/15단계: 주어진 알고리즘에 각도 변경 블록 추가하여 루프 안에 넣
기(각도에 대한 힌트 없음)
분석 스크립트
Ÿ [6번 반복] 1번, [왼쪽으로 180°돌기] 1번 사
용
Ÿ 6개의 다이아몬드를 그리기 위하여 추가될 블
록을 선택하는 단계이다. 중첩반복을 이용하여
해결한다.
moveForward(50);
turnRight(120);
moveForward(50);
turnRight(60);
}
turnLeft(180);
}
- 6/15단계: 주어진 알고리즘의 반복횟수 지정하기(힌트 없음)
분석 스크립트
Ÿ 다이아몬드의 격자무늬를 그리기 위하여 중첩
반복을 이용하는 단계이다.
Ÿ 미리 구성되어있는 알고리즘을 이해하여 반복
횟수를 지정하여야한다.
moveForward(50);
turnRight(120);
moveForward(50);
turnRight(60);
}
turnRight(180);
}
jumpBackward(100);
turnRight(60);
jumpBackward(250);
turnLeft(60);

- 276 -
- 7/15단계: 알고리즘 수정하기(뒤로 100 점프를 뒤로 50점프로 바꾸라
고 말하고 뒤의 블록 이동 거리 지정하도록 함)
분석 스크립트
Ÿ [4번 반복] 제거 후 [7번 반복] 1번 사용, [뒤로
100 점프] 제거 후 [뒤로 50 점프] 1번 사용,
[뒤로 250 점프] 1번 제거 후 [뒤로 275 점프]
1번 사용
Ÿ 더 복잡한 모양을 만들기 위하여 전 단계의 알
고리즘을 수정하는 단계이다. 뒤로 점프를 50
으로 바꿀 경우에 뒤의 뒤로 점프 블록을 어떻
게 수정해야하는지를 물었다.
Ÿ 차근차근 단계별로 움직여보면 답을 찾을 수
있다. 반복횟수 또한 수정해야한다.
moveForward(50);
turnRight(120);
moveForward(50);
turnRight(60);
}
turnRight(180);
}
jumpBackward(50);
turnRight(60);
jumpBackward(275);
turnLeft(60);
- 8/15단계: 루프 이용한 알고리즘 만들기(각도 60도를 이용하고 변의
길이가 40이라고 힌트를 줌)
분석 스크립트
Ÿ 루프를 이용하여 육각형을 그리는 단계이다.
회전할 각도는 주어졌다.
moveForward(40);
turnRight(60);
}

- 277 -
- 9/15단계: 주어진 알고리즘에 거리 이동 블록 추가하여 루프 한 번 더
사용하기(가장 서로 먼 점 사이의 거리를 80이라고 알려주고 반복횟
수 알려줌)
분석 스크립트
Ÿ [3번 반복] 1번, [앞으로 60 점프] 1번 사용
Ÿ 주어진 육각형을 그리는 알고리즘을 이용하여
3개의 육각형을 그리는 단계이다.
Ÿ 하나의 육각형을 그린 후 다음 육각형을 그리
기 위하여 점프 이동 블록을 사용한 후 내포된
루프를 이용하여 반복시키면 된다.
moveForward(40);
turnRight(60);
}
jumpForward(80);
}
- 10/15단계: 주어진 알고리즘을 루프로 묶고 반복횟수 지정하기(두 개
의 줄이라고 주어짐)
분석 스크립트
Ÿ 미리 주어진 알고리즘을 파악하여 주어진 도형
을 그리는 단계이다. 주어진 알고리즘을 차근
차근 단계를 밟아 세 개의 육각형을 그린 후
다시 세 개를 그리기 위한 자리에 돌아온다는
것을 아는 것이 중요하다.
moveForward(40);
turnRight(60);
}
jumpForward(120);
}
turnRight(60);
jumpForward(40);
turnLeft(60);
jumpBackward(320);
}

- 278 -
- 11/15단계: 주어진 알고리즘에 거리 이동 블록 추가하여 루프 사용하
고 반복횟수 지정하기(4번의 반복횟수와 뒤로 120 점프 블록을 추가
해야한다고 힌트를 줌)
분석 스크립트
Ÿ [4번 반복] 1번, [뒤로 120 점프] 1번 사용
Ÿ 미리 주어진 알고리즘을 파악하여 주어진 그림
을 그리는 단계이다. 다시 처음의 자리에 돌아
가기 위하여 이동하기 위한 점프 블록과 이를
반복할 횟수를 정해야 한다.
moveForward(40);
turnRight(60);
}
jumpForward(120);
}
turnRight(60);
jumpForward(40);
turnLeft(60);
jumpBackward(320);
}
jumpBackward(120);
- 12/15단계: 주어진 알고리즘을 루프로 묶고 반복횟수 지정하기(원의
총 각도는 360도이고 각 루프는 3도 회전한다고 힌트를 줌)
분석 스크립트
Ÿ 루프를 이용하여 반원을 그리는 단계이다.
Ÿ 주어진 알고리즘이 무엇을 그리는지 파악하여
몇 회 반복해야하는지 정한다.
moveForward(1);
turnRight(3);
}

- 279 -
- 13/15단계: 주어진 알고리즘을 파악하고 반대 방향의 반원을 그리는
알고리즘 추가한 뒤 루프로 묶어 반복횟수 지정하기
분석 스크립트
Ÿ [앞으로 1 이동] 1번, [왼쪽으로 3°돌기] 1번,
[60번 반복] 1번, 4번 반복] 1번 사용
Ÿ 반원을 그리는 알고리즘을 이용하여 주어진 그
림을 그리는 단계이다.
Ÿ 오른쪽으로 회전하여 그리는 반원과 왼쪽으로
회전하여 그리는 반원으로 이루어진 그림이 네
번 반복되고 있다는 것을 파악하여 그리면 된
다.
moveForward(1);
turnRight(3);
}
moveForward(1);
turnLeft(3);
}
}
- 14/15단계: 주어진 알고리즘에 툴 박스에 주어진 블록 모음 추가하기
분석 스크립트
Ÿ [30번 반복] 1번, [앞으로 1 이동] 1번, [왼쪽으
Ÿ 반원과 반원에 1/4을 추가한 3/4원을 이용한
그림을 그리는 단계이다. 모서리에만 3/4원이
있는데 따라서 1/4을 추가하는 알고리즘을 추
가해야하는데 툴박스에 보기로 주어졌다.
Ÿ 이 네 가지 알고리즘
이 주어졌다.
moveForward(1);
turnRight(3);
}
moveForward(1);
turnLeft(3);
}
}
moveForward(1);
turnLeft(3);
}

- 280 -
- 15/15단계: 자유롭게 그리기
사용 할 수 있는 블록
분석
Ÿ 이제까지 배운 루프와 ‘~인 동안 반복’블록과 중첩반복을 이용하여 그리고 싶은 것을 그리도록 하
여 배운 것을 확인한다.

- 281 -
IV. 제4코스(베타) Code.org 분석
1. 스테이지1: 탱그램
◦ 개요 : 알고리즘을 상세하게 표현할수록 결과물이 본래 목표했던 결과
와 비슷하게, 구체적으로 나타나는 알고리즘의 주요 특성을 파악한다.
◦ 학습 목표
- 이미지를 행동할 수 있는 명령으로 전환시키는 어려움과 씨름한다.
- 이미지를 복사하기 위해 친구들에게 명령들을 전달한다.
- 친구들과 작업을 분석하여 결과가 성공적인지 여부를 결정한다.
◦ 활동
- 1/1단계 : 언플러그드 활동(생활속의 예로 알고리즘 설명하기)
Ÿ 학생들이 자신에게 주어진 이미지를 재
현하기 위해 탱그램 조각들을 조작하는
과정에서 알고리즘이 사용된다는 것을
인식한다.
Ÿ 탱그램 조각들을 이용하여 이미지를 만
드는 과정에서 사람마다 조금씩 다른
이미지를 만들어낼 수 있다는 것을 인
지하고, 알고리즘이 간단하게 제시될수
록 재현되는 이미지들이 다양하게 나타
난다는 것을 알 수 있다.
Ÿ 일상생활 속에서 조리법이나 장보기목
록 등 알고리즘이 많이 사용된다는 것
을 이해한다.
주요 개념
알고리즘 : 과제를 마치기 위해 따라야 하는 단계들의 모음
탱그램 : 사각형을 7개의 조각으로 잘라 놓은 것을 여러 형태로 맞추는 중국식 퍼즐

- 282 -
2. 스테이지2: 미로와 꿀벌
◦ 동영상(순차문)
Ÿ 미로퍼즐의 기본적인 이해를 돕기 위해 설명한다.
Ÿ 캐릭터가 돼지를 향해 이동해가는 모습을 나타낸다.
Ÿ 각 블록들 안에는 실제로 스크립트와 같은 코드들이 존재한다
는 것을 인식하게 한다.
Ÿ 미로퍼즐 활동의 화면 구성에 대해 세 부분(실행화면, 도구상
자, 작업화면)으로 나누어 하나하나 설명한다.
◦ 활동
- 1/10단계 : 앞으로 세 번 이동하기
분석 스크립트
moveForward();
moveForward();
moveForward();

- 283 -
- 2/10단계 : 앞으로 이동과 회전하여 오른쪽으로 가기
분석 스크립트
Ÿ 방향 이동 블록과 회전 블록 등의 순차문을 이해한다.
moveForward();
turnLeft();
moveForward();
turnRight();
moveForward();
- 3/10단계 : 앞으로 이동과 회전하여 밑으로 가기
분석 스크립트
Ÿ 방향 이동 블록과 회전 블록 등의 순차문을 이해한다.
moveForward();
turnRight();
moveForward();
moveForward();
moveForward();
turnLeft();
moveForward();
moveForward();

- 284 -
◦ 동영상(반복문)
Ÿ 반복문(루프)을 다시 한 번 소개하며 루프의 개념을 이해시킨
다.
Ÿ 루프 사용의 효율성을 강조한다.
Ÿ 실제 블록들을 조작하는 모습을 보여주며 반복문(루프)의 사
용을 권장하고 있다.
- 4/10단계 : 반복문을 사용하여 앞으로 다섯 번 가기
분석 스크립트
Ÿ 반복문(루프)의 사용을 이해한다.
moveForward();
}

- 285 -
- 5/10단계 : 반복문 한 번 사용 후 방향을 회전하여 반복문 한 번 더 사용하기
분석 스크립트
Ÿ [4번 반복] 1번 사용, [앞으로 이동] 2번 사용, [오
른쪽으로 회전] 1번 사용, [5번 반복] 1번 사용
Ÿ 반복문(루프)을 여러 번 사용하여 문제를 해결할
수 있다.
moveForward();
}
turnRight();
moveForward();
}
- 6/10단계 : 방향회전 블록을 포함한 반복문 만들기
분석 스크립트
Ÿ 반복문(루프) 안에 여러 명령 블록들을 넣어 알고리즘
을 작성할 수 있다.
moveForward();
moveForward();
turnRight();
}

- 286 -
◦ 동영상(조건문)
Ÿ 다음 단계부터 사용될 조건문 블록에 대한 이해를 위해 실제
사용하는 모습을 화면으로 보여준다.
Ÿ 꽃꿀을 얼마나 얻을 수 있는지, 또는 꿀을 얼마나 만들 수 있
는지 모르는 상황에서 조건문이 유용하게 쓰일 수 있음을 설
명한다.
Ÿ 조건문 블록에서 조건을 충족할 경우 실행할 명령 블록을 붙
이는 모습을 화면으로 보여준다.
Ÿ 문제를 해결하는 데 필요한 블록들의 구성과 순서 등을 어떻
게 정해야 하는지 생각해본다.
- 7/10단계 : 반복문과 조건문 사용하여 꽃꿀 얻기
분석 스크립트
Ÿ [3번 반복] 1번 사용, [앞으로 이동] 1번 사용, [만약~
에서 실행] 1번 사용, [꽃꿀 얻기] 1번 사용
Ÿ 물음표가 꽃인지 벌집인지에 따라 다른 명령을 실행
해야 한다.
Ÿ 물음표가 꽃일 때만 ‘꽃꿀 얻기’라는 명령을 실행
하도록 조건문을 작성한다.
moveForward();
}
if (atFlower()) {
getNectar();
}

- 287 -
- 8/10단계 : 반복문과 조건문을 두 번씩 사용하여 꽃꿀 얻기
분석 스크립트
으로 회전] 2번 사용, [만약~에서 실행] 2번 사용, [꽃
꿀 얻기] 2번 사용
Ÿ 물음표가 꽃인지 벌집인지에 따라 다른 명령을 실행해
야 한다.
Ÿ 물음표가 꽃일 때만 ‘꽃꿀 얻기’라는 명령을 실행하
도록 조건문을 작성한다.
Ÿ 가장 적은 블록을 사용하여 알고리즘을 작성하기 위해
서는 반복문을 최대한 활용해야 함을 인식한다.
Ÿ 논리적 사고를 통해 필요한 캐릭터의 이동과 회전을
생각한다.
moveForward();
moveForward();
turnRight();
}
if (atFlower()) {
getNectar();
}
turnRight();
moveForward();
}
if (atFlower()) {
getNectar();
}
◦ 동영상(조건문의 확장)
Ÿ if~else(만약~아니면~) 블록을 새로 도입한다.
Ÿ if~else 블록으로 두 가지 조건에 따라 행동을 명령할 수 있음
을 이해한다(조건을 만족할 경우 A 실행, 조건을 만족하지 않
을 경우 B 실행).
Ÿ Else는 제시된 특정 조건을 만족하지 않는 반대되는 모든 상황
을 의미하는 것으로, 컴퓨터가 조건에 따라 명령을 실행하는
원리를 이해한다.
Ÿ if~else 블록이 실제로 어떻게 사용되는지 구체적인 조건을 보
여주며 이해시킨다.

- 288 -
- 9/10단계 : if~else~문을 사용하여 꽃꿀을 얻거나 꿀을 만들기
분석 스크립트
Ÿ [앞으로 이동] 2번 사용, [만약~실행~아니면~] 1번 사용, [꽃
꿀 얻기] 1번 사용, [꿀 만들기] 1번 사용
Ÿ 물음표가 꽃 또는 벌집이라는 상황을 이해하여 꽃일 경우 꽃
꿀을 얻고 벌집일 경우 꿀을 만드는 알고리즘을 작성한다.
moveForward();
moveForward();
if (atFlower()) {
getNectar();
} else {
makeHoney();
}
- 10/10단계 : 꽃꿀의 개수가 1개~3개일 때 꽃꿀을 얻는 알고리즘 완성하기
분석 스크립트
Ÿ [앞으로 이동] 1번 사용, [만약~실행~아니면~] 2번 사용,
[3번 반복] 1번 사용, [꽃꿀 얻기] 3번 사용, [2번 반복]
1번 사용
Ÿ 꽃의 개수에 따라 다른 명령을 실행해야 하는 상황을
이해한다.
Ÿ 꽃이 3개일 때, 2개일 때, 1개일 때 각각 어떤 명령을
실행해야 하는지 생각한다.
moveForward();
getNectar();
}
} else {
getNectar();
}
} else {
getNectar();
}

- 289 -
3. 스테이지3: 예술가
◦ 동영상(순차문과 반복문)
Ÿ 자신이 마음대로 프로그램을 작성하여 캐릭터가 다양한 그림
을 그리도록 할 수 있다는 것을 이해한다.
Ÿ 프로그램의 알고리즘과 그림을 그리는 방법 사이의 관계를 파
악한다.
Ÿ 거리 이동 블록과 각도 회전 블록을 설명하며 이 블록들을 어
떻게 사용하는지 보여준다.
Ÿ 이 블록들이 사용하는 단위들에 대해 설명하며 사용자들이 원
활히 조작할 수 있도록 한다.
- 1/13단계 : 반복문을 사용하여 한 변의 길이가 힌트로 주어진 정사각형 그리기
분석 스크립트
Ÿ 순차문만을 사용하여 그리는 것보다 반복문을 사용하
면 알고리즘을 더 간단히 표현할 수 있음을 인식한
다.
Ÿ 프로그램을 실행해보며 얼마나 이동해야 하는지 파악
한다.
moveForward(200);
turnRight(90);
}

- 290 -
- 2/13단계 : 한 변의 길이가 300으로 지정된 정사각형을 그리기 위해 반복문 사용하기
분석 스크립트
Ÿ 순차문만을 사용하여 그리는 것보다 반복문을 사용하
면 알고리즘을 더 간단히 표현할 수 있음을 인식한
다.
moveForward(300);
turnRight(90);
}
- 3/13단계 : 회전하며 선을 그리기 위해 반복문 사용하기
분석 스크립트
Ÿ [8번 반복] 1번 사용, [랜덤 색 설정] 1번 사용, [앞으
로 100 이동] 1번 사용, [뒤로 100 이동] 1번 사용,
Ÿ 반복문(루프)와 거리 이동 블록, 각도 회전 블록 등을
사용하여 문제를 해결할 수 있다.
moveForward(100);
moveBackward(100);
turnRight(45);
}

- 291 -
- 4/13단계 : 1°씩 돌며 원을 그리기 위해 반복문의 반복횟수 설정하기
분석 스크립트
[앞으로 100 이동] 1번 사용, [뒤로 100 이동] 1번
사용, [오른쪽으로 1°돌기] 1번 사용
Ÿ 반복문(루프)와 거리 이동 블록, 각도 회전 블록 등
을 사용하여 문제를 해결할 수 있다.
moveForward(100);
moveBackward(100);
turnRight(1);
}
- 5/13단계 : 중첩 반복문 사용의 필요성을 자연스럽게 인식하기
분석 스크립트
[오른쪽으로 120°돌기] 1번 사용, [앞으로 50 점
프] 1번 사용
Ÿ 반복문을 중첩하여 사용하면 알고리즘을 더 간단
히 만들 수 있음을 이해한다.
moveForward(50);
turnRight(120);
}
jumpForward(50);
}

- 292 -
◦ 동영상(중첩 반복)
Ÿ 중첩 반복의 의미를 설명과 실제 예를 통해 이해한다.
Ÿ 중첩 반복의 필요성을 알게 하고, 반복문(루프)을 드래그 앤
드롭으로 중첩시켜 알고리즘을 작성하는 과정을 화면으로 보
여준다.
- 6/13단계 : 반복문 한 번 실행 후의 회전각도와 중첩 반복문의 반복횟수 설정하기
분석 스크립트
[왼쪽으로 120°돌기] 1번 사용, [오른쪽으로
120°돌기] 1번 사용
Ÿ 작은 삼각형 하나를 만들기 위한 알고리즘을 몇
번 반복해야 문제를 해결할 수 있는지 생각한다.
moveForward(100);
turnLeft(120);
}
turnRight(120);
}

- 293 -
- 7/13단계 : 반복문을 반복해야할 횟수를 파악하여 중첩 반복문의 반복횟수 설정하기
분석 스크립트
[3번 반복] 1번 사용, [앞으로 100 이동] 1번 사
용, [왼쪽으로 120°돌기] 1번 사용, [오른쪽으로
Ÿ 회전 각도에 유의하여 작은 삼각형 하나를 만들
기 위한 알고리즘을 몇 번 반복해야 문제를 해
결할 수 있는지 생각한다.
moveForward(100);
turnLeft(120);
}
turnRight(36);
}
분석 스크립트
Ÿ [12번 반복] 1번 사용, [랜덤 색 설정] 1번 사용, [3번
반복] 1번 사용, [앞으로 50 이동] 2번 사용, [왼쪽으로
120°돌기] 1번 사용, [오른쪽으로 30°돌기] 1번 사용
Ÿ 회전 각도에 유의하여 작은 삼각형 하나를 만들기 위
한 알고리즘을 몇 번 반복해야 문제를 해결할 수 있
moveForward(50);
turnLeft(120);
}
moveForward(50);
turnRight(30);
}

- 294 -
분석 스크립트
Ÿ [10번 반복] 1번 사용, [랜덤 색 설정] 1번 사용, [2번
반복] 1번 사용, [앞으로 100 이동] 1번 사용, [오른쪽
으로 60°돌기] 1번 사용, [앞으로 50 이동] 1번 사용,
[오른쪽으로 120°돌기] 1번 사용, [오른쪽으로 36°
돌기] 1번 사용
Ÿ 회전 각도에 유의하여 작은 사각형 하나를 만들기 위
한 알고리즘을 몇 번 반복해야 문제를 해결할 수 있
moveForward(100);
turnRight(60);
moveForward(50);
turnRight(120);
}
turnRight(36);
}
- 10/13단계 : 반복문을 두 번 사용하여 그림을 그리고 공유하기
실행 전 블록 입력 전 그려지는 그림
분석 스크립트
Ÿ 주어진 블록 프로그램을 실행하면 위와 같은 그림이
그려진다는 것을 보여준다.
※ 그린 그림을 인쇄하거나 페이스북과 트위터에 공유할
수 있도록 구성하였다.
moveForward(40);
turnRight(60);
}
moveForward(80);
turnRight(120);
}

- 295 -
- 11/13단계 : 앞으로 점프 후 중첩 반복문을 사용하여 알고리즘 작성하기
분석 스크립트
Ÿ 제시된 그림을 재현하기 위해 어떻게 프로그램을
작성해야 하는지 탐구한다.
Ÿ 시도와 오류를 두려워하지 않고 여러 번 프로그램
을 작성해보며 문제를 해결한다.
Ÿ 정해진 블록의 개수가 없기 때문에 자유롭게 알고
리즘을 작성하고 구현할 수 있다.
※ 그린 그림을 인쇄하거나 페이스북과 트위터에 공
유할 수 있도록 구성하였다.
jumpForward(20);
turnLeft(60);
moveForward(30);
turnRight(60);
}
moveForward(80);
turnRight(120);
moveForward(80);
turnRight(180);
}

- 296 -
- 12/13단계 : 두 개의 반복문을 포함하는 중첩 반복문 만들기
분석 스크립트
Ÿ 제시된 그림을 재현하기 위해 어떻게 프로그램을 작
성해야 하는지 탐구한다.
Ÿ 시도와 오류를 두려워하지 않고 여러 번 프로그램을
작성해보며 문제를 해결한다.
Ÿ 정해진 블록의 개수가 없기 때문에 자유롭게 알고리
즘을 작성하고 구현할 수 있다.
※ 그린 그림을 인쇄하거나 페이스북과 트위터에 공유
할 수 있도록 구성하였다.
moveForward(60);
turnRight(60);
}
moveForward(80);
turnRight(120);
}
}
- 13/13단계 : 자유 시간
분석
Ÿ 지금까지의 단계들에서 배운 내용들을 활용하여 자신이 원하는 그림을 그릴 수 있다.

- 297 -
4. 스테이지4: 변수들 묶기
◦ 개요 : 변수들의 의미를 이해하고 변수들을 사용하는 다양한 방법들을
알 수 있으며, 이를 통해 추상화의 개념 학습에 기초를 마련한다.
◦ 학습 목표
- 변수들을 확인하고 그 값들을 결정한다.
- 실제 활동들의 맥락에서 변수들을 규정하고 호출한다.
- 변수의 사용을 필요로 하는 상황을 생성한다.
- 협동심을 발휘하여 창의적인 게임을 만든다.
◦ 활동
- 1/1단계 : 언플러그드 활동(영어 문장들을 예시로 변수의 개념 설명하기)
Ÿ 실제 큰 단위의 문제를 작은 단위들로
분해하여 당연시 여겼거나 빠져 있는
부분들을 확인한다.
Ÿ 우리가 알지 못하는 정보 조각들을 빈
칸이나 기호 또는 텍스트 등으로 대신
하여 작업을 계속할 수 있다.
Ÿ 우리가 사용하는 소프트웨어들은 대부
분 변수들을 사용하여 세부적인 정보
조각들을 다룬다는 것을 이해한다.
Ÿ 학생들에게 변수가 들어간 문장을 제시
하거나 학생들이 직접 만들어보도록 한
다.
주요 개념
변수 : 변화하는 정보의 조각을 대신하는 기호나 텍스트의 일부

- 298 -
5. 스테이지5: Madlibs(매들립)
◦ 개요 : 컴퓨터과학에서 추상화를 통해 문제를 간단하게 만들고 불필요
한 반복을 제거하는 원리를 이해하고, 학생들 스스로 이야기를 분석하
며 그 속의 차이점들을 파악한다.
◦ 학습 목표
- ‘추상화’의 개념을 내면화할 수 있는 기회를 마련한다.
- 창의성을 개발하기 위해 글을 지을 때 추상화를 적용해본다.
- 비슷할 수 있는 일상적인 이야기들에서 차이점을 발견하는 분석활동
을 해본다.
◦ 활동
- 1/1단계 : 언플러그드 활동(영어 이야기를 예시로 추상화 설명하기)
Ÿ 이야기의 빈칸을 채우는 활동을 통해
비슷한 이야기도 각자 다르게 만들 수
있다는 것을 이해한다.
Ÿ 추상화의 과정에서 차이점들과 세부사
항들이 제거된다는 것을 이해한다.
Ÿ 문제 상황에서 추상화의 기능과 유용성
을 인식하여 활용할 수 있다.
주요 개념
추상화 : 구체적인 차이점들로부터 만든 한 가지 해결책으로 다양한 문제들에 적용하는 것

- 299 -
6. 스테이지6: 예술가, 변수
◦ 활동
- 1/18단계 : 반복문을 사용하여 정삼각형 그리기
분석 스크립트
Ÿ [3번 반복] 1번 사용, [앞으로 100 이동] 1번 사용, [왼
Ÿ 문제 해결에 필요한 블록들이 무엇인지 파악할 수 있
다.
moveForward(100);
turnLeft(120);
}
◦ 동영상
Ÿ 변수라는 것이 값들을 저장하는 그릇과 같은 개념이며 알고리
즘에서 값들을 사용해야 할 때는 그 그릇을 열어 사용하는 것
과 비슷하다는 것을 이해한다.
Ÿ 그러나 변수는 상황에 따라 다른 값들을 호출한다는 것을 이
해한다.
Ÿ 생일 축하 문장을 예로 들어 매년 나이가 바뀌어가는 부분을
제외하고는 문장이 동일하다는 것을 인식시킨다.
Ÿ 나이가 매년 +1씩 증가한다는 것을 인식한다.
Ÿ 이처럼 변수는 값이 일정하게 변화하도록 만들 때 유용하게
사용할 수 있음을 안다.

- 300 -
- 2/18단계 : 길이 변수의 입력값 설정하기
분석 스크립트
Ÿ [길이를 150으로 설정] 1번 사용, [3번 반복] 1번 사용,
[길이만큼 앞으로 이동] 1번 사용, [왼쪽으로 120°돌기]
1번 사용
Ÿ 삼각형의 한 변의 길이를 고려하여‘길이’를 얼마로 설
정해야 하는지 생각한다.
Ÿ 힌트를 참조하여 한 변의 길이를 파악한다.
var length2;
length2 = 150;
moveForward(length2);
turnLeft(120);
}
- 3/18단계 : 중첩 반복문에 사용된 길이 변수의 입력값 설정하기
분석 스크립트
[길이만큼 앞으로 이동] 2번 사용, [왼쪽으로 120°돌
기] 1번 사용
Ÿ 작은 삼각형 하나의 한 변의 길이를 고려하여‘길이’
를 얼마로 설정해야 하는지 생각한다.
Ÿ 힌트를 참조하여 한 변의 길이를 파악한다.
var length2;
length2 = 50;
turnLeft(120);
}
}

- 301 -
- 4/18단계 : 작은 정육각형 한 변의 길이가 주어지지 않았을 때 길이 변수의 입력값 설정하기
분석 스크립트
[랜덤 색 설정] 1번 사용, [길이만큼 앞으로 이동] 1번
사용, [왼쪽으로 60°돌기] 2번 사용
Ÿ 작은 육각형 하나의 한 변의 길이를 고려하여‘길이’
를 얼마로 설정해야 하는지 생각한다.
Ÿ 작은 육각형 하나를 그리는 알고리즘에서 왼쪽으로
360/60°를 보여주어 왜 그 각도만큼 회전해야 하는지
알 수 있다.
var length2;
length2 = 60;
turnLeft(360 / 6);
}
turnLeft(60);
}
- 5/18단계 : 길이 변수의 입력값이 주어졌을 때 변수블록 사용하기
분석 스크립트
[길이만큼 앞으로 이동] 1번 사용, [왼쪽으로 90°돌기] 1
번 사용
Ÿ ‘길이’가 설정된 상태에서 이번에는 길이 이동 블록에
변수를 삽입해본다.
var length2;
length2 = 200;
turnLeft(90);
}

- 302 -
- 6/18단계 : 입력값이 주어진 변수블록 두 번 사용하기
분석 스크립트
[랜덤 색 설정] 1번 사용, [길이만큼 앞으로 이동] 2번
사용, [왼쪽으로 72°돌기] 1번 사용
Ÿ ‘길이’가 설정된 상태에서 이번에는 길이 이동 블록
에 변수를 삽입해본다.
var length2;
length2 = 100;
turnLeft(72);
}
}
◦ 동영상
Ÿ 세로의 길이가 50이고 가로의 길이가 100인 직사각형을 그리
는 경우를 가정해본다.
Ÿ 가로의 길이가 세로의 길이의 2배라는 것을 인식한다.
Ÿ [2번 반복], [앞으로 50 이동], [오른쪽으로 90°돌기], [앞으로
100 이동] 블록을 사용하여 그림을 그릴 수 있다.
Ÿ 이번에는 세로의 길이를 ‘height’라는 변수로 나타내고, 가
로의 길이를 그 변수의 2배로 나타내본다.
Ÿ 컴퓨터의 변수를 이용한 수학적 문제해결 과정을 이해한다.

- 303 -
- 7/18단계 : 입력값이 주어진 변수(폭)블록을 변형하여 사용하기
분석 스크립트
Ÿ [폭을 100으로 설정] 1번 사용, [2번 반복] 1번 사용, [얼
마만큼 앞으로 이동] 2번 사용, [왼쪽으로 90°돌기] 2번
사용
Ÿ ‘폭’이 설정된 상태에서 변수를 이용해 알고리즘을 완
성한다.
var width;
width = 100;
moveForward(width);
turnLeft(90);
moveForward(width * 2);
turnLeft(90);
}
- 8/18단계 : 입력값이 주어진 변수(변)블록을 변형하여 사용하기
분석 스크립트
Ÿ [변을 4로 설정] 1번 사용, [변수만큼 반복] 1번 사용,
[앞으로 150 이동] 1번 사용, [왼쪽으로 얼마만큼 돌기]
1번 사용
Ÿ 변의 개수가 설정된 상태에서 변수를 여러 가지 블록
에서 활용하여 알고리즘을 완성한다.
var sides;
sides = 4;
for (var count = 0; count < sides; count++) {
moveForward(150);
turnLeft(360 / sides);
}

- 304 -
- 9/18단계 : 변수의 입력값을 수정하기
분석 스크립트
Ÿ [변을 6으로 설정] 1번 사용, [변수만큼 반복] 1번 사
용, [앞으로 150 이동] 1번 사용, [왼쪽으로 얼마만큼
돌기] 1번 사용
Ÿ 변의 개수를 수정하고, 변수를 여러 가지 블록에서 활
용하여 알고리즘을 완성한다.
var sides;
sides = 6;
for (var count = 0; count < sides;
count++) {
moveForward(150);
}
- 10/18단계 : 변수를 사용한 프로그램을 실행시켜 그림을 그린 후 공유하기
분석 스크립트
Ÿ 주어진 블록 프로그램을 실행하면 위와 같은 그림이
그려진다는 것을 보여준다.
※ 그린 그림을 인쇄하거나 페이스북과 트위터에 공유할
수 있도록 구성하였다.
var sides;
sides = 4;
for (var count = 0; count < sides;
count++) {
moveForward(100);
}

- 305 -
- 11/18단계 : 변수의 입력값을 설정하는 블록을 추가하고 변수블록 사용하기
분석 스크립트
Ÿ [변을 3으로 설정] 1번 사용, [변수만큼 반복] 1번
사용, [앞으로 200 이동] 1번 사용, [왼쪽으로 얼
마만큼 돌기] 1번 사용
Ÿ 변의 개수를 직접 설정하고, 변수를 여러 가지
블록에서 활용하여 알고리즘을 완성한다.
var sides;
sides = 3;
moveForward(200);
}
- 12/18단계 : 변수의 입력값을 수정하고 거리이동 블록 수정하기
분석 스크립트
Ÿ [변을 5로 설정] 1번 사용, [변수만큼 반복] 1번
사용, [앞으로 100 이동] 1번 사용, [왼쪽으로 얼
마만큼 돌기] 1번 사용
Ÿ 변의 개수를 수정하고, 알고리즘을 적절하게 수
정하여 문제를 해결할 수 있다.
var sides;
sides = 5;
moveForward(100);
}

- 306 -
- 13/18단계 : 중첩 반복문에 사용된 변수의 입력값을 수정하기
분석 스크립트
Ÿ [변을 4로 설정] 1번 사용, [변수만큼 반복] 2번 사
용, [앞으로 100 이동] 2번 사용, [왼쪽으로 얼마만
큼 돌기] 1번 사용, [오른쪽으로 얼마만큼 돌기] 1
번 사용
Ÿ 작은 사각형 하나를 그리기 위한 변의 개수를 수정
한다.
Ÿ 변수가 포함된 반복문을 중첩하여 사용할 수 있음
을 이해한다.
var sides;
sides = 4;
for (var count2 = 0; count2 < sides; count2++) {
moveForward(100);
}
moveForward(100);
turnRight(360 / sides);
}
- 14/18단계 : 변수가 두 개일 때 변수의 입력값을 수정하거나 추가하기
분석 스크립트
Ÿ [변을 5로 설정] 1번 사용, [길이를 75로 설정] 1번
사용, [변수만큼 반복] 2번 사용, [길이만큼 앞으로
이동] 2번 사용, [왼쪽으로 얼마만큼 돌기] 1번 사
용, [오른쪽으로 얼마만큼 돌기] 1번 사용
Ÿ 변수를 두 개 이상 설정하여 알고리즘을 작성할 수
있다는 것을 이해한다.
var sides;
var length2;
sides = 5;
length2 = 75;
}
}

- 307 -
- 15/18단계 : 한 변수의 값이 다른 변수를 포함할 때 변수의 입력값을 수정하고 변형하기
분석 스크립트
Ÿ [변을 8로 설정] 1번 사용, [길이를 300/‘변’으로
설정] 1번 사용, [‘변’만큼 반복] 2번 사용, [길이
만큼 앞으로 이동] 2번 사용, [왼쪽으로 얼마만큼
돌기] 1번 사용, [오른쪽으로 얼마만큼 돌기] 1번
사용
Ÿ 한 변수를 다른 변수를 포함하여 설정할 수 있다는
것을 이해한다.
var sides;
var length2;
sides = 8;
length2 = 300 / sides;
}
}

- 308 -
- 16/18단계 : 변수가 두 개 포함되어 있는 다중중첩 반복문을 사용한 알고리즘을
작성해 그림을 그리고 공유하기
분석 스크립트
Ÿ 주어진 블록 프로그램을 실행하면 위와 같은 그림
이 그려진다는 것을 보여준다.
var sides;
var length2;
sides = 8;
length2 = 200 / sides;
}
}
}

- 309 -
- 17/18단계 : 변수가 두 개 포함되어 있는 다중중첩 반복문을 사용한 알고리즘 작성하기
분석 스크립트
Ÿ 제시된 그림을 재현하기 위해 어떻게 프로그램을
작성해야 하는지 탐구한다.
Ÿ 시도와 오류를 두려워하지 않고 여러 번 프로그램
을 작성해보며 문제를 해결한다.
Ÿ 정해진 블록의 개수가 없기 때문에 자유롭게 알고
리즘을 작성하고 구현할 수 있다.
Ÿ 제시된 그림을 겹치는 부분을 포함하여 같은 구조
의 네 부분으로 나눈 다음, 그 부분을 작은 사각형
4개로 나누어 알고리즘을 작성한 후 하나씩 거리
와 회전 각도에 유의하여 프로그램을 완성해간다.
var sides;
var length2;
sides = 4;
length2 = 50;
}
jumpForward(length2 / 2);
}
}
- 18/18단계 : 자유 시간
분석
Ÿ 지금까지의 단계들에서 배운 내용들을 활용하여 자신이 원하는 그림을 그릴 수 있다.

- 310 -
7. 스테이지7: 플레이 랩, 변수
◦ 활동
- 1/8단계 : 제시된 프로그램을 실행해보며 알고리즘과 조작법 이해하기
분석
Ÿ 프로그램을 실행하고 방향키를 움직이며 조작해보며 플레이 랩의 사용법과 알고리즘을 이해한다.
Ÿ 프로그램을 실행하면 화면에 점수가 생기는 것을 확인하고, 조작을 마쳤으면 ‘마침’버튼을 누
른다.
◦ 동영상
Ÿ 알고리즘의 개념과 특성을 이해한다.
Ÿ 변수는 특정 상황마다 다른 값들을 호출하여 입력한다는 것을
파악한다.
Ÿ 플레이 랩에서는 알고리즘을 작성하거나 수정할 필요 없이, 각
각의 변수들을 변화시켜보며 변수 자체의 기능과 특성을 파악
해본다.
Ÿ 스마트폰의 화면의 크기를 늘이거나 줄이는 기능도 변수를 이
용해 구현할 수 있다는 것을 보여준다.

- 311 -
- 2/8단계 : 두 캐릭터의 속도를 동일하게 변경하기
실행 전 변수 변경 전 변수 변경 후
분석
Ÿ 게임의 공정성을 위해 강아지의 속도와 고양이의 속도를 동일하게 변경할 수 있다.
Ÿ 프로그램을 실행하여 강아지와 고양이 중 먼저 10점을 올리는 캐릭터가 이기는 게임을 할 수 있
다.
Ÿ 이 때, 사용자가 조작하는 캐릭터는 강아지라는 것에 유의한다.
- 3/8단계 : 제시된 프로그램을 실행해보며 알고리즘과 조작법 이해하기
분석
Ÿ 제시된 프로그램을 실행시켜 방향키로 조작해보며 알고리즘을 이해한다.

- 312 -
- 4/8단계 : 캐릭터가 이동하는 높이 변수의 입력값 수정하기
분석
Ÿ 높이를 100에서 200으로 변경하여 캐릭터가 200의 높이까지 도달할 수 있도록 한다.
- 5/8단계 : 초기 점수가 설정된 프로그램을 실행해보며 알고리즘 이해하기
분석
Ÿ 제시된 프로그램을 실행시켜 화면에 점수가 나오는지 확인한다.

- 313 -
- 6/8단계 : 변수를 사용해 점수를 설정하는 알고리즘 작성하기
분석
Ÿ 제시된 프로그램을 실행시켜 화면에 입력한 점수가 나오는지 확인한다.
- 7/8단계 : 점수 변수를 사용하여 점수가 누적되도록 만들기
분석
Ÿ 점수의 초기값을 0으로 지정한 후, 강아지가 발사한 하트에 고양이가 닿을 때마다 점수가 +1씩
올라가도록 변수를 설정한다.
Ÿ 점수가 10점이 되면 게임이 끝나도록 만들어야 하나, 알고리즘 상에는 나타나 있지 않다.

- 314 -
- 8/8단계 : 자유롭게 게임 만들기
이벤트(Events) 행동(Actions) 반복문(Loops)
논리문(Logic) 수학문(Math) 변수(Variables)
분석
Ÿ 여러 가지 종류의 블록들을 활용하여 자신이 원하는 게임을 만들 수 있다.

- 315 -
8. 스테이지8: 재미있는 반복
◦ 개요 : 반복문(루프)을 통해 계속적으로 반복되는 것들을 효율적으로
처리할 수 있음을 알고, 다른 알고리즘 구조 내에 반복문을 포함시켜
작성할 수 있다.
◦ 학습 목표
- 초기값과 완료값, 그리고 그 사이의 간격을 결정하여 ‘For’ 반복문
을 생성할 수 있다.
- 프로그램이 실시되는 동안 ‘For’ 반복문에서 매번 반대값을 구할
수 있다.
◦ 활동
- 1/1단계 : 언플러그드 활동(For 반복문의 초기값, 완료값, 사이값 설명하기)
Ÿ 초기값과 완료값 사이를 등급으로 나누
어 등급 간의 간격을 몇으로 설정할지
정하는 과정을 이해한다.
Ÿ 학생들이 주사위를 세 번 던져 초기값,
완료값, 간격을 결정한 후 그 사이값(초
기값과 완료값 포함)들을 모두 더하여
점수를 내는 게임을 한다.
Ÿ ‘For’반복문을 사용하는 작업들이 매
우 많다는 것을 인지한다.
주요 개념
‘For’반복문 : 구체적인 초기값과 완료값, 그리고 그 사이의 증가되는 간격이 있는 반복문

- 316 -
9. 스테이지9: 꿀벌, 반복
◦ 활동
- 1/10단계 : 반복문을 사용하여 앞으로 이동하며 꽃꿀 얻기
분석 스크립트
얻기] 1번 사용
Ÿ 반복문을 사용하여 문제를 해결한다.
moveForward();
getNectar();
}

- 317 -
- 2/10단계 : 꽃꿀을 다섯 번 얻는 반복문 추가하기
분석 스크립트
Ÿ [앞으로 이동] 5번 사용, [꽃꿀 얻기] 6번 사용, [3번 반복] 1
번 사용, [4번 반복] 1번 사용, [5번 반복] 1번 사용
Ÿ 사용되는 블록의 개수가 적을수록 효율적으로 알고리즘을 작
성하는 것이라고 할 때, 같은 행동을 3번 이상 반복할 때 반
복문(루프)를 사용하는 것이 알고리즘 작성의 효율성을 돕는
다는 것을 이해한다.
moveForward();
getNectar();
moveForward();
getNectar();
getNectar();
moveForward();
getNectar();
}
moveForward();
for (var count2 = 0; count2 < 4; count2++)
{
getNectar();
}
moveForward();
for (var count3 = 0; count3 < 5; count3++)
{
getNectar();
}
◦ 동영상
Ÿ 명령을 반복해야 될 횟수를 모르는 상황 등에서 For 루프 사
용의 필요성을 인식한다.
Ÿ For 반복문의 변수에 어떤 요소들이 있으며 어떻게 작성되어
있는지 보여준다.
Ÿ 실제 For 반복문에서는 세 요소들이 어떻게 포함되어있는지
보여준다.
Ÿ 실제로 For 반복문을 사용하는 것의 장점과 효율성에 대해 설
명한다.
Ÿ counter라는 변수가 이 반복문에서 어떤 기능을 하는지 보여
준다.
Ÿ 변수를 어떻게 변화하도록 설정할 수 있는지 구체적으로 설명
한다.

- 318 -
- 3/10단계 : For 반복문이 사용된 알고리즘을 실행해보기
분석 스크립트
Ÿ 따로 블록을 수정하거나 추가할 필요 없이 실행해
본다.
Ÿ 제시된 프로그램을 실행시켜보며 For 반복문에 대
해 이해한다.
Ÿ 먼저 변수에 대해 설정한 후 그 변수를 포함한 반
복문을 작성한다는 것을 알게 한다.
var counter;
for (counter = 1; counter <= 5; counter++) {
moveForward();
for (var count = 0; count < counter; count++) {
getNectar();
}
}
- 4/10단계 : For 반복문의 완료값을 5로 설정하기
분석 스크립트
Ÿ 변수의 완료값을 5로 설정한다.
Ÿ 변수의 설정 요소들에 대해 이해한다.
var counter;
moveForward();
getNectar();
}
}

- 319 -
- 5/10단계 : For 반복문의 완료값을 6으로 설정하기
분석 스크립트
Ÿ 변수의 완료값을 6으로 설정한다.
var counter;
moveForward();
getNectar();
}
}
- 6/10단계 : For 반복문의 초기값과 완료값을 설정하고 사이값 수정하기
분석 스크립트
Ÿ 변수를 5부터 1까지 1씩 감소하도록 설정한
다.(‘1씩 빼면서’를 설정할 수가 없어 ‘-1씩
더하면서’라고 설정할 수밖에 없다.)
var counter;
for (counter = 5; counter >= 1; counter--) {
moveForward();
getNectar();
}
}

- 320 -
- 7/10단계 : For 반복문의 사이값을 2로 설정하기
분석 스크립트
Ÿ 꽃의 수가 몇 씩 증가하는지 확인하여 변수를 설
정한다.
var counter;
for (counter = 1; counter <= 7; counter += 2) {
moveForward();
getNectar();
}
}
- 8/10단계 : For 반복문의 사이값을 3으로 설정하고 변수를 사용해 알고리즘 완성하기
분석 스크립트
Ÿ 꽃의 수가 몇 씩 증가하는지 확인하여 변수를 설
정한다.
Ÿ For 반복문을 여러 블록들을 사용하여 직접 작성
해볼 수 있다.
var counter;
moveForward();
getNectar();
}
}

- 321 -
- 9/10단계 : For 반복문의 값들을 설정하고 변수를 사용해 알고리즘 완성하기
분석 스크립트
Ÿ 변수의 초기값과 완료값, 그리고 사이 간격값을
파악하여 설정한다.
Ÿ For 반복문을 여러 블록들을 사용하여 직접 작성
해볼 수 있다.
var counter;
moveForward();
getNectar();
}
}
- 10/10단계 : For 반복문과 변수를 사용하여 알고리즘 작성하기
분석 스크립트
Ÿ 변수의 초기값과 완료값, 그리고 사이 간격값을
파악하여 설정한다.(‘3씩 빼면서’를 설정할 수
가 없어 ‘-3씩 더하면서’라고 설정할 수밖에 없
다.)
Ÿ For 반복문을 처음부터 직접 작성해볼 수 있다.
Ÿ 행동문(Actions)과 반복문(Loops)로 나뉘어 블록들
이 들어가 있다.
※ 알고리즘을 올바르게 작성하여도 오류가 뜬다.
var counter;
for (counter = 9; counter >= 3; counter -= 3) {
moveForward();
getNectar();
}
}

- 322 -
10. 스테이지10: 예술가, 반복
◦ 개요 : 비슷한 모양이 반복되거나 일정 규칙으로 확장해가는 그림을
그리기 위해 변수를 활용한 For 반복문으로 알고리즘을 작성한다.
◦ 학습 목표
- 처음에는 제시된 알고리즘을 실행시켜보며 For 반복문에 대해 이해
한 후, 점차 직접 변수를 활용한 For 반복문으로 알고리즘을 작성할
수 있다.
- 제시된 그림에서 일정한 규칙을 찾아 이를 알고리즘 작성에 적용할
수 있다.
◦ 활동
- 1/12단계 : 반복문을 사용한 알고리즘을 작성하여 정삼각형 그리기
분석 스크립트
Ÿ [3번 반복] 1번 사용, [앞으로 50 이동] 1번 사용, [왼
Ÿ 반복문과 다른 명령 블록들을 사용하여 문제를 해결
한다.
moveForward(50);
turnLeft(120);
}

- 323 -
- 2/12단계 : For 반복문이 사용된 알고리즘을 실행해보며 이해하기
분석 스크립트
Ÿ 화면의 그림을 그리기 위해서 제시된 알고리즘
과 같이 작성할 수 있음을 보여준다.
Ÿ 프로그램을 실행시켜보며 제시된 알고리즘에 대
해 이해한다.
var counter;
moveForward(counter);
turnLeft(120);
}
}
- 3/12단계 : For 반복문의 값들을 수정하기
분석 스크립트
Ÿ [counter를 20부터 200까지 20씩 증가] 1번 사용,
[3번 반복] 1번 사용, [앞으로 counter만큼 이동]
1번 사용, [왼쪽으로 120°돌기] 1번 사용
Ÿ 화면 그림의 가장 작은 삼각형의 한 변의 길이
가 20이라는 힌트를 고려하여 counter 변수의 설
정을 수정한다.
Ÿ For 반복문의 변수를 다양하게 활용하여 문제를
해결할 수 있음을 인지한다.
var counter;
turnLeft(120);
}
}

- 324 -
- 4/12단계 : For 반복문으로 설정된 변수블록을 사용하기
분석 스크립트
[4번 반복] 1번 사용, [앞으로 counter만큼 이동]
1번 사용, [왼쪽으로 90°돌기] 1번 사용
Ÿ counter 변수의 설정이 올바르게 되어있는지 확
인한다.
Ÿ 행동(Actions), 수학(Maths), 반복문(Loops) 중에서
변수 블록을 찾아 올바른 위치에 넣을 수 있다.
var counter;
turnLeft(90);
}
}
- 5/12단계 : For 반복문으로 설정된 변수블록을 사용하기
분석 스크립트
Ÿ [counter를 1부터 10까지 1씩 증가] 1번 사용, [60번
반복] 1번 사용, [앞으로 counter만큼 이동] 1번 사용,
Ÿ counter 변수의 설정이 올바르게 되어있는지 확인한
다.
Ÿ 행동(Actions), 반복문(Loops) 중에서 변수 블록을 찾아
올바른 위치에 넣을 수 있다.
var counter;
turnRight(6);
}
}

- 325 -
- 6/12단계 : For 반복문 안에 반복문을 추가하여 알고리즘 완성하기
분석 스크립트
[앞으로 counter만큼 이동] 1번 사용, [오른쪽으
Ÿ 오른쪽으로 120°씩 돌면서 변의 길이가 20씩
증가한다는 힌트를 고려하여 정삼각형들이 겹겹
이 싸져있는 모양이 아니라 미로처럼 각 변마다
길이가 증가하는 모양이라는 것을 인식한다.
Ÿ 반복문을 사용하지 않고 변수를 활용한 For 반
복문으로 알고리즘을 작성해야한다는 것을 이해
한다.
var counter;
turnRight(120);
}
- 7/12단계 : For 반복문으로 값이 설정된 변수를 사용하고 회전각도 설정하기
분석 스크립트
[앞으로 counter만큼 이동] 1번 사용, [오른쪽으
Ÿ 오른쪽으로 90°씩 돌면서 변의 길이가 10씩 증
가한다는 힌트를 고려하여 정사각형들이 겹겹이
싸져있는 모양이 아니라 미로처럼 각 변마다 길
이가 증가하는 모양이라는 것을 인식한다.
Ÿ 변수를 활용한 For 반복문으로 알고리즘을 작성
한다.
var counter;
turnRight(90);
}

- 326 -
- 8/12단계 : For 반복문에서 변수의 값들을 설정하기
분석 스크립트
Ÿ [counter를 1부터 75까지 1씩 증가] 1번 사용, [앞
으로 counter만큼 이동] 1번 사용, [오른쪽으로
Ÿ 1부터 75까지 이동한다는 힌트를 고려하여 알고
리즘을 한 번 작성해본 후 프로그램을 실행시켜
보며 문제를 해결한다.
Ÿ 변수를 활용한 For 반복문으로 알고리즘을 작성
한다.
var counter;
turnRight(25);
}
- 9/12단계 : For 반복문으로 값이 설정된 변수블록을 사용하고 각도회전 블록 추가하기
분석 스크립트
Ÿ [counter를 10부터 200까지 10씩 증가] 1번
사용, [앞으로 counter만큼 이동] 1번 사용,
Ÿ 89°씩 회전해보라는 힌트를 고려하여 알
고리즘을 한 번 작성해본 후 프로그램을
실행시켜보며 문제를 해결한다.
Ÿ 일부 주어진 For 반복문을 완성시켜 알고
리즘을 작성한다.
var counter;
turnRight(89);
}

- 327 -
- 10/12단계 : 변수를 사용하고 그 값들을 For 반복문에서 설정하기
분석 스크립트
[counter번 반복] 1번 사용, [앞으로 100 이동] 1번
사용, [오른쪽으로 360-counter°돌기] 1번 사용
Ÿ 정삼각형부터 정사각형... 정십각형까지 같은 길이
의 변을 공유하는 도형들을 그려가는 알고리즘을
작성하기 위해 변수 counter을 어떻게 설정해야할
지 생각한다.
Ÿ 반복하는 횟수와 회전 각도 등 다양한 블록에 변
수를 넣어 문제를 해결할 수 있음을 인식한다.
Ÿ 완성된 프로그램을 실행시키면 그려진 그림과 함
께 페이스북이나 트위터에 공유할 수 있도록 구성
하였다.
var counter;
moveForward(100);
turnRight(360 / counter);
}
}
- 11/12단계 : For 반복문과 변수를 사용하여 알고리즘 완성하기
분석 스크립트
[counter번 반복] 1번 사용, [앞으로 10*counter만
큼 이동] 1번 사용, [오른쪽으로 360/counter°돌
기] 1번 사용
Ÿ 정삼각형부터 정오각형... 정구각형까지의 도형들
을 그려가는 알고리즘을 작성하기 위해 변수
counter을 어떻게 설정해야할지 생각한다.
Ÿ 다양한 블록에 변수를 넣어 문제를 해결할 수 있
음을 인식한다.
Ÿ 완성된 프로그램을 실행시키면 그려진 그림과 함
께 페이스북이나 트위터에 공유할 수 있도록 구성
하였다.
var counter;
moveForward(10 * counter);
turnRight(360 / counter);
}
}

- 328 -
- 12/12단계 : For 반복문과 변수를 사용하여 알고리즘 작성하기
분석 스크립트
[counter-1번 반복] 1번 사용, [앞으로 40 이동]
1번 사용, [오른쪽으로 360/counter°돌기] 1번
사용
Ÿ n번째 도형과 n+1번째 도형이 한 변을 공유하
고 있다는 것을 인식하여 counter-1번 반복하
더라도 다음번 실행 시 그 변을 그릴 수 있다
는 것을 이해한다.
Ÿ 완성된 프로그램을 실행시키면 그려진 그림과
함께 페이스북이나 트위터에 공유할 수 있도록
구성하였다.
var counter;
var repeat_end = counter - 1;
for (var count = 0; count < repeat_end; count++) {
moveForward(40);
turnLeft(360 / counter);
}
}

- 329 -
11. 스테이지11: 플레이 랩, 반복
◦ 개요 : For 반복문을 사용하여 숫자를 세는 프로그램을 작성하고, 최
종적으로 자신이 원하는 게임을 만들 때 For 반복문을 사용할 수 있
다.
◦ 학습 목표
- 플레이 랩 프로그램을 실행시키기 위한 반복 블록 사용 능력을 쉬운
단계부터 점진적으로 높인다.
◦ 활동
- 1/6단계 : For 반복문으로 값이 설정된 변수블록 사용하기
분석
Ÿ [counter를 1부터 100까지 1씩 증가] 1번 사용, [캐릭터가 counter에 대해 0.1초 기다리며 말하기]
1번 사용
Ÿ 제시된 알고리즘에 설정된 counter라는 변수를 넣어 알고리즘을 완성한다.
- 2/6단계 : For 반복문의 사이값을 설정하고 변수가 포함된 블록 추가하기
분석
Ÿ [counter를 10부터 1000까지 10씩 증가] 1번 사용, [캐릭터가 counter에 대해 0.1초 기다리며 말하
기] 1번 사용
Ÿ 제시된 알고리즘에 명령 블록을 넣어 알고리즘을 완성한다.

- 330 -
- 3/6단계 : For 반복문과 변수를 사용해 10부터 10씩 더해가며 말하게 만들기
분석
Ÿ [counter를 10부터 1000까지 10씩 증가] 1번 사용, [캐릭터가 counter에 대해 0.1초 기다리며 말하
기] 1번 사용
Ÿ 전 단계들보다 큰 수들을 세기 위한 프로그램을 만들 수 있다.
Ÿ 행동(Actions) 블록과 반복문(Loops) 블록에서 원하는 블록을 찾아 알고리즘을 작성할 수 있다.
- 4/6단계 : 변수블록을 변경하여 1부터 10까지 제곱수를 말하게 만들기
분석
Ÿ [counter를 1부터 10까지 1씩 증가] 1번 사용, [캐릭터가 counter∧2에 대해 0.1초 기다리며 말하
기] 1번 사용
Ÿ counter 변수의 설정을 변화시키지 않고 1, 4, 9, 16 등 제곱수를 세기 위한 알고리즘을 작성할
수 있다.
Ÿ 행동(Actions) 블록, 반복문(Loops) 블록, 수학(Maths) 블록에서 원하는 블록을 찾아 알고리즘을 작
성할 수 있다.

- 331 -
- 5/6단계 : 변수블록을 수정하여 1부터 10까지 세제곱수를 말하게 만들기
분석
Ÿ [counter를 1부터 10까지 1씩 증가] 1번 사용, [캐릭터가 counter∧3에 대해 0.1초 기다리며 말하
기] 1번 사용
Ÿ counter 변수의 설정을 변화시키지 않고 1, 8, 27, 64 등 제곱수를 세기 위해 알고리즘을 수정할
수 있다.
- 6/6단계 : 자유 시간
행동(Actions) 반복문(Loops)
수학문(Math) 변수(Variables) 논리문(Logic)
분석

- 332 -
12. 스테이지12: 예술가, 함수
◦ 활동
- 1/15단계 : 반복문을 사용하여 정사각형 만들기
분석 스크립트
Ÿ 반복문을 사용하여 문제를 해결한다.
moveForward(100);
turnLeft(90);
}
- 2/15단계 : 중첩 반복문을 사용하여 정사각형 세 개 만들기
분석 스크립트
Ÿ [3번 반복] 1번 사용, [4번 반복] 1번 사용, [앞으
로 100 이동] 1번 사용, [왼쪽으로 90°돌기] 1번
사용, [앞으로 120 점프] 1번 사용
Ÿ 반복문을 중첩하여 사용해 문제를 해결한다.
Ÿ 지금까지 배운 알고리즘 블록들을 활용하여 최대
한 효율적으로 알고리즘을 작성해본다.
moveForward(100);
turnLeft(90);
}
jumpForward(120);
}

- 333 -
- 3/15단계 : 함수문을 사용하여 정사각형 그리기
실행 전 함수 알고리즘 함수문의 설정
분석 스크립트
Ÿ 처음으로 함수문을 도입한다.
Ÿ 함수문을 실행시켜보며 함수문이 어떤 기능을 하는지
파악한다.
moveForward(100);
turnLeft(90);
}
}
draw_a_square();
- 4/15단계 : 프로그램을 실행해보며 설정되어있는 함수문을 이해하기
분석 스크립트
Ÿ 함수문의 ‘수정하기’를 눌러 함수문이 어떤 기능을
하는지 파악한다.
Ÿ 반복되는 블록들을 함수로 지정하여 묶으면 알고리즘
을 더욱 단순화시킬 수 있다는 것을 이해한다.
moveForward(100);
turnLeft(90);
}
}
draw_a_square();
turnRight(120);
}

- 334 -
◦ 동영상
Ÿ 컴퓨터가 실행할 행동을 함수문으로 코딩하는 것의 개념과 효
율성에 대해 설명하고 이를 프로그래밍 언어에 적용할 수 있
음을 알게 한다.
Ÿ 함수문의 기능을 지정하고 다시 함수문을 호출해 사용하는 과
정에 대해 이해시킨다.
Ÿ 전 단계들에서 사용한 ‘사각형 그리기’라는 함수문을 예로
들어 함수문을 사용하는 모습을 보여준다.
Ÿ ‘사각형 그리기’라는 블록을 예로 들어 ‘수정하기’를 통
해 함수문을 지정하거나 수정할 수 있음을 이해시킨다.
Ÿ ‘수정하기’는 함수문의 이름과 기능, 그리고 블록들을 드래
그 앤 드롭으로 지정할 수 있는 작업공간으로 구성되어있음을
보여준다.
- 5/15단계 : 정사각형을 그리는 함수문 수정하기에서 함수의 기능 작성하기
분석 스크립트
Ÿ 함수문의 ‘수정하기’에서 함수의 기능을 작성하
여 저장한 후 닫기를 누른다.
Ÿ 함수문의 기본적인 구성과 그 기능을 이해한다.
moveForward(100);
turnLeft(90);
}
}
draw_a_square();

- 335 -
- 6/15단계 : 정사각형 세 개를 그리는 프로그램의 함수문 설정기능 작성하기
분석 스크립트
Ÿ 2단계의 문제를 이번에는 함수문을 이용하여 알고리
즘을 작성한다.
Ÿ 함수문의 설정을 확인한 후 ‘사각형 그리기’라는
블록을 실행하면 프로그램이 어떻게 실행될지 생각해
본다.
moveForward(100);
turnLeft(90);
}
}
draw_a_square();
jumpForward(120);
}
- 7/15단계 : 제시된 정사각형의 한 변의 길이를 고려해 함수문 알고리즘 수정하기
분석 스크립트
Ÿ 사각형의 한 변의 길이가 200이라는 것을 고려하여 함
수문의 설정을 수정한다.
moveForward(200);
turnLeft(90);
}
}
draw_a_square();

- 336 -
- 8/15단계 : 함수문 알고리즘의 반복횟수 수정하기
분석 스크립트
Ÿ 삼각형을 그리기 위해서 함수문의 설정을 3번 반복으
로 입력한다.
function draw_a_triangle() {
moveForward(100);
turnLeft(120);
}
}
draw_a_triangle();
- 9/15단계 : 설정되어있는 삼각형 함수문과 사각형 함수문을 사용하여 프로그램 작성하기
분석 스크립트
Ÿ 화면의 그림이 정삼각형과 정사각형으로 이루어져있
다는 것을 인식한다.
Ÿ 제시된 정삼각형을 그리기 위한 함수문과 정사각형
을 그리기 위한 함수문의 설정을 확인한 후 이를 어
떻게 사용할지 생각한다.
Ÿ 삼각형을 그린 후 사각형을 그리기 위한 방향으로
회전하기 위해 어떤 블록을 사용해야할지 생각한다.
moveForward(100);
turnLeft(120);
}
}
moveForward(100);
turnLeft(90);
}
}
draw_a_triangle();
turnRight(90);
draw_a_square();

- 337 -
- 10/15단계 : 사각형을 그리는 함수문 알고리즘을 작성하기
분석 스크립트
Ÿ 사각형을 그리기 위해 함수문 설정의 작업공간에서 필
요한 블록들을 드래그 앤 드롭으로 가져와 함수문의
알고리즘을 작성한다.
Ÿ 사각형의 한 변의 길이가 40이라는 힌트를 고려한다.
moveForward(40);
turnLeft(90);
}
}
draw_a_square();
- 11/15단계 : 프로그램을 실행해보며 중첩 반복문이 사용된 함수문 이해하기
분석 스크립트
Ÿ 제시된 함수문의 설정이 화면의 그림을 그리기 위한
올바른 알고리즘인지 확인한다.
Ÿ 프로그램을 실행시켜보며 함수문의 알고리즘을 어떻
게 작성하였는지 이해한다.
function draw_a_line_of__squares() {
moveForward(40);
turnLeft(90);
}
moveForward(40);
}
}
draw_a_line_of__squares();

- 338 -
- 12/15단계 : 함수문의 설정을 확인하여 회전하며 함수문을 그리는 프로그램 작성하기
분석 스크립트
Ÿ 전 단계에서 사용한 함수문 알고리즘을 반복하
여 문제를 해결한다.
Ÿ 함수문이 한 번 실행된 후 어느 방향으로 얼마
나 회전해야 문제를 해결할 수 있는지 생각한
다.
function draw_a_line_of_squares() {
moveForward(40);
turnLeft(90);
}
moveForward(40);
}
}
draw_a_line_of_squares();
turnLeft(90);
}

- 339 -
- 13/15단계 : 이동거리와 회전각도를 고려해 설정된 함수문으로 프로그램 작성하기
분석 스크립트
Ÿ 전 단계들에서 사용한 함수문 알고리즘을 반복
하여 문제를 해결한다.
Ÿ 함수문이 한 번 실행된 후 어떻게 이동하여야
문제를 해결할 수 있는지 생각한다.
Ÿ 이동거리와 회전각도에 대한 주어진 힌트를 고
려하여 알고리즘을 작성한다.
function draw_a_square_line() {
moveForward(40);
turnLeft(90);
}
moveForward(40);
}
}
draw_a_square_line();
moveForward(60);
turnLeft(144);
}

- 340 -
- 14/15단계 : 함수문 알고리즘의 반복횟수를 수정하고 프로그램 작성하기
분석 스크립트
Ÿ 전 단계들에서 사용한 함수문 알고리즘을 반복하여
문제를 해결한다.
Ÿ 함수문의 설정을 6번 반복에서 3번 반복으로 수정한
다.
Ÿ 함수문을 한 번 실행했을 때의 끝 지점이 다음 함수
문 실행의 시작 지점과 동일하다는 점을 인식하여
회전 각도를 계산한다.
function draw_a_square_line() {
moveForward(40);
turnLeft(90);
}
moveForward(40);
}
}
draw_a_square_line();
turnLeft(60);
}
- 15/15단계 : 자유 시간
행동(Actions) 색깔(Color)
반복문(Loops) 수학문(Math) 기능문(Functions)
분석
Ÿ 여러 가지 종류의 블록들을 활용하여 자신이 원하는 그림을 그릴 수 있다.

- 341 -
13. 스테이지13: 매개변수를 사용한 노래 만들기
◦ 개요 : 학생들이 직관적으로 왜 코드들을 함수문으로 만드는 것이 효
율적인지 그 이유를 이해하고 이를 계속적으로 연습한다.
◦ 학습 목표
- 노래 가사에서 일정하게 반복되는 부분을 찾아본다.
- 후렴 등 노래의 반복되는 부분들을 확인하여 함수문으로 만들어본다.
- 함수문을 수정하여 매개변수를 수용한다.
- 함수문과 매개변수가 프로그램 작성을 쉽게 만드는 방법을 설명한다.
◦ 활동
- 1/1단계 : 언플러그드 활동(노래가사 중 코러스를 매개변수에 비유하여 설명)
Ÿ 기본적인 구조는 동일하되 약간의 차이
가 발생하며 반복되는 작업에서 매개변
수를 사용하여 프로그램을 간단히 만들
수 있다는 개념을 노래 만들기와 아이
스크림 만들기를 통해 설명한다.
Ÿ 노래 가사가 A-Ch(Chorus)-B-Ch-C-Ch..
와 같이 진행될 때 후렴의 개념을 컴퓨
터 프로그램에 적용시켜 매개변수를 설
명할 수 있다.
Ÿ 반복되는 규칙성을 파악하고, 변화하는
부분이 있다면 차이점을 인식할 수 있
어야 한다.
주요 개념
함수문 : 계속해서 호출할 수 있는 코드의 일부
매개변수 : 함수문에 전달하여 특정 요구에 맞게 변화하는 정보의 일부

- 342 -
14. 스테이지14: 예술가, 매개변수를 사용하는 함수
◦ 활동
- 1/17단계 : 함수문을 사용하여 정사각형 그리기
분석 스크립트
Ÿ 한 변의 길이가 50인 정사각형을 그리기 위한 함
수문 알고리즘을 작성한다.
function Draw_a_square() {
moveForward(50);
turnLeft(90);
}
}
Draw_a_square();
◦ 동영상
Ÿ 함수문을 직접 생성하는 방법을 배운다.
Ÿ ‘함수문 생성하기’블록은 함수문의 이름, 기능, 그리고 다른
블록들로 함수문의 기능을 지정할 수 있는 작업공간으로 이루
어져있다는 것을 보여준다.
Ÿ 함수문 블록의 작업공간에서 드래그 앤 드롭으로 프로그램을
실행했을 때 실행할 명령 블록들을 지정하는 모습을 보여준다.
Ÿ 함수문 생성을 완료하면 함수문(Functions) 칸에 생성된 함수
문이 초록색 블록으로 생긴 것을 볼 수 있다.

- 343 -
- 2/17단계 : 정삼각형을 그리는 함수문 알고리즘 작성하기
분석 스크립트
Ÿ ‘함수문 생성하기’에서 한 변의 길이가 50인 정삼각
형을 그리기 위한 블록 알고리즘을 작성한 후 생성된
함수문으로 실행할 프로그램을 만든다.
f u n c t i o n
_EC_82_BC_EA_B0_81_ED_98_95__EA_B7_B8
_EB_A6_AC_EA_B8_B0() {
moveForward(50);
turnLeft(120);
}
}
_EC_82_BC_EA_B0_81_ED_98_95__EA_B7_B8
_EB_A6_AC_EA_B8_B0();
- 3/17단계 : 설정되어있는 삼각형 그리기 함수문을 사용해 프로그램 작성하기
분석 스크립트
Ÿ 생성되어있는 ‘삼각형 그리기’함수문의 설정을 확
인한 후 이를 사용하여 문제를 해결하기 위한 프로그
램을 작성한다.
moveForward(50);
turnLeft(120);
}
}
draw_a_triangle();
jumpForward(100);
}

- 344 -
- 4/17단계 : 힌트를 보고 길이 매개변수의 입력값을 각각 설정하기
분석 스크립트
Ÿ 삼각형 세 개가 각 변의 길이만 다를 뿐 모양은 같
다는 점에 주목한다.
Ÿ length라는 매개변수를 사용하여 차이점인 각 변의
길이를 표현할 수 있다는 것을 이해한다.
Ÿ 그 각 변의 길이는 프로그램의 매개변수 옆에 각각
입력하여 설정할 수 있다.
var length2;
function draw_a_triangle_with_length(length2) {
turnLeft(120);
}
}
draw_a_triangle_with_length(150);
jumpForward(175);
jumpForward(100);
- 5/17단계 : 힌트를 보고 길이 매개변수의 입력값을 설정하기
분석 스크립트
Ÿ 오각형을 그리기 위한 함수문 알고리즘에서 length라는
매개변수가 무엇을 의미하는지 이해한다.
Ÿ 오각형의 한 변의 길이가 100이므로 매개변수 length가
100이 되어야함을 인식한다.
var length2;
function draw_a_pentagon(length2) {
turnLeft(72);
}
}
draw_a_pentagon(100);

- 345 -
- 6/17단계 : 힌트를 보고 길이 매개변수의 입력값을 설정하기
분석 스크립트
Ÿ 삼각형, 사각형, 육각형을 그리기 위한 함수문 알고
리즘의 설정을 확인한 후 반복되는 점과 차이점을
파악한다.
Ÿ 세 함수문에서 매개변수 length의 역할을 이해한다.
Ÿ 삼각형, 사각형, 육각형에서 각각 length의 길이가
얼마가 되어야 하는지 계산한다.
var length2;
function draw_a_triangle(length2) {
turnLeft(360 / 3);
}
}
function draw_a_square(length2) {
turnLeft(360 / 4);
}
}

- 346 -
- 7/17단계 : 매개변수의 입력값을 설정하여 4단계와 반대로 점점 커지는 삼각형 그리기
분석 스크립트
Ÿ 삼각형 세 개가 각 변의 길이만 다를 뿐 모양은 같다
는 점에 주목한다.
Ÿ length라는 매개변수를 사용하여 차이점인 각 변의 길
이를 표현할 수 있다는 것을 이해한다.
Ÿ 그 각 변의 길이는 프로그램의 매개변수 옆에 각각 입
력하여 설정한다.
var length2;
function draw_a_triangle(length2) {
turnLeft(120);
}
}
draw_a_triangle(25);
jumpForward(50);
jumpForward(75);
- 8/17단계 : 7단계를 For 반복문의 변수를 사용하여 표현하기
분석 스크립트
Ÿ 삼각형 세 개가 각 변의 길이만 다를 뿐 모양은
같다는 점에 주목한다.
Ÿ For 반복문과 함수문을 사용하여 프로그램을 작
성할 수 있다.
Ÿ 삼각형의 각 변의 길이가 25, 50, 75로 증가한다
는 점을 인식하여 매개변수 length를 통해 변화
하는 길이를 표현한다.
Ÿ 변수 counter와 매개변수 length의 차이를 이해
한다.
var length2;
var counter;
function draw_a_triangle_with_length(length2) {
turnLeft(120);
}
}
draw_a_triangle_with_length(counter);
jumpForward(100);
}

- 347 -
◦ 동영상
Ÿ 비슷한 알고리즘이 내부의 값만 변화하며 반복될 때 매개변수
를 사용하여 편리하게 작업할 수 있다는 것을 설명한다.
Ÿ 매개변수가 함수문에서 사용할 수 있도록 직접 값을 전달하는
역할을 한다는 것을 이해한다.
Ÿ 예를 들어 모양은 일정하되 크기만 바뀌며 반복되는 도형을
그릴 때 매개변수를 활용한 함수문으로 알고리즘을 작성할 수
있음을 보여준다.
Ÿ 함수문 알고리즘 작업 시 ‘매개변수 추가’를 통해 필요한
매개변수를 호출할 수 있음을 보여준다.
Ÿ 어떤 상황에서 어떤 매개변수가 필요한지 인지한다.
Ÿ 매개변수에 값을 입력하는 방법을 알 수 있다.
- 9/17단계 : 매개변수 블록을 사용하고 For 반복문으로 사각형 3개 그리기
분석 스크립트
Ÿ 먼저 주어진 함수문의 설정에서 매개변수 length
를 추가하여 세 사각형를 길이만 변화시켜가며
그릴 수 있다.
Ÿ 변수 counter가 포함된 For 반복문으로 함수문을
반복할 수 있음을 이해한다.
Ÿ 변수 counter와 매개변수 length의 차이점을 안
다.
var length2;
var counter;
function draw_a_square(length2) {
turnLeft(90);
}
}
draw_a_square(counter);
jumpForward(100);
}

- 348 -
- 10/17단계 : 매개변수를 사용하여 함수문 알고리즘 작성하기
분석 스크립트
Ÿ 매개변수와 함수문을 호출하여 육각형을 그릴 수 있다.
Ÿ 수학문(Math)에서 매개변수의 값을 입력할 수 있는 블
록을 가져와 함수 알고리즘을 작성한다.
var length2;
function draw_a_hexagon(length2) {
turnLeft(60);
}
}
draw_a_hexagon(100);
- 11/17단계 : 매개변수(변)의 입력값을 설정하고 이를 반복횟수에 사용하기
분석 스크립트
Ÿ 화면의 그림이 육각형 여섯 개로 이루어져있다는 것
을 인식한다.
Ÿ 육각형 하나를 그리기 위한 함수문에서 매개변수
length와 sides의 의미와 기능을 이해한다.
Ÿ 매개변수 length와 sides의 입력값을 얼마로 설정해
야하는지 파악한다.
var sides;
var length2;
function draw_a_polygon(sides, length2) {
}
}
draw_a_polygon(6, 100);
turnRight(60);
}

- 349 -
- 12/17단계 : 설정되어있는 모양 그리기 함수문을 사용하여 삼각형, 사각형, 육각형 그리기
분석 스크립트
Ÿ 화면의 그림이 같은 점(변)을 공유하는 정삼각형, 정
사각형, 정육각형으로 이루어져있다는 것을 인식한
다.
Ÿ 도형 하나를 그리기 위한 함수문에서 매개변수
Ÿ 각 도형을 그리기 위한 알고리즘에서 매개변수
length와 sides의 입력값을 각각 얼마로 설정해야하
는지 파악한다.
var length2;
var sides;
function draw_a_shape(length2, sides) {
}
}
draw_a_shape(100, 3);

- 350 -
- 13/17단계 : 함수문과 For 반복문을 사용하여 삼각형, 사각형, 오각형, 육각형 그리기
분석 스크립트
Ÿ 화면의 그림이 같은 점(변)을 공유하는 정삼각형, 정
사각형, 정오각형, 정육각형으로 이루어져있다는 것
을 인식한다.
Ÿ 도형 하나를 그리기 위한 함수문에서 매개변수
Ÿ For 반복문과 변수 counter를 사용하여 도형을 반복
적으로 그릴 수 있다.
var length2;
var sides;
var counter;
}
}
draw_a_shape(100, counter);
}

- 351 -
- 14/17단계 : 매개변수(변)를 사용해 함수문 알고리즘을 완성하고 매개변수(길이)
의 입력값 설정하기
분석 스크립트
Ÿ ‘도형 그리기’함수문에서 매개변수 sides를 추가
하여 사용할 수 있다.
Ÿ 각 도형을 그리기 위한 알고리즘에서 매개변수
length와 sides의 입력값을 얼마로 설정해야하는지
파악한다.
var length2;
var sides;
}
}
jumpForward(150);
jumpForward(100);

- 352 -
- 15/17단계 : 매개변수(길이)를 사용해 함수문 알고리즘을 완성하고 매개변수(변)
의 입력값 설정하기
분석 스크립트
Ÿ 각 나선형 그림의 변이 몇 개로 돌아가는지 파
악한다.
Ÿ ‘나선형 도형 그리기’함수문에서 매개변수
sides를 추가하여 사용할 수 있다.
Ÿ 문제에서 이동하며 그림을 그리는 길이나 회전
각도보다는 함수 알고리즘의 설정과 매개변수
입력값의 설정에 유의한다.
var length2;
var sides;
var counter;
function draw_a_spiral_shape(length2, sides) {
}
draw_a_spiral_shape(counter, 4);
}
jumpForward(125);
}
jumpBackward(100);
turnLeft(180);
}

- 353 -
- 16/17단계 : For 반복문과 함수문 등을 자유롭게 사용하여 주어진 그림 그려보기
분석 스크립트
Ÿ 큰 그림에서 반복되는 구조와 그 안의 세부적인
구조에서의 반복되는 구조를 발견하여 규칙성을
찾을 수 있다.
Ÿ 그림을 심층적으로 분석하여 가장 작은 단위의
그림을 그리기 위한 알고리즘을 작성한 후, 그것
을 확장하여 큰 그림을 그리기 위한 알고리즘을
어떻게 표현할 수 있을지 생각한다.
Ÿ 때로는 큰 그림부터 작은 그림으로 나아가며 그
리는 것이 효율적일 수 있다.
Ÿ For 반복문의 변수 counter와 매개변수 length,
sides의 역할을 구분하여 사용할 수 있다.
var length2;
var sides;
var counter;
}
}
for (counter = 17; counter >= 3; counter -= 3) {
draw_a_shape(30, counter);
}
moveForward(20);
turnRight(60);
}

- 354 -
- 17/17단계 : 자유 시간
행동(Actions) 색깔(Color) 기능문(Functions)
반복문(Loops) 수학문(Math) 변수(Variable)
분석
Ÿ 여러 가지 종류의 블록들을 활용하여 자신이 원하는 그림을 그릴 수 있다.

- 355 -
15. 스테이지15: 플레이 랩, 매개변수를 사용하는 함수
◦ 개요 : 매개변수와 함수문을 사용하여 기본적인 게임 구조를 만드는
방법을 이해하고, 이를 응용하여 조건에 따라 다양한 효과를 생성하는
게임을 만들어볼 수 있다.
◦ 학습 목표
- 매개변수를 이용하여 캐릭터를 다양한 입력값에 따라 다양하게 행동
하도록 만들 수 있다.
- 특정 조건에 따라 점수를 누적적으로 획득하거나 잃는 상황을 만들
수 있고, 레벨을 부여하여 그에 따라 화면을 변경할 수 있다.
◦ 활동
- 1/12단계 : 위쪽 방향키를 눌렀을 때 실행할 조건문 작성하기
분석
Ÿ 위쪽 방향키를 눌렀을 때 캐릭터로 위아래로 움직이도록 함수문을 설정할 수 있다.
Ÿ 함수문을 사용한 프로그램을 실행시켜보며 함수문으로 플레이 랩을 만드는 방법을 이해한다.

- 356 -
- 2/12단계 : 위쪽과 아래쪽 방향키를 눌렀을 때 실행할 조건문을 매개변수를 사용해 작성하기
분석
Ÿ 위쪽 방향키를 눌렀을 때는 위로 200 이동하고 아래쪽 방향키를 눌렀을 때는 위로 100 이동하
도록 함수문의 매개변수로 설정할 수 있다.
Ÿ ‘점프하기’함수문의 매개변수 height의 입력값을 위로 이동해야할 거리를 고려하여 입력한다.
- 3/12단계 : 프로그램을 실행해보며 두 매개변수의 기능 이해하기
분석
Ÿ actor라는 매개변수가 무엇을 의미하는지 이해하고 사용한다.
Ÿ ‘실행하기’버튼을 눌렀을 때 각 캐릭터가 순차적으로 함수문을 실행할 수 있도록 한다.

- 357 -
- 4/12단계 : 주어진 거리를 이용해 위아래로 움직이는 함수문 알고리즘 작성하기
분석
Ÿ 캐릭터가 한 번 위아래로 움직이도록 만드는 patrol 함수문을 작성한다.
- 5/12단계 : 위아래로 움직이는 함수문의 캐릭터 매개변수 입력값을 설정하기
분석
Ÿ 작성되어 있는 patrol 함수문의 알고리즘을 보고 매개변수 actor이 어떤 기능을 하는지 인식한
다.
Ÿ 각 캐릭터들이 명령을 실행할 수 있도록 매개변수 actor의 입력값을 입력한다.

- 358 -
- 6/12단계 : 함수문 알고리즘에 캐릭터 매개변수를 넣어보고 그 입력값을 설정하기
분석
Ÿ 이번에는 patrol 함수문의 알고리즘에 매개변수 actor을 넣어 알고리즘을 완성해본다.
Ÿ 각 캐릭터들이 명령을 실행할 수 있도록 매개변수 actor의 입력값을 입력한다.
- 7/12단계 : 함수문 알고리즘에 속도 매개변수를 넣어보고 그 입력값 설정하기
분석
Ÿ patrol 함수문의 알고리즘에 캐릭터별로 속도를 설정할 수 있도록 매개변수 speed를 넣는다.
Ÿ 캐릭터별로 속도를 1에서 3까지 설정할 수 있도록 매개변수 speed의 입력값에 입력한다.

- 359 -
- 8/12단계 : 프로그램을 실행해보며 캐릭터별로 속도가 다르게 움직이는 방법 이해하기
분석
Ÿ 전체 알고리즘과 함수문 알고리즘을 확인해본 후 프로그램을 실행시켜보며 게임의 조작방법에
대해 이해한다.
Ÿ 실제 기본적인 게임을 만들기 위한 기능과 조작법을 배울 수 있다.
Ÿ 조작하는 캐릭터와 다른 캐릭터들을 구분한다.
- 9/12단계 : 다른 캐릭터에 닿았을 때 처음 위치로 돌아가게 만들기
분석
Ÿ 전 단계의 프로그램에서 조작하는 캐릭터가 다른 캐릭터들에 닿았을 때 다시 처음 위치로 돌아
가도록 블록을 추가한다.

- 360 -
- 10/12단계 : 점수 매개변수를 넣어 점수가 누적되도록 만들기
분석
Ÿ ‘점수 획득하기’함수문에서 매개변수 points를 사용하여 점수가 누적되도록 알고리즘을 작성
할 수 있다.
Ÿ 점수를 +1점과 –1점씩 계산하여 총 10점이 되면 게임이 완료되도록 구성하였다.
- 11/12단계 : 누적된 점수가 10이 넘었을 때 레벨이 상승되도록 만들기
분석
Ÿ 시작 점수와 레벨에서 시작하여 누적된 포인트가 10이 넘을 때마다 레벨이 상승하고 레벨이 4
가 넘으면 게임이 완료되도록 구성하였다.
Ÿ ‘누적된 포인트가 10이 넘을 때 레벨이 상승한다.’라는 조건문을 작성한다.
Ÿ ‘점수 획득하기’ 함수문과‘레벨이 상승한다.’라는 함수문의 알고리즘을 확인하고 프로그램
을 실행시켜보며 레벨이 상승할 때마다 배경이 바뀌도록 설정한 것을 확인한다.

- 361 -
- 12/12단계 : 자유 시간
행동(Actions) 이벤트(Events) 반복문(Loops)
수학문(Math) 기능문(Functions) 변수(Variables)
분석

- 362 -
16. 스테이지16: 꿀벌, 매개변수를 사용하는 함수
◦ 개요 : 꿀벌이 이동해야하는 경로 속에서 함수문이 필요한 상황을 인식하고
매개변수를 이용해 조건에 따라 행동해야하는 명령을 다르게 프로그래밍한다.
◦ 학습 목표
- 꿀벌이 이동해야 하는 경로의 알고리즘 속에서 몇몇 값을 제외하고
비슷한 구조를 파악하여 조건문이나 함수문으로 설정할 수 있다.
- 매개변수가 필요한 상황을 인식하여 추가하여 사용하거나 자신이 필
요한 함수문을 호출하여 작성하고 명명할 수 있다.
◦ 활동
- 1/8단계 : 꽃꿀을 세 번 얻는 함수문을 이용해 알고리즘 작성하기
분석 스크립트
Ÿ ‘꽃꿀 3개 얻기’함수문의 알고리즘을 확인하여 그
알고리즘을 그대로 사용할지 수정하여 사용할지 결정
한다.
Ÿ 문제를 해결하는 다양한 방법이 있음을 인식하고 간
단한 알고리즘으로 문제를 해결하는 방법을 탐색한다.
Ÿ 이동 경로의 반복되는 부분을 인식하여 반복문 또는
함수문으로 묶으면 효율적으로 문제를 해결할 수 있
음을 이해한다.
turnLeft();
moveForward();
moveForward();
getNectar();
}
moveBackward();
moveBackward();
turnRight();
}
moveForward();
moveForward();
get_3_nectar();
moveForward();
}
get_3_nectar();
moveForward();
moveForward();
get_3_nectar();

- 363 -
- 2/8단계 : 꽃꿀 세 번 얻기 함수문의 회전방향 수정하기
분석 스크립트
Ÿ 함수문 설정에서 오른쪽으로 회전과 왼쪽으로 회전의
위치를 바꾼다.
Ÿ 제시된 프로그램의 실행을 머릿속으로 그려보고 올바
르게 작성되었는지 확인한다.
turnRight();
moveForward();
moveForward();
getNectar();
}
moveBackward();
moveBackward();
turnLeft();
}
moveForward();
moveForward();
get_3_nectar();
moveForward();
}
get_3_nectar();
moveForward();
moveForward();
get_3_nectar();

- 364 -
- 3/8단계 : 함수문 안의 조건문에서 방향에 따라 어떤 방향회전 블록을 사용해야하
는지 결정하기
분석 스크립트
Ÿ 회전할 방향을 direction이라는 매개변수를 통해 입력
할 수 있다.
Ÿ 꽃꿀을 획득하기 위해 오른쪽으로 회전하여 앞으로 갔
다면, 다시 뒤로 돌아온 뒤에는 반대방향인 왼쪽으로
회전해야 한다는 것을 인식한다.
var direction;
var left;
var right;
function get_3_nectar(direction) {
if (direction == left) {
turnLeft();
} else {
turnRight();
}
moveForward();
moveForward();
getNectar();
}
moveBackward();
moveBackward();
turnRight();
} else {
turnLeft();
}
}
left = 0;
right = 1;
moveForward();
moveForward();
get_3_nectar(right);
moveForward();
moveForward();
get_3_nectar(left);
moveForward();
moveForward();

- 365 -
- 4/8단계 : 반복문과 꽃꿀 세 번 얻기 함수문을 사용하여 알고리즘 작성하기
분석 스크립트
Ÿ 회전할 방향을 direction이라는 매개변수를 통해 입력
할 수 있다.
Ÿ 꽃꿀을 획득하기 위해 오른쪽으로 회전하여 앞으로
갔다면, 다시 뒤로 돌아온 뒤에는 반대방향인 왼쪽으
로 회전해야 한다는 것을 인식한다.
Ÿ 회전해야 할 방향을 매개변수 옆에 입력하여 알고리
즘을 완성한다.
var direction;
var left;
var right;
function get_3_nectar(direction) {
turnLeft();
} else {
turnRight();
}
moveForward();
moveForward();
getNectar();
}
moveBackward();
moveBackward();
turnRight();
} else {
turnLeft();
}
}
left = 0;
right = 1;
moveForward();
get_3_nectar(left);
moveForward();

- 366 -
- 5/8단계 : 꽃꿀을 다섯 번 얻는 함수문을 직접 만들어보고 이를 사용하여
전체 알고리즘 작성하기
분석 스크립트
Ÿ 매개변수와 함수문을 이용하여 문제를 해결하기 위한
프로그램을 처음부터 모두 작성할 수 있다.
Ÿ 함수문을 어느 경로부터 어느 경로까지 설정하면 효율
적으로 문제를 해결할 수 있는지 생각해본다.
var direction;
var left;
var right;
function get_5_nectars(direction) {
turnLeft();
} else {
turnRight();
}
moveForward();
moveForward();
getNectar();
}
moveBackward();
moveBackward();
turnRight();
} else {
turnLeft();
}
}
left = 0;

- 367 -
- 6/8단계 : 꽃꿀의 개수만큼 반복하기 위한 새로운 매개변수 추가하기
분석 스크립트
Ÿ 매개변수가 필요한 상황을 인식하여 새로운 매개변수
를 추가하여 사용할 수 있다.
var direction;
var number;
var left;
var right;
function get_some_nectars(direction, number) {
turnLeft();
} else {
turnRight();
}
moveForward();
moveForward();
for (var count = 0; count < number; count++) {
getNectar();
}
moveBackward();
moveBackward();
turnRight();
} else {
turnLeft();
}
}
left = 0;
right = 1;
moveForward();
get_some_nectars(left, 2);
moveForward();
get_some_nectars(right, 3);
moveForward();
moveForward();
get_some_nectars(left, 3);
moveForward();
moveForward();

- 368 -
- 7/8단계 : 설정되어있는 함수문을 여러 번 사용하여 알고리즘 작성하기
분석 스크립트
Ÿ 작성되어 있는 함수문을 이용하여 매개변수 direction과
nectars의 입력값을 변화시켜가며 프로그램을 작성할 수
있다.
var direction;
var nectars;
var left;
var right;
function get_many_nectar(direction, nectars) {
turnLeft();
} else {
turnRight();
}
moveForward();
moveForward();
for (var count = 0; count < nectars; count++) {
getNectar();
}
moveBackward();
moveBackward();
turnRight();
} else {
turnLeft();
}
}
left = 0;
right = 1;
moveForward();
moveForward();
get_many_nectar(right, 1);
get_many_nectar(left, 2);
moveForward();
moveForward();
get_many_nectar(left, 4);
moveForward();
get_many_nectar(right, 3);

- 369 -
- 8/8단계 : 꽃꿀의 개수와 꿀의 개수를 지정할 수 있는 매개변수를 이용해 알고리즘 작성하기
분석 스크립트
Ÿ 문제에서 꽃꿀일 경우 매개변수 nectar units만큼
반복하여 꽃꿀을 얻고 꿀일 경우 매개변수 honey
units만큼 반복하여 꿀을 만드는 프로그램을 작성
해야 함을 인식한다.
Ÿ 세 매개변수의 역할과 기능을 충분히 이해하고
매개변수의 입력값이 0이라는 것의 의미를 안다.
var direction;
var nectar_units;
var honey_units;
var left;
var right;
function get_nectar_make_honey(direction, nectar_units,
honey_units) {
turnLeft();
} else {
turnRight();
}
moveForward();
moveForward();
for (var count = 0; count < nectar_units; count++) {
getNectar();
}
for (var count2 = 0; count2 < honey_units; count2++) {
makeHoney();
}
moveBackward();
moveBackward();
turnRight();
} else {
turnLeft();
}
}
left = 0;
right = 1;
moveForward();
get_nectar_make_honey(right, 0, 2);
moveForward();
get_nectar_make_honey(left, 2, 0);
moveForward();
get_nectar_make_honey(right, 3, 0);
moveForward();
get_nectar_make_honey(left, 0, 3);

- 370 -
17. 스테이지17: 2진
◦ 개요 : 학생들이 다양한 형태의 2진법으로 정보가 표현될 수 있음을
알고 컴퓨터가 매우 복잡한 정보들을 2진법으로 저장하고 사용할 수
있다는 개념을 설명할 수 있는 단계까지 나아간다.
◦ 학습 목표
- 그림들을 2진법으로 암호화하는 방법을 확인한다.
- 2진법 암호화를 사용하여 친구들에게 그림을 전달한다.
- 2진법 암호를 바탕으로 그림을 복사한다.
◦ 활동
- 1/1단계 : 언플러그드 활동(흑과 백 등 2가지 선택조건에서 2진법 개념 이끌어내기)
Ÿ 흰색과 검은색이라는 두 가지 선택조건
을 가지는 사각형 그림을 보여주고 아
이들에게 새로운 암호체계를 도입한다.
Ÿ 두 가지 선택조건(흑/백)에 대해 학생들
이 엄지손가락을 위/아래로 세우는 등
각자 몸이나 말로 표현해보는 기회를
갖게 한다.
Ÿ 이를 확장하여 [주요 화면1]과 같은 그
림들에 대해 1과 2 등의 2진법으로 표
현해보게 한다.
Ÿ 컴퓨터는 0과 1이라는 선택조건을 가진
2진법 구조를 기본으로 하여 프로그래
밍을 작업하거나 그림 또는 소리를 표
현한다는 것을 이해한다.
Ÿ 이를 if 조건문과 연관시켜 어떤 조건을
만족할 때는 두 선택조건 중 하나를 실
행하고 어떤 조건을 만족시키지 않을
때는 나머지 선택조건 하나를 실행하는
프로그래밍으로 만들 수 있음을 이해한
다.
주요 개념
2진법 : 2가지 선택조건만을 사용하여 정보를 표현하는 방법
2진법 알파벳 : 2진법 암호에 사용된 2가지 선택조건

- 371 -
수탁연구 CR 2015-02
Code.org 분석
발 행 2015년 10월 30일
발행인 전주교육대학교 정영식
발행처 전주교육대학교 컴퓨터교육과
주 소 전북 전주시 완산구 동서학로 50.
전주교육대학교 교사교육센터
컴퓨터교육과
등 록
인쇄처
㈜ 버드비원
전화 : (02) 647-1313
ISBN
보고서 내용의 무단 복제를 금함. <비매품>

Code.org분석

More Related Content

Similar to Code.org분석 (20)

More from YoungSik Jeong (9)

Code.org분석