Напиши програм на основу којега ће робот доћи на поље (3, 3) и покупити лоптицу.

Да би дошао на жељено поље робот мора два пута да иде напред, да се окрене на лево, затим опет да иде два пута напред и на крају да покупи лоптицу. То му можемо наредити наредним програмом.


1
from karel import *
2
napred()      # idi napred
3
napred()      # idi napred
4
levo()        # okreni se nalevo
5
napred()      # idi napred
6
napred()      # idi napred
7
uzmi()        # uzmi lopticu
(Карел_на_поље_33)

Прва линија програма from karel import * је линија којом почињу сви програми за Карела - остави је таквом каква јесте. Након тога се роботу задаје једна по једна наредба, свака у посебном реду. Иза сваке наредбе роботу наведене су заграде (њих не смемо изоставити). Додатно, свака наредба мора бити у посебном реду и испред наредби не смеш писати размаке. Оваква правила називају се синтаксичка правила и ако се неко од њих не испоштује долази до синтаксичке грешке. Програм не сме садржати ни једну синтаксичку грешку да би исправно радио.

Текст иза знака # представља такозване коментаре. Робот тај текст не чита - написали смо га само да би теби било јасније шта која наредба значи.

У наредном програму има неколико синтаксичких грешака. Ако покушаш да га покренеш добићеш поруку

SyntaxError: bad input on line 4
Примети да је грешка пријављена у линији 4 иако је грешка направљена већ у линији 3, где су изостављене заграде. Ово се често дешава, па када анализираш где је грешка настала, увек провери и линију испред оне која је у поруци о грешци наведена.

Исправи све синтаксичке грешке, па онда покрени програм.


1
from karel import *
2
napred()
3
napred
4
  levo()
5
napred)
6
    napred[]
7
 uzmi{}
(Карел_на_поље_33_грешке)

У претходном програму је свака наредба Карелу била написана у посебној линији. Могуће је задати и више наредби у једној линији, али тада их је потребно раздвојити тачка-запетом (симболом ;).


1
from karel import *
2
napred(); napred(); levo(); napred(); napred(); uzmi()
(Карел_на_поље_33_један_ред)

Решење у којем је свака наредба у посебној линији се ипак мало чешће користи (вероватно зато што се такав код лакше чита и мења, ако је то потребно).

Претходни садржај можеш погледати и у наредној видео-лекцији.


Програмирање слагањем блокова
Пошто претпостављамо да већ познајеш програмирање уз помоћ слагања блокова (на пример у програму MIT Scratch или на сајту code.org), омогућили смо ти да прве програме пишете на два начина: текстом у програмском језику Python или слагањем блокова. Сваки програм написан за робота Карела се може приказати и у облику блокова - довољно је да притиснеш дугме Blockly. Програм састављен од блокова можеш мењати и прилагођавати (можеш променити редослед блокова, додати нове блокове, обрисати неке блокове, променити вредности уписане у неке блокове и слично) и када завршиш дугметом Врати у Python које се налази у доњем десном углу прозора тај програм можеш добити написан у језику Python. Ускоро ћеш и сам/сама видети да је писање текста често бржи и ефикаснији начин креирања програма (зато сви професионални програмери своје програме пишу у текстуалним, а не у блоковским језицима), тако да те охрабрујемо да од самог почетка кренеш да програме уносиш куцањем текста у програмском језику Python, а да блокове користиш само као помоћно средство када се заглавиш.

Испробај ту могућност на примеру који смо мало пре видели, тако што ћеш коришћењем блокова додати наредбе која недостају, тако да робот дође до поља (3, 3) и покупи лоптицу.


1
from karel import *
2
napred()      # idi napred
3
napred()      # idi napred
4
napred()      # idi napred
5
napred()      # idi napred
(Карел_на_поље_33_Blockly)

Ако покренеш програм пре него што додаш наредбу да робот скрене, видећеш да ће доћи до грешке током извршавања твог програма. Наиме, у трећем кораку напред робот ће ударити у зид и добићеш поруку Робот је ударио у зид.

