Codemonkey之編碼冒險之特技模式1-165關卡學習筆記與參考答案

CodeMonkey過關學習筆記系列1-165關卡

特技關卡 -
你可以在不使用 右轉 turn right 指令的前提下解決這一關嗎 ?

turn left
turn left
turn left
step 


或者：
turn -
step 
           

特技關卡 -
turn left
step 
turn left
step 


           

特技關卡 -
step 
turn right
step 
turn right
step 

           

特技關卡 -
step 
turn right
step 
turn right

step 
turn left
step 
turn right
step 


           

特技關卡 -
turn 
step 

           

特技關卡 -
turn 
step distanceTo bananas[]

turn -

step distanceTo bananas[]

           

特技關卡 -
step 
turn left
step 
turn left
step 





           

特技關卡 -
step 
turn right
step 
turn right
step 

           

特技關卡 -
step 
step -
turn right
step 
step -


           

特技關卡 -

step -
turn left
step 

           

特技關卡 -
turn 
step -
step 
turn left
step 
           

特技關卡 -
turnTo bridge
step 
turnTo banana
step 

           

特技關卡 -

turnTo bush
step 
turnTo banana
step 

           

特技關卡 -
turtle.step 
step 
turn left
step 

           

特技關卡 -
step 
step -
turtle.step 
step 

           

特技關卡 -
step 
turn right
step 
turn right

turtle.step 
step 

           

特技關卡 -
turtle.turn left 
monkey.step 

turtle.step 

monkey.step 

           

特技關卡 -
turtle.step 
monkey.turnTo turtle
monkey.step 
turtle.step -
monkey.step -

           

特技關卡 -
turtle.turnTo banana
monkey.turnTo turtle
step 
turtle.step 

           

特技關卡 -
turtle.step 
turtle.step -

           

特技關卡 -
turtle.turnTo monkey
turtle.step 
turtle.step -


           

特技關卡 -
times ->
    turn right
    step 

           

特技關卡 -
times ->
    step 
    turn 

           

特技關卡 -
times ->
    turn  
    step 
           

特技關卡 -
times ->
    step 
    turn 
    step 
    turn -

           

特技關卡 -
times ->
    step 
    turn left
    step 
    turn right
step -
           

特技關卡 -
step 
times ->
    turtle.step 
    turtle.turn 


           

特技關卡 -
times ->
    step 
    step -
    turn 
           

特技關卡 -
times ->
    turn right
    step 

step 

           

特技關卡 -
turnTo turtle
step 
times ->
    turtle.turn -
    turtle.step 
turtle.step 
step 
           

特技關卡 -
turn left
times ->
    step 
    step -
    step 
    turtle.step 

           

特技關卡 -
x = 
step x
           

特技關卡 -
x = 
times ->
    turn 
    step x
或者
x = -
times ->
    step x
    turn -

           

特技關卡 -
num = 
distance = 
degree = 

num.times ->
    step distance
    turn degree
或者
num = 
distance = -
degree = -
num.times ->
    turn degree
    step distance

           

特技關卡 -
d = 

times ->
    step 
    turn d
    d = d + 

           

特技關卡 -
x = 

turtle.step x
step x
turn left
step x

           

特技關卡 -
x = 
times ->
    step x
    step -x-x
    step x
    turtle.step 

           

特技關卡 -
x = 
say x

turnTo banana
step x

           

特技關卡 -
x = 
turtle.step x
times ->
    turn right
    step x


           

特技關卡 -
x = distanceTo banana
step x

           

特技關卡 -
x = monkey.distanceTo bridge
y = bridge.distanceTo banana

step x
turnTo banana
step y



           

特技關卡 -
d = distanceTo banana

step -d

           

特技關卡 -
x = turtle.distanceTo banana
y = monkey.distanceTo banana

turtle.turnTo banana
turtle.step x
monkey.step y

           

特技關卡 -
d = turtle.distanceTo islands[]
turtle.step d
m = monkey.distanceTo turtle
step m

turtle.step -d
turtle.turnTo banana
turtle.step m

           

特技關卡 -
say "RUN!"
monkey.step distanceTo bush

monkey.turnTo banana
monkey.step distanceTo banana

           

特技關卡 -
x = 
times ->
    turnTo bananas[x]
    step 
    x = x + 

           

特技關卡 -
turtles[].step 
turtles[].step -
turtles[].step +
step 

           