Коришћење блокова демонстрирано је и у наредној видео-лекцији.


Пребаци лоптицу на поље (3, 5)

У овом задатку ћемо нашем роботу дати мало компликованији задатак. Потребно је дође до поља (4, 3) на којем се налази једна лоптица, а затим да ту лоптицу пребаци у рупу на пољу (3, 5).

Допуни наредни програм тако да робот изврши дати задатак.


1
from karel import *
2
napred()
3
napred()
4
levo()
5
napred()
6
napred()
7
desno()
8
napred()
9
uzmi()
10
???    # dodaj naredbe koje nedostaju ovde
11
ostavi()
(Карел_пребаци_лоптицу)

Ако користиш блокове, на месту на ком треба да додаш нове наредбе добићеш један велики зелени блок који треба да избациш (на пример, да га превучеш до канте за смеће) и да га замениш одговарајућим наредбама. Наравно, покушај задатак да решиш као прави профи-програмер: писањем програмског кода, а не слагањем блокова!

Пребаци обе лоптице у рупу

У овом задатку робот Карел има задатак да покупи обе лоптице и пребаци их у рупу (на њој пише колико лоптица треба да оставиш у рупу).

Помози сада роботу тако што ћеш попунити недостајућа места у коду.


1
from karel import *
2
desno(); napred(); napred();                    # idi do prve loptice
3
uzmi();                                         # uzmi je
4
???                                             # idi do rupe
5
ostavi();                                       # ostavi lopticu
6
???                                             # idi do druge loptice
7
???                                             # uzmi je
8
desno(); desno(); napred(); desno(); napred();  # idi do žutog polja
9
ostavi()                                        # ostavi lopticu
(Карел_пребаци_две_лоптице_1)

Понављање - бројачка петља for
Често робот исту наредбу треба да понови више пута. Да би се такви програми могли једноставније писати је коришћење петљи.

Иди 8 поља напред

У наредном лавиринту постоји 8 поља испред робота. Коришћењем петље учини да робот дође до лоптице и да је затим покупи.

Један начин да решимо задатак је да роботу 8 пута задамо наредбу да иде напред и затим наредбу да покупи лоптицу.


1
from karel import *
2
napred()
3
napred()
4
napred()
5
napred()
6
napred()
7
napred()
8
napred()
9
napred()
10
uzmi()
(Карел_8_поља_напред)

Замислимо колико би досадно било куцати десет или сто пута наредбу да робот иде напред, када би лавиринт био већи. Пошто се у програмима често јавља потреба да се неке наредбе понављају, сви програмски језици обезбеђују начин да се то постигне. У програмском језику Python, који наш робот Карел разуме, понављање се постиже коришћење наредбе for. Понављања у програмима се називају циклуси или петље (по чему је наша фондација „Петља” добила име). Погледајмо како се претходни програм може скратити употребом петље for.


1
from karel import *
2
for i in range(8):
3
    napred()
4
uzmi()
(Карел_8_поља_напред_for)

Овде смо употребили петљу for i in range(n): која је уобичајени начин да се изрази да се наредбе наведене у телу петље извршавају n пута (ми смо уместо n навели 8, чиме смо постигли то да се наредба napred() изврши 8 пута). Овим смо дакле рекли „Понови пет пута корак напред”. Уместо i смо могли употребити и неко друго слово или реч (или знак _).

Наредбе које се понављају (за њих се каже да чине тело петље) се обавезно морају увући у односу на наредбу for (обично помоћу неколико размака, најчешће 4, или једног табулатора тј. карактера Tab који се на тастатурама налази лево од тастера Q). Када се петља заврши, извршава се наредба која је наведена иза петље и то поравната са речју for (у претходном програму то је наредба uzmi()). Наредба uzmi() након петље for није увучена, што значи да се она извршава само једном и то када се заврши извршавање петље for тј. када се њено тело изврши одговарајући број пута. Када би она била увучена и она би се понављала.

Неке честе грешке
Нагласимо да се на крају линије у којој се употребљава наредба for обавезно ставља двотачка (симбол :). Ако се она не наведе добићеш поруку о грешци

SyntaxError: bad input on line ???
Ово значи Синтаксичка грешка: лош унос на линији ??? - број линије ти може указати на то где је грешка направљена (немој да заборавиш да провериш и линију изнад те). Јако честа грешка програмера-почетника је да забораве двотачку на крају наредбе for - обрати пажњу на тај важан детаљ.

Ако заборавиш да увучеш тело петље, поново ћеш добити поруку

SyntaxError: bad input on line ???
Још једна грешка која може наступити услед неодговарајућег увлачења наредби је и

IndentationError: unindent does not match any outer indentation level on line ???
На енглеском језику IndentationError значи Грешка у увлачењу.

У складу са претходном дискусијом, исправи наредни програм.


1
from karel import *
2
for i in range(8)
3
napred()
4
 uzmi()
(Карел_8_поља_напред_for_грешке)

Петљама ћемо се много детаљније бавити у поглављу Понављање.

Иди 7 поља напред
Пробај сада сам/сама да допуниш наредни програм тако да робот покупи лоптицу. Не заборави да се пре петље окрене у правом смеру.


1
from karel import *
(Карел_7_поља_напред)

Покупи 10 лоптица

Испред робота се налази 10 лоптица. Напиши програм којим робот купи све те лоптице.


1
from karel import *
(Карел_покупи_10_лоптица)

Савет: употреби поново петљу for да се иста наредба не би понављала пуно пута.

Покупи пет лоптица на пет поља испред

Напиши програм у којем робот купи лоптице на пет поља испред себе.


1
from karel import *
2
for i in range(5):
3
    napred()
4
    uzmi()
(Карел_покупи_5_лоптица_на_5_поља_испред)

Приметимо да су у овом програму две наредбе робота понављале пет пута (наредба napred() и наредба uzmi()) и да су обе биле увучене по 4 карактера. Пробај сада да наредиш роботу да се врати на почетно поље када покупи лоптице.


1
from karel import *
2
for i in range(5):
3
    napred()
4
    uzmi()
5
???  # dopuni ovde kod
(Карел_покупи_5_лоптица_на_5_поља_испред_и_врати_се)

На крају, модификуј програм тако да робот док се враћа оставља по једну лопту на сваком пољу, тако да распоред лоптица буде исти као и на почетку.


1
from karel import *
2
for i in range(5):
3
    napred()
4
    uzmi()
5
???  # dopuni ovde kod
(Карел_покупи_5_лоптица_на_5_поља_испред_и_врати_се_остављајући_лоптице)

Претходни садржај можеш погледати и у наредној видео-лекцији.


Покупи по три лоптице на пет поља испред

На сваком од пет поља испред робота налазе се по три лоптице. Напиши програм на основу којег робот купи све те лоптице.


1
from karel import *
2
for i in range(5):
3
    napred()
4
    for j in range(3):
5
        uzmi()
(Карел_покупи_по_3_лоптице_на_5_поља_испред)

Приметимо да се у претходном програму петља for налази у телу петље for. Такве се петље називају угнежђене петље. Приметимо да смо у њима морали употребити различита слова (у спољној смо употребили i, а у унутрашњој j). Више детаља о овоме биће у наредним поглављима.

Претходни садржај можеш погледати и у наредној видео-лекцији.


Домаћи задатак
Пребаци обе лоптице у рупу

Задатак је исти као мало пре, једино се лавиринт мало променио. Потребно је да робот пребаци обе лоптице у рупу.


1
from karel import *
2
??? # idi do prve loptice i uzmi je
3
??? # idi do druge loptice i uzmi je
4
??? # idi do rupe i ostavi obe loptice
(Карел_пребаци_две_лоптице_2)

Размакнуте лоптице