特技關卡 -
step 
turtles[].step 
step 
turtles[].step 
step 
turtles[].step -

           

特技關卡 -
turtle.turnTo bananas[]
turtle.step 

turtle.turnTo bananas[]
turtle.step 


turtle.turnTo bananas[]
turtle.step 

//或者利用distanceTo來測量距離
turtle.turnTo bananas[]
turtle.step distanceTo bananas[]

turtle.turnTo bananas[]
turtle.step distanceTo bananas[]


turtle.turnTo bananas[]
turtle.step distanceTo bananas[]

//或者 使用之前我們學過的times循環
i = 
times ->
    turtle.turnTo bananas[i]
    turtle.step distanceTo bananas[i]
    i++

//或者 使用我們還沒學到的for循環
for b in bananas
    turtle.turnTo b
    turtle.step distanceTo b



           

特技關卡 -
turnTo bananas[]
step distanceTo bananas[]

turnTo bananas[]
step distanceTo bananas[]

turnTo bananas[]
step distanceTo bananas[]

turnTo bananas[*]
step distanceTo bananas[*]


           

特技關卡 -
step 
beavers[].step 
beavers[].step -
turn left
step 
turn left
step 

           

特技關卡 -
x=
times ->
    beavers[x].step *(x+)
    x += 
step distanceTo banana

           

特技關卡 -
beavers[].step 
beavers[].step 
beavers[].step 
step distanceTo banana

           

特技關卡 -
x = 
times ->
    turnTo bananas[x]
    step distanceTo bananas[x]
    x = x+


           

特技關卡 -

crocodiles[].turn left
crocodiles[].turn -


step 
turn left
step 
turn right
step 


           

特技關卡 -
goats[].step 
goats[].hit()
goats[].step -
goats[].hit()
goats[].step 
goats[].hit()
goats[].step -
goats[].hit()
times ->
    step 
    turn right

//另外一種解法
turnStepHit = (goat, banana) ->
    goat.turnTo banana
    goat.step goat.distanceTo banana
    goat.hit()
turnStepHit(goats[], bananas[])
turnStepHit(goats[], bananas[])
turnStepHit(goats[], bananas[])
turnStepHit(goats[], bananas[])
times ->
    step 
    turn right

//另外一種解法   
eatBananas = (monkey, goat, banana, next) ->
    goat.turnTo(banana)
    goat.step(goat.distanceTo(banana))
    goat.hit()
    monkey.step(monkey.distanceTo(banana))
    monkey.turnTo(next)

eatBananas(monkey, goats[], bananas[], bananas[])
eatBananas(monkey, goats[], bananas[], bananas[])
eatBananas(monkey, goats[], bananas[], bananas[])
eatBananas(monkey, goats[], bananas[], bananas[])

//monkey eat bananas with goat help
eatBananas = (banana, next, goat) ->
    goat.turnTo(banana)
    goat.step(goat.distanceTo(banana))
    goat.hit()
    step(distanceTo(banana))
    turnTo(next)
eatBananas(bananas[], bananas[],goats[])  # 第一個參數順序很重要
eatBananas(bananas[], bananas[],goats[])
eatBananas(bananas[], bananas[],goats[])
eatBananas(bananas[], bananas[],goats[])
           

特技關卡 -
for b in bananas
    turnTo b
    step distanceTo b

           

特技關卡 -
for b in bananas
    turnTo bridge
    step distanceTo bridge
    turnTo b
    step distanceTo b

           

特技關卡 -
turnTo bridges[]
step distanceTo bridges[]
for b in bananas
    turnTo b
    step distanceTo b


           

特技關卡 -
for b in bushes
    turnTo b
    step distanceTo b

           

特技關卡 -
for t in turtles
    step distanceTo t
    t.step 

           

特技關卡 -
for t in turtles
    step distanceTo t
    times ->
        t.step 
        t.turn 


           

特技關卡 -
for t in turtles
    t.step 
    step 
           

特技關卡 -
for b in bananas
    turnTo b
    step distanceTo b

           

特技關卡 -
for c in crocodiles
    c.turnTo bananas[]

for i in islands
    turnTo i
    step distanceTo i

           

特技關卡 -
for c in crocodiles
    step distanceTo c
    c.turn left
    step 
    step -
    c.turn right


           

特技關卡 -
for c in crocodiles
    turnTo c
    step distanceTo c

for r in rafts
    turnTo r
    step distanceTo r

for i in islands
    turnTo i
    step distanceTo i

           

特技關卡 -
i = 
for t in turtles
    d = t.distanceTo bananas[i++]
    t.step d
    monkey.step distanceTo t
    t.step -d
    t.step d


           

特技關卡 -
for c in crocodiles
    c.turn 
    step -
或者
for c in crocodiles
    c.turn 
    step 
    turn 


           

特技關卡 -
x = 
#這個循環會幫助你拿到河邊的香蕉
times ->
    turnTo bananas[x]
    step distanceTo bananas[x]
    beaver.step 
    x = x + 
#現在寫一個 for 循環，拿到剩下的香蕉吧
for b in bushes
    turnTo b
    step distanceTo b

           

特技關卡 -
for g in goats
    g.step 
    g.hit()
monkey.step distanceTo bananas[]





           

特技關卡 -

step distanceTo match
grab()
step -(distanceTo bush)
turnTo pile
step distanceTo pile
drop()

           

特技關卡 -
turnTo match
step distanceTo match
grab()
turtle.step 
turnTo pile
step distanceTo pile
drop()

           

特技關卡 -
goto = (m) ->
    turnTo m
    step distanceTo m

goto match
grab()
goto pile
drop()
           

特技關卡 -
goto = (t) ->
    turnTo t
    step distanceTo t

for m in matches
    goto m
    grab()
    goto pile
    drop()
           

特技關卡 -
goto = (t) ->
    turnTo t
    step distanceTo t

grab()
newturtles = turtles.reverse()
for t in newturtles
    goto t
    t.step 
goto pile

drop()

           

特技關卡 -
goto = (t) ->
    turnTo t
    step distanceTo t

for m in matches
    goto m
    grab()
    goto pile
    drop()

           

特技關卡 -
getAndReturn = (d) ->
    step d
    grab()
    step -d
    drop()

x = 
times ->
    getAndReturn x
    x = x + 

           

特技關卡 -
halfCircle = () ->
    times ->
        step 
        turn 

halfCircle()
grab()
halfCircle()
drop()
           

特技關卡 -
goto = (t) ->
    turnTo t
    step distanceTo t

grab()
goto bushes[]
goto bushes[]

goto pile
drop()
           

特技關卡 -
goto = (t) ->
    turnTo t
    step distanceTo t
goto bushes[]
goto pile
goto match
grab()
goto pile
drop()
           

特技關卡 -
goto = (t) ->
    turnTo t
    step distanceTo t

gotoBanana = (index) ->
    #你隻能修改這裡的代碼
    goto bananas[index]

gotoBanana 
gotoBanana 
gotoBanana 
gotoBanana 
gotoBanana 
           

特技關卡 -
goto = (d) ->
    turnTo d
    step distanceTo d
rideTurtle = (t) ->
    goto turtle
    turtle.step t
getMatches = () ->
    for m in matches
        rideTurtle 
        goto m
        grab()
        rideTurtle -
        goto pile
        drop()
getMatches()
           

特技關卡 -
foo = (x) ->
    beavers[x].step x*
goto = (t) ->
    turnTo t
    step distanceTo t
i = 
times ->
    foo i
    i = i + 
grab()
goto pile
drop()
           

特技關卡 -
goto = (t) ->
    turnTo t
    step distanceTo t

allStep = (kind) ->
    for a in kind
        a.step 

#這兩行應該建成兩座橋
allStep beavers
#完成這裡的代碼

goto match
grab()
allStep turtles

goto pile
drop()
           

特技關卡 -
goto = (t) ->
    turnTo t
    step distanceTo t

allCrocsTurn = (d) ->
    for c in crocodiles
        c.turn d


allCrocsTurn right
goto raft
allCrocsTurn left
for b in bananas
    goto b
           

特技關卡 -
until near banana
    turnTo banana
    step 
           

特技關卡 -
for b in bananas
    until near b
        turnTo b
        step 
           

特技關卡 -
chase = (b) ->
    until near b
        turnTo b
        step 

chase bananas[]
chase bridge
chase bananas[]
           

特技關卡 -
until near banana
    say "Not yet..."
    crocodile.turn 
           

特技關卡 -
until beavers[].near bananas[]
    beavers[].step 
until beavers[].near bananas[]
    beavers[].step 
until beavers[].near bananas[]
    beavers[].step 

step distanceTo islands[]
           

特技關卡 -
until near banana
    turtle.turnTo banana
    turtle.step 
           

特技關卡 -
until cat.sleeping()
    wait()

step distanceTo banana
           

特技關卡 -

step distanceTo islands[]

until near banana
    wait()
           

特技關卡 -
i = 
for b in bridges
    turnTo b
    step distanceTo b
    until near bananas[i]
        wait()
    i++
           

特技關卡 -
for c in crocodiles
    c.turn 
for b in bananas

    step 
    until near b
        wait()

           

特技關卡 -
for banana in bananas
    until near banana
        wait()
           

特技關卡 -
for banana in bananas
    until near banana
        crocodile.turn 
        wait()

           

特技關卡 -
until cats[].sleeping()
        wait()
    step 
until cats[].sleeping()
        wait()
    step 

           

特技關卡 -
i = 
for t in turtles
    step distanceTo t
    d = distanceTo bushes[i]
    t.step d
    until near bananas[i]
        wait()
    t.step -d
    i = i + 
           

特技關卡 -
goto = (t) ->
    turnTo t
    step distanceTo t
until cat.sleeping()
    wait()
goto bananas[]
until cat.sleeping()
    wait()
goto bushes[]
goto bushes[]
until near bananas[]
    wait()
           

特技關卡 -

for b in bananas
    if  b.frozen()
        goat.goto b
        goat.hit()
    goto b
           

特技關卡 -
goat.goto(bridge)
for b in bananas
    if b.frozen()
        goat.goto(b)
        goat.hit(b)
    goto b
           

特技關卡 -
for t in turtles
    t.step 

for b in bananas
    if b.frozen()
        goat.goto(b)
        goat.hit(b)
    goto b

           

特技關卡 -
x = 

times ->
    if bananas[x].frozen()
        goat.goto bananas[x]
        goat.hit()


    x = x - 


goto turtle
turtle.step 
for b in bananas
    goto b
           

特技關卡 -
#你知道演習嗎？誰先去？
for b in bananas
    if b.frozen()
        turtle.goto b
        goat.hit()
        turtle.step -
step 
           

特技關卡 -
i = 
times ->
    if bananas[i].frozen()
        goats[i].goto bananas[i]
        goats[i].hit()
    monkey.goto bananas[i]
    i = i + 
           

特技關卡 -
for b in bananas
    if b.frozen()
        turtle.goto b
        goat.hit()
        turtle.step -
    goto b
           

特技關卡 -
#提示：這裡我們有多少隻烏龜？

for b in bananas
    if b.frozen()
        goat.hit()
    goto b
    goto turtles[]
    for t in turtles
        t.step 
           

特技關卡 -
#提示：猴子可以等待山羊完成
#首先撞擊所有的冰凍香蕉

for b in bananas
    if b.frozen()
        goat.goto b
        goat.hit()
#現在讓我們獲得那些香蕉。
#我們應該從哪裡開始？并且多少次？
x = 
times ->
    goto bananas[x]
    x = x - 

           

特技關卡 -
x = 
for g in goats
    times ->
        g.goto bananas[x]
        if bananas[x].frozen()
            g.hit()
        x = x + 
for b in bananas
    goto b
           

特技關卡 -
x = 
times ->
    times ->
        if bananas[x].frozen()
            goat.goto bananas[x]
            goat.hit()
        goto bananas[x]
        x = x + 
    goat.goto bridge
    goto bridge
           

特技關卡 -
for b in bananas
    if not b.green()
        goto bridges[]
        goto b
    else
        goat.goto bridges[]
        goat.goto b
           

特技關卡 -
for b in bananas
    #山羊和猴子都不可以得到所有的香蕉
    #完成編碼
    if b.green()
        goat.goto crocodile
        crocodile.turnTo b
        goat.goto b
    else
        turtle.goto b
        goto b
           

特技關卡 -
for b in bananas
    #首先，我們需要打破冰凍的香蕉
    if b.frozen()
        goat.goto b
        goat.hit()
        goat.goto turtles[]
    #現在，如果香蕉是綠色的，山羊會吃掉它
    if b.green()
        goat.goto b
        goat.step -
    #如果不是，猴子會吃掉它
    else
        goto b
        step -

    for t in turtles
        t.step 
           

特技關卡 -
#确定你可以解決這個
#提示：檢查哪隻海狸可以幫助哪隻動物
#過河
beavers[].step 
beavers[].step 

for b in bananas
    if b.green()
        goat.goto b
    else
        monkey.goto b

           

特技關卡 -
breakBanana = (banana) ->
    #對冰凍的香蕉增加山羊撞擊的編碼
    say "frozen"
    turtles[].goto banana
    goat.hit()


eatBanana = (banana) ->
    #增加山羊吃綠色香蕉的編碼
    if banana.green()
        turtles[].goto banana
    else
        turtles[].goto banana


for b in bananas
    if b.frozen()
        breakBanana(b)
    eatBanana b

           

特技關卡 -
for b in bananas
    if b.green()
        mover = goat
    else
        mover = monkey
    say mover
    mover.goto b
           

特技關卡 -
mover = monkey
for b in bananas
    if b.green()
        x = 
        mover = goat
    else
        x = 
        mover = monkey
    mover.step x
           

特技關卡 -
#如果x>，那麼烏龜前進
#如果x<，那麼烏龜後退

x = 
for b in bananas
    if b.green()
        turtle.step -x
        goat.goto turtle
        turtle.step *x
        goat.goto b
    else
        monkey.goto turtle
        turtle.step -*x
        monkey.goto b
           

特技關卡 -
#提示：你應該等待直到什麼時候？
for b in bananas
    until tiger.sleeping() and bear.sleeping()
        wait()
    goto b
           

特技關卡 -
for b in bananas

    until tiger.sleeping() and bear.sleeping()
        wait()    #在這裡增加編碼
    if b.frozen()
        goat.goto b
        goat.hit()
    until tiger.sleeping() and bear.sleeping()
        wait() 
    goto b
           

特技關卡 -
x = 
times ->
    until bears[x].sleeping() and tigers[x].sleeping()
        wait()
    goto bananas[x]
    x = x + 
           

特技關卡 -

until tiger.sleeping() and bear.sleeping()
    wait() 
for b in bananas
    goto b    
           

特技關卡 -
for b in bananas
    #我們需要等待直到熊睡覺或是玩耍
    #或者意味着我們要等到其中之一的條件出現
    until bear.sleeping() or bear.playing()
            wait()

    #當安全條件錯過時，我們應該怎麼做？
    if b.green()
        goat.goto b
    else
        monkey.goto b
           

特技關卡 -
for b in bananas

    if b.green()
        until tiger.sleeping() or tiger.playing()
            wait()
        goat.goto b
        #是以如果可以安全通行，誰應該獲得香蕉呢？
    else
        until bear.sleeping() or bear.playing()
            wait()
        #在這裡增加你的編碼
        goto b
           

特技關卡 -
x = 
times ->
    until bears[x].sleeping() or bears[x].playing()
        wait()
    #我們最好等待熊睡覺或是玩耍
    goto bananas[x]
    x = x - 
           

特技關卡 -

until tiger.sleeping() or tiger.playing()
    wait()
goat.goto bridges[]


monkey.goto bridges[]

#都是你的…
for b in bananas
    if b.frozen()
        goat.goto(b)
        goat.hit()
    monkey.goto b
           

特技關卡 -
for b in bananas
    #首先我們希望山羊走過所有的香蕉（綠色的或是冰凍的）
    #打破冰凍的香蕉并拿到綠色的香蕉。
    #然後，猴子隻收集剩下的
    if b.green() or b.frozen()
        if b.frozen()
            goat.goto b
            goat.hit()
        goat.goto b

#現在輪到猴子了
goto bananas[]
           

特技關卡 -
#首先讓山羊走過所有的香蕉
#打破冰凍的香蕉并獲得綠色的香蕉
for b in bananas
    if b.green() or b.frozen()
        if b.frozen()
            goat.goto b
            goat.hit()
        goat.goto b

#現在這裡隻有非冰凍的黃色香蕉
#猴子可以得到所有的香蕉
times ->
    step 
    turn left
           

特技關卡 -
#變量chaser 可以在老虎和熊之間變換
chaser = bear
times ->
    say chaser
    until chaser.sleeping() or chaser.playing()
        wait()
    step 
    chaser= tiger
           

特技關卡 -
#設定chaser 和 mover根據香蕉是綠色的或是其他
#首先chaser是老虎，mover是猴子
chaser = tiger
mover = monkey

for b in bananas
    if b.green()
        #完成我：
        chaser = bear
        mover = goat
    else
        #和我：
        chaser = tiger
        mover = monkey

    until chaser.sleeping() or chaser.playing()
        wait()
    mover.goto b
           

特技關卡 -
#首先猴子移動然後是山羊
x = 
times ->
    for stepper in [monkey,goat]
        until tigers[x].sleeping() and bears[x].sleeping()
            wait()
        stepper.step    
    x = x + 
           

特技關卡 -
waitFor = (b) ->
    until b.sleeping() or b.playing()
        wait()
x = 
times ->
    waitFor(bears[x])
    goto bananas[x]
    waitFor(bears[x])
    goto turtle
    turtle.step 
    x = x + 
           

特技關卡 -
#我們将使用圓括号檢查他們中的條件
#檢查剩下的之前是yes還是no

#這裡，我們檢查：
#老虎是玩耍還是在睡覺
#熊是在玩耍還是在睡覺
#是yes和是yes
until (tiger.playing() or tiger.sleeping()) and (bear.playing() or bear.sleeping())
    wait()

#現在可以安全通過
goto banana
           

特技關卡 -
for b in bananas
    #在這裡增加你的編碼
    until ( bear.playing() or bear.sleeping() ) and ( tiger.playing() or tiger.sleeping() ) 
        wait()
    goto b
           

特技關卡 -
a = yes

if not a
    turn left

step 
           

特技關卡 -
for b in bananas
    if b.green()
        goat.goto b
    else if not b.rotten()
        goto b
           

特技關卡 -
for b in bananas
    if not b.green()
        goto b
           

特技關卡 -
for b in bananas
    if not b.green() 
        turtle.goto b
           

特技關卡 -
for b in bananas
    if not (b.green() or b.rotten())
        goto b
           

特技關卡 -
x = 
times ->
    b = bananas[ x-- ]
    if not b.green() and not b.rotten()
        goto b


           

特技關卡 -
#奶牛會一直吃，直到大門上的條件變為真實的
#然後，大門被打開了！
until cow.weight() == 
    cow.eat()

goto banana
           

特技關卡 -
#我們需要做什麼直到奶牛的體重将打開大門？
until cow.weight() == 
    cow.eat()

goto banana
           

特技關卡 -
turtle.step 
goto turtle

#檢查門上的條件來打開大門。
until cow.weight() >= 
    cow.eat()

for b in bananas
    goto b
           

特技關卡 -
until cow.weight() == 
    cow.eat()

goto banana
           

特技關卡 -
for c in cows
    until c.weight() == 
        #修複這裡
        c.eat()

goto banana
           

特技關卡 -
until cows[].weight() == 
    cows[].eat()
    cows[].eat()
for b in bananas
    goto b
           

特技關卡 -
for c in cows
    until c.weight() == 
        c.eat()
for b in bananas
    goto b
           

特技關卡 -

until cow.weight() == 
    cow.eat()
for b in bananas
    goto b
    if health() < 

        goto healthZone

        until monkey.health() == 
            wait()

           

特技關卡 -
for cow in cows
    until cow.weight() > 
        cow.eat()
i = 
times ->
    goto bananas[i--]


           

特技關卡 -
yummyBanana = (y) ->
    if not y.green() and not y.rotten()
        goto y
for b in bananas
    yummyBanana b
           

特技關卡 -
#修複這個函數:
yummyBanana = (y) ->
    if y.green() or y.rotten()
        return no
    return yes

#一旦你修複yummyBanana這個函數，這個編碼是好的。
x = 
times ->
    times ->
        if yummyBanana bananas[x]
            goto bananas[x]
        x = x + 
        goto turtle
    turtle.step 
           

特技關卡 -
#nearestZone函數傳回健康地帶
#那更接近猴子
nearestZone = () ->
    d0 = distanceTo healthZones[]
    d1 = distanceTo healthZones[]
    if d0 < d1
        #修複函數來傳回正确的對象
        return healthZones[]
    else
        return healthZones[]

#一旦你修複nearestZone函數，這個編碼是有效的
for b in bananas
    goto b
    if health() < 
        zone = nearestZone()
        goto zone
        until health() == 
            wait()
           

特技關卡 -
#nearestBridge 函數傳回最近的橋
nearestBridge = () ->
    d0 = distanceTo bridges[]
    d1 = distanceTo bridges[]
    #完成這個函數來傳回最近的橋
    if d0 <= d1
        return bridges[]
    else
        return bridges[]

#當健康值很低時，猴子後巷最近的橋
#然後去健康地帶
#這個函數是正确的！
getHealthy = () ->
    goto nearestBridge()
    goto healthZone
    until health() == 
        wait()
    goto nearestBridge()

#這裡不需要更改
for b in bananas
    goto b
    if health() < 
        getHealthy()
           

特技關卡 -
#safeFrom函數傳回yes如果老虎
#睡覺或是玩耍
safeFrom = (a) ->
    return a.sleeping() or a.playing()

for t in tigers
    until safeFrom t
        wait()
    step 
    #現在輪到誰了？
    until safeFrom t
        wait()
    goat.step 
           

特技關卡 -
safeFrom = (a) ->
    #這個函數應該傳回什麼呢？
    return a.sleeping() or a.playing()

#一旦你修複了 safeFrom這個函數，這個編碼就是正确的。
x = 
for stepper in [monkey, goat]
    #首先猴子先過去，然後是山羊。
    until safeFrom(tigers[x])
        wait()
    stepper.step 
    #等待熊
    until safeFrom(bears[x])
        wait()
    stepper.step 
    x = x + 
           

特技關卡 -
# nearestGoat函數會獲得一個對象
#并比較每隻山羊到對象的距離
#函數傳回哪隻山羊距離對象最近
nearestGoat = (y) ->
    d0 = goats[].distanceTo y
    d1 = goats[].distanceTo y
    if d0 < d1
        return goats[]
    else
        return goats[]

for b in bananas
    #這裡有一個小修複
    if b.green()
        g = nearestGoat b
        say g
        g.goto b
    else
        goto b
           

特技關卡 -
whichAnimal = (y) ->
    if y.green()
        return goat
    return monkey
for b in bananas
    mover = whichAnimal b
    mover.goto b
           

特技關卡 -
whichAnimal = (y) ->
    if y.green()
        return goat
    else
        return monkey


for b in bananas
    mover = whichAnimal b
    mover.goto b
           

特技關卡 -
#修複函數useGoat傳回yes
#當香蕉是綠色的時候
useGoat = (y) ->
    return y.green()

nearestGoat = (y) ->
    d0 = goats[].distanceTo y
    d1 = goats[].distanceTo y
    if d0 < d1
        return goats[]
    else
        return goats[]

for b in bananas
    mover = monkey
    if useGoat b
        mover = nearestGoat b
    say mover
    mover.goto b
           

特技關卡 -
#這個函數傳回哪隻烏龜距離香蕉更近
#這個函數的編碼是正确的！
nearestTurtle = (y) -> 
    d0 = turtles[].distanceTo y
    d1 = turtles[].distanceTo y
    if d0 < d1
        return turtles[]
    else
        return turtles[]

for b in bananas
    t = nearestTurtle(b)
    t.goto b

           

特技關卡 -
#這個函數傳回多少次
#奶牛吃：
leftToEat = (c) ->
    return  - c.weight()


say leftToEat(cow)

#修複這個條件，什麼時候循環應該停止？
until leftToEat(cow) == 
    cow.eat()

goto banana
           

特技關卡 -
#這個函數檢測奶牛的重量是否
#和門上的條件相同
shouldNotEat = (c) ->
    return c.weight() == 

say shouldNotEat(cow)

until shouldNotEat(cow)
    cow.eat()
for b in bananas
    goto b
           

特技關卡 -
#修複這個函數傳回如果奶牛的重量是
#和門上的條件相同
shouldNotEat = (c) ->
    return c.weight()==

#使用shouldNotEat函數打開大門
for i in [,,]
    until shouldNotEat(cows[i]) 
        cows[i].eat()
    goto bananas[i]
           

特技關卡 -
startWithBananaZero = () ->
    d0 = distanceTo bananas[]
    d2 = distanceTo bananas[]
    if d0 < d2
        return yes
    else
        return no

if startWithBananaZero()
    x = 
    times ->
        goto bananas[x]
        x = x + 
else
    x = 
    times ->
        goto bananas[x]
        x = x -