Informatika I Racunarstvo PDF

М и р о с л а в И л и ћ
ПРОГ РА МСКИ ЈЕЗИК
ДЕЛФИ
П Р В И К О Р А Ц И
(програмирање од А до Ш)
Београд, 2014.
Програмирање није само написати програм који решава одређени проблем.
Програмирање је више од тога, много више.
Програмирање је уметност.
Сваки, па био то и најједноставнији задатак може се решити тако да буде на ваш начин занимљив,
необичан, привлачан, заводљиво оригиналан, ...
Ако желите да се бавите програмирањем радите то из љубави, нека сваки програмски ред буде стих
у поеми вашег живота, мисао која плени духом.
Ако и не будете програмери у свом будућем животу, чак и тада посао који обављате нека буде
прављење најлепшег букета који ћете поклањати свету.
Мирослав Илић Девета гимназија "Михаило Петровић Алас" Нови Београд

Садржај
Решавање проблема помоћу рачунара . . . . . . . . . . . . . . . . . . . . . . 5

Основи алгоритмизације. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Трансформација проблема на облик погодан за решавање на рачунару. . . . . 7
Програмски језици и њихова синтакса и семантика. . . . . . . . . . . . . . . . . . . 8
Класификација програмских језика . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Програмски језик паскал . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Питања на која треба обратити пажњу . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Програми засновани на прозорима . . . . . . . . . . . . . . . . . . . . . . . 17
Основне карактеристике програма заснованих на прозорима . . . . . . . . . . 18
Елементи графичког корисничког интерфејса (Graphical User Interface) . . 22
Програми руковођени догађајима . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Увод у развојно окружење програмског језика . . . . . . . . . . . . . . . 25
Почетак рада и управљање развојним окружењем. . . . . . . . . . . . . . . . . . . 27
Празан пројекат. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Чување и отварање пројекта. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Форма и подешавање њених својстава. . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Додавање компоненти форми. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Компонента у жижи. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Једноставне компоненте . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Натпис (Label) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Оквир за уношење и приказивање текста (Edit) . . . . . . . . . . . . . . . . . . . . . . . . 38
Дугме (Button) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Мемо поље (Memo) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Часовник (Timer) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Оквир за графички објекат (Image). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Компоненте избора . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Радио-дугме (RadioButton) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Оквир за потврду (CheckBox) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Оквир с листом (ListBox). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Комбиновани оквир (ComboBox). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Контејнерске компоненте . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Оквир за групу (GroupBox) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Плоча (Panel) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Догађаји компоненти и обрада догађаја. . . . . . . . . . . . . . . . . . . . . . . . . . 43
Типови података. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Основни елементи програмског језика . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Структура програма . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Подела типова података . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Целобројни тип (integer). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Реални тип (rеаl) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Логички тип (boolean) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Знаковни тип (char) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
Стринг тип . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
Набројиви тип и интервални тип . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

4 Рачунарство и информатика за трећи разред гимназије 4
Скуповни тип . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Класа и методе класе – основни појмови . . . . . . . . . . . . . . . . . . . . . . . . . 57
Наредбе и изрази . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Синтакса и семантика израза. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Аритметички и логички изрази . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Наредбе програмског језика . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Конверзија типова података. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Уношење и приказивање података. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Алгоритам размене вредности две променљиве. . . . . . . . . . . . . . . . . . . . . . . . 61
Програмирање израчунавања по једноставним математичким формулама.. . . . 61
Уводни задаци . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Задаци за самосталан рад . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
Наредбе гранања . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Синтакса наредбе If . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Синтакса наредбе Case. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Алгоритми са гранањем . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Питања на која треба обратити пажњу . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Задаци са гранањем . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Неке занимљиве компоненте . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Задаци за самосталан рад. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
Наредбе за организацију циклуса . . . . . . . . . . . . . . . . . . . . . . . 151
Синтакса наредби за организацију циклуса. . . . . . . . . . . . . . . . . . . . . . . . . . . 151
Примена наредби break и continue у циклусима . . . . . . . . . . . . . . . . . . . . . . . 153
Неки алгоритми са циклусима . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
Питања на која треба обратити пажњу . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
Задаци са циклусима. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
Опис методе класе . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
Примери једноставнијих функција . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
Примери једноставнијих процедура . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
Примери рекурзивних функција и процедура. . . . . . . . . . . . . . . . . . . . . . . . . . 207
Питања на која треба обратити пажњу . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
Задаци са функцијама и процедурама . . . . . . . . . . . . . . . . . . . . . . . . . . 209
Задаци за самостални рад . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
Тип низ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
Једнодимензионални низови. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
Основне операције са низовима . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
Дводимензионални низови. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
Алгоритми за израчунавања и трансформације на табели и њеним деловима. . 241
Визуелна компонента за табеларни приказ текста. . . . . . . . . . . . . . . . . . . . 242
Задаци са низовима . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
Тип слог и датотеке . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
Тип слог . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
Датотеке . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
Формирање датотеке . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271
Упис података, читање и претраживање датотеке . . . . . . . . . . . . . . . . . . . 273
Уређивање података датотеке . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
Брисање података или датотеке . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
Задаци са слоговима и датотекама . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
Литература . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
Решавање проблема помоћу рачунара
Рачунари се, у данашње време, могу применити у готово свим областима људског
деловања и од њих се очекује да решавају све проблеме на које се може наићи. Међутим,
потребно је знати да рачунар сам не може решити ни један (и најједноставнији) проблем. Он
само извршава низ инструкција које му корисник задаје. Према томе, само ако корисник
разуме проблем и познаје пут за решавање тог проблема до најситнијих детаља, он ће бити у
стању да тај пут представи преко низа инструкција које рачунар може да разуме и прихвати.
Тек тада можемо очекивати од рачунара да тај низ инструкција веома брзо и тачно изврши и
да дође до резултата који су потребни. То значи да рачунар не олакшава кориснику рад на
решавању проблема, већ само извршава задати програм и у веома кратком времену даје
одговарајуће резултате.
Када се процес решавања неког проблема спроводи без рачунара, о сваком кораку се
мисли непосредно у тренутку када тај корак треба да се спроведе, тј. када покушавамо да
решимо неки проблем ми не знамо унапред шта ћемо све радити док не дођемо до решења, већ
одлучујемо само о првом следећем кораку. Међутим, када се за решавање проблема користи
рачунар, тада цео низ корака које тај процес обухвата мора бити прецизно одређен и унапред
задат са свим могућностима које могу да се појаве у току извршавања у зависности од задатих
почетних вредности. Тај низ корака мора бити прецизно дефинисан у облику веза и логичких
услова. То значи да се, пре него што се приступи коришћењу рачунара за решавање неког
проблема, мора написати програм. Са написаним програмом и улазним подацима, који
одређују вредности низа параметара који се јављају у програму, рачунар може да добије
резултате задатка који се решава.
Основи алгоритмизације
Појам програмирања подразумева дуг процес размишљања о задатку. У том процесу

решавања датог проблема користимо познате методе и правила или сами одређујемо
поступке решења. Када се заврши мисаони процес решавања проблема, програм је готов. Сада
је процес записивања програма само нужна формалност коју и не мора да обави сам
програмер. Довољно је да се идеја решења запише у погодном облику да би на основу тог
записа нека, за то квалификована особа, кодирала програм - уписала га у меморију рачунара и
извршила. Да би се идејно решење проблема могло записати тако да га свако за то
квалификован, може разумети морају се поштовати нека прописана и формализована
правила понашања. Тај коначан скуп строго формулисаних правила којима је одређен низ
радњи за решавање одређеног проблема чини алгоритам.
Алгоритам је у математику увео арапски математичар Мухамед Ал
Хорезми (Abu Abdullah Muhammad bin Musa al-Khwarizmi живео око 825.
године нове ере). Он је написао књигу Ал Хорезми о индијској вештини
рачунања где у арапску математику уводи индијске цифре и децимални
бројни систем. У књизи су прецизно, корак по корак, дефинисане све четири
основне математичке операције (сабирање, одузимање, множење и дељење)
у облику упутстава која се састоје од елементарних корака. Када је касније
књига преведена на латински добила је назив Algoritmi de numero indorum.
Од овог лошег латинског превода презимена арапског математичара и
потиче сама реч алгоритам, која је дуго затим означавала поступак за
рачунање са децималним бројним системом (и индијским, односно, арапским
цифрама) и прецизан начин описивања пута до решења проблема у математици. Даљим
развојем науке, алгоритам је постао један од основних појмова како у математици тако и у
рачунарству.

Алгоритам је коначан низ једноставних корака којим се описује поступак решавања

одређеног реалног проблема, али такав да се, после коначно много времена, поступак
завршава. Многе реалне ситуације у животу одвијају се по тачно одређеним корацима тако да
можемо рећи да су алгоритми саставни део свакодневног живота. Постоји релативно
прецизан поступак по коме покрећемо аутомобил, телефонирамо, прелазимо улицу, кувамо
кафу… Чак, можемо рећи да се и сам живот одвија по неким, мање или више строгим,
правилима. Добар пример алгоритма је сваки кулинарски рецепт; у њему јасно разликујемо
шта је улаз (потребни састојци), шта је обрада (прецизно описан поступак за кување) и шта је
излаз (готово јело). Алгоритам можемо у најопштијим цртама приказати шемом:
Постоји много начина да се алгоритам прецизније дефинише, али за нас је довољна и

једна оваква, не престрога, дефиниција:
Алгоритам је повезани низ елементарних правила, односно, алгоритамских
корака у којима се улазне величине поступно трансформишу све док се не добије коначно
решење.
Сваки алгоритам красе следеће карактеристике:
• одређеност - сваки алгоритамски корак мора да буде прецизно и једнозначно
дефинисан,
• детерминисаност - вредност која се добија после извршавања сваког корака
једнозначно је одређена вредностима из претходног корака
• коначност - алгоритам се мора завршити после коначно много алгоритамских корака,
• масовност - алгоритам се прави тако да се може применити за решавање читаве групе
сродних проблема без обзира на различите полазне величине,
• ефикасност - алгоритам треба да доведе до решења за што краће време и у што мањем
броју алгоритамских корака.
Алгоритам је употребљив ако се његовом применом добија резултат у коначном
„разумном” времену. Алгоритам који би бирао потез играча шаха тако што ће испитати све
могуће последице потеза, захтевао би милијарде година на најбржем рачунару. Поступци
израде алгоритама нису једнозначни, иначе би постојали генератори алгоритама који сами
решавају све проблеме. Самим тим, алгоритмизација проблема захтева и велику дозу
креативности. У пракси алгоритми се на рачунару представљају изворним кодом (source)
неког вишег програмског језика. Програмски језици имају веома строга правила писања
инструкција и дефинисања података која, код различитих програмских језика могу бити мање
или више слична, али и битно различита.
Да би се логичко одвијање процеса решавања проблема лакше сагледало, алгоритам се
представља дијаграмом тока, тј. графичком алгоритамском шемом.
Према форми веза у шеми алгоритми могу бити:
• прост линијски алгоритам - сваки алгоритамски корак се остварује тачно једном од
горе на доле,
• разгранати линијски алгоритам - сваки алгоритамски корак се остварује највише
једном, тј. има и корака који се неће остваривати за дате полазне величине,
• циклични алгоритам - постоје алгоритамски кораци који се остварују више пута,
• селективни алгоритам - у зависности од датог критеријума бирају се следећи
алгоритамски кораци.
Међутим, код решавања неког проблема, програмер нема пред собом обавезу да направи
један од строго одређених типова алгоритама. Најчешће се дешава да се за решење проблема
морају употребити различите, готово све поменуте структуре алгоритама у појединим
сегментима програма, зато ову поделу алгоритама схватамо само као теоријску.

Трансформација проблема на облик погодан за решавање на рачунару
Да бисмо решили неки проблем коришћењем рачунара, неопходно је креирати програм у

неком програмском језику. Тај процес је комплексан и у њему можемо издвојити следеће фазе:
Поставка проблема. Проблем који се решава треба прецизно и потпуно описати на
природном језику. То ради корисник коме је намењен програм. Да не би дошло до грешке при
формулисању захтева пожељно је да наручилац буде рачунарски описмењен што неретко није
случај, зато се већ у овом кораку мора остварити јака сарадња са програмерима. Јасно се
одређује циљ и основна намена програма, анализирају се постојеће информације и врши се
избор неопходних почетних информација, описују се сви излазни подаци.
Анализа проблема. У овој фази прецизно се дефинишу улазни и излазни подаци,
ограничења њихових вредности и дефинишу све везе између података. У овој фази треба
детаљно поставити задатак, уочити и упознати све елементе значајне за решавање задатка.
Потребно је критички оценити значај свих елемената и изабрати оне који су битни за
решавање постављеног задатка. Дефинисање проблема је у многим случајевима веома
једноставно, међутим, често се догађа да је пут до дефиниције проблема веома дуг. Од тога
како је проблем дефинисан веома зависи какве ће се тешкоће појавити у конструисању
алгоритма и каква ће бити употребљивост програма. Резултат ове фазе је формалан опис
проблема, израда математичког модела који се може реализовати на рачунару који ће
представљати скелет програма. Ту спада, на пример, избор математичке методе која је
примерена датом проблему. Приликом избора методе треба имати на уму да проблем
решавамо на рачунару, а не ручно. Тако се, имајући у виду велику брзину рачунара у
извршавању неких врста операција, можемо радије одлучити за поступак који захтева велики
број врло простијих операција, него за елегантнију и бржу методу која се састоји од
интелигентнијих операција.
Разрада алгоритма. У овој фази се дефинише начин на који се од почетних, улазних
података долази до тражених, излазних резултата. Већина проблема може се решити на више
начина, зато треба проанализирати све начине и изабрати онај који је оптималан. Сложеност
решења проблема можемо посматрати са аспекта броја потребних операција (времена
потребног за извршавање алгоритма) и са аспекта потребних меморијских ресурса да се
алгоритам изврши (просторна сложеност алгоритма). Доказ о коректности изабраног
поступка за решавање проблема неопходно је прецизно извести. О овим аспектима треба
посебно водити рачуна при решавању сложених проблема, док их код једноставних проблема
занемарујемо.
Пројектовање опште структуре програма. У овој фази врши се избор програмског
језика. Разматра се цео проблем и дели се у логичке целине; свака целина се даље дели у
зависности од њене сложености. Прецизно се дефинише начин чувања информација, тј.
дефинише се структура података.
Кодирање. У овој фази описују се, у неком програмском језику, подаци и поступак
решавања проблема, који су дефинисани у претходним фазама, то је запис алгоритма у облику
прихватљивом за рачунар. Овако записан алгоритам назива се програм. Програм записан у
неком програмском језику често се зове код, зато се ова фаза и назива кодирање. Програм
може бити записан на машинском, симболичком или неком вишем програмском језику.
Писање програма представља фазу реализације, јер програм оспособљава рачунар за
решавање одређеног задатка. Ако смо у претходним фазама прецизно разрадили алгоритам,
структуру програма и структуру података, ова фаза је релативно једноставна за извођење.
Фаза превођења, извршавања и тестирања програма. Подсетимо се да се на рачунару
може извршавати само програм који је написан помоћу бинарних цифара (на машинском
језику). Зато је потребно програм написан на програмском језику вишег нивоа превести на
машински језик; превођење се врши помоћу посебних програма: компајлера, односно,
интерпретера. Да би се програм извршавао, потребно је формирати извршну верзију (exe
верзију). То се постиже помоћу специфичних програмских алата који се разликују од језика до
језика (повезивачи, билдери). Врло често су фаза превођења и фаза прављења извршног фајла
обједињене. Тестирањем програма треба проверити да ли програм у потпуности решава
постављени задатак. То је врло важна фаза у којој треба открити евентуалне скривене грешке.
Ово је крупан проблем у програмирању. Обично се дешава да програм није потпуно исправан,
па је потребно пронаћи грешке. На неке грешке нас упозорава рачунар тиме што за програм
јавља дијагностичку поруку која садржи листу грешака. Када отклонимо те грешке то још увек
не значи да је програм исправан. Програм се тестира тако што се извршава за одабране

скупове улазних величина. Примерима можемо показати да програм није исправан, али не
можемо показати да је исправан. Иако је рачунар идеално средство за тестирање, исправност
програма не можемо доказивати тако што ћемо програм извршити за сваки могући скуп
улазних величина. За велики број програма овакво тестирање би трајало годинама. Зато се
проверавање врши са подацима за тестирање које треба одабрати тако да се без већих напора
могу предвидети исправни резултати и којима треба да обухватимо све могуће ситуације,
свакако и оне кад постављени проблем нема решења. Ако је програм и даље неисправан на то
ће нас упозорити неочекивани резултати. Овај поступак може бити веома дуготрајан и да од
програмера захтева много спретности и досетљивости. По потреби се враћамо на претходне
фазе.
Израда документације. У документацији програма описује се шта програм ради
(поставка задатка и алгоритам за његово решавање), дају се упутства како се користи (начин
задавања улазних величина и издавања резултата), детаљније се описује алгоритам и
објашњавају поједине формуле и поступци када је у питању решавање сложенијих проблема и
слично. Документацију никако не треба започињати када је програм написан, већ је треба
писати током израде програма, али је свакако треба допунити на крају када је програм
комплетно завршен. Детаљна документација о програму омогућава лако коришћење
програма, као и евентуалне касније промене у програму.
Одржавање програма. Током коришћења програма могу се уочити неке грешке, које се
морају отклонити. Понекад треба извршити неке промене у програму услед нових околности.
Ако је програм читко написан и ако има добру документацију, онда је ова фаза једноставна,
како за саме ауторе програма, тако и за друге програмере. У супротном, многим програмерима
је лакше да напишу нови програм него да преправљају већ постојећи. У овој фази долази и до
проширивања програма додавањем нових функционалности. Када се развија велики пројекат,
све претходно наведене фазе су једнако важне. Оспособљавање програмера за успешно
реализовање великих пројеката је дуготрајан процес. У едукацији полазимо од једноставних
примера ка сложенијим. У овом процесу проблеми које решавамо су једноставни, па су све
фазе, осим фазе разраде алгоритма, једноставне.
Програмски језици и њихова синтакса и семантика.
Језик је средство комуницирања у процесу размене и обраде информација и података.

Постоје природни и вештачки језици. Природни језици су језици људи. Иако су врло богати
могућностима изражавања, ови језици су практично неупотребљиви у комуникацији на
релацијама човек - машина или машина - машина, бар у данашњим условима. Да би се
остварила оваква комуникација приступило се конструкцији вештачких језика. Вештачки
језици су једнако приступачни и човеку и машини. У зависности од области и начина примене,
конструисани су бројни вештачки језици. Програмски језици су подврста ових језика.
Програмски језици су вештачки језици одређени помоћу изабраног скупа симбола. У њима се
јављају и неки специфични знаци у односу на језичке конструкције природних језика.
Елементарне конструкције програмског језика имају одређена значења, али се у програму
никада не јављају као самостални елементи који утичу на рад рачунара. То су константе,
подаци, променљиве, низови и изрази. Повезани низ симбола и елементарних конструкција
који има одређено значење, а може да представља самосталну целину у програму, односно,
може да проузрокује акцију на рачунару је сложена конструкција програмског језика. Такве
конструкције су наредбе, програмски редови, потпрограми и програми.
Правила помоћу којих се формулишу елементарне и сложене конструкције програмског
језика чине његову граматику. Правила помоћу којих се гради и проверава коректност
језичких конструкција чине синтаксу програмског језика. Програмски језици су тако
конструисани да рачунар може да уочава и упозорава на синтаксне, формалне грешке.
Значење појединих језичких конструкција проучава семантика. Састављање програма,
исписивање програмских инструкција, тј. кодирање програма врши се на основу алгоритма.
Семантичке грешке настају као последица грешке у алгоритму. Ову врсту грешака рачунар не
може уочити.
Синтакса се односи на начине на који појединачни симболи могу да креирају исправне
реченице језика (или програме). Синтакса дефинише формалне релације између елемената
језика, тиме пружајући структурне описе различитих израза који чине исправне ниске језика.
Синтакса се бави само формом и структуром симбола језика без било каквих разматрања у
вези са њиховим значењем. За разлику од природних језика, сваки програмски језик има скуп
строго дефинисаних правила којима се описује поступак писања програма. Пошто се ради о
језику за комуникацију са рачунаром и најмања двосмисленост доводи до грешака. Синтакса
програмског језика се описује помоћу метајезика. Синтаксне дефиниције се често задају
помоћу специјалне металингвистичке симболике која је позната под именом Проширени
Бекус-Науров запис (Extended Backus- Naur Form) или скраћено EBNF. EBNF омогућава врло
прецизан и компактан опис елементарних језика, коришћењем неколико симбола специјалне
намене – метасимбола. Најпростији појмови су симболи и резервисане речи језика. Они се
називају терминални симболи или терминали и пишу се између наводника. Сви остали
појмови, нетерминали, се постепено изводе из терминалних помоћу специјалних
металингвистичких формула и стављају се између угластих заграда. За опис синтаксе језика,
због веће прегледности, користе се и синтаксни дијаграми. Они се састоје из кружића, овалних
симбола и правоугаоника повезаних у одређеном поретку. Кружићи или овали означавају
терминале. Правоугаоници означавају конструкције које се накнадно дефинишу
(нетерминале), тј. које се ослањају на друге синтаксне дијаграме. Између EBNF и синтаксних
дијаграма постоји веза која омогућава представљање појмова који су записани у EBNF преко
синтаксних дијаграма и обрнуто.
Семантика придружује значење синтаксно исправним нискама језика. За природне
језике, ово значи повезивање реченица са неким специфичним објектима, мислима и
осећањима. За програмске језике, семантика описује понашање рачунара током извршавања
програма написаног на неком језику. Ово понашање може се описати релацијама између улаза
и излаза програма или корак-по-корак објашњењем како ће се програм извршавати на
стварној или апстрактној машини.
Класификација програмских језика

Према степену зависности од рачунара програмски језици се деле на:
• машински зависне и
• машински независне језике.
Машински зависни језици се деле на:
• машинске и
• машински оријентисане језике.
Машински језици су језици најнижег нивоа. По структури су најближи машини. Толико су
зависни од типа рачунара за који су прављени да се не могу применити на било који други тип
рачунара. Главна предност ових језика у односу на све друге је брзина извршавања програма.
Нема губљења времена на било каква превођења. Оног тренутка када је програм у меморији
рачунара он се и извршава. Зато се овај језик користио за писање неопходних системских
програма.
Машински оријентисани језици се деле на:
• симболичке и
• макро језике.
У симболичким језицима се поједине групе симбола машинског језика замењују
мнемоничким симболом, па су зато разумљивији, али још јако зависе од рачунара за који су
прављени. Брзина извршења програма се смањила, у односу на машинске језике, јер се
програм најпре преводи на машински језик, па тек онда извршава. Међутим, још се ту ради о
завидној брзини извршења програма. Због тога се ови језици користе за писање неких
системских програма.
Макро језици су највиши ниво машински зависних језика. Код ових језика се група
команди симболичког језика замењује једном макро командом. Зато се програми на макро
језицима пишу много једноставније него на симболичким, разумљивији су и краћи, али још
увек у великој мери зависе од рачунара за који су прављени. Ови језици се, углавном, користе
за писање системских програма.
Машински независни језици се деле на:
• процедуралне језике и
• проблемски оријентисане језике.
Процедурални језици подразумевају најпре алгоритамско решавање проблема, а затим

формално исписивање програма. Програми писани овим језицима, релативно једноставно,
могу да се пренесу са једног типа рачунара на други.
Проблемски оријентисани језици су језици највишег нивоа. Код оваквих језика програмер
треба само да назначи проблем и пут за његово решавање, а програм генератор даље преузима
посао формирања алгоритамског решења проблема и формалног исписа програма. Због
овакве своје структуре, ови језици су за сада незграпни, троше пуно времена и меморије и
прилично су спори. Ипак, то су језици будућности и са даљим развојем науке и технике ће се
све више усавршавати.
Пошто је написан неки програм, природно је да се он изврши. Да би се неки програм
могао извршити, све наредбе се морају превести на машински језик. Само се програми на
машинском језику могу извршити непосредно, без превођења. Посао превођења наредби
неког програмског језика на машински језик обављају преводиоци. То су посебни програми
који повезују програмске конструкције језика са командама машинског језика. Према нивоу
језика са кога се програм преводи преводиоце делимо на:
• асемблере,
• макроасемблере,
• компилаторе и
• генераторе.
Симболички језици су асемблери, макро језици су макроасемблери, процедурално
орјентисани језици су компилатори, а проблемски орјентисани језици су генератори.
Процес превођења и процес извршавања програма су два битна процеса са којима се
сусрећемо приликом рада на неком програму. Они могу бити временски раздвојени или
повезани. Према тој временској карактеристици преводиоци се деле на компајлере и
интерпретаторе. Код компајлера процес превођења наредби програма је потпуно временски
раздвојен од процеса извршења. Код интерпретатора се у процесу превођења свака преведена
наредба изврши, а затим се прелази на следећу наредбу.
Компајлерског типа су програмски језици:
• fortran - FORmula TRANslation system, намењен је пре свега решавању проблема у
области математичких наука и технике; први важнији алгоритамски језик у историји
програмирања; дизајнирао га је тим програмера америчке компаније ИБМ, 1957. године,
на чијем је челу био Бекус (John Backus); дизајниран је са идејом да служи потребама
научника и научних израчунавања са реалним бројевима (бројевима са покретним
зарезом) као и скуповима реалних бројева организованих у један или више низова;
• cobol - COmmon Business Oriented Language, један од најстаријих виших програмских
језика који је и данас у употреби; углавном служи за писање бизнис и финансијских
апликација и као подршка административним системима у компанијама и владама;
најновија спецификација, кобол 2002, садржи механизме објектно-оријентисаног
програмирања и многе друге модерне могућности;
• algol - ALGOritmic Language, за решавање математичких и научно-техничких проблема;
дизајнирао га је комитет америчких и европских научника рачунарства за сврху објављивања
алгоритама, али и за рачунарска израчунавања, између 1958. и 1960. године; алгол
поседује рекурзивне потпрограме, односно, процедуре које могу саме себе позивати
приликом решавања задатог проблема, редукујући га на мањи проблем било које врсте;
новост у алголу је блок структура, програм је компонован од блокова и може да садржи и
податке и инструкције које имају исту структуру као и сам програм; блок структура је
врло брзо постала стандард за конструисање масивних програма од малих компоненти;
• lisp - LISt Processing, прилагођен симболичкој обради; развио га је и имплементирао
Макарти (John McCarthy) око 1960. године, базирајући га на математичкој теорији
рекурзивних функција; програм развијен у лиспу је функција примењена на податке, а не
низ процедуралних корака, као што је случај у фортрану и алголу;
• pl/1 - Program Language no. 1, развијен је са намером да замени алгол, фортран и кобол,
али није испунио очекивања, тако да није применљив у свим областима рада;
• c - универзални програмски језик; развили су га Ричи (Dennis MacAlistair Ritchie) и
Керниган (Brian Wilson Kernighan) 1972. године, у АТ&Т корпорацији за програмирање
оперативних система; у данашње време је један од популарнијих због своје једноставности,
природности и широке применљивости; неки системски програми пишу се у њему;

• ada - универзални, вишенаменски програмски језик високог нивоа који је заснован на

Паскалу, развијен по налогу америчког Министарства одбране, крајем седамдесетих
година 20. века, са циљем да буде примарни језик овог Министарства и ту се углавном и
користи, име добио по Ади (Ејди) Аугусти Бајрон;
• gps - General Problem Solver, прилагођен моделирању; развили су га Невил (Allen Newell)
и Сајмон (Herbert Alexander Simon) 1957. године у покушају да имитирају људски начин
размишљања;
• simula - применљив у моделирању, настао је 60-их године у Норвешкој, развили су га Дал
(Ole-Johan Dahl) и Најгард (Kristen Nygaard); синтаксно је врло сличан алголу; веома је
утицао на имплементацију неких објеката у програмским језицима С++, Java и С#;
• pascal - развио га је професор Никлаус Вирт (Niclaus Wirth), као језик погодан за учење
структурног програмирања; именован је по чувеном француском математичару и
филозофу Блезу Паскалу (Blaise Pascal), творцу прве рачунске машине која је имала
могућност извођења операције сабирања; паскал је стандардизован 1983. године од
стране Међународног комитета за стандардизацију; данас се користи као почетни
програмски језик за обуку будућих програмера, наручито оних који намеравају да раде на
програмском језику C
и много других мање или више познатих.
Интерпретаторског типа су програмски језици:
• basic - Beginners All-purpose Symbolic Instruction Code, универзални, широко
распрострањени програмски језик; то је назив за више програмсих језика чија је
заједничка особина да су пројектовани са намером да буду једноставни за коришћење;
првобитна верзија овог програмског језика је развијена 1964. године под руководством
Кемењиа (John George Kemeny) и Керца (Thomas Eugene Kurtz). Имплементиран је за
рачунаре серије G.E.225 и за велики број некада популарних кућних рачунара био је у
склопу оперативног система; план је био да то буде једноставан језик за учење
програмирања, да буде почетни корак за студенте који треба да савладају моћније језике
као што су фортран или алгол; један од недостатака бејзика је непостојање стандарда, па
програми писани за један тип рачунар не раде на другим;
• prolog - PROgramming LOGic, прву верзију овог програмског језика развио је 1971.
године Колмерер (Alain Colmerauer); намењен симболичкој обради са елементима
вештачке интелигенције; 1977. године Ворен (David H. D. Warren) је направио први
интерпретатор и компајлер за пролог; јапански научници су почетком осамдесетих
година најављивали да ће њихови рачунари пете генерације бити засновани на овом
програмском језику; пролог је замишљен као машински језик јапанских рачунара пете
генерације; од тада је написано много експертних система на њему; уз лисп, ово је
најпознатији језик вештачке интелигенције
• planer - је дизајнирао Хјуит (Carl Hewitt) 1969. године; намењен симболичкој обради са
елементима вештачке интелигенције;
и други. Неки програмски језици се јављају у обе варијанте (на пример бејзик).
Најпознатији проблемски оријентисани језици су:
• RPG - Report Program Generator, развијен је у IBM, 1959. године за пословне апликације
са намером да замени и истисне Cobol и PL/1, постоје верзије за мејнфрејм и
микрорачунаре; ово је језик врло високог нивоа;
• COGO - Civil Engineering Coordinate Geometry
• STRESS - STRuctural Engineering System Solver
• HYDRO - Hydraulic Engineering Computations
• Mars, Arius, Proza, Graph и други.
Програмски језик паскал

Шездесетих година двадесетог века развија се велики број нових програмских језика, а
најпопуларнији је алгол 60. Као одговор на све веће проблеме у вези са пројектовањем и
одржавањем великих програмских система, до тада коришћеним техникама и језицима за
програмирање, јавила се жеља да се направи такав универзални језик који би покупио све
добре особине свих до тада познатих језика, а отклонио све њихове слабости, језик који би био
применљив у свим областима људске делатности. Зато међународна федерација за обраду
информација (IFIP) 1965. године образује радну групу WG2.1 чији је задатак да на основу
програмског језика алгол 60 начини језик који би био задовољавајући у сваком погледу. На
самом почетку заједничког рада радна група се распала на два табора, јер је дошло до
неслагања у погледу сложености новог програмског језика. Из редова бројнијег табора
изникла је нова верзија програмског језика алгол позната под именом алгол 68 (1968. године
је објављена прва верзија овог језика). Остатак групе је, нешто касније, 1969/70. године
представио потпуно нов програмски језик који је назван паскал по презимену француског
математичара, физичара и филозофа Паскала (Blaise Pascal, 1623-1662.) који је један од првих
конструктора механичких машина за сабирање. Конструктор програмског језика паскал је
професор Високе техничке школе у Цириху (Swiss Federal Institute of Technology) Никлаус
Вирт (Niclaus Wirth), поборник структурираног програмирања.
Структурирано програмирање је скуп техника за израду програма са јасном и лако
разумљивом структуром, уз коришћење података са јасно дефинисаним структурама. Овај
процес карактерише модуларност и техника писања програма одозго на доле.
- Модуларност значи да се у оквиру програма разликују одговарајуће целине, које се
даље могу разлагати на мање и тако даље све до елементарних целина. Свака целина се може
представити у облику потпрограма. На овај начин се један велики, компликовани програм
може разделити на неколико релативно независних целина - модула. Сваки од модула је
релативно лако анализирати и открити евентуалне грешке. На овај начин се избегавају
бескрајна проверавања програма за различите полазне податке.
- Програмирање одозго на доле подразумева писање програма од општег ка појединачном.
Проблем се рашчлани на потпроблеме и сваки од њих се решава као независни проблем. За
сваки се пише одговарајући потпрограм који се, затим, повезују у структурни програм.
Програмски језик паскал подржава ове принципе свим својим основним управљачким
структурама (селекције и циклуси) и структурираним типовима података (низови, записи,
скупови, датотеке). За њега постоји и међународни (ISO) стандард. Са појавом паскала
остварила се идеја структурираног програмирања, али и формалног доказивања коректности
програма. По својој универзалности, једноставности и разумљивости паскал је далеко испред
свих до тада познатих програмских језика. Паскал краси и изражајност, преносивост и
језгровитост. Популарност коју је стекао не опада ни до данашњих дана. Готово да нема
области делатности где се паскал не може применити и где се не примењује.
Стандардна верзија паскала је званично објављена 1979. године. То је језик са једноставном
и логичном структуром и због тога се доста лако учи. Врло је погодан за почетнике, за
савлађивање основних принципа програмирања, као и за усвајање организованог и разумљивог
начина размишљања и изражавања. Стандардни паскал има и неколико озбиљних мана које га
чине неподесним за писање великих програмских система. Пре свега, захтева се да целокупан
текст изворног програма, укључујући и све потпрограме, буде у једној датотеци. Основна идеја
је да се преводиоцу омогући да проверава исправност позивања потпрограма. Једна од
најнепријатнијих врста грешака у програмима, које се и врло тешко проналазе у сложеним
програмским системима, управо је неслагање типова стварних аргумената потпрограма на
местима позивања са типовима формалних аргумената у дефиницији потпрограма. Поред
тога, ова мера требала је и да онемогући паметним програмерима да свесно наведу стварне
аргументе другачијих типова од очекиваних, постижући тиме неке специјалне, нестандардне
(и сумњиве) ефекте. Такви програми се косе са једним од основних принципа структурираног
програмирања - тешко их је разумети. Друга мана су врло ограничене могућности рада са
датотекама. Стандардни паскал предвиђа само секвенцијалне, датотеке са секвенцијалним
приступом. Релативне датотеке са директним приступом не постоје, а још мање индексне
датотеке које би омогућавале приступ помоћу кључа. Да ситуација буде још гора, имена
датотека које програм треба да обрађује, не могу да се бирају у току извршавања програма,
нити су уграђена у сам програм. Датотеке се у програмима представљају симболичким именима
и препуштено је оперативном систему рачунара на који ће начин та имена повезати са физичким
датотекама. На избор датотека корисник, евентуално, може да утиче командама оперативног
система пре почетка извршавања програма. Трећа мана је нефлексибилност потпрограма при
раду са низовима као аргументима. Бројеви елемената низова приликом сваког позивања морају
да буду исти као бројеви елемената предвиђених у дефиницији потпрограма. Чему правити
засебан потпрограм за сортирање низова од по 100 елемената као и засебан за оне од по 500
елемената? Стандардни паскал, такође, нема ни могућност графичког приказивања резултата.
Поред стандардне верзије паскала у то време се користе и турбо верзије. Програмски
језик Turbo Pascal производ софтверске куће Borland појавио се на персоналним рачунарима
под оперативним системом DOS (Disk Operating System) са извесним бројем нестандардних
проширења. Нека од тих проширења обезбеђују боље искоришћавање

хардверских могућности рачунара коме је језик намењен, док друга отклањају
недостатке стандардног паскала. За боље искоришћавање хардверских
могућности рачунара уведено је неколико формата целобројних података и
неколико формата реалних података, који се међусобно разликују по опсегу
вредности и по прецизности израчунавања (стандардни паскал предвиђа
само једну врсту целих и једну врсту реалних бројева). Уведени су и
специјални оператори за манипулисање са битовима унутар целобројних
података. Потреба за писањем текста целокупног програмског система у
једној датотеци отклоњена је увођењем програмских модула. Ти модули се
преводе одвојено и називају се јединицама превођења (compilation units).
Свака датотека програмског текста је један модул и дели се на део за везу са
осталим делом система и део за дефинисање садржаја потпрограма који се
налазе у њој. У првом делу потребно је описати све потпрограме (тип
резултата и типове аргумената) и све глобалне променљиве, који се користе
и изван те јединице. У току превођења делова програма у којима се користе
ти елементи, преводилац ће да консултује делове за везу ради провере
исправности коришћења тих потпрограма и глобалних података. Мора се
признати да се преводилац може преварити вештим манипулацијама, али знатно теже него
што је то био случај у програмским језицима који су се користили пре појаве паскала.
Преводиоцу је потребно подметнути датотеку са лажним делом за везу, што у стандардном
паскалу није могуће. Рад са датотекама је, такође, побољшан. Уведена је могућност придруживања
симболичких имена физичким датотекама у току извршавања програма. Наравно, то уводи
елемент зависности програма од рачунара и од оперативног система, детаљ који се желео избећи
у стандардном паскалу. Поред тога, уведена је и могућност директног приступања појединим
записима у датотекама, без чега не постоји ефикасна обрада датотека. Са појавом верзије 3.0
делимично је решен и недостатак графичког приказа увођењем команди Turtlegraphic групе.
То јесте била нека врста графике, али није задовољавала захтеве. Зато се у верзијама 4.0 и
даљим, уз паскал испоручује и све комплетнији графички пакет Graph.tpu. Актуелна верзија
7.0 уводи могућност рада са мишем, са више програма истовремено, објектно програмирање,
рад са прозорима, програмирање у оквирима оперативног система Windows и друго. Свака од
до сада објављених седам верзија турбо паскала је донела неке новине у односу на претходну,
отклањање уочених грешака и увођење нових могућности у језик. У најзначајнија проширења,
свакако, спадају увођење подршке за објектно оријентисано програмирање (ООП), почев од
верзије 5.5 и подршке за израду атрактивних спрега апликација са корисником, заснованих на
прозорима и менијима (Turbo Vision) при раду под оперативним системом ДОС.
Објектно оријентисано програмирање је нова методологија израде великих програмских
система која се појавила када су програмски системи толико нарасли да технике структурираног
програмирања више нису давале задовољавајуће резултате. Док је у центру пажње структурираног
програмирања структура програма, у центру пажње објектно оријентисаног програмирања су
објекти. Објекти су интелигентни подаци који могу да се налазе у одређеним стањима. Та
стања могу да се промене применом одређених метода. Скуп објеката са истим особинама
чини једну класу. Класе су аналогне типовима података, као што су цели бројеви или реални
бројеви, али могу да представљају произвољно сложене апстрактне објекте (на пример
геометријске фигуре).
Појава програмског језика паскал и велика популарност коју је врло брзо стекао оставила
је дубоке трагове на даљи развој програмских језика. Наиме, из њега су се развили: Mesa,
Concurrent Pascal, Euclid, Gypsy, PLZ, Modula, Telos, Edison, Ada и многи други.
Аугуста Ада Бајрон, грофица од Лавлејса (Augusta Ada (Byron) King, Countess of
Lovelace) је кћи Ана Изабеле Милбанке (Anna Isabella Milbanke) и Џорџа Гордона Ноел
Бајрона (George Gordon Noel Byron), рођена je 10. децембра 1815. године у Лондону, Енглеска.
Ада своја прва знања из области математике добија од Августа Де Моргана (Augustus
DeMorgan, 1806-1871.). Адина мајка је хтела да пробуди интерес за математиком и охрабри
рационалне аспекте њеног карактера насупрот романтичним утицајима њеног оца. Када је
имала 18 година, Ада је слушала предавање о диференцијалној машини коју је дизајнирао
Чарлс Бебиџ (Charles Babbage, 1791-1871.). Почевши писмом од 18. јануара 1836., па све до
своје смрти, Ада је водила дуготрајну кореспондецију са Бебиџом. У октобру 1842, Луиђи
Федерико Менабреа (Luigi Federico Menabrea, 1809-1896.), италијански професор на
Универзитету машинства у Торину објавио је рад којим описује функцију и теорију Бебиџове

аналитичке машине. Ада је превела овај рад са француског на енглески и додала сопствене опсежне коментаре.
Превод је објављен 1843. године. И сам Бебиџ био је импресиониран неким компликованим програмима које је Ада
написала, најсложенији од њих био је одређивање низа Бернулијевих бројева. Тако је Ада стекла репутацију првог
компјутерског програмера (иако су и Бебиџ и неки други, такође, написали бројне програме за никад завршену
аналитичку машину). Оптерећена коцкарским дуговима и раком материце, Ада је умрла у 37. година, 27. новембра
1852. године, а сахрањена је, на лични захтев, поред свога оца у породичној гробници у цркви Свете Марије
Магдалене у Хакналу (Church of St. Mary Magdalene in Hucknall, Nottingham).
Никлаус Емил Вирт (Niklaus Emil Wirth), рођен 15. фебруара 1934. године у
Винтертуру (Winterthur) у Швајцарској је швајцарски информатичар. Звање инжењера
електронике је стекао на Швајцарском универзитету технологије у Цириху 1959. а
докторирао је на Калифорнијском универзитету Беркли 1963. Сматра се изузетним
стручњаком из области рачунарства, а најпознатији је као творац програмског језика
Паскал. Осим паскала пројектовао је и програмске језике Euler, Algol W, Pascal, Modula,
Modula-2, Oberon, Oberon-2, Oberon-07. За свој рад је 1984. године добио Тјурингову награду.
Предавао је на универзитету Станфорд на катедри за рачунарске науке (1963 - 1967.) као и
на Швајцарском технолошком универзитету. 1975. године је написао књигу „Алгоритми +
структуре података = програми“ (Algorithms + Data Structures = Programs). Од априла
1999. jе у пензији.
"Шта је човек у васиони, између две бесконачности: бескрајно великог и бескрајно малог? Ништавило у
погледу на бескрајност; све у погледу на ништавило; средина између ничега и свег." - Блез Паскал.
Блез Паскал (Blaise Pascal, 1623 - 1662.) је био француски математичар, физичар и
филозоф. Још од малена показивао је интересовање за науку, па је већ са 18 година
конструисао прву математичку машину, механички сабирач како би помогао свом оцу у
пословању. 1650. године напушта свет науке и окреће се религији, односно како је он написао
„разматрању величине и мистерије човека“. Блез Паскал рођен је 19. јуна у Клермон Ферану
(Clermont-Ferrand), у Француској. као треће дете Етјена Паскала (Etienne Pascal) и
Антоанете Бегон (Antoinette Begon). Мајка му је умрла када је имао само три године,
остављајући га са две сестре – Гилберт и Жаклин. Године 1631. породица Паскал напушта
Клермон и сели се у Париз. Децембра 1639. године, Паскалова породица је напустила Париз да
би живела у Руану где је Етјен био примљен као скупљач пореза за горњу Нормандију. Брзо по
смештању у Руану, Блез је написао свој први рад назван Есеј о конусним пресецима, издат
фебруара 1640. године. Исте године Паскал је изумео и први дигитални калкулатор са намером да помогне своме
оцу у прикупљању пореза и такси. Догађаји 1646. године су били врло значајни за младог Паскала. Те године је његов
отац повредио ногу и морао је да се опоравља код куће. О њему су се бринула његова млађа браћа, који су били у
религиозном покрету из Руана. Они су имали дубок утицај на Блеза и он је постао јако религиозан. Етјен Паскал је
умро у септембру 1651. године. После очеве смрти, Блез је писао једној од својих сестара, давајући, при томе смрти
једно дубоко хришћанско значење; и за њега је очева смрт била нешто посебно. Тада је оформио своје идеје које су
послужиле као основа за његова писма, обједињена у филозофски рад под називом Мисли (Пенсеес). После овога,
Паскал је посетио јансенски манастир Порт Ројал де Шамп, који се налазио око 30 км југозападно од Париза. Почео
је да издаје анонимна дела на тему религије. 18 провинцијалних писама је било издато у периоду између 1656. године
до почетка 1657. године. Све је то било писано као знак одбране од његовог пријатеља Антоана и великог
противника Језуита и браниоца јансенизма, који је иначе пре својих студија теологије у Паризу, био осуђиван због
свог контраверзног религиозног рада. Паскалов најпознатији рад из филозофије је Мисли, а на издању о својим
личним мислима везаним за људску патњу, судбину и Бога, којем је приступио касне 1656. године, наставио је да
ради током 1657. и 1658. године. Овај рад садржи и Паскалову опкладу као доказ да је веровање у Бога разумно само
са пратећим аргументима. Ако Бог не постоји, онај ко не верује у њега неће изгубити ништа, а ако, пак, Бог постоји,
тај исти човек ће изгубити све зато што није веровао у њега. Паскал је у својој опклади користио математичке
аргументе и аргументе из вероватноће, али његова главна реченица је: …ми смо сви присиљени да се коцкамо.
Питања на која треба обратити пажњу
• Разлика између решавања проблема у животу и на рачунару

• Појам алгоритма
• Порекло имена појма алгоритам
• Дефиниција алгоритма
• Особине алгоритма
• Врсте алгоритама
• Фазе у решавању проблема на рачунару
• Појам програмског језика
• Граматика програмског језика

• Синтакса програмског језика
• Семантика програмског језика
• Основна подела програмских језика
• Машински језици
• Машински оријентисани језици
• Процедурални језици
• Проблемски оријентисани језици
• Подела преводилаца
• Подела програмских језика према односи процеса превођења и извршавања
• Фазе у извршавању програма
• Интерпретерски програмски језици
• Компајлерски програмски језици
• Структурно програмирање и особине
• Објектно оријентисано програмирање


Програми засновани на прозорима
Апликације су програмски системи пројектовани за решавање одређеног проблема. Поступак

израде апликације назива се пројектовање, а предмет тог поступка пројектом апликације или
скраћено, само пројектом. Другим речима, пројекат апликације представља апликацију у фази
израде или пројектовања. Скица прозора у току пројектовања апликације назива се обрасцем
(form). Скица главног прозора за време пројектовања је главни образац пројекта.
Основна одлика апликација заснованим на прозорима је комуникација апликације и
корисника, заснована на прозорима и другим визуелним компонентама као што су: дугмад,
оквири за текст, менији и слично. Помоћу тих компоненти корисник управља радом
апликације и прима информације од апликације. Прозори могу да се схвате као оквири који
обједињују компоненте у логичке целине.
Свака апликација има барем један прозор који се назива главним прозором, main
window. Осим њега може да постоји произвољан број других прозора, secondary windows.
Главни прозор је обично стално на екрану, док се секундарни појављују и нестају са екрана
према тренутним потребама. Има случајева када се и неки од секундарних прозора дуже
задржавају на екрану. По намени, специјалну врсту секундарних прозора чине прозори за
дијалог, dialog box. Користе се за саопштавање разних порука кориснику и за прикупљање
различитих података од корисника. По завршетку дијалога увек нестају са екрана. Прозори за
дијалог су специфични и по томе што корисник, све док их не затвори, не може ништа да уради
ни у једном од других прозора дате апликације. Прозори са том особином називају се
условљеним (modal) прозорима, јер је наставак рада условљен њиховим затварањем. У овом
смислу, остали прозори називају се и неусловљеним (modeless) прозорима. Условљени
прозори су везани за једну апликацију, тј. и у случају да је на екрану отворен условљени прозор
једне апликације, увек може да се приђе прозору друге апликације и да се ради у њој.
Када постоји више прозора у апликацији, они се исцртавају један преко другога. Тренутно
активан прозор види се у целини, док остали могу да буду делимично или у потпуности заклоњени,
у зависности од њихових величина и положаја на екрану. Корисник може помоћу миша да
помера независно све прозоре по екрану, мења им мења величине или да их уклони са екрана.
Постоји специјална врста прозора који се налазе унутар радног простора неког другог
прозора. Ти прозори називају се децом, child window, оних прозора у чијем се радном простору
налазе, а који се, с друге стране, називају родитељима, parent window, те деце. Прозори деца
могу да се померају само унутар радног простора прозора родитеља. Померањем прозора
родитеља по екрану померају се и његова деца. Променом величине прозора родитеља не
мењају се величине прозора деце. Ако после промене величине прозора родитеља у радни
простор не стану прозори деце, појавиће се клизачи уз ивице радног простора прозора родитеља,
помоћу којих корисник невидљиве прозоре или њихове делове доводи у видно поље.
Основни начин за управљање апликацијама заснованим на прозорима је помоћу миша.
Место на коме може да се делује мишем обележава се показивачем миша, mouse cursor.
Показивач миша може да има различите графичке представе. Основни облик је стрелица чији
врх означава место показивача на екрану. Алтернативни облици могу да се користе за
означавање тренутне улоге миша. На пример, изнад разних оквира за текст показивач миша
обично има облик танке вертикалне линије са водоравним испустима на горњем и доњем
крају. Такав облик је погодан да се означи место између два знака у тексту.
Постоје две основне радње које могу да се обаве помоћу миша:
• Притисак - click и
• Одвлачење - drag and drop.
Под притиском мишем подразумева се померање показивача миша изнад одређене
компоненте и притисак и отпуштање левог тастера на мишу. Тако се на екрану може
притиснути неко дугме, одабрати нека ставка у менију, променити стање неког оквира за
потврду и слично и тиме дати неки сигнал који ће се касније обрадити у апликацији.
Под одвлачењем мишем подразумева се померање прозора по екрану или промена величине
прозора. Изводи се тако што се показивач миша доведе изнад натписа прозора, притисне се
леви тастер миша, помера се показивач миша уз притиснути леви тастер на неко друго место и
отпусти се тастер миша. Ако се на тај начин мишем ухвати ивица или угао прозора, померањем
показивача помериће се ивица или угао са суседним ивицама, чиме се мења величина прозора.
У зависности од апликације, на овај начин понекад могу да се померају и компоненте унутар
прозора, да им се промени величина или да се постигну неки други ефекти.
Осим мишем, радом апликације може да се управља и преко тастатуре. Основна употреба
тастатуре је уношење текста у оквире за текст. Место у тексту на коме може нешто да се
промени обележава се показивачем текста, text cursor. То је, обично, вертикална трептећа
линија која се увек налази између два знака у тексту. Треба јасно разликовати показивач миша
од показивача текста. Показивач миша може да се помера помоћу миша по целом екрану, док
се показивач текста помера тастерима са стрелицама на тастатури само унутар текста.
Притиском мишем на оквир за текст у некој тачки, показивач текста може да се премести на
тренутни положај показивача миша. Под неким условима, и преко тастатуре могу да се
производе ефекти притиска мишем. За то могу да се користе одређени тастери са словима у
комбинацији са тастером Alt или Ctrl, као и тастери Enter и Esc. За компоненту која на овај
начин може да се активира каже се да јој је придружен знак пречица (ShortCut) - accelerator
character. Знакови пречице приказују се подвучено у натписима компоненти којима су
придружени у менијима, а често се дешава и да је на крају описа у менију исписана и
комбинација тастера које треба откуцати, нарочито ако је пречица другачија од уобичајених
или ако не постоји други начин да се учини видљивом кориснику апликације.
Основне карактеристике програма заснованих на прозорима
Слика приказује главни прозор апликације WordPad, једне од стандардних апликација

заснованих на прозорима. На њеном примеру ће бити објашњени елементи о којима треба водити
рачуна приликом пројектовања неке апликације за рад у графичком оперативном окружењу.

Прозори апликације могу да имају следеће делове:

1. Трака са натписом - Caption bar, налази се уз горњу ивицу прозора. Састоји се од
натписа и управљачких дугмади. Натпис садржи име апликације и, евентуално, име датотеке
која се тренутно обрађује. Четири могућа управљачка дугмета су:
• Дугме управљачког менија - control menu button, налази се на левом крају траке са
натписом и садржи сличицу - icon, придружену прозору. Притиском на дугме отвара се
управљачки мени.
• Дугме за минимизирање прозора - minimize. Притиском на њега прозор се уклони са
екрана при чему остане дугме које га представља у палети послова (Taskbar) у радном
простору - (Desktop) виндоуса или се претвара у минимални облик (типично за
секундарне прозоре за које обично не постоји придружено дугме у палети послова).
Дугме у палети послова садржи сличицу која је придружена прозору и део натписа
прозора. Притиском на то дугме левим тастером миша, прозор се поново појави на
екрану у првобитној величини и на првобитном месту. Притиском десним тастером на
дугме у палети послова отвара се управљачки мени. Минимални облик прозора се састоји
од скраћеног облика траке са натписом која садржи сличицу придружену прозору, део
натписа и представља дугме за враћање прозора у првобитно стање.
• Дугме за максимизирање прозора - maximize. Притиском на њега прозор ће се раширити
тако да попуни цео екран. Само дугме, након ове акције, мења изглед: до притиска имало
је изглед квадратића, а сада ће садржати два делимично преклопљена правоугаоника -
restore. Поновним притиском на то дугме, прозор ће се вратити на првобитно место у
првобитној величини.
• Дугме за затварање прозора - close. Притиском на ово дугме прозор се уклони са екрана.
Уклања се и придружено дугме, ако постоји, из палете послова. Ако се ради о главном
прозору, апликација се завршава.
2. Трака главног менија - menu bar, налази се испод траке са натписом. Садржи ставке
главног менија за избор појединих група радњи које апликација може да обави. Трака главног
менија обично постоји само у главном прозору апликације. Апликације без главног менија се
врло ретко срећу у пракси.
3. Трака са алаткама - toolbars, налази се испод траке главног менија. Садржи дугмад са
сличицама помоћу којих се најчешће коришћене радње могу лакше позвати него помоћу менија.
4. Статусна трака - status bar, налази се уз доњу ивицу прозора. Садржи податке о стању
апликације укључујући и кратка упутства или поруке кориснику.
5. Радни простор - client area, заузима сав преостали простор у прозору. У том простору се
налазе визуелне компоненте које су смештене у прозору. Уз ивице тог оквира могу да се
налазе клизачи помоћу којих се делови прозора који нису стали у радни простор доводе у
видно поље, померањем клизача по потреби.
6. Ивице прозора - window borders. Ограђују целокупан прозор. Ивице прозора имају
различит изглед у зависности од тога да ли величина прозора може да се мења помоћу миша или
не, или се ради о прозору за дијалог.
Радом апликација управља се командама помоћу којих се могу подешавати параметри
обраде или тражити спровођење појединих радњи које су предвиђене у апликацији. Основни
начин издавања команди је помоћу менија - menu, мада рад апликација може да се организује
и другачије.
Мени садржи низ ставки од којих једна може да се одабере да би се назначила нека акција
апликације. Да листа ставки не би била предугачка, ставке се групишу и образују се менији
чија хијерархијска структура садржи више нивоа. Први ниво ставки је главни мени - main
menu, чије ставке представљају групе могућих операција. Избором ставки главног менија
појављује се подмени - submenu чије ставке могу да представљају конкретне операције или
подменије на следећем нивоу. У пракси најчешће има два нивоа менија, тј. ставке главног
менија готово никад не представљају конкретне акције.
Ставке главног менија стално су видљиве у траци главног менија, испод траке са
натписом прозора. Ставке подменија приказују се само за тренутно одабрану ставку главног
менија, поређане усправно испод одговарајуће ставке главног менија. Евентуални подменији
који припадају некој од ставки подменија приказују се десно (или, у ретким случајевима, лево)
од подменија, са врхом у висини ставке подменија. Постојање подменија означава се
стрелицом у облику попуњеног троугла уз десну ивицу одговарајуће ставке.

Тренутно одабране ставке у менију приказују се истицањем другом бојом подлоге и

слова у односу на остале ставке. Пошто ставке у различитим подменијима могу имати исте
натписе, нека ставка у менију је једнозначно одређена низом ставки које треба одабрати,
почев од главног менија, да би се стигло до ње. Избор ставки главног менија и подменија може
да се врши на више начина:
• Притиском на леви тастер миша, када је показивач миша изнад жељене ставке главног
или подменија.
• Активирањем главног менија притиском на тастер Алт, а затим, тастерима  и 
крећемо се по ставкама главог менија, а тастерима  и  по ставкама тренутно активног
подменија. Ако ставка подменија има свој подмени, притиском на тастер  отвара се тај
подмени. Обрнуто, враћање на претходни ниво подменија постиже се тастером . Избор
се остварује притиском на тастер Ентер када је изабрана одговарајућа ставка подменија.
• Истовременим притиском тастера Алт и тастера подвученог слова у ставки главног
менија отвара се одговарајући подмени. После тога треба притиснути тастер подвученог
слова у ставки подменија (сада више тастер Алт не мора, али може да буде притиснут).
Подвучени знакови у натписима ставки менија су знакови пречице.
Избором команди иза чијих се имена у подменију налазе три
тачке (...) отвара се посебан прозор за дијалог. Тај прозор садржи
образац чијим попуњавањем треба да се задају подаци неопходни
за извршавање тих команди. Прозори за дијалог, поред компоненти
за уношење или избор вредности потребних података, обично,
садрже и два дугмета:
• дугме за потврду - ОК којим се захтева спровођење започете
активности са тренутно видљивим вредностима у прозору, и
• дугме за одустајање - Cancel којим се одустаје од спровођења
акције.
Осим мишем, дугме за потврду може да се активира и помоћу тастера на тастатури (у
случајевима када је оивичен правоугаоником дебљим од оног око остале дугмади или су слова
уоквирена испрекиданом линијом). Дугме за одустајање увек може да се активира помоћу
тастера Esc на тастатури. Одустајање се постиже и затварањем прозора за дијалог помоћу
управљачког менија или притиском мишем на дугме за затварање прозора. Понекад прозор за
дијалог служи само да би корисник потврдио да стварно жели спровођење одабране
активности. Тиме му се пружа још једна прилика за евентуално одустајање. Такви прозори
обично садрже текст одговарајућег питања и дугмад Yes и No. Поред наведених, прозори за
дијалог могу да садрже другу дугмад различите намене зависно од функције дијалога, а
најчешће и дугме за помоћ - Help. Притиском на то дугме добија се пригодна приручна помоћ,
ако је предвиђена у оквиру апликације.
За активирање неких радњи апликције, представљених одговарајућим ставкама
подменија, могу да постоје тастери пречице - shortcut keys. За разлику од знакова пречица,
помоћу којих се по менију креће корак по корак, као и помоћу миша, притиском на тастер
пречицу, ставка менија којој је он придружен активира се у једном потезу. При том се мени не
отвара и одабрана ставка се уопште не види на екрану. Не смета ако је у тренутку притиска на
тастер пречицу мени отворен са било којом истакнутом ставком, укључујући и ставку која се
њиме бира. Тастери пречице могу да буду функцијски тастери од F1 до F12 сами или у
комбинацији са управљачким тастерима Shift, Alt и/или Ctrl, као и тастери са словима у
комбинацији са тастером Alt и/или Ctrl. Постојање тастера пречице означава се уз десну ивицу
менија, после натписа ставке менија. За разлику од знакова пречица, чије тумачење може да се
мења у току извршавања апликације, тумачење тастера пречица је јединствено у току целог
извршавања апликације.
Поред евентуалног главног менија са пратећим подменијима сваки прозор поседује
управљачки мени - control menu који се назива и системски мени - system menu. Управљачки
мени активира се притиском на дугме управљачког менија на левом крају траке са натписом
прозора. Помоћу управљачког менија прозор може да се минимизира командом Minimize, да
се максимира - Maximize, да му се поврати претходна величина - Restore, да се помера по
екрану - Move, да му се промени величина - Size и да се затвори - Close. Све ове радње могу и на
други начин да се постигну, па је отварање управљачког менија ретко потребно.
Прозори поред менија садрже и разне компоненте помоћу којих корисник може да утиче
на ток извршавања апликације. Међу њима се најчешће користе:
• Ознака - label. Приказује текст, натпис ознаке - Caption који може да буде нека порука
кориснику или опис намене друге компоненте. Корисник апликације не може да делује
на ознаке помоћу миша.
• Дугме - button. Корисник може мишем да га притисне и тиме да сигнал за неку акцију.
Натпис на дугмету означава његову намену. Уношење података у прозоре за дијалог
обично се завршава притиском на једно од дугмади.
• Оквир за текст - edit box. Корисник у овај оквир уноси произвољан текст преко тастатуре.
Постоје оквири који могу да садрже само један ред текста и оквири који могу да садрже
више редова текста.
• Оквир за потврду - check box. Мали квадрат поред натписа овог оквира може да садржи
знак за потврду () или да буде празан. Присуство знака за потврду означава да особина
у натпису важи, а одсуство да не важи. Левим кликом миша мења се стање из
непотврђеног у потврђено, и обрнуто.
• Радио-дугме - radio button. Мали круг поред натписа ове компоненте може да садржи
црну тачку () или да буде празан (). Користи се у групама с тим да само једно дугме у
групи може да има попуњен кружић. Те групе се користе за избор једне од неколико,
медусобно искључивих, могућности.
Неке од компоненти у прозору или неке ставке менија могу да буду привремено
недоступне. Такве компоненте обично се приказују бледо - dimmed.
Сваког тренутка само је један од тренутно видљивих прозора на екрану активан. За такав
прозор се каже да је у жижи (focus). Од осталих прозора се разликује видљиво по другачијој
боји траке са натписом прозора и текста у њој. Корисник може да активира прозоре по
произвољном редоследу, осим ако је тренутно активан прозор условљени прозор, простим
притиском мишем на било коју тачку која припада жељеном прозору. У тренутно активном
прозору сваког тренутка је само једна компонента активна. За ту компоненту се каже да је у
жижи. Компонента која је у жижи, обично се видљиво разликује од других компоненти исте
врсте. Три карактеристична начина разликовања су:
• натпис компоненте уоквирен правоугаоником од танке испрекидане линије, за компоненте
које имају натписе;
• трептећи показивач текста унутар оквира за текст или
• уоквирена једна од ставки унутар оквира са листама.
Притиском на неку компоненту мишем или одабирањем помоћу знака пречице, жижа се
помери на ту компоненту. Поред тога, жижа може да се помери са једне компоненте на другу
према одређеном редоследу, притискањем тастера Tab () на тастатури, односно, комбинације
тастера Shift + Tab по обрнутом редоследу. Редослед померања жиже са компоненте на компоненту
на овај начин зависи од апликације и корисник не може да утиче на његову промену. У добро
пројектованој апликацији редослед померања жиже са компоненте на компоненту следи логичан
ток уношења података, примерен датој ситуацији. Такође, у добрим апликацијама компоненте
су тако распоређене да логичан редослед њиховог обиласка на екрану буде слева удесно и одозго
надоле (ово није обавезно, али кориснику у великој мери олакшава коришћење апликације).
Све апликације засноване на прозорима могу да се поделе у две групе:
• Апликације за рад са једним документом (Single Document Interface Applications - СДИ
апликације). Могу истовремено да обрађују само један документ (текст, слику итд.). У
главном прозору се обрађује један документ (текст, слика или други скуп података), а
евентуални остали прозори у апликацији служе само као подршка за остваривање те обраде.
Сви су прозори обични, у смислу да међу њима нема прозора родитеља нити прозора деце.
• Апликације за рад са више докумената (Multiple Document Interface Applications - МДИ
апликације). Могу одједном да обрађују више докумената. Главни прозор је прозор
родитељ који садржи барем један прозор дете. Сваки прозор дете садржи по један
документ који се обрађује у апликацији. Апликација може да има и известан број обичних
прозора који служе као подршка за обраду докумената. Појединим радњама у апликацији
делује се на документ у прозору детету који је тог тренутка активан.
Делфи је апликација заснована на прозорима, а са друге стране, делфи служи за израду
апликација заснованим на прозорима. Препорука пројектантима је да се труде да своје
апликације што више уклопе у опште прихваћену шему јер тиме повећавају изгледе да њихов
производ лакше прихвате будући корисници. Делфи у потпуности подржава и потпомаже
пројектовање стандардних и атрактивних апликација за оперативни систем Windows.

Елементи графичког корисничког интерфејса (Graphical User Interface)
Графичко корисничко окружење (Graphical User Interface, GUI) је тип корисничког

окружења који омогућава људима да рукују рачунаром или уређајима контролисаним
рачунаром. То је начин интеракције човека с рачунаром кроз манипулацију графичким
елементима и додацима уз помоћ текстуалних порука и обавештења. Графичко корисничко
окружење користи иконице, визуелне индикаторе или специјалне графичке елементе
(widgets) уместо обичних текстуалних менија или ручног уношења команди. Иконице се често
употребљавају заједно са текстом или ознакама да потпуно прикажу информацију и радње
доступне кориснику. Графички кориснички интерфејс се ослања на WIMP узор рада
корисника са рачунаром. Основни елементи овог модела су:
• Window (прозор) - ограничене правоугаоне области које садрже радну површину, меније,
дугмиће, траке за вертикално померање скроловање садржаја прозора и друго. Апликације и
датотеке се приказују унутар прозора (мада не мора свака апликација имати свој прозор).
• Icon (икона или сличица) - икона је визуeлни репрезент објеката у саставу рачунарског
система. Објекти могу бити физички или логички (програми или датотеке са подацима).
Асоцијативно делује на корисника: јасно означава функцију, лако се памти и разликује се
од осталих икона. Селектовањем иконе покреће се програм или отвара датотека, преко
путање до садржаја на меморијском медијуму где су смештени.
• Menu (мени) - основни механизам интеракције корисника са програмом, при чему се
кориснику прикаже низ могућности у датој ситуацији, а корисник се опредељује за једну
од њих.
• Pointer (показивач) - графички симбол којим управља миш или неки други улазни уређај, а
користи се за лоцирање, позиционирање и избор визуелног репрезента објекта на
екрану монитора.
Корисник у GUI окружењу може помоћу миша селектовати и кликнути на жељену
иконицу (icon), чиме стартује одговарајући програм. Без помоћи GUI интерфејса корисник би
све команде морао да уноси у текстуалном облику преко тастатуре. GUI програми приказују
визуелне елементе попут:
• икона (сличице на десктопу, тј. позадини)
• прозора
• дугмад са текстом и/или сликама (button)
• оквири за унос текста (edit)
• квадратићи за одабир и типа (могуће је одабрати више квадратића - check box)
• кружићи за одабир или типа (могуће је одабрати само један кружић - radio button)
Претходници GUI програма су развијани су на Станфордском факултету, на челу са
Енглбартом (Douglas Englebart) и користили су текстуалне повезнице за управљање. Касније
су истраживачи на Xerox PARC-у унапредили и отишли даље од само текстуалних повезница и
почели су користити графичко окружење за њихов Alto рачунар. То је био претходник свих
данашњих графичких окружења, звао се PUI. PUI је и тада користио прозоре, меније, дугмад,
квадратиће за одабир, иконе уз употребу неких показних уређаја као што је миш.
Први пут GUI је искористио Apple на својим Macintosh рачунарима и оперативним системима
(1984.), док је касније(1985.) Microsoft копирао Apple-ове идеје у својим првим верзијама Windows
оперативног система. Примери неких графичких окружења су Mac OS, Microsoft Windows,
NEXTSTEP и X Window System од којег су настали Qt (KDE), GTK+ (GNOME) и Motif (CDE).
Помоћу графичког окружења употреба данашњих рачунара је много једноставнија него у
доба DOS оперативног система који је био прилично негостољубљив према новим корисницима
рачунара. Већина данашњих оперативних система има могућност употребе графичког окружења,
дакле курсора, икона, прозора и других елемената.
У програмима које ћемо писати, најчешће ћемо користити следеће компоненте:
• Form (форма, образац) - ова компонента ће се користити за креирање спољашњег изгледа
нашег програма и на њу ће се постављати остале компоненте.
• Label (лабела, натпис) - може се поставити било где на форми, користи се за приказ
текстуалних података.
• Edit (едит, оквир за текст) - може се поставити било где на форми, користи се за унос
текстуалних података.

• Button (тастер, дугме) - може се поставити било где на форми, користи се за потврду
почетка неке акције.
• Memo (мемо поље, оквир за вишередни текст) - користи се за приказ и унос вишередног
текста.
Програми руковођени догађајима
У објектно оријентисаним програмским језицима у центру пажње су догађаји на које

могу реаговати распоређене компоненте. Постоји велики број догађаја на које поједине
компоненте реагују, а програмом се дефинишу они на које ће поједине компоненте реаговати.
На пример, ако је тастер компонента чије реакције на догађаје се обрађују, онда догађаји могу
бити: клик мишем на објекат, повлачење објекта, прелазак мишем преко њега, померање
миша на горе или на доле, активирање објекта, напуштање објекта, притисак неког тастера на
тастатури, отпуштање тастера на тастатури, унос неког карактера помоћу тастатуре и други.
Извор догађаја може бити миш, тастатура или неки од постављених објеката, а
програмер дефинише на које од њих ће постављена компонента реаговати и на који начин.
Клик на неки тастер може проузроковати затварање апликације, покретање неке процедуре
или неку активност те или неке друге компоненте. Промена садржаја оквира за текст може
покретати неку процедуру или дефинисати неку акцију те или неке друге компоненте. И само
покретање апликације представља један догађај, исцртавање неке компоненте такође је
догађај који може утицати на почетак извршавања неке дефинисане процедуре. Овакав начин
покретања појединих делова апликације повећава динамичност и непосредност апликације.
Померањем миша можемо проузроковати померање објеката на форми чиме се добија
могућност креирања атрактивних апликација које одржавају пажњу корисника и усмеравају
га на одговарајућу активност.
• Одлике апликација заснованих на прозорима

• Врсте прозора у апликацијама и њихове карактеристике
• Карактеристике рада са мишем
• Управљање радом апликације помоћу тастатуре
• Елементи прозора апликације и њихова функција
• Главни мени апликације и систем подменија
• Прозори за дијалог
• Најчешће коришћене компоненте које могу бити елементи апликације
• Подела апликација заснованих на прозорима
• Елементи графичког корисничког интерфејса
• Извори догађаја и утицај њихове обраде на квалитет апликације


Увод у развојно окружење програмског језика
На персоналним рачунарима данас врло је популаран рад под оперативним системом

Windows и развој апликација за ту платформу. Као одговор на ово велико интересовање,
софтверска кућа Borland је давне 1994. године објавила своје моћно интегрисано развојно
програмско окружење Delphi за израду апликација за рад под оперативним системом виндоус.
Програмско окружење делфи садржи врло моћне алате за брзо и лако организовање и
уобличавање комуникације на релацији апликација - корисник у стилу професионалних
апликација за виндоус платформу. Ти алати омогућавају визуелно уређивање појединих
прозора (образаца) и подешавање параметара компонената у тим обрасцима, померањем
компонената по екрану помоћу миша и попуњавањем одговарајућих формулара. У том делу
посла нема никаквог писања програма. Поступци које апликација треба да обави као одговор
на разне догађаје, као што је притисак мишем на неко дугме у прозору, програмирају се на
језику Object Pascal. Објектни паскал представља даље усавршавање турбо паскала у домену
објектно оријентисаног програмирања. Уграђена је подршка за непосредно коришћење АПИ
(API - Application Programming Interface - рутине за управљање датотекама, приказ података
и слично) функција, стандардног алата који фирма Microsoft нуди за израду апликација за
виндоус окружење. Програмер у делфи окружењу релативно ретко непосредно позива те АПИ
функције. Алати које делфи пружа чине то уместо њега.
Програмски језик делфи настао је као први програмски језик са визуелном компонентом.
Иако је у то време већ постојао Visual Basic (ВБ), не може се рећи да је он први програмски језик
за визуелно програмирање јер су се програми у ВБ извршавали под контролом преводиоца. У
делфију се изворни програмски код преводи директно у машински чиме се постиже већа брзина
код извршавања програма и независност програма од програмског преводиоца, тј. програм
написан у делфију и преведен у извршни код може се извршавати без обзира да ли је на
рачунару инсталиран делфи преводилац.
Прва верзија делфија прављена је за оперативни систем Windows 3.1x и правила је
16-битне апликације у машинском коду. Могла је да се користи и под оперативним системима
Windows 95 и Windows NT, али није могла да искористи нове погодности које су пружала та
нова, 32-битна окружења. Резултујуће апликације су биле искључиво 16-битне, без обзира под
којим оператиним системом се радило. Креиране апликације су могле да се извршавају у свим
поменутим окружењима. Подршка за 32-битно програмирање је уграђена у верзију 2. Осим
тога у ова верзија укида ограничење дужине знаковних низова на 255 знакова. Боље
управљање меморијом, истовремено извршавање више нити програма (multithreading), већи
број новоуведених компоненти, бољи рад са базама података и повезивање са SQL језиком
упита су, такође, новине. Ова знатно прерађена и допуњена верзија, која је објављена у
фебруару 1996. године, могла је да се користи само под оперативним системима Windows 95 и
Windows NT, а и развијене апликације су могле да се извршавају само под тим оперативним
системима. Трећа верзија из 1997. године донела је само неколико новина и побољшања већ
постојећих карактеристика (много већи скок је направљен између верзија 1 и 2). Пре свега,
побољшана је помоћ за писање кода апликација, подршка пакетима кода којима могу
приступити различити програми, подршка Active X контролама, могућност креирања
објектног кода (.оbj) чиме се отвара могућност увоза програмског кода у друге програмске
језике. Додате су и интернет компоненте за креирање апликација које могу да користе
предности глобалне мреже. Делфи 4 из 1998. године доноси знатна побољшања већ постојећих
карактеристика претходне верзије и прилагођавање делфија новим верзијама оперативног
система са модернијим изгледом и једноставнијом употребом алатки. Делфи 5 доноси знатна
олакшања у раду са базама података и даља унапређења Active X контрола. Делфи 6 је до
крајњих граница поједноставио изградњу апликација увођењем чаробњака који помажу код
почетног формирања различитих апликација. Палете са алаткама су препуне новим
компонентама. Делфи 7 је прерађена и мало побољшана верзија делфи 6 пакета прилагођена
оперативном систему Windows XP и допуњена пакетом за креирање извештаја Rave Designer.

Убрзо, затим, појавила се верзија Делфи 8 и то је последњи пројекат

компаније Borland. Испоставило се да је то још један од пословних промашаја
фирме, односно, да готово ништа ново и значајно није донео. Компанија је
запала у дугове због овог, али и још неких других пословних промашаја и
постојала је оправдана сумња да ће се пројекат Делфи угасити. Спас је дошао
са појавом верзије Delphi 2009 која је прилагођена раду у мрежном
окружењу и новим 64-воро битним оперативним системима, а која је
настала у тренутку када је компанију Borland преузела компанија CodeGear.
Ово је прва верзија делфија која је испоручивана у пакету са C++ билдером,
тако да су њиме могли бити задовољни и љубитељи делфија и
це-програмери. Даљи развој оперативних система довео је до појаве
делфија у верзији ХЕ. Актуелна је верзија ХЕ3.
Карактеристика свих верзија делфија је да генеришу прави
машински програм (native code), што резултује бржим извршавањем
апликација у односу на друга визуелна окружења која генеришу неки
међукод који се после извршава интерпретацијом. Коначан резултат
пројектовања је једна извршна датотека (са наставком .еxе) програма
који чини апликацију. Приликом инсталације апликације, осим евентуалних датотека које
користи апликација, додатне датотеке нису потребне (на пример, библиотеке са динамичким
повезивањем, датотеке са наставком .dll), под условом да апликација не користи подршку за
рад са базама података и за израду извештаја. Ако се користи нека од тих подршки, BDE
(Borland Database Engine), односно, Report Smith морају да се инсталирају. Смештање
целокупног кода у извршни облик програма има и један недостатак: најмања апликација
заузима барем 275 килобајта. Ако се на једном рачунару користи више апликација које су
развијене помоћу делфија, долази до знатног утрошка простора на диску (данас је овај
проблем знатно ублажен снижењем цене хард дискова и повећањем стандарда на 500
гигабајтова, али средином 90-их година хард дискови су били величине 80 - 500 мегабајтова).
Због тога је у верзији 3.0 уведена могућност прављења пакета са динамичким повезивањем
(.dpl - Delphi Package Library) који по намени одговарају виндоусовим библиотекама са
динамичким повезивањем (.dll). Библиотека визуелних компонената се испоручује у облику
таквих пакета. Пројектант апликације може да назначи који ће од тих пакета да се уграде у
извршни облик апликације, а који не. Наравно, пакети који нису уграђени морају да се испоруче
одвојено кориснику апликације.
Привредна комора Београда, Удружење информатичке делатности у сарадњи са

компанијом Ембаракадеро Интернационал и локалним партнером Code Factory,
премијерно су представили EMBARACADERO - RAD STUDIO XE3 који садржи програмске
алате Делфи/Ц++/ХТМЛ5 за развој софтвера за најновије оперативне системе Windows
8, Mac Mountain Lion, Mobile на стручном скупу: "EMBARACADERO - Нови RAD STUDIO XE3"
који је одржан у уторак 11. септембра 2012., са почетком у 11.00 часова у сали VI, зграде
Привредне коморе Београда, Кнеза Милоша 12. Нови алат представљен је као најбржи
пут до Windows 8 апликација. По њима, Delphi XЕ3 и C++builder XЕ3 са компонентама за
Метрополис су једини алати који омогућавају надоградњу класичних Windows UI
апликација на Windows 8 Style. Апликације раде на WinXP, Vista, Windows 7 и 8, и то како на
десктоп тако и на таблет окружењима као што су Slate и Surface Pro. Апликације у
делфију ХЕ3 сада подржавају HD/3D графику задивљујућег изгледа. Пакет укључује и
најновију верзију FireMonkey компоненати – FireMonkey FM2 са којима можемо
програмирати апликације изузетаног изгледа за Enterprise и ISV и то за Windows 8, Mac
OS X Mountain Lion и Mobile и све то из истог изворног кода. Ту је и најновији механизам за повезивање са базама
података. Нови Visual LiveBindings пружа најлакши начин за повезивање корисничког интерфејса са подацима у
базама. Приступачније него икада до сада, Rad Studio XЕ3 Visual LiveBindings омогућава повезивање без писања
иједног реда кода. Повезивање података и контрола је изузетно.
Већина савремених програмских језика подржава ООП. Сви ООП језици су засновани на
три концепта:
енкапсулацији - Eнкапсулација представља имплементацију која ће довести до жељеног
понашања објеката. Битан њен аспект је и сакривање небитних особина класе,
тј. сакривање структуре класе. Свака класа има два дела: интерфејс и
имплементацију. Интерфејс класе обухвата само спољашњи изглед класе и
преко њега се установљава да ли апстракција има жељено понашање. Са друге
стране, имплементација обухвата реализацију свих механизама који доводе
до тог жељеног понашања.
наслеђивању - Механизам наслеђивања (inheritance) састоји се у томе да једна класа може

бити врста друге класе са додатним особинама, наслеђујући њену структуру,
понашање и комплетну функционалност те класе и додајући евентуално неке
своје особености које је чине аутономним ентитетом.
полиморфизму - Полиморфизам је својство да објекат изведене класе извршава операцију
на начин својствен изведеној класи, иако му се приступа као објекту основне
класе. Полиморфизам обезбеђује генерички софтверски интерфејс тако да
колекцијом различитих типова објеката може да се манипулише униформно.
Програмски језик објектни паскал који делфи користи је ООП проширење стандардног
језика паскал. Синтакса програмског језика паскал је обимнија и читљивија од синтаксе, на
пример, језика Ц, а његово ООП проширење прати исти приступ и даје му моћ једнаку
најновијим ООП језицима Јави или Ц++.
Ако питамо било којег програмера који је програмски језик најбољи добићемо увек исти
одговор, онај који он користи јер је ефикасан, једноставан, лак за учење итд. Права истина
крије се баш у томе. Најбољи је онај језик који најбоље познајемо. А како онда одлучити шта је
најбоље ако не знамо ниједан програмски језик. Нема правог одговора. Ако ћемо сами учити,
најбоље је почети од језика за који имамо најбољу литературу (теоријске основе и примере
развоја различитих апликација, нарочито оних каквим ћемо се бавити), а ако ће нам неко
помагати онда препустимо њему да нас води. Када савладамо неке елементарне технике онда
даље можемо и сами, а у зависности од прилика можемо и прећи на неки други програмски
језик који ће захтевати конкретни посао.
Почетак рада и управљање развојним окружењем.
Покретањем апликације отвара се неколико прозора које ћемо укратко описати.

Широка трака на врху екрана је главни изборни прозор или главни прозор апликације.
Њен изглед можемо прилагодити свом укусу, али и карактеристикама рачунара на коме
радимо (монитор са вишом резолуцијом даје нам више могућности распоређивања делова).
Стандардна трака прозора садржи назив програмског модула (Delphi 7 - Project1) са

иконицом која представља дугме управљачког менија (Control Menu Button) и три екранска
тастера (стандардни управљачки тастери): Minimize, Restore Down / Maximize и Close.
Подразумева се да знамо да минимизацијом овог прозора са екрана нестају и сви други,
зависни прозори делфија и да се у том моду не може радити ништа. Затварањем овог прозора
излази се из делфија. Ако оно што смо пре затварања није сачувано програм ће нас упозорити
на то и тражити потврду акције или претходно чување нашег рада. Испод ње се налази линија
главног менија са стандардним опцијама: File, Edit, Search, View, Project, Run, Component,
Database, Tools, Window и Help. Велики део команди у менијима знамо из рада са неким
другим виндоус апликацијама и зато ћемо се кратко задржати на њиховим специфичностима
у делфију, а остале нећемо објашњавати јер се не уклапају у програм овог курса.
Из File мени ћемо користити следеће команде:
New - отвара подмени из кога треба одабрати опцију Application
Open - отвара дијалошки прозор за учитавање постојећих пројеката и других
текстуалних датотека које могу бити саставни део пројекта или не. Команду не
треба га користити док мало боље не савладамо рад са делфијем
Open Project - отвара дијалошки прозор за учитавање постојећих пројеката
Reopen - отвара подмени са листом од пет последњих пројеката које смо сачували (из
које се кликом мишем може изабрати жељени) и дужом листом паскалских
програма (јунита) који се могу учитати, али не и покренути из делфија (листу
користимо за налажење путање до неког пројекта, а не за његово учитавање)

Save - омогућава чување тренутно активне датотеке са датим именом (команду

треба пажљиво користити јер не чува пројекат, па се може десити да касније не
можемо отворити и покренути програм за који смо мислили да је сачуван)
Save As - омогућава чување тренутно активне датотеке са промењеним именом; користи
се када већ урађен сличан задатак желимо да искористимо да брже урадимо
наредни задатак (команду треба обавезно користити у пакету са наредном да
бисмо сачували и пројекат са промењеним именом, а не да у претходно
отвореном пројекту само променимо име активне датотеке и тако изгубимо
претходни задатак)
Save Project As - омогућава чување активног пројекта са промењеним именом; користи се
када већ урађен сличан задатак желимо да искористимо да брже урадимо
наредни задатак
Save All - омогућава чување активног пројекта са свим припадајућим датотекама
Close - затвара активни пројекат са припадајућим датотекама (корисније је, у ову
сврху употребљавати наредну команду)
Close All - затвара све отворене датотеке
Print - штампа активну датотеку на штампачу
Exit - затвара се отворени пројекат и напушта делфи апликација; ако оно што смо
пре затварања није сачувано програм ће нас упозорити на то и тражити
потврду акције или претходно чување нашег рада.
Из Edit менија ћемо користити команде:
Undo/Undelete - поништава последњу акцију или брисање
Redo - враћа последњу акцију поништену претходном командом
Cut - селектовани део активне датотеке брише и премешта на clipboard
Copy - селектовани део копира на clipboard не бришићи га из активне датотеке
Paste - копира садржај са clipboard-а у активну датотеку
Delete - брише селектовани део активне датотеке
Select All - селектује комплетан садржај активне датотеке
Из Search менија ћемо користити команде:
Find - проналази наведени текст, ако постоји, и маркира га
Replace - проналази наведени текст, ако постоји, и мења га другим наведеним текстом
Search Again - понавља претходно дефинисано претраживање
Из View менија ћемо користити команде:
Object Inspector - отвара и приказује прозор Object Inspector ако је претходно био затворен
Object TreeView - отвара и приказује прозор Object TreeView ако је претходно био затворен
Alignment Palette - отвара и приказује прозор Alignment Palette
Toggle Form/Unit - на врх екрана поставља један од прозора form или unit
Из Run менија ћемо користити команде:
Run - преводи написани програм на машински језик и извршава га (ако нема грешака)
Program Reset - насилно прекида извршење програма, ослобађа радну меморију и враћа нас
у делфи да бисмо наставили рад на истом или другом програму (користи се
када програм из неког разлога не може да се искључи на регуларан начин).
Већина поменутих команди из ових менија има одговарајућу пречицу - комбинацију
једног или више тастера којом се може извршити без директног отварања менија и избора
команде из њега.
У оквиру овог прозора могу се наћи и бројне тулбар траке које могу бити различито
распоређене. На њима се налазе екрански тастери - speed buttons којима се, као и пречицама,
поједине команде могу извршити без директног отварања менија и избора исте команде из
њега. Неки од ових тастера не убрзавају рад са одговарајућом командом (јер команда може
бити јако сложена), али је приступ команди једноставнији, па су они зато и постављени на
одговарајућу траку. Сада ћемо навести тулбар траке које се стандардно налазе у главном
прозору делфија и тастере који се налазе на њима без објашњавања одговарајуће команде јер
смо команде које ћемо користити већ објаснили кроз систем менија.
Испод траке са називом апликације су тулбар траке (toolbar):
• Desktop са оквиром Desktop speedsetting и екранским тастерима: Save current desktop и
Set debug desktop (у првом реду, у продужетку главног менија)

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

• Standard са тастерима: New, Open, Save, Save All, Open project, Add file to project, Remove
file from project
• Custom са тастером: Help contents
У трећем реду испод главног менија је:
• View са тастерима: View unit, View form, Toggle Unit/Form, New form
• Debug са тастерима: Run, Pause, Trace into, Step over
Са десне стране у продужетку од последња два реда са тулбар тракама налази се палета са
објектима које можемо уградити у свој програм. Навешћемо их све, а затим објаснити само оне
које ћемо користити у овом курсу (компоненте које су неопходне да би наш програм радио).
• Component palette са листићима: Standard, Additional, Win32, System, Data Access, Data
Controls, dbExpress, DataSnap, BDE, ADO, InterBase, WebServices, InternetExpress,
Internet, WebSnap, Decision Cube, Dialogs, Win 3.1, Samples, ActiveX, Rave, Indy Clients,
Indy Servers, Indy Intercepts, Indy I/O Handlers, Indy Misc, COM+, InterBase Admin, IW
Standard, IW Data, IW Client Side, IW Control, Servers у оквиру којих се налазе објекти које
можемо уградити у свој програм једноставним превлачењем објекта на форму. Део
листића се не види, па да би се до њих стигло треба притиснути неколико пута
одговарајући тастер са стрелицом
Најчешће ћемо користити листић Standard јер се ту налазе најједноставније компоненте за
комуникацију програма са корисником, у ретким случајевима ћемо користити неке од
компоненти са листића Additional, Win32, System. Остале листиће и компоненте нећемо
користити.
Селектовање компоненте коју желимо да уградимо у свој програм остварује се кликом
миша на њену графичку представу на листићу, а затим кликом на одговарајућу позицију на
форми постављамо изабрану компоненту. Ако смо се предомислили, па не желимо ту
компоненту можемо:
- кликнути на другу компоненту, ако је потребно уградити је у програм, или
- кликнути на стрелицу на почетку траке са компонентама, ако не желимо да додамо било шта.
Са листића Standard најчешће ћемо користити компоненте:
- Label (сличица са великим словом A)
- Edit (сличица са малим словима ab)
- Button (сличица са словима ОК)
- Меmо (сличица између едита и тастера),
- ComboBox (једанаеста сличица не рачунајући стрелицу за деселекцију) и
- Panel (претпоследња сличица на листићу).
Са листића Additional најчешће ћемо користити компоненте:
- BitBtn (компонента личи на тастер са могућношћу комбиновања слике и текста на њој),
- Image (када желимо да свој програм украсимо сликом) и
- LabeledEdit (компонента која представља комбинацију лабеле и едита).
Са листића Win32 ћемо користити компоненту DateTimePicker за читање времена и датума.
Са листића System ћемо користити компоненту Timer, а занимљиве су и PaintBox и Media
Player код креирања мултимедијалних апликација, али их нећемо користити на почетку учења.
Централни део екрана заузима прозор са именом Form1. Форма (образац) представља
радну површину програма. То је оно што ће се видети на екрану када се програм извршава. На
форму се постављају објекти. Дефинисањем параметара - карактеристика (Properties) форме
дефинишемо изглед нашег програма. Једна од карактеристика форме је име - Form1, уопштено,
аутоматски додељено на почетку рада што значи да се и оно може, по жељи, променити. Затим
ширина и висина форме, боја позадине, основни фонт итд. Као и сваки прозор, форма у десном
горњем углу има тастере Minimize, Restore Down/Maximize и Close, дугме управљачког менија,
Control Menu Button, у облику иконице која je симбол програмског језика делфи (ови елементи
се могу искључити у фази извршења апликације) и назив форме (може бити празан).
Испод овог прозора налази се прозор Unit1. У њему се пишу кодови процедура и функција
које се користе у програму. Подељен је на два дела. У левом делу, који се зове Code Explorer и
може бити самосталан прозор изван прозора јунита, виде се називи компоненти које смо
уградили у свој програм, називи свих променљивих и константи које су декларисане и
дефинисане и њихове везе. У десном делу, који се назива Edit Window, су изворни кодови
процедура и функција, као и декларације и дефиниције. Наравно, ако програм који пишемо,
садржи више независних целина, тј. јунита, десни део овог прозора ће имати посебне листиће
за сваки од њих, а прелазак из једног у други листић је стандардни клик левим тастером миша
над његовим именом. Прелазак из прозора јунита у прозор форме и обрнуто омогућава тастер
F12. Уколико имамо више прозора са јунитима прелазак из једног у други омогућава
комбинација Ctrl+F12, а ако имамо више прозора са формама прелазак из једног у други
омогућава Shift+F12. Наравно, ако су ови прозори видљиви или бар неки њихов део, из једног у
други можемо прећи и једноставним кликом миша на неки од њих. Јунит нема карактеристике
јер је невидљив када се програм покрене, а назив јунита се даје приликом чувања пројекта.
Лево од ова два прозора (мада се распоред прозора може по жељи мењати, али говоримо
о стандардном, изворном распореду прозора - пре било какве акције корисника) су још два
стандардно отворена прозора:
• Object Tree View и
• Object Inspector.
За разлику од претходних прозора, ови се не могу ни минимизирати нити максимизирати
помоћу стандардних тастера. Можемо их увећавати или смањивати повлачењем ивица уз
помоћ миша или затворити левим кликом на X. Но, то не представља њихов недостатак с
обзиром да су то помоћни прозори са дефинисаним садржајем који програмер не може мењати.
У случају да су намерно или грешком затворени притиском тастера X или другачије отварају се
притиском тастера F11 (Object Inspector) и Shift+Alt+F11 (Object TreeView) или одговарајућим
командама из Edit менија.
Object TreeView је помоћни прозор у коме се виде називи свих
употребљених компоненти програма, њихова повезаност са главном
формом и, евентуална, припадност неким другим компонентама које се
налазе на главној форми програма. Нарочито је значајан када се пишу
компликованији програми са више панела или форми, програми у којима
се поједине компоненте, односно, објекти који су постављени на форму
преклапају тако да неки чак и нису видљиви (јер су прекривени другим
компонентама), па их је зато немогуће селектовати ради постављања
или измене њихових карактеристика. Да бисмо селектовали један такав
скривени објекат довољно је да једноставно кликнемо на његово име у
Object TreeView прозору и онда можемо, иако га не видимо, да мењамо
његове карактеристике (наравно, морамо тачно знати који се ефекат
постиже изменом неке карактеристике, нарочито ако се она односи на
спољашњи изглед објекта који не видимо).
Object Inspector је врло користан помоћни прозор у коме за активну компоненту, тј.
објекат чије име се исписује у првом оквиру, дефинишемо карактеристике и његово реаговање
на разне догађаје. Овај прозор има два листића: Properties и Events.
Листић Events садржи листу свих догађаја на које одређени објекат може “реаговати”.
Двокликом у оквир десно од назива догађаја аутоматски се отвара процедура коју треба да
напише програмер, а која ће представљати реакцију објекта на тај догађај. У случају да је
програмер већ дефинисао неке процедуре које могу бити реакција на изабрани догађај, левим
кликом на стрелицу на десном крају оквира тог догађаја ће се отворити листа са њиховим
именима из које се може изабрати само једно, тј. на један догађај се може реаговати само на

један начин. Листа догађаја објекта може бити променљиве дужине у

зависности од врсте објекта чија се реакција дефинише, тј. немају сви
објекти исту осетљивост на разне догађаје.
Листић Properties садржи све могуће карактеристике изабраног
објекта (величина, боја, положај, хоризонтално и вертикално уређење,
наслов, облик рубова, фонт, име итд) и њихове предефинисане вредности,
ако постоје, а код неких карактеристика и све вредности од којих се може
изабрати само једна. Програмер има могућност да промени карактеристике
објекта не пишући програмски код, већ директним уносом вредности
карактеристике у предвиђени оквир. Различити објекти имају различит
број карактеристика, па је зато дужина овог листића променљива, осим
тога, неке карактеристике које се не мењају често могу бити сакривене,
невидљиве или се могу приказивати, по жељи програмера. Неке
карактеристике означене су симболом + или - јер представљају сложене,
тј. вишедимензионалне карактеристике, на пример: карактеристика
Font се састоји из детаља: Charset - кодна страна, Color - боја исписа,
Height - висина у тачкама, Name - назив фонта, Pitch - растојање између
узастопних слова, Size - величина слова и Style - стил исписа који је,
такође, сложен и састоји се из подкарактеристика fsBold, fsItalic,
fsUnderline, fsStrikeOut. Притиском на симбол + отварају се сви детаљи
који припадају тој карактеристици, а симбол + прелази у симбол -. И неки
детаљи, такође, могу бити означени овим симболима, па ако су означени
симболом + на исти начин се отварају. Притиском на симбол - затварају се
сви детаљи који припадају тој карактеристици, а симбол - прелази у
симбол +. Карактеристике објеката у оквиру овог листића су обично
уређене по абецедном редоследу, али могу бити уређене и по
категоријама, ако нам је тако једноставније да пронађемо
карактеристику коју желимо да дефинишемо. Промену начина уређења
карактеристика објеката извршићемо притиском десног тастера на
било којем делу Object Inspector прозора, избором опције Arrange и, затим,
опције by Category или by Name. Избором опције Properties можемо
дефинисати боје позадине и исписа (што, на почетку учења, није претерано
важно, али некоме може нешто и значити) као и шта ће се приказивати
код карактеристика. Промена неке карактеристике објекта одмах се
приказује на селектованом објекту и задржава се све док се програмски или
новом променом на овом листићу не дефинише њена другачија вредност.
Ако се промена карактеристике изврши у програму (када се програм
стартује) онда она није трајна, тј. поновним стартовањем истог програма
карактеристике објеката се постављају на оне које су претходно
дефинисане у листићу Properties.
Осим ових, стандардно отворених прозора на радној површини
делфија могу се појавити и многи други помоћни прозори. Погледајмо (и
опишимо) сада само неке од њих:
To-Do List прозор приказује редослед одвијања операција код
извршења програма.
Components (претраживач компоненти је корисна алатка ако знамо
назив објекта, али не знамо на којој палети се он налази);

Project Manager је прозор у коме се виде групе пројеката и пројекти у оквиру групе
пројеката и омогућава навигацију, кретање кроз пројектне датотеке. Овај прозор можемо
користити и код додавања или брисања пројеката из групе као и за активацију пројекта у
оквиру групе. Везано за пројекат, помоћу њега се додају, бришу, чувају и копирају датотеке које
припадају том пројекту. Овде се могу видети називи свих jунита и припадајућих форми у
оквиру пројекта или групе пројеката.
Align - помаже код уређења положаја објеката, леви клик миша на
одговарајуће дугме у овом прозору док су селектовани неки објекти на
форми помериће некe у смеру стрелице на дугмету до постизања
жељеног положаја).
Осим поменутих прозора могу се отварати и други.
На пример, разни Debug прозори отварају се, на захтев,
код превођења програма, у њима се исписују евентуалне
грешке у програмском коду, у прозору Evaluate/Modify
могу се исписивати и мењати вредности променљивих у
појединим фазама програма, у прозору Watch могу се
исписивати вредности променљивих или израза у току
извршавања програма и слично што програмеру може
помоћи да тестира понашање и отклони недостатке
програма. Ове прозоре нећемо сада објашњавати јер нису
неопходни за рад на почетку дружења са делфијем.
Уз програмски пакет Delphi иде детаљно упутство за
радознале и оне који би да науче о овом пакету више него
што је обимом ове књиге предвиђено. Упутство је
прилагођено раду под оперативним системом XP, а да би
се користило под новијим оперативним системом треба
инсталирати програмски додатак са сајта његовог
произвођача (www.microsoft.com).
Празан пројекат.
Отварањем делфи апликације отворили смо празан пројекат. И овакав пројекат је

виндоуз апликација. Може се покренути (након компајлирања). Има све карактеристике
апликације: радни прозор, наслов апликације, системски мени са одговарајућим тастерима.
Радни прозор се може премештати, можемо му мењати димензије и облик, али ништа не ради
(јер нисмо написали програмски код који би вршио неку активност).
Основне датотеке које садржи сваки делфи пројекат су:
Project1.cfg - конфигурацијски документ који чува параметре пројекта неопходне за рад
самог делфија у току израде апликације;
Project1.dpr - (Delphi Project) датотека - основни програмски код који генерише сам делфи
и не би је требало дирати без превелике потребе;
Project1.res - ресурсна датотека, садржи различите ресурсе које користи апликација коју
креирамо, дефинитивно је не треба уклањати;
Project1.dof - садржи тренутно важеће параметре за опције у пројекту као што су
компајлерски и линкерски параметри, директоријуми, директиве и командни
параметри;
Unit1.pas - (Delphi Source File), изворни код делфи/паскалског програма;
Unit1.dfm - (Delphi Form), датотека која садржи основне параметре извршног прозора
апликације коју креирамо. То је текстуална датотека коју делфи интерпретира
графички.
Осим ових могу се јавити и још неке датотеке које се аутоматски креирају (Unit1.dcu,
Unit1.ddp и друге), а компајлирањем програма формира се и Project1.exe - извршна датотека.
Име пројекта се аутоматски додељује - Project1. Име пројекта може се, по жељи, променити,
али то није обавезно, ако усвојимо договор да се сваки пројекат чува у засебном фолдеру. Ово
ће бити и име извршне верзије програма, па ако се озбиљно желимо бавити писањем
програма, онда би требало променити га. Сада ћемо видети структуру сваког програма.
Отворићемо датотеку Project1.dpr која се може отворити било којим едитором текста, на
пример, помоћу Notepad-а, само пажљиво, да се не би десило да датотеку придружимо овом
едитору, па да је касније не можемо, аутоматски, отворити помоћу делфијевог едитора:
program Project1;
uses
Forms,
Unit1 in 'Unit1.pas' {Form1};
{$R *.res}
begin
Application.Initialize;
Application.CreateForm(TForm1, Form1);
Application.Run;
end.
Пројект се састоји из јунита и форме. Јунит (Unit1.pas) на почетку рада изгледа овако:
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs;
type
TForm1 = class(TForm)
private
{ Private declarations }
public
{ Public declarations }
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
end.
Празна форма са предефинисаним димензијама и изгледом и са натписом Form1
дефинише се као текст датотека, неки атрибути могу имати и другачије вредности у
зависности од карактеристика рачунара на коме се ради, (датотека Unit1.dfm):
object Form1: TForm1
Left = 192
Top = 114
Width = 870
Height = 640
Caption = 'Form1'
Color = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -11
Font.Name = 'MS Sans Serif'
Font.Style = []
OldCreateOrder = False
PixelsPerInch = 96
TextHeight = 13
end
Покретање ове празне, као и било које друге апликације, остварује се избором команде
Run из одговарајућег менија, кликом на тастер у облику зеленог троуглића (плеј дугме) или
коришћењем пречице - функцијски тастер F9. Пре покретања апликације, добро је сачувати је
како нам се не би десило да изгубимо свој труд у случају непланираног и неконтролисаног
напуштања делфи апликације било услед грешке у програмском коду, било из неког другог,
спољашњег разлога (код новијих оперативних система, нарочито ако су 64-воробитни, програм је
обавезно сачувати да би се могао покренути). Опште правило у раду са рачунаром је да би
требало свој рад чувати често и у фази израде и касније код сваке измене. Учесталост чувања се,
обично, одређује обимом посла, тј. кад год урадимо нешто што не бисмо желели да радимо још
једном, колико год то било, треба то и сачувати. Празан пројекат је полазна основа у изградњи
било које апликације. Наравно, када радимо неки пројекат који мање или више личи на неки
претходни, не морамо кренути од празног пројекта и губити време на подешавање истих
карактеристика, писање истих или сличних програмских кодова, већ можемо искористити
постојећи. У таквом случају, одмах по отварању пројекта који желимо да искористимо за
креирање новог потребно је сачувати га са другим именом, како не бисмо изгубили претходни.

Чување и отварање пројекта.
Једна од важнијих ствари које морамо научити пре писања било ког програмског кода је
како сачувати свој пројекат. Пошто се сваки пројекат састоји из већег броја датотека морамо, пре
чувања пројекта, креирати нови фолдер, па тек онда у њега сачувати свој пројекат. Фолдер се
може креирати пре отварања новог пројекта или у току рада на новом пројекту. Објаснићемо
други начин (јер се претпоставља да је први познат од раније).
Из менија File изабраћемо команду Save All. Отвориће се прозор за дијалог Save Unit1 As.
Када први пут чувамо пројекат, најпре ћемо креирати нови фолдер кликом на сличицу
фолдера са звездицом у горњем десном углу или десним кликом у празни део прозора и
избором опције New -> Folder. Фолдеру треба дати име које ће нас подсећати на проблем који
се тим програмом решава овим пројектом (на пример: ResavanjePravouglogTrougla). Име
фолдера не треба да садржи размаке, интерпункцијске знаке ни наша слова (сва ћирилична ни
латинична слова ш, ђ, ч, ћ, ж). У новим верзијама оперативног система употреба ових
карактера неће представљати никакав проблем, али због евентуалног преношења нашег
програма на рачунаре са различитим верзијама оперативног система, треба поштовати
препоруку). Затим треба отворити тај фолдер, двокликом на његову иконицу или кликом на
дугме Open (које ће се исцртати уместо дугмета Save). У оквиру означеном са File name: треба
уписати име програма (ово није обавезно, тј. име јунита не мора се мењати, може се оставити
понуђено Unit1, јер ће у овом фолдеру бити само један јунит). Код давања имена јуниту не би
требало користити размаке, знаке интерпункције, латинична слова ш, ђ, ч, ћ, ж нити наша
ћирилична слова. Када смо дали име јуниту кликнућемо на дугме Save.
Сада се отвара нови дијалошки прозор Save Project1 As у којем треба уписати име
пројекта (ово, такође, није обавезно, тј. име пројекта не мора се мењати, може се оставити
понуђено Project1, јер ће у овом фолдеру бити само један задатак, односно, само један
пројекат). За име пројекта важе исте напомене као и за име јунита, а име пројекта не би
требало да буде исто као име јунита.
Код сваке значајне измене програма, без обзира да ли смо на форму додали нове
компоненте или смо мењали програмски код, треба сачувати пројекат помоћу команде Save
All при чему се претходни прозори више неће отварати (само ћемо себи уштедети мало
времена и много нерава у случају да се нешто непредвиђено деси са рачунаром, па да писање
програм не морамо да почнемо од почетка).
У случају да нисмо отворили нови пројекат, већ користимо постојећи за креирање новог
(јер има случну форму или се део програмског кода преклапа са новим или из било којег другог
разлога) применом команди Save или Save All преко старог пројекта сачуваћемо нови. На тај
начин бисмо изгубили претходни пројекат. Да се то не би десило, у оваквом случају поступак
чувања пројекта биће другачији. Из менија File изабраћемо прво команду Save As. Отвориће се
прозор за дијалог као на првој слици и сачуваћемо јунит како је раније описано (креираћемо
нови фолдер и у њему са истим или промењеним именом сачувати јунит). Затим ћемо из
менија File изабрати команду Save Project As. Отвориће се прозор за дијалог као на другој
слици и сачуваћемо пројекат како је описано.

Пројекат затварамо изабором команде Close All из менија File.

Ако претходни пројекат нисмо сачували програм ће нас упозорити
на то и дати нам могућност да измене сачувамо пре затварања
пројекта.
Нови празан пројекат отвара се изабором команде New ->
Application из менија File. И у овом случају, ако је претходно био
отворен неки пројекат који није сачуван отвориће се исти дијалошки прозор упозорења који ће
нам дати нам могућност да измене сачувамо пре затварања претходног и отварања новог
пројекта.
Отварање постојећег пројекта остварује
се тако што се из менија File изабере команда
Open Project. Ако претходни пројекат нисмо
сачували поново ће се отворити претходно
описани дијалошки прозор, упозорити нас на
то и дати нам могућност да измене сачувамо
пре отварања новог пројекта. Након тога ће се
отворити прозор за дијалог као на слици. Треба
пронаћи фолдер из којег желимо да отворимо
пројекат и отворити га двокликом. Двокликом
на само име пројекта или обележавањем
простим кликом миша и кликом на дугме Open
отвориће се жељена апликација. У случају да
се апликација не отвори онда претходни
поступак чувања пројекта није испоштован
или је накнадно обрисана нека од важних
датотека. У неким од таквих случајева то се може решити активностима у оперативном
систему, али у већини случајева то значи да ту апликацију не можемо користити за измене или
креирање нове. Зато је од изузетне важности научити правилно чување пројекта.
Отварање неког постојећег пројекта могуће је и из оперативног система, пре покретање
делфи пакета, тако што се отвори одговарајући фолдер и двокликом изабере пројекат који се
отвара. Оперативни систем ће аутоматски покренути делфи апликацију и у њој отворити
изабрани пројекат. У овој верзији делфија нема могућности рада са више пројеката
истовремено. У једном тренутку могу бити отворена два или више програма, али то
подразумева да смо два или више пута покренули програмски пакет делфи. Код неких врста
програма, то може значајно успорити или сасвим онемогућити рад на развоју апликације. Ако
желимо да гледамо решење једног задатка и на основу њега решавамо други, сличан, треба
отворити јунит у неком текст едитору, на пример у Notepad-у, одакле га можемо или копирати
или само гледати решење.
Форма и подешавање њених својстава.
Почетни изглед форме описан је у Unit1.dfm датотеци и додавањем нових елемената на

форму или мењањем карактеристика већ постојећих, ова датотека се допуњава. Ово је
текстуална датотека и њен садржај прегледати у неком едитору. Садржај датотеке може се и
мењати у едитору без последица по рад програма уколико не направимо неку грешку. Док је
програм отворен у делфију не би требало мењати садржај ове датотеке отворене неком у
другом едитору. Својства форме се могу, у зависности од самог својства, подешавати
директно, помоћу миша (ово се односи само на величину и положај форме) или уписивањем
одговарајућих карактеристика на листићу Properties прозора Object Inspector (односи се на
готово сва својства форме), а могу се поједина својства подешавати и програмски, тј. у фази
извршавања пројекта форма може мењати изглед и друге карактеристике. Најчешће се мењају
следећа својства:
• Спољашње димензије форме, односно, ширина (Width) и висина (Height) прозора, али и
унутрашње димензије прозора ClientWidth и ClientHeight, при чему се не могу
истовремено користити и спољне и унутрашње димензије јер су зависне једне од других.
• Позиција на екрану, односно, растојање од левог (Left) и од горњег (Top) руба екрана, а осим
са ове две, може се дефинисати и карактеристиком Position (са вредностима poDefault,
poDefaultPosOnly, poDefaultSizeOnly, poDesigned, poDesktopCenter, poMainFormCenter, poOwner

FormCenter, poScreenCenter) и карактеристиком Align (са вредностима alBottom, alClient,
alCustom, alLeft, alNone, alRight, alTop) при чему ова последња појединим вредностима
онемогућава дефинисање ширине или висини прозора апликације.
• Назив прозора (Caption), односно, текст који ће се исписивати у ттраци на врху прозора.
• Боја радне површине (Color), избор се врши између 20 стандардно понуђених боја или
двокликом на ову карактеристику отварамо палету са које можемо да креирамо једну од
преко 16 милиона боја.
• Стил рубова прозора (BorderStyle), односно, дозвољавамо или забрањујемо кориснику да
манипулише позицијом и величином прозора (bsDialog, bsNone, bsSingle, bsSizeable,
bsSizeToolWin, bsToolWindow су дозвољене вредности, друга и четврта дозвољавају пуну
слободу кориснику, а остале делимично или потпуно ограничавају измену прозора
апликације).
• Дебљина оквира (BorderWidth), карактеристика практично дефинише део радне површине
уз рубове прозора који се не могу користити за постављање објеката (нешто слично
маргинама у текст процесорима).
• Контролна дугмад прозора biSystemMenu, biMinimize, biMaximize, biHelp се могу видети
на горњем рубу прозора или не, што се подешава у оквиру карактеристике BorderIcons.
• У оквиру карактеристике Font дефинишемо основни фонт који ће се аутоматски
придруживати свим објектима које касније поставимо на форму.
• Стил форме (FormStyle) дефинише да ли је прозор апликације зависан или не од неког
другог прозора и да ли ће бити увек на врху свих отворених прозора, могуће вредности су
fsMDIChild, fsMDIForm, fsNormal, fsStayOnTop.
• Облик прозора (WindowState) са вредностима wsMaximized, wsMinimized, wsNormal.
Додавање компоненти форми.
Додавање компоненти форми је врло једноставно. Пронађемо жељену компоненту на

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

тастера Delete на тастатури или десним кликом на компонету, па избором команде Delete из
подменија Edit падајућег менија који смо отворили. Ако смо додали једну компоненту на
форму, а желимо још неколико таквих, можемо понављати поступак додавања потребан број
пута или додату компоненту селектовати и ископирати потребан број пута. Копирање се може
остварити десним кликом миша на компоненту и подменија Edit падајућег менија који се отвара
или селектовањем компоненте помоћу миша и коришћењем пречица помоћу тастатуре (Ctrl+C
за копирање објекта у меморију и Ctrl+V, потребан број пута, за постављање копија објекта на
форму). Компоненте се на форму могу додати и копирањем са неке друге форме као и
програмски (програмер може дефинисати појављивање објекта на форму, али се за овакав
начин додавања компоненти захтева виши ниво познавања програмирања у објектно
оријентисаним програмским језицима).

Компонента у жижи.
Компонента може бити у жижи и тада јој се могу мењати карактеристике. Да бисмо знали
која је компонента активна довољно је да погледамо на врх прозора Object Inspector-а. Њено
име је исписано у првом оквиру. Активна компонента је означена и са осам црно обојених
квадратића, на угловима и срединама страница.
У извршној верзији апликације, такође, битно је знати
која је компонента тренутно активна, односно, у жижи. Када
се програм покрене, нема Object Inspector-а, а нема ни црних
тачкица на рубовима компоненте и тада активну компоненту
можемо препознати по неким другим карактеристикама које
зависе од врсте компоненте. Ако се ради о текст компоненти,
она је у жижи ако у њој трепери курсор. Ако се ради о
графичкој компоненти, она је у жижи ако је око натписа на
њој видљив испрекиданим линијама исцртан правоугаоник.
На слици је чекбокс компонента у жижи (што препознајемо по
тачкицама исцртаном оквиру око текста).
У једном тренутку, само једна компонента може бити у жижи. Жижу са компоненте на
компоненту премештамо тастером Tab на тастатури или кликом миша на изабрану компоненту.
Неке компоненте не могу бити у жижи. Да би компонента могла бити у жижи мора поседовати
карактеристику TabStop. Карактеристиком TabStop дефинишемо редослед постављања
компоненти у жижу. Овај, природни, редослед може се пореметити кликом мишем на
одговарајућу компоненту. Добро организовани програм има редослед доласка компоненти у
жижу који прати алгоритамско решење.
Једноставне компоненте
Селектовањем неке компоненте, у Object Inspector-у на листићу Properties можемо

изабрати и подесити одговарајућу карактеристику те компоненте. Карактеристике
компоненти могу се подешавати и из саме апликације у току извршавања, ако се у програмски
код угради одговарајућа рутина. Већина карактеристика компоненти може се подесити из
апликације (у фази извршавања програма) простом наредбом:
компонента.карактеристика:=вредност;
Најчешће коришћене компоненте су:
• Label
• Edit
• Button
• Memo
• Timer
• Image
Натпис (Label)
Label, натпис је компонента која омогућава једносмерну комуникацију на релацији
програм-корисник, односно, помоћу ње се кориснику програма саопштава нешто; корисник не
може да мења садржај лабеле нити на било који начин да утиче на њен изглед и величину осим
када је то програмом дефинисано, односно, када је испрограмирано да се на неки начин
промене карактеристике задате у фази дизајнирања програма. Када се програм извршава, ова
компонента не може бити у жижи. Компонента се налази на листићу Standard на четвртом
месту (велико слово А). Као и сваки други објекат, лабела има одређене особине које се могу
подешавати како би се постигли одговарајући ефекти. Најчешће ћемо подешавати следећа
својства:
Align - положај лабеле у односу на рубове форме
Alignment - уређење текста у оквиру лабеле
AutoSize - аутоматско подешавање величине лабеле

Color - боја лабеле

Caption - текст који је исписан на лабели
Font - врста слова, начин исписа, величина, боја и ефекти
Height - висина објекта
Layout - вертикално уређење текста у лабели
Left - растојање објекта од левог руба форме
Name - име објекта
Top - растојање објекта од врха форме
Transparent - провидност позадине лабеле
Visible - видљивост објекта
Width - ширина објекта
WordWrap - пренос текста на лабели у нови ред
Оквир за уношење и приказивање текста (Edit)

Edit, оквир за текст је компонента која омогућава двосмерну комуникацију на релацији
програм-корисник, односно, помоћу ове компоненте програм може да саопштава поруке
кориснику и корисник може да се обраћа програму уносом одговарајућих података; кориснику
се програмом може дозволити или забранити измена садржаја ове компоненте. Када је ова
компонента у жижи у њеном оквиру трепери курсор. Компонента се налази на листићу
Standard на петом месту (мала слова аб). Најчешће ћемо подешавати следећа својства:
CharCase - исписивање малих и великих слова у едиту
Color - боја едита
Enabled - да ли је дозвољено приступити едиту
MaxLength - максимални број карактера који се може уписати
ReadOnly - да ли је дозвољено мењање садржаја едита
TabOrder - редни број објекта
Text - садржај едита
Дугме (Button)
Button, тастер или дугме је компонента којом се корисник обавештава о могућности
извршења неке акције у програму за коју је потребна конкретна активност корисника,
односно, кликом мишем на ову компоненту корисник програму саопштава да жели да се нека
акција изврши; корисник нема права да мења изглед и функцију ове компоненте јер је то
програмом дефинисано. Компонента се налази на листићу Standard на седмом месту (сличица
са словима ОК). Најчешће ћемо подешавати следећа својства:
Caption - текст који је исписан на тастеру
Enabled - да ли је дозвољено приступити тастеру
Height - висина тастера
WordWrap - пренос текста на тастеру у нови ред

Мемо поље (Memo)

Мемо поље (Memo) је компонента којом се омогућава унос и приказивање вишередног
текста. Ова компонента представља неки облик елементарног едитора текста без могућности
напредног уређивања текста. Компонента се налази на листићу Standard на шестом месту
(сличица која подсећа на лист папира из свеске). Најчешће ћемо подешавати следећа својства:
Align - положај објекта у односу на рубове форме
Alignment - уређење текста у оквиру поља
Color - боја позадине поља за текст
Enabled - да ли је дозвољено приступити пољу
Lines - садржај мемо поља
ReadOnly - да ли је дозвољено мењање садржаја мемо поља
WordWrap - пренос текста у нови ред
Часовник (Timer)
Компонента која омогућава извршавање програмских елемената периодично, тј. у тачно
одређеном тренутку у односу на њено активирање. Може да се користи код симулација
кретања као и код других аудио и визуелних ефеката који треба да се појављују у једнаким
временским интервалима. Једна компонента може да контролише само једну програмску
целину. Дозвољена је употреба произвољног броја ових компоненти. Пошто су на извршном
екрану невидљиве, ове компоненте неће нарушити уређење излазне форме апликације
колико год да их је активирано. Компонента се налази на листићу System на првом месту
(часовник). Подешаваћемо следећа својства:
Enabled - да ли је тајмер активан, укључен
Interval - период у милисекундама који активира неки догађај
Name - име тајмера
Оквир за графички објекат (Image).

Излазни екран (лице) апликације може бити ефикасније ако се додају различити
графички објекти, цртежи или слике. Да би се омогућило такво опремање форме потребно је
искористити компоненту оквир за слику - Image. Компонента се налази на листићу Additional
на шестом месту (плави пејзаж). Најчешће ћемо подешавати следећа својства:
Align - положај слике у односу на рубове форме
AutoSize - аутоматско подешавање величине оквира слике
Center - центрираност слику у оквиру
Enabled - да ли је дозвољено приступити оквиру слике
Height - висина оквира слике
Left - растојање од левог руба форме
Name - име оквира за слику
Picture - слика која се приказује у оквиру
Stretch - да ли слика испуњава оквир за слику
Transparent - провидност оквира за слику
Top - растојање од врха форме
Visible - видљивост оквира са сликом
Width - ширина оквира за слику

Компоненте избора
Коришћење програма подразумева унос неких почетних података чијом се обрадом

добија жељени резултат. Унос података може се остварити слободним уносом, тј. корисник
уноси било шта или се кориснику унос ограничи на неколико података од којих треба да
изабере један. У првом случају се користе едити и мемо поља, у другом се користе компоненте
избора. Најчешће коришћене компоненте избора су:
• RadioButton
• CheckBox
• ListBox
• ComboBox
Радио-дугме (RadioButton)
Радио дугме је компонента која дозвољава унос једне вредности од понуђених.
Ако постоји само једно дугме, корисник може изабрати тај податак или га не
изабрати. Много чешће се радио дугмад групишу, па се кориснику дозвољава шири
избор, тј. од више понуђених података може изабрати један. Контрола избора је на
програму, тј. избором једног податка аутоматски се поништава претходни избор. На
слици је приказана радио група којом би се могао унети одговор на питање: На којој
планети живимо?. Могуће је изабрати само један од понуђених одговора. Радио
дугмад могу бити распоређена хоризонтално, верикално или у облику табеле.
Најчешће се подешавају следеће карактеристике:
Caption - наслов (назив опције)
Color - боја позадине
Top - удаљеност од горње ивице форме
Left - удаљеност од леве ивице форме
Width - ширина, ако је краћа од дужине наслова део наслова се неће видети
Height - висина компоненте
Font - врста фонта који се користи за испис опција
Checked - дефинише да ли је опција селектована или не
Оквир за потврду (CheckBox)

Оквир за потврду је компонента која дозвољава унос једног или више података
од понуђених. Као и у претходном случају, може постојати више података при чему
се кориснику допушта да изабере један или више података. На слици је приказана
група оквира за потврду којом би се могао унети одговор на питање: Коју бисте
планету волели да посетите. Могуће је изабрати један или више од понуђених
одговора. Оквири могу бити распоређени хоризонтално, верикално или у облику
табеле. Најчешће се подешавају следеће карактеристике:
Caption - наслов (назив опције)
Width - ширина, ако је краћа од дужине наслова део наслова се неће видети
Height - висина компоненте
Font - врста фонта који се користи за испис опција
Checked - дефинише да ли је опција селектована или не
Оквир с листом (ListBox)

Оквир са листом је компонента помоћу које можемо изабрати више од
понуђених одговора, опција. Број понуђених опција није ограничен.
Вишеструки избор омогућен је комбинованом употребом миша и тастера
Shift или Ctrl. Помоћу првог тастера селектујемо све одговоре од првог
селектованог до другог селектованог, а помоћу другог тастера можемо
селектовати одговоре који нису један поред другога. Ако на листи има више
одговора него што може стати у оквир са десне стране се појављује клизач којим се могу
откривати одговори који се не виде. Најчешће се подешавају следеће карактеристике:
Width - ширина оквира
Height - висина оквира
Font - врста фонта који се користи у оквиру
Border Style - врста ивице оквира
Items - опције, ставке у листи
MultiSelect - дозвољава или забрањује вишеструко селектовање опција листе
ItemIndex - редни број опције у листи (бројање почиње од 0)
Sorted - дефинише да ли ће опције бити абецедно уређене
Комбиновани оквир (ComboBox)

Комбиновани оквир је компонента која се састоји из оквира у
који се може уписати податак и стрелице на крају оквира којом се
отвара контејнер у који су смештени подаци које је дозвољено унети.
Контејнер може бити ограничавајући или информативни. У првом
случају кориснику се не дозвољава да унесе ништа осим понуђеног, а
у другом случају корисник може изабрати нешто од понуђеног или
уписати нешто друго. Падајућа листа може бити сакривена и по потреби се отвара, а може бити
и стално видљива. Ако број понуђених одговора не може да стане у предвиђени оквир падајуће
листе са десне стране се појављује клизач којим се могу откривати тренутно невидљиви
одговори. Користи се нарочито у ситуацијама када је врло битан начин исписа податка који се
уноси или ако су подаци који се уносе јако компликовани, а могућности (број различитих
уноса) су ограничене. Компонента се налази на листићу Standard на једанаестом месту
(сличица едита са спуштеном листом за избор). Најчешће ћемо подешавати следећа својства:
AutoComplete- аутоматско исписивање податка који одговара унетом првом слову (или
групи слова)
AutoDropDown - аутоматско спуштање листе када објекат постане активан
CharCase - исписивање малих и великих слова у оквиру
Color - боја позадине поља за текст
Enabled - да ли је дозвољено приступити оквиру
ItemHeight - висина податка са листе
ItemIndex - редни број податка са листе који је изабран
Items - листа података
Sorted - да ли су подаци на листи уређени
Text - податак који је исписан у главном оквиру
Контејнерске компоненте
Контејнерске компоненте се користе за визуелно издвајање и груписање компоненти

које су повезане неким поступком, особином или чине посебну целину у програму. Овим
компонентама се постиже боља прегледност маске за унос и приказивање података и
ефикаснија контрола компоненти из програма.
Овде ћемо поменути две компоненте:
• GroupBox и
• Panel.
Оквир за групу (GroupBox)

Када желимо да неколико истих или различитих компоненти
повежемо јер су део једног процеса или акције која треба да се изврши онда
користимо компоненту оквир за групу. Оквир за групу има своје име, а
димензије могу да се мењају како би се компоненте које се повезују
распоредиле тако да следе природни ток алгоритма. Могу се повезивати
разнородне компоненте, радио дугмад, дугмад, едити, лабеле, чек боксови
и други. Доступност компоненти из програма можемо да контролишемо
преко оквира за групу. На тај начин можемо једном командом да искључимо све компоненте у
групи или да их привремено уклонимо са форме и у погодном тренутку поново вратимо.
Специјална врста оквира је RadioGroup коју чине само радио дугмад. Најчешће се подешавају
следеће карактеристике:
Caption - наслов који објашњава функцију компоненти унутар оквира
Width - ширина оквира
Height - висина оквира
Font - врста фонта који се користи у оквиру (ако је дефинисан, може да се преноси
на све компоненте које се стављају на оквир, а може и да се наслеђује од
компоненте на којој се налази)
Плоча (Panel)
Када желимо да постигнемо специјалне ефекте, да маске за
унос и приказивање података начинимо ефектнијим
користимо панеле. Панел може да се распростре по читавој
форми или да заузима само део ње, може да има рубове који
дају утисак тродимензионалности, могу да се покрећу, да се
појављују или нестају, да буду доступни или не. Све
компоненте које су смештене на једном панелу деле судбину
панела. Панели се могу да користе увек, али се најчешће
користе код мало сложенијих програма у којима има јако пуно
компоненти и опција које не би требале истовремено да се
приказују јер би форма била пренатрпана. А понекад се користе и за добијање специјалних
ефеката, на пример, код приказа слика, помоћу панела, можемо додати рам за слику. Ако су два
или више панела истовремено на форми могу се неке компоненте визуелно раздвајати и
груписати по својим функцијама и употреби. Најчешће се подешавају следеће карактеристике:
Caption - наслов (најчешће на панелу нема наслова)
Width - ширина панела
Height - висина панела
Font - врста фонта који се користи на панелу (ако је дефинисан, може да се преноси
на све компоненте које се стављају на панел, а може и да се наслеђује од
компоненте на којој се налази)
Align - позиција, поравњање панела у односу на форму
BevelInner - изглед унутрашњег дела оквира панела
BevelOuter - изглед спољашњег дела оквира панела
BevelWidth - дебљина оквира панела
BorderStyle - врсте ивица панела
BorderWidth- дебљина ивице панела
Визуелно издвајање компоненти на форми може се постићи и коришћењем компоненте
Bevel (оквир), али ово није контејнерска компонента јер само уоквирава компоненте, али не
дефинише њихову припадност и не може директно да преноси своје карактеристике на

уоквирене компоненете.
Догађаји компоненти и обрада догађаја.
У објектно оријентисаном програмирању тежиште је на објектима (као што и само име

каже) и оно што може да се догоди са или око објеката, односно различити догађаји. Шта може
бити догађај? Све што урадимо директном акцијом помоћу миша или тастатуре, али и све што
је последица извршавања програма или неког његовог дела, може бити догађај. Клик мишем
или само притисак или отпуштање тастера на мишу, прелазак показивача миша преко објекта,
превлачење објекта, промена димензија, притисак неког тастера на тастатури, унос неке
вредности, појава или нестајање објекта и друго, све су то неки догађаји који се могу осетити
или не у зависности од врсте објекта. Задатак програмера је да одлучи на које догађаје ће,
поједини објекти који су саставни део апликације реаговати, односно, на које догађаје ће бити
осетљиви и какво ће бити њихово понашање, тј. шта ће се дешавати. Ако ниједан догађај није
обрађен, онда написани програм неће радити ништа, тј. он је бескористан.
Неки од важнијих могућих догађаја објеката су:
• OnActivate - када објекат постане активан
• OnClick - када се мишем кликне изнад објекта
• OnClose - када се објекат затвори
• OnCreate - када се објекат креира
• OnDblClick - када се двапут кликне мишем изнад објекта
• OnDeactivate - када објекат престане да буде активан
• OnDestroy - када се објекат избрише
• OnDragDrop - када се објекат превуче и отпусти
• OnDragOver - када се објекат довлачи
• OnHide - када се објекат сакрије, тј. објекат још увек постоји, али се не види.
• OnKeyDown - када се на тастатури притиска било који тастер
• OnKeyPress - када је на тастатури откуцан неки тастер
• OnKeyUp - када се на тастатури отпушта неки тастер
• OnMouseDown - када се миш креће на доле преко објекта
• OnMouseMove - када се миш креће преко објекта
• OnMouseUp - када се миш креће на горе преко објекта
• OnMouseWheel - када се покрене точкић на мишу
• OnMouseWheelDown - када покрећемо точкић на мишу према себи
• OnMouseWheelUp - када покрећемо точкић на мишу од себе
• OnResize - када се објекту мења величина
Наравно, не могу сви објекти реаговати на све догађаје. Неки објекти су осетљивији, тј.
могу да реагују на више догађаја, а неки, опет, нису, тј. реагују на врло мали број догађаја.
Пажљивим одабиром објеката и дефинисањем њихове осетљивости могу се направити врло
атрактивне апликације (наравно, да би то било успешно треба имати много искуства, знања,
маште, воље и времена, али се исплати).
Код обраде догађаја, пошто неки могу бити сложени и састојати се из неколико других
догађаја, мора се водити рачуна да једна реакција не поништава другу. Може се десити и да
једна реакција производи други догађај, па се поништи претходна реакција или се програм
заблокира. Зато треба бити јако пажљив и, пре писања неке реакције, добро размислити о свим
последицама које реакција може произвести, а то је већ уметност програмирања.

• Објектно оријентисано програмирање, основни концепти

• Изглед развојног окружења делфи пакета
• Елементи главног прозора делфи пакета
• Функције помоћних прозора и рад са њима
• ObjectTreeView, карактеристике
• ObjectInspector, карактеристике и функције
• Подешавање својстава форме пројекта
• Чување новог пројекта
• Отварање новог и постојећег пројекта
• Рад са палетом са компонентама
• Најчешће коришћене компоненте и њихова својства
• Додавање компоненти на форму пројекта
• Селектовање компоненте
• Врсте догађаја на које компоненте могу да реагују

Типови података
Основни елементи програмског језика
Азбуку програмског језика чине сви дозвољени знаци који се користе приликом
кодирања програма и то су:
• велика и мала слова енглеске абецеде
• цифре декадног бројног система: 0,1,2,3,4,5,6,7,8,9
• специјални знаци: + - * / = ^ < > () [] {} . ,: ; ‘ # $
За математичка израчунавања се користе ознаке:
* за множење
/ за дељење
+ за сабирање
- за одузимање
() за промену приоритета извршења операција
У конструкцији програма се користе ознаке:
:= у наредбама додељивања
. ознака краја програма
; ознака краја наредбе
# ASCII кодови
$ хексадецимални бројеви
(* *) или
{} коментар или директива преводиоцу
+ укључење директиве преводиоца
- искључење директиве преводиоца
‘ почетак или крај карактера или стринга
, граничник између две променљиве
За упоређивање или тестирање се користе
= једнако
< мање од
> веће од
<= мање или једнако
>= веће или једнако
<> различито
За структуру података се користе:
^ показивач или контролни кодови са тастатуре
(. .) или [ ] индексирање и димензионисање низова
() листа параметара
. граничник записа поља
.. распон (интервал)
Резервисане речи су интегрални део језика и оне се не могу редефинисати ни користити
као имена променљивих или константи у програму. Резервисане речи у делфију су:
And, Array, As, Asm, Begin, Constructor, Case, Class, Const, Div, Destructor, Dispinterface, Do, Downto, Else, End,
Except, Exports, File, Finalization, Finally, For, Function, Goto, If, Implementation, In, Inline, Inherited, Initialization,
Interface, Is, Label, Library, Mod, Nil, Not, Object, Of, Or, Out, Packed, Procedure, Program, Property, Raise, Record,
Resourcestring, Repeat, Set, Shl, Shr, String, Then, Thread, Var, To, Try, Type, Unit, Until, Uses, Var, While, With, Xor
Стандардни идентификатори су речи дефинисане у програмском језику, али се могу и
редефинисати, мада их је боље користити у изворном облику да не би долазило до забуне. На

пример, можемо дефинисати integer као скуп речи, али је нормалније оно што је дефинисано
програмским језиком, да integer представља целе бројеве.
Граничници су симболи који служе за раздвајање појединих елемената језика. Дозвољени
граничници у делфију су:
; ознака за крај наредбе
, крај идентификатора у набрајању
. крај програма или поља у слогу
eol (end-of-line, крај реда) не види се на екрану - означава се притиском тастера
Ентер
// коментар у једном реду
{ ... } вишередни коментар
space (празнина) означава се притиском размакнице
Програмска линија је низ идентификатора максималне дужине 255 карактера рачунајући
и празнине. У паскалу, све иза 255-ог карактера се игнорише, у делфију програмски ред може
бити и дужи од 255 карактера, али се тако записани програми тешко читају.
Структура програма
Најједноставнија дефиниција програма је:

Програм је запис алгоритма за решавање неког проблема
на одговарајућем програмском језику.
Да би се написао програм, потребно је познавати проблем који се решава како би се могао
сачинити алгоритам и познавати детаље програмског језика на којем ће се описати алгоритам.
Основни елементи сваког програма су конструкције програмског језика које служе за описивање
података и радњи - то су идентификатори.
• Наредба је основни елемент програма који описује неко дејство података или изазива
акцију рачунара. Наредбе могу бити описне и извршне.
• Коментар је основна елементарна конструкција програма помоћу које се објашњавају
поједини делови програма. Намењен је програмеру, а не кориснику. Добар програм има
одговарајућу, добро одмерену подршку у облику коментара. Требало би да су сви кључни
детаљи програма објашњени коментаром.
Делфи је наследио структуру програма из паскала. Паскал је програмски језик у коме се
програми, осим функционалношћу и ефикасношћу, могу похвалити и лепотом. Наравно, сасвим
је свеједно да ли сте написали леп или ружан програм ако он ради оно што је замишљено, али,
кад већ можете, дозволите себи луксуз да програм визуелно као и програмским решењима
буде леп. Визуелна лепота и склад програма нису бескорисни. При евентуалном тражењу
грешака (а код великих и компликованих програма и најбољи програмери греше) много је
лакше пронаћи грешку ако је програм уредно исписан, са издвојеним структурним целинама и
пропраћен добрим и одговарајућим коментарима. Зато ћемо се трудити да научимо да
пишемо лепе и корисне програме.
Сваки програм у паскалу састоји се из два дела: заглавља и тела програма. Они могу бити
редуковани, али се не могу изоставити. Заглавље програма почиње именом програма и
декларацијама променљивих и дефиницијама константи и других података који ће бити
коришћени у програму:
PROGRAM MojPrviProgram;
...
Програмска линија са именом програма може се изоставити, али, чини се да програм
много комплетније и лепше изгледа, ако се на почетку представи. Назив програма може бити
произвољне дужине, али је важно напоменути да се у њему не могу налазити знаци
интерпункције, наша слова нити размак. Најбоље је да се називом најкраће саопшти шта
програм ради, са две до три речи које се раздвајају или тако што се пишу великим почетним и
осталим малим словима или цртицом за подвлачење. На пример:
PROGRAM ProracunUbrzanjaSatelita; или
PROGRAM Proracun_Ubrzanja_Satelita;

Наравно, програмер може и сам да осмисли начин на који ће написати назив програма,
али је овако читљивији.
У делфију су велика и мала слова равноправна тако да то да ли наредбе пишемо великим
или малим или великим почетним, а осталим малим зависи само од укуса програмера и ефекта
који се жели постићи када се само баци око на програм. Наравно, треба бити доследан у
коришћењу неког начина записивања програма јер на тај начин помажемо и себи код тражења
неких детаља или грешака у програму.
Део за декларације и дефиниције садржи:
• Одељак за декларација типова, почиње резервисаном речи type.
• Одељак за декларација променљивих, почиње резервисаном речи var.
• Одељак за дефинисање константи, почиње резервисаном речи const.
• Одељак за дефинисање лабела, почиње резервисаном речи label.
• Одељак за дефинисање кориснички дефинисаних функција, почиње резервисаном речи
function.
• Одељак за дефинисање кориснички дефинисаних процедура, почиње резервисаном речи
procedure.
Редослед одељака није битан, важно је само да декларације и дефиниције налазе испред
тела програма, односно, пре програмског реда који почиње резервисаном речи begin.
Тело програма почиње почетком (begin), а завршава крајем (end):
begin {овде се пишу наредбе, а ово је коментар}
...
end.
Тачка на крају програма се не сме изоставити. Испред тела програма (функције или
процедуре) не смеју се писати никакве наредбе. Програмске наредбе се једна од друге
раздвајају знаком ; који се може изоставити само у специјалним случајевима које ћемо
нагласити касније, када се са њима будемо сусретали. Будући да је делфи креиран тако да сам
гради основну структуру програма, нећемо морати много да бринемо о њеном поштовању.
Подела типова података
Програми се пишу да би се обрадили неки подаци који могу бити бројеви, речи или нешто
друго. У зависности од типа података дозвољене су различите операције са њима. Не могу се
две речи помножити или бројеви делити на слогове. Програмски језици су, углавном, строги у
односу на типове података и не дозвољавају њихово мешање.
Типови података могу да се деле разне начине, а најчешћа подела је на:
• стандардне и
• изведене.
Стандардни типови су они који су дефинисани и уграђени у структуру програмског језика
и могу се одмах и увек користити у свим програмима. Изведени тип података, по потреби,
дефинише корисник у свом програму и важи само у том програму, тј. ако га желимо користити у
неком другом програму морамо га у том програму поново дефинисати. Тип података се
дефинише именом које се не сме поклапати са неком од резервисаних речи програмског језика и
навођењем свих елемената који припадају том типу. Након дефиниције неког типа у програму
он се може користити као стандардни, али само у том програму.
Друга подела типова података (која не искључује прву) је на:
• просте,
• стрингове,
• структурне и
• показиваче.
Просте типове података чине:
• уређени типови и
• реални тип.
За уређене типове (ordinal types) карактеристично је да се за сваки њихов елемент зна
који је испред, а који иза њега. Деле се на:
• char - слова или у општем случају, карактери (јер и симболе 1, 2, 3, *, / и друге можемо
третирати као словни податак, а нико за њих неће рећи да су слова);
• integer - цели бројеви (... , -2, -1, 0, 1, 2, ...);
• boolean - логички тип, (вредности true и false);
• набројани тип и
• интервални тип
Прва три уређена типа су стандардни типови података, а последња два немају унапред
задати домен већ се дефинишу у зависности од потребе корисника.
Структурни типови су:
• Set - скуповни тип;
• Array - низовни тип;
• Record - слоговни тип;
• File - датотечни тип;
• Class - класе
Структурни типови могу да се користе као стандардни ако је њихова примена могућа без
посебно дефинисаног имена, али врло често се дефинишу у складу са захтевима програма.
Важно је напоменути да у оквиру појединих од поменутих типова података постоје
подтипови који се међусобом разликују по броју елемената и прецизности, а за све подтипове
истог типа важе исте операције и у неким случајевима дозвољено је њихово мешање, односно, у
неким случајевима променљивама једног подтипа могу се додељивати вредност променљивих
другог подтипа истог типа података.
Целобројни тип (integer)

Integer је прости уређени тип података чије вредности могу бити сви цели бројеви који
се могу представити у меморији рачунара. Добро је уређен, тј. за било који елемент овог типа
зна се који елемент је испред и који елемент је иза њега. У оквиру типа integer постоје бројни
подтипови. Основни су:
Integer -2147483648 .. 2147483647, тј. -231 .. 231-1. Овај подтип има и позитивни и
негативни део бројне праве
Cardinal 0 .. 4294967295, тј. 0 .. 232-1. Овај подтип има само позитивни део бројне праве.
Остали подтипови типа integer приказани су у таблици. Они могу да се поделе у две
групе, прва четири подтипа имају и позитивне и негативне вредности, а последња три имају
само позитивне вредности. Ако се у програму захтева неки од ужих подтипова, а унесе се број
ван дозвољеног опсега програмски преводилац нас упозорава на грешку типа. Најчешће се у
задацима користе променљиве типа Integer јер је то довољна прецизност за већину проблема
са којима се сусрећемо.
подтип распон вредности подтипа меморија
ShortInt -128 .. 127 8 битова
Smallint -32768 .. 32767 16 битова
Longint -2147483648 .. 2147483647 32 бита
Int64 -263 .. 263-1 64 бита
Byte 0 .. 255 8 битова
Word 0 .. 65535 16 битова
LongWord 0 .. 4294967295 32 бита
Аритметичке операције и стандардне функције са овим типом података су:
Pred претходни
Succ следећи
+ сабирање
- одузимање
* множење
Div целобројно дељење
Mod остатак при целобројном дељењу
Abs апсолутна вредност

Sqr квадрат броја
Дељење (/) није затворено у односу на скуп целих бројева, јер се може десити да количник
два цела броја не буде цео број, зато ова операција није дозвољена унутар целобројног типа.
Целе бројеве је дозвољено делити, али резултат дељења не може се доделити целобројној
променљивој, чак ни ако смо сигурни да ће резултат бити цео број. Ради затворености
операција претходни и следећи по дефиницији испред првог елемента је последњи елемент, а
иза последњег је први елемент. Због затворености операција +, - и * у овом скупу као резултати
њихове примене могу се добијати чудни резултати ако се не води рачуна о величини резултата
ових операција, наиме, када резултат пређе преко највеће могуће вредности целог броја враћа
се преко негативног дела потребан број пута. На пример, ако је највећи дозвољени број 127 и
ми на њега додамо 1, програм се неће прекинути и пријавити грешку, већ ће као резултат
исписати -128 што представља најмањи број у овом случају.
Приоритет операција наслеђен је из математике, тј. најпре се извршавају једночлане
операције и све су истог приоритета, а затим двочлане, при чему су множење и дељење вишег
приоритета у односу на сабирање и одузимање.
Када домен и кодомен функције није исти скуп података, такве функције зовемо
претварачким (или конверзионим). Такве су:
Ord - редни број, која за аргумент има променљиву типа карактер, а као вредност
даје редни број тог карактера у ASCII табели, односно, број од 0 до 255 и
Chr - карактер, која за аргумент има број од 0 до 255, а као резултат даје карактер
из ASCII табеле чији је редни број једнак аргументу функције.
Програмски језик са којим радимо, не дозвоља унос и исписивање нумеричких података.
Зато, да би се могли уносити нумерички подаци и исписивати резултати примене различитих
операција над њима, морају постојати функције које нумерички податак претварају у текст и
обрнуто. Овакве функције су, такође, претварачке јер претварају текст у број или обрнуто. Са
целобројним типом постоје три такве функције и то су:
StrToInt(tekst) - функција којом се унети текст претвара у цео број. Једноставна функција,
али има и својих мана. Ако је текст празан или не може да се преведе у цео број
преводилац ће открити грешку и програм ће се прекинути. Да би се ово
избегло потребно је направити рутину која ће обрађивати такве грешке. Мада
то није посебно тешко, овде се тиме нећемо бавити.
StrToIntDef(tekst,broj) - функција којом се текст претвара у цео број с тим да је уведена
аутоматска контрола исправности уноса, тј. ако унети текст не може да се
претвори у цео број (јер садржи неки карактер који није цифра) или је празан
као вредност функције узима се задати број (као предефинисана вредност,
најчешће се узима 0 или 1, али то није обавезно).
IntToStr(broj) - функција којом се нумерички податак претвара у текстуални. У овом случају
не може доћи до грешке приликом претварања јер сваки број може да се
посматра и као неки текст.
Осим функција, за претварање нумеричких података у текстуалне и обрнуто могу се
користити и две стандардне процедуре:
Str(broj, tekst) - процедура којом се нумерички податак из променљиве broj претвара у
текстуални податак у променљивој tekst. Аргумент broj може бити
променљива, неки израз или конкретна вредност, а аргумент tekst мора бити
променљива типа текст. Код ове процедуре не може доћи до грешке (јер сваки
број може да се посматра и као неки текст), а главна разлика у односу на
одговарајућу функцију, је могућност форматирања текста, али о томе ћемо
касније, када нам та предност буде затребала.
Val(tekst, broj, kod_greske) - процедура којом се текстуални податак из променљиве tekst
претвара у нумерички податак у променљивој broj. Ако је текст празан или
нема структуру целог броја преводилац ће регистровати грешку и њен редни
број записати у променљиву kod_greske, али програм се неће прекидати
(наравно добијени резултати, у случају грешке, неће бити коректни). Зато се у
овом случају мора тестирати вредност променљиве kod_greske и у зависности
од те вредности бирати наредне кораке у програму. Ни ово није тешко, али
захтева увођење питања и условних корака о чему ће бити речи мало касније.

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

општем случају променљиве се декларишу на следећи начин:
var ImePromenljive:TipPromenljive;
Декларација променљивих целобројног типа може изгледати овако:
var a,b,c,d:integer; // листа променљивих са заједничким типом
var a:integer; b:integer; c:integer; d:integer; // свака променљива са својим типом
var a:integer; // свака променљива са својим типом, сваака у новом реду
b:integer;
c:integer;
d:integer;
var a:integer; // испред сваке променљиве са својим типом пише се службена реч var
var b:integer;
var c:integer;
var d:integer;
Али никако не може овако:
var a: integer; b: integer; a:integer;
// променљива а декларисана је два пута (променљива се не сме два пута декларисати)
Променљиве могу бити:
• глобалне, тј. могу се користити у читавом програму, свуда могу добијати и мењати вредност
и
• локалне, тј. могу се користити само у функцијама и процедурама у којима су декларисане.
Глобалним променљивама се може доделити иницијална, почетна вредност приликом саме
декларације, тј. не мора се чекати акција корисника којом се променљивој додељује вредност.
var a: integer = 5; // глобалној променљивој а додељена је почетна вредност 5
Групно иницијализовање променљивих није дозвољено, односно, групи променљивих
не може се доделити почетна вредност на следећи начин:
var x,y,z: integer = 1;
Свакој променљивој мора се посебно додељивати почетна вредност (без обзира на то
што је иницијална вредност иста за све променљиве), овако:
var x: integer = 1;
y: integer = 1;
z: integer = 1;
Локалним променљивама није дозвољено додељивати почетне вредности.
Реални тип (rеаl)

Реални тип је прости тип података кога чине сви реални бројеви који се могу представити у
меморији рачунара. Реални бројеви се у меморији рачунара памте у експоненцијалном запису:
mantisaE±eksponent
0.0123456 1.23456e-2
1.23456 1.23456e+0
1234.56 1.23456e+3
Мантиса и експонент се чувају у посебним меморијским локацијама, зато реални тип
података заузима више меморије од целобројног. За чување експонента резервисано је увек
два бајта меморије (без обзира на величину експонента), а за мантису се користи различита
количина меморије у зависности од величине бројева који се памте.
Основни тип real обухвата бројеве у распону од 5.0 x 10-324 .. 1.7 x 10308 са максимално
15-16 значајних децимала. У оквиру реалног типа разликујемо неколико подтипова. У
следећој таблици они су дати са количинама меморије коју захтевају и максималним бројем
значајних децимала:
подтип распон вредности подтипа децимала меморија
-39 38
Real48 2.9 x 10 .. 1.7 x 10 11 - 12 6 бајтова
Single 1.5 x 10-45 .. 3.4 x 1038 7 -8 4 бајта
-324 308
Double 5.0 x 10 .. 1.7 x 10 15 - 16 8 бајтова
-4951 4932
Extended 3.6 x 10 .. 1.1 x 10 19 - 20 10 бајтова
Comp -263.. 263 -1 (-9223372036854775808..9223372036854775807) 19 - 20 8 бајтова
Currency -922337203685477.5808 .. 922337203685477.5807 19 - 20 8 бајтова

• Real48 треба избегавати јер није у складу са архитектуром интелових процесора, па

знатно умањује перформансе рачунара у току извршавања програма.
• Single и Double се најчешће користе, нарочито у једноставнијим програмима у којима
немамо потребу за превеликим или премалим вредностима и прецизношћу.
• Extended подтип даје већу прецизност од осталих подтипова, али са њим долазе и
проблеми са преносивошћу програма на различите рачунарске платформе.
• Comp је најприроднији за интелове процесоре и мада представља 64 - воробитни цео број
припада реалном типу јер се не понаша као уређени (ordinal) тип већ као реални без
децимала. Пошто се вредности овог типа чувају као целобројне нема дела меморије
резервисаног за чување експонента (зато овај тип заузима мање меморије од претходног).
• Currency је реални тип који је због мањих грешака код заокругљивања посебно прилагођен
програмима везаним за финансијско пословање и банкарство. Подаци овог типа се чувају у
фиксном зарезу, тј. нема дела меморије за чување експонента. Подаци овог типа увек
имају четири децимале (Вредности су исте као код претходног типа само подељене са
10.000).
И код реалног типа важи да се ужи подтипови не могу мешати са ширим (променљивој
типа Single не сме се доделити вредност из Extended типа).
Реални бројеви који се могу представити у рачунару чине низ интервала на бројној правој,
тј. није могуће у меморији представити све реалне бројеве са бројне праве. Вредности у таблици
за све подтипове обухватају само позитивни део реалне праве, а подразумева се да је у рангу и
негативни део реалне праве симетричан датом позитивном делу. Изузетак од овог правила је
подтип comp који из у таблици датог интервала бројева узима само целобројне вредности.
Колона у таблици у којој је дат број цифара подразумева задату математичку прецизност
израчунавања са одређеним подтипом при чему се на екрану приказује највише 15 цифара и
експонент, тј. једна цифра испред децималног зареза, 14 децимала и експонент са четири
цифре. Пошто сви ови типови у основи имају реални број могу се међусобно упоређивати и
могу се вредности преносити са ужег на шири (овде је и обрнути пренос вредности дозвољен,
али се при томе мора водити рачуна о рангу, у противном се у превођењу пријављује грешка, тј.
програм неће радити или ће оног тренутка када вредност променљиве изађе изван ранга
програм бити прекинут). Наравно, у формалном исписивању вредности променљивих ових
подтипова неће бити никакве разлике, уколико се ради о вредностима које су у рангу свих
променљивих, односно, ако се ради о вредностима изван ранга, разлика ће се појављивати
само на граничним децималама.
Аритметичких операција и функција са реалним типом има јако пуно, неке су стандардне
и могу се увек користити, а неке су смештене у посебну библиотеку математичких функција
Math и могу се користити само када jе та библиотека укључена у програм (дописана у реду
који почиње са uses у датотеци Unit.pas). Овде ћемо поменути само стандардне функције јер се
најчешће користе. То су:
+ - сабирање
- - одузимање
* - множење
/ - дељење
frac - издваја децимални део броја, резултат је реални број чији је целобројни део 0
int - издваја целобројни део, без заокругљивања, резултат је реални број без децимала
abs - апсолутна вредност броја
sin - синус угла датог у радијанима
cos - косинус угла датог у радијанима
arctan - угао у радијанима чији је тангенс дати број
ln - природни логаритам броја
exp - степен броја е датим бројем
sqr - квадрат броја
sqrt - квадратни корен броја
random - генерише псеудослучајан број између 0 и 1 (не рачунајући граничне).
Код формирања (генерисања) псеудослучајних бројева у паскалу, приметићемо да се на
свим рачунарима у истом програму добијају увек исти бројеви и увек истим редоследом. Да се
то не би дешавало употребићемо паскал процедуру Randomize која мења основу за
формирање случајних бројева. Ова процедура се мора употребити једном у програму пре прве
употребе функције Random.
Претварачке функције са реалним типом су:

round заокругљени целобројни део реалног броја
trunc издваја целобројни део, без заокругљивања, резултат је цео број
Да би се реални бројеви могли уписивати и исписивати у делфију користићемо следеће
претварачке (конверзионе) функције:
FloatToStr - функција која реални број претвара у текст (стринг) да би се он могао исписати
у едиту, лабели или неком другом објекту за приказивање текстова.
StrToFloat - функција која текст написан у едиту претвара у реалан број, при чему сва
ограничења поменута код функције StrToInt важе и овде.
StrToFloatDef - функција која текст написан у едиту претвара у реалан број, при чему све
напомене и сва ограничења поменута код функције StrToIntDef важе и овде.
Стандардне процедуре које имају исту сврху (исте као и већ поменуте код целобројног типа):
Str(broj, tekst) - процедура којом се нумерички податак из променљиве broj претвара у
текстуални податак у променљивој tekst. Аргумент broj може бити
променљива, неки израз или конкретна вредност, а аргумент tekst мора бити
променљива типа текст. Код ове процедуре не може доћи до грешке (јер сваки
број може да се посматра и као неки текст), а главна разлика у односу на
одговарајућу функцију, је могућност форматирања текста, али о томе ћемо
касније, када нам та предност буде затребала.
Val(tekst, broj, kod_greske) - процедура којом се текстуални податак из променљиве tekst
претвара у нумерички податак у променљивој broj. Ако је текст празан или
нема структуру целог броја преводилац ће регистровати грешку и њен редни
број записати у променљиву kod_greske, али програм се неће прекидати
(наравно добијени резултати, у случају грешке, неће бити коректни). Зато се у
овом случају мора тестирати вредност променљиве kod_greske и у зависности
од те вредности бирати наредне кораке у програму. Ни ово није тешко, али
захтева увођење питања и условних корака о чему ће бити речи мало касније.
Код слагања разних операција, такође, као и код целобројног типа, треба водити рачуна о
приоритету операција да би програм радио оно што се од њега очекује. Као једночлане,
операције Frac, Int, Round, Trunc, Abs, Sin, Cos, ArcTan, Ln, Exp, Sqr и Sqrt су највишег приоритета,
затим операције множење и дељење да би, на крају, биле операције сабирање и одузимање
које су најнижег приоритета. Уколико нам приоритет операција не одговара, редослед
извршавања ћемо променити заградама ( ).
У задацима које ћемо решавати променљиве ћемо декларисати основним типом real.
Декларација може изгледати овако:
var a,b,c,d:real; // листа променљивих са заједничким типом
var a:real; b:real; c:real; d:real; // свака променљива са својим типом
var a:real; // свака променљива са својим типом, сваака у новом реду
b:real;
c:real;
d:real;
var a:real; // испред сваке променљиве са својим типом пише се службена реч var
var b:real;
var c:real;
var d:real;
Али никако не може овако:
var a: integer; b: real; a:real;
// променљива а декларисана је са два типа (променљива може бити само једног типа).
Корисно је још знати и да је у програмски језик стандардно уграђена константа пи ()
која се врло често користи у задацима са тригонометријским функцијама, задацима везаним за
круг и делове круга и сличним и треба је користити јер има много тачнију вредност од
приближне 3,14. Ознака pi користи се као реална константа  чија је вредност
3.1415926535897932385
Логички тип (boolean)

Код неких програма које ћемо писати биће нам важније да ли је нешто тачно или не, а
мање важно ће нам бити шта је или колика је вредност променљиве. Када се говори о таквим
односима између података онда се ради о њиховим логичким вредностима. Неке задатке, које

ћемо касније решавати, без логичког типа не бисмо никако могли испрограмирати (било да се
користе логичке променљиве или само логички изрази).
Логички тип је прости уређени тип података који има две вредности, true и false.
И логички тип има четири подтипа, то су:
• Boolean (заузима 1 бит, тј. има две могуће вредности, 0 и 1),
• ByteBool (заузима 8 битова или 1 бајт меморије, тј. има 256 вредности),
• WordBool (заузима 16 битова, 2 бајта или једну реч меморије, тј. има 65536 вредности) и
• LongBool (заузима 32 бита, 4 бајта или две речи меморије, тј. има 4294967296 вредности).
Но, сви они имају исте вредности (false је 0, а true све остале вредности), а направљени су
да би се обезбедио интегритет података у раду са виндоус апликацијама. У виндоус апликацијама
логичке променљиве могу добијати вредности различите од 0 и 1, па су зато неопходни
различити подтипови у складу са целобројним типом, тако су подтипови Boolean и ByteBool
осмобитни, WordBool је шеснаестобитни, а LongBool тридесетдвобитни, но како постоје само
две логичке константе, то се константи false придружује вредност 0, а све остале вредности се
придружују константи true. У задацима које ћемо радити ћемо користити само подтип Boolean.
Стандардне логичке операције и функције са подацима овог типа су:
not - негација, има вредност true ако исказ није тачан
or - дисјункција, има вредност true ако је бар један од исказа тачан
and - конјункција, има вредност true ако су оба исказа тачна
xor - ексклузивна дисјункција, има вредност true ако је само један од исказа тачан
pred - претходни
succ - наредни
Претварачке функције са подацима овог типа су:
odd - непарно, има вредност true ако је аргумент непаран број у противном је false.
ord - редни број, при чему је Ord(false) = 0 и Ord(true) = 1.
BoolToStr - претвара логичку вредност у текст.
StrToBool - претвара текст у логичку вредност.
StrToBoolDef - претвара текст у логичку вредност уз могућност корекције уноса.
Релације са подацима овог типа су:
< мање
<= мање или једнако
<> различито
= једнако
>= веће или једнако
> веће
in релација повезује скуповни тип са логичким, тачна је ако елемент припада скупу.
Приоритет операција је стандардан: једночлане операције Not, Odd, Pred, Succ и Ord су
истог, највишег приоритета, затим је операција And, па операције Or и Xor које су истог најнижег
приоритета. Логичке релације <, <=, <>, =, >=, > и in приоритет добијају одговарајућим
ограничавањем заградама. Важно је напоменути да операције Not, And, Or и Xor раде само са
простим уређеним типовима података (Char, Integer и Boolean), набројаним и интервалним типом.
Можда би било корисно запамтити следеће релације:
• false < true
• Succ(false) = true, Pred(false) = true
• Pred(true) = false, Succ(true) = false
У задацима које ћемо решавати променљиве ћемо декларисати основним типом boolean.
Декларација може изгледати овако:
var a,b,c,d:boolean; // листа променљивих са заједничким типом
var a:boolean; b:boolean; c:boolean; d:boolean; // свака променљива са својим типом
var a:boolean; // свака променљива са својим типом, сваака у новом реду
b:boolean;
c:boolean;
d:boolean;
var a:boolean; // испред сваке променљиве са својим типом пише се службена реч var
var b:boolean;
var c:boolean;
var d:boolean;

Знаковни тип (char)

Карактер тип (char) је прости уређени тип података чије вредности могу бити сви знаци
из ASCII табеле (односно сви елементи азбуке програмског језика). За било који елемент овог
типа зна се који елемент је испред, а који иза њега. Редослед елемената одређује њихов код
или редни број из ASCII табеле. Ради затворености операција претходни и следећи, по
дефиницији, испред првог елемента је последњи елемент, а иза последњег је први елемент.
Овај тип има 256 елемената.
Стандардне операвије и функције са подацима типа карактер су:
Pred - претходни, одређује елемент који претходи елементу који је аргумент функције,
Succ - наредни, одређује елемент који следи иза елемента који је аргумент функције
UpCase - велико слово, као резултат даје велико слово ако је аргумент функције мало
слово.
Претварачке функције су оне код којих су област дефинисаности и скуп вредности
функције различитог типа. Претварачке функције са подацима овог типа су:
Ord - редни број, која за аргумент има променљиву типа карактер, а као вредност
даје редни број знака у ASCII табели, односно, број од 0 до 255 и
Chr - карактер, која за аргумент има број од 0 до 255, а као резултат даје знак из
ASCII табеле чији је редни број једнак аргументу функције.
У задацима које ћемо решавати декларација променљивих може изгледати овако:
var a,b,c,d:char; // листа променљивих са заједничким типом
var a:char; b:char; c:char; d:char; // свака променљива са својим типом
var a:char; // свака променљива са својим типом, сваака у новом реду
b:char;
c:char;
d:char;
var a:char; // испред сваке променљиве са својим типом пише се службена реч var
var b:char;
var c:char;
var d:char;
Стринг тип
У раду са знаковним, карактер подацима чешће се срећемо са подацима који се састоје из
више од једног знака. Такви подаци могу се обрађивати знак по знак, али би то додатно
оптерећивало програм. Уместо једне променљиве радили бисмо са низом променљивих што
оптерећује и компликује писање програма. Зато је уведен тип String (енгл. string - ниска, низ
карактера, реч). Максималан број карактера који може бити вредност променљиве типа
String у паскалу је 255.
У делфију постоји још неколико подтипова овог типа:
ShortString који се поклапа са паскалским типом String (максимална дужина 255),
AnsiString има максималну дужину 231 карактера,
WideString има максималну дужину 230 карактера и има подршку за националне симболе
(Unicode).
Подтипови типа стринг могу да се мешају и размењују вредности, али се мора водити
рачуна о њиховим специфичностима приликом позива функција и процедура. Подаци овог
типа се памте као низови карактера с тим што је, будући да је ово стандардни тип података,
програмском преводиоцу остављено да води рачуна о дужини.
Код декларације променљивих овог типа могуће је унапред дефинисати максималну
дужину низа или задржати уграђену дужину (правила за декларацију променљивих су иста
као и код претходних типова података само се овде појављују у две варијанте):
VAR a:STRING;
{декларисали смо променљиву типа String која може имати највише 255 карактера
дужине, тј. може имати мање, али не може имати више од 255 карактера, рачунајући
и размаке и специјалне знакове}
VAR b:STRING[11];
{декларисали смо променљиву типа String која може имати највише 11 карактера
дужине, тј. може имати мање, али не може имати више од 11 карактера, рачунајући
и размаке и специјалне знакове}
Променљивама типа String може се додељивати вредност која не одговара њиховој
декларацији, тј. променљивој а може се доделити вредност која има више од 255 карактера

дужине, а променљивој b вредност која има више од 11 карактера и програмски преводилац

неће пријављивати грешку, али ће се у меморији сачувати само вредност декларисане дужине,
остали карактери неће се памтити и са њима програм неће радити. Зато у раду са овим типом
треба пажљиво осмислити декларацију променљивих како не бисмо добијали чудне, односно,
неочекиване резултате.
Стандардне функције/операције са подацима овог типа су:
+ - слепљивање, надовезивање стрингова, вредност функције се мора доделити
некој стринг променљивој, на пример: а:=b+c+d; а:=а+b+c+d;
copy(a,n,m) - функција за копирање дела стринга, из стринга а се од позиције n копира m
карактера, вредност функције се мора доделити некој стринг променљивој;
применом ове функције стринг а остаје непромењен
length(a) - функција за одређивање дужине, броја карактера у стрингу а може имати
вредности од 0 до 255
pos(b,a) - функција за одређивање позиције стринга b у стрингу а, вредност функције је
цео број 0 ако се b не налази у стрингу а или цео број 1-255 ако b почиње од
карактера са тим редним бројем у стрингу а (функција је осетљива на мала и
велика слова, па треба о томе водити рачуна код писања програма)
LowerCase - функција којом се сва велика слова енглеске абецеде у речи која је аргумент
функције замењују малим словима (функција не реагује на слова других
националних абецеда)
UpperCase - функција којом се сва мала слова енглеске абецеде у речи која је аргумент
функције замењују великим словима (функција не реагује на слова других
националних абецеда)
Стандардне процедуре за рад са подацима типа стринг су:
concat(a,b,...) - процедура којом се надовезују стрингови (слично као +), први аргумент
процедуре мора бити променљива на коју се надовезују вредности осталих
аргумената који могу бити функције и променљиве (на пример: Concat(a,b,c)
исто је што и а:=а+b+c)
delete(a,n,m) - процедура за брисање дела стринга, из стринга а се од позиције n брише m
карактера, тј. стринг а се мења.
insert(b,a,n) - процедура за уметање стринга у стринг, стринг b се умеће у а од позиције n.
val(tekst, broj, kod_greske) - процедура за претварање стринга у број (процедура је иста као
код типа Integer и Real где је и детаљно објашњена)
str(broj, tekst) - процедура за претварање броја у стринг (процедура је иста као код типа
Integer и Real где је и детаљно објашњена)
Код рада са стринговима задате дужине морамо водити рачуна да њиховим слепљивањем
не изгубимо део њиховог значења јер ако се добије стринг дужине веће од декларисане узима
се само почетни део стринга до декларисане дужине.
Набројиви тип и интервални тип

Када решавамо неке типове задатака, може се десити да нам стандардни типови нису
довољни. У таквом случају можемо сами дефинисати нови тип података тако што ћемо му
дати име и навести све елементе који му припадају. Такав тип зове се набројиви (јер су сви
елементи који му припадају набројани у дефиницији). Спада у уређене типове, а редослед
података дефинисан је редоследом навођења елемената у дефиницији типа.
Примери:
Type DaniUNedelji=(pon, uto, sre, cet, pet, sub, ned);
Type Godina=(jan, feb, mart,apr, maj, jun, jul, avg, sept, okt, nov, dec);
Type Boje=(pik, karo, herc, tref);
Када смо дефинисали неки тип, у даљем раду, понашамо се као да је тај тип одувек
постојао, тј. можемо помоћу њега декларисати променљиве. Променљиве се могу декларисати
и директним навођењем елемената набројивог типа, без претходне дефиниције типа:
Var dan:DaniUNedelji;
Var mesec:Godina;
Var znak:Boje;
Var boja:(crvena,zuta,zelena,plava);

Са набројивим типом радимо као и са другим, стандардним типовима података. Да бисмо

исписали вредност променљиве овог типа у делфи апликацији морамо дефинисати функцију
која ће овај тип конвертовати у тип стринг.
Са подацима овог типа дозвољене су само следеће три функције:
Ord - редни број елемента у дефинисаном типу,
Pred - претходни, одређује елемент који претходи елементу који је аргумент функције,
Succ - наредни, одређује елемент који следи иза елемента који је аргумент функције.
Друге операције, које би нам могле затребати, морамо претходно сами да дефинишемо.
Када желимо да постигнемо неке специјалне ефекте приликом решавања појединих
задатака можемо елементе стандардно дефинисаних уређених типова издвојити у посебан
тип. Ако су елементи узастопни онда ће такав тип бити интервални. Пошто настаје од
уређених типова овај тип је, такође, уређен. Редослед података наслеђује се од основног типа,
а такође и дозвољене операције и све друге особине. Предност увођења овог типа је незнатна
уштеда меморије за чување података и лепша структура програма.
Погледајмо примере:
Type Jednocifreni=0..9;
Type Minut=0..59; Cas=0..23;
Type Godina=1..365;
Када смо дефинисали неки тип, у даљем раду, понашамо се као да је тај тип одувек
постојао, тј. можемо помоћу њега декларисати променљиве. Променљиве се могу декларисати
и директним навођењем елемената интервалног типа, без претходне дефиниције типа:
Var cifra:Jednocifreni;
Var m:Minut;c:Cas;
Var dan:Godina;
Var LotoBroj:1..39;
Скуповни тип
У задацима са издвајањем појединих слова користићемо појам скуп или колекција - сет
(set). И други задаци могу се елегантније решавати коришћењем овог типа. Скуповни тип је
посебна врста података. То је скуп свих подскупова скупа вредности основног типа. Основни
тип скупа може бити било који прости уређени тип података boolean, char, integer или
набројани тип. Максималан број елемената у скупу је 255 (то значи не могу ни сви цели
бројеви бити елементи скупа). У раду са скуповним подацима важе правила алгебре скупова.
Елементи скупа се не могу понављати.
Скуповни тип се дефинише у делу за декларације и дефиниције на следећи начин:
TYPE slova = SET OF 'a'..'z';
cifre = SET OF 0..9;
mesec = (jan,feb,mart,apr,maj,jun,jul,aug,sept,okt,nov,dec);
godina = SET OF mesec;
Променљива скуповног типа се декларише помоћу претходно дефинисаног скуповног типа
или директно:
VAR a:slova;
cifra:cifre;
znak:SET OF (pik,karo,herc,tref);
ceobroj:SET OF 0..255;
Основне операције са подацима скуповног типа су:
+ унија,
* пресек и
- разлика.
Основне релације над подацима скуповног типа су:
= једнако ,
<> неједнако ,
< или <= подскуп,
> или >= надскуп и
in елемент скупа.
Празан скуп дефинише се командом:
с:=[];
Додавање елемента е неком скупу с остварује се командом:
с:=с+[е];

Ако су два скупа декларисана истим типом то никако не значи да су им елементи

аутоматски придружени и да су скупови једнаки. Елементи се морају придружити скуповима у
програму и тек онда можемо говорити о једнакости та два скупа. Додељивање елемената
скупу може се извршити вишеструком употребом команде за додавање елемената скупу или
њиховим директним навођењем:
с:=[’А’,’Е’,’И’,’О’,’У’];
Наравно, два скупа су једнака ако се састоје из истих елемената, односно, сви елементи
једног скупа су сви елементи другог скупа (ознака a=b), у противном, тј. ако постоји бар један
елемент било ког од та два скупа који није елемент другог скупа, та два скупа су неједнака
(ознака a<>b). Неки скуп је подскуп другог (ознака a<b или a<=b) ако је сваки његов елемент
уједно и елемент другог скупа. У том случају кажемо да је други скуп надскуп првог скупа
(ознака a>b или a>=b). Неки скуп је прави подскуп (ознака a<b) другог ако су сви елементи
првог скупа елементи другог и осим њих, други скуп има бар још један елемент. Неки скуп је
прави надскуп другог (ознака a>b) ако постоји бар један елемент првог скупа који није елемент
другог и сви елементи другог скупа су истовремено и елементи првог скупа.
Класа и методе класе – основни појмови
Објектни језици полазе од податка као доминантног концепта и уз податак везују

операције – то представља објекат. Објекат може бити, на пример, број 5 са свим операцијама које
се могу применити на њега, на пример Додај(параметар), Одузми(параметар),
Помножи(параметар), Подели(параметар), али објекат може бити и нека сложена структура –
на пример ОСОБА, па и цео програмски систем са скупом свих операција које се на њега могу
применити. Класа представља апстрактну слику скупа неких објеката који имају исте особине.
То је структурирани кориснички дефинисани тип података који обухвата податке (атрибуте)
који описују стање објеката класе и функције којима се дефинишу операције над подацима
класе. Објекат класе је један примерак класе, а функције које су део класе називају се методе.
Класа се дефинише навођењем података и функција које јој припадају. Класа је скуп објеката са
истим својствима (тзв. инстанцним променљивим које се могу се замислити као поља неке
сложене структуре), и понашањем, односно, операцијама. На пример, Integer може бити једна
класа. Сваки објекат је примерак неке класе. Објекти између себе комуницирају порукама којима
се од објекта који их прима захтева да изврши неку од операција дефинисаних у класи којој
припада. Поруке су догађаји на које објекти могу да реагују. Објекат на примљену поруку
одговара извршавањем методе, односно, операције за коју само објекти из те класе знају како се
извршава (само је њима позната имплементација методе).
Подаци могу бити дефинисани (иницијализација) или само декларисани и не могу бити
типа класе која се помоћу њих дефинише (јер би то била циркуларна дефиниција), али могу
бити било којег другог типа, па и нека друга, претходно, дефинисана класа. Исто важи и за
функције, тј. могу бити само декларисане (наводи се само заглавље) или дефинисане (имају и
заглавље и тело са наредбама). Ако су само декларисане, онда мора постојати и њихова
дефиниција која се налази негде изван дефиниције класе. Аргументи и резултат функције
могу бити било којег типа, па и тип класе која се дефинише. Класа мора бити дефинисана тамо
где се и користи, тј. мора бити саставни део кода програма у коме се користи. Пример класе коју
користимо сваки пут када пишемо било коју апликацију:
type
Memo1: TMemo;
Button1: TButton;
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
Као што видимо, иза резервисане речи class следе објекти, елементи који припадају
класи, а ту могу бити наведене и методе (под методама овде подразумевамо и функције и
процедуре) које припадају класи. У деловима означеним са private (приватне, односно,
невидљиве) и public (јавне, односно, видљиве) наводимо декларације функција које припадају
класи.

У овом тренутку неће нам бити значајна карактеристика видљивост методе, па када будемо
писали апликације нећемо размишљати о томе где ћемо писати декларацију методе коју
додељујемо класи. Општи метод ће бити да функције и процедуре које представљају реакцију на
неки догађај декларишемо у делу изнад резервисане речи private (зато што их делфи аутоматски
исписује на том месту), а оне које дефинишемо независно од неког догађаја писаћемо изнад
резервисане речи public (односно, биће приватне, не зато што тако мора него само да бисмо
направили визуелну разлику између ове две врсте функција и процедура).
Резервисана реч end; обавезна је на крају дефиниције класе и иза ње можемо писати
друге декларације и дефиниције које су нам потребне у програму.
У објектном моделу примењује се скривање информација, тј. објекту се може
приступити само преко порука тј. метода које су дефинисане за класу којој објекат припада.
Сама структура објекта, односно, његова својства (инстанцне променљиве) нису видљиве
другим објектима. Објектни модел карактерише учаурење података и операција у објекат
што омогућује једноставну измену структуре објекта и класе и имплементације операција без
ефекта на апликације које тај објекат користе (све док су дефиниције операција непромењене, тј.
са истим називима и параметрима). Нова класа може се дефинисати као подкласа већ
дефинисане класе (своје надкласе). Подкласа наслеђује операције и својства од своје надкласе,
али може имати и своје сопствене.
На пример, за дефинисану класу ОСОБА може се дефинисати подкласа СТУДЕНТ, која има
сва својства класе ОСОБА, али и нека своја специфична. Програми које ћемо писати у оквиру
овог курса неће захтевати увођење нових класа.
• Подела типова података

• Целобројни тип и операције са целим бројевима
• Подтипови целобројног типа
• Реални тип и операције са реалним бројевима
• Подтипови реалног типа
• Карактер тип и операције са подацима тог типа
• Подтипови типа карактер
• Логички тип, операције и релације
• Подтипови логичког типа
• Набројани тип
• Интервални тип
• Скуповни тип
• Декларација променљивих
• Конверзија типова података
• Дефинисање новог типа података
• Шта је класа
• Комуникација између објеката
• Public декларације
• Private декларације
• Однос између класе и подкласе

Наредбе и изрази
Синтакса и семантика израза.

Свака група карактера чини некакав израз, а да би тај израз имао смисла и значење морају
се поштовати нека правила. Правила на основу којих се граде изрази у неком програмском
језику дефинисана су синтаксом. Правила којима се одређује значење синтаксно исправног
израза дефинисани су семантиком. Код писања програма синтаксна правила морају бити
задовољена да бисмо могли тестирати и користити програм. Ова правила су једноставна и
лако је проверити да ли смо их испоштовали или не. Најједноставнија правила за формирање
израза у програмирању заснована су на устаљеним правилима у математици која су прилагођена
одговарајућем програмском језику. Нека од основних правила су:
• Свака отворена заграда мора бити затворена.
• Два знака операције (или више њих) не могу се наћи непосредно један поред другога.
• Израз не може стајати самостално у програму.
• Вредност израза израчунава се аутоматски приликом доделе вредности параметрима.
Аритметички и логички изрази

Изрази који се могу наћи у оквиру програма могу бити аритметички или логички.
Аритметички изрази своју вредност имају у оквиру неког од нумеричких типова података, а
логички имају истиносну вредност тачно или нетачно. Основна правила за креирање
аритметичких и логичких израза су истоветна и морају се поштовати.
a+*b није синтаксно исправан израз јер су + и * један за другим
a+b=c је синтаксно исправан логички израз који је тачан ако су променљиве a, b и c
истог типа и збир прве две вредности је идентичан трећој
a+b:=c није синтаксно исправан израз јер се изразу не може додељивати вредност
2*(a+b)-c је аритметички израз који је синтаксно исправан
a(b+c) није синтаксно исправан израз јер испред отворене заграде, а иза променљиве
a мора стајати ознака неке операције, нема подразумеваних операција у
програмирању
Наредбе програмског језика
Према нивоу сложености, наредбе можемо поделити на просте и структурисане.

Просте наредбе су:
• празна наредба
• наредба додељивања
• процедуралне наредбе (наредбе улаза и излаза)
• GOTO наредба
Структурисане наредбе су:
• наредба састављања
• наредбе гранања (If наредба, Case наредба)
• наредбе циклуса (For, Repeat, While)
Празна наредба је наредба која нема ефекта на извршавање програма. Користи се само у
случајевима када нека структурисана наредба захтева извршење неке програмске наредбе,
али алгоритамски нема потребе за било каквом извршном наредбом.
У програмима ћемо најчешће користити наредбу додељивања. Структура ове наредбе је:

promeljiva := vrednost;
Ознака := је знак доделе и не може се изоставити. На левој страни је име променљиве
којој се додељује вредност, а на десној страни је конкретна вредност, израз или функција чија
се вредност додељује променљивој. Променљива са леве стране знака додељивања и вредност
са десне стране морају се слагати по своме типу, у противном, преводилац пријављује грешку и
програм се не може покренути.
Наредбе улаза и излаза (Read, Write) се користе у паскалу за унос података и издавање
резултата. У делфију се користе само специјални облици ових наредби за рад са
секвенцијалним датотекама и то врло ретко јер се и датотеке овог типа користе врло ретко у
модерним програмима, а за унос података и приказивање резултата користе се одговарајуће
текст компоненте.
Наредба GOTO постоји у готово свим програмским језицима, па и овде, али се не користи
јер није у складу са правилима структурног програмирања. Представља безусловни прелазак
(скок) на неку наредбу програма не водећи рачуна о структури која се тренутно извршава.
Добар програмер никада нема потребу за овом наредбом јер се алгоритмом може предвидети
структура програма која нема потребу за прескакањем дела алгоритамских корака без неког
посебног разлога.
Структурисане наредбе су сложене наредбе. У своју синтаксну дефиницију уграђују и
неке друге просте или структурисане наредбе које се извршавају.
Најпростија структурисана наредба је наредба састављања. Ова наредба почиње
службеном речи Begin, а завршава службеном речи End. У оквиру наредбе састављања може се
појавити било која наредба, па и друга наредба састављања. У ширем смислу, читав програм
можемо сматрати једном наредбом састављања. Општи облик ове наредбе је:
begin <naredbe>
end;
Програмски преводилац аутоматски сваком елементу Begin придружује одговарајући
елемент End, у фази превођења, и у случају грешке, односно, ако неки од елемената недостаје
или се појављује вишак неког од елемената даје одговарајућу поруку.
Остале структурисане наредбе су нешто компликованије, па ћемо им посветити посебна
поглавља.
Конверзија типова података.

Конверзија типова података подразумева да се подаци једног типа преводе у податке
другог типа. Најчешће се конверзија врши између стрингова и бројева. Оправдање за ово је
принцип рада визуелних програмских језика. Наиме, у делфи програм се, као улазне величине,
не могу унети нумерички подаци, већ се уносе низови карактера који се, да би се користили за
израчунавање, претварају у одговарајуће нумеричке податке. Отуда потреба да постоје
функције и процедуре које ће неки текст покушати да преведу у цео или реалан број. Исто тако,
нумерички резултати рада делфи програма се не могу приказати, већ се морају претворити у
стринг, низ карактера који личи на нумерички податак, а затим се тај стринг приказује као
резултат рада програма. Отуда потреба да постоје функције и процедуре које ће нумеричке
податке превести у текстуалне податке.
Понекад и неки други разлози стварају потребу за конверзијом једног типа података у
други. Рецимо, ако треба над неким податком извршити неку операцију која није дозвољена у
оквиру типа података коме припада, онда је потребно тај податак конвертовати у податак
другог типа са којим је та операција дозвољена. Функције за конверзију имају једноставну
синтаксу. Аргумент функције је податак типа који се конвертује, а вредност функције је
податак типа у који се конвертује. Највећи број конверзионих функције има име које подсећа
на врсту конверзије, односно, састоји се из:
• Симбола који представља тип података који се конвертује (Str, Int, Float, Bool, ...),
• Енглеске речи ТО која означава смер конверзије и
• Симбола који представља тип података у који се конвертује (Str, Int, Float, Bool, ...).
Већ смо се упознали са неким конверзионим функцијама, па ћемо их сада само исписати
ради подсећања, а без поновног објашњавања значења: StrToInt, StrToFloat, StrToBool, IntToStr,
FloatToStr, BoolToStr, ...

Уношење и приказивање података.

Да би се програм извршио морају се унети почетне вредности. Пошто се подаци уносе као
низови карактера, за унос било ког податка морамо на форму програма поставити текст
компоненте у које ће се они уписивати. Најчешће се за унос података користи компонента
едит (Edit - оквир за текст), али је могуће користити и неке друге компоненте. Компонента
едит може прихватити произвољно дуг низ карактера, али са ограничењем да се уписије само
у једном реду. Да би програм приказао резултате рада, на форму се морају поставити
компоненте које приказују низ карактера. Најчешће се за приказивање резултата користе
компоненте лабела (Label - налепница) и едит (Edit - оквир за текст), али је могуће користити
и неке друге компоненте у зависности од врсте и количине података који се исписују. Могуће
је унос и исписивање података остварити и помоћу неких компоненти које се стандардно не
користе за то (на пример: дугмад (Button), панели (Panel) и слично), али у таквом случају се
морају писати посебне рутине којима ће се омогућити приказивање података на таквим
компонентама. Ово није увек једноставно, али је, у неким ситуацијама, или неопходно или даје
посебан изглед програму. Ако то није случај, онда нема оправдања за такав начин уноса и
приказивања података.
Ако је алгоритамски захтев такав да се захтева унос једног од неколико унапред
познатих података, за унос се могу користити компоненте избора (RadioButton, CheckBox,
ComboBox, ListBox, ...). Коју ћемо од компоненти избора употребити зависи од тога колико
дозвољених вредности има и да ли је дозвољено изабрати само једну или можемо унети више
вредности по неком захтеву. Компоненте избора смањују могућност погрешног уноса
вредности јер кориснику није дозвољено да уписује податак и погреши, већ може да бира
један или више од понуђених података.
Алгоритам размене вредности две променљиве.

Врло често, нађемо се у ситуацији таквој да имамо две променљиве које треба међусобно
да размене своје вредности. У неким програмским језицима, за то постоји посебна функција
(Swap). У делфију (и у свим другим, паскалоликим програмским језицима) таква функција не
постоји, већ се проблем решава алгоритмом размене вредности уз коришћење помоћне
променљиве. Помоћна променљива има задатак да на почетку привремено сачува вредност
једне променљиве како би она могла да преузме вредност друге, а на крају се другој
променљивој додељује вредност помоћне.
Овај стандардни алгоритам, покушаћемо да објаснимо следећом таблицом:
програм a b pom шта се стварно дешава

5 7 -
pom:=a; 5 7 5 помоћној променљивој додељује се вредност прве
a:=b; 7 7 5 првој променљивој додељује се вредност друге
b:=pom; 7 5 5 другој променљивој додељује се вредност прве која је сачувана у помоћној
Програмирање израчунавања по једноставним математичким формулама.

Свака математичка формула може се написати у облику неког израза у духу програмског
језика. Програм којим се израчунава вредност израза састоји се из три корака:
• Унос почетних вредности параметара који учествују у формули
• Израчунавање вредности по формули
• Исписивање добијених вредности
Приказаћемо овај поступак на конкретном примеру одређивања обима и површине
правоугаоника са страницом a и дијагоналом d.
Најпре ћемо написати формуле за обим и површину:
O=2(a+b) у програму ћемо написати овако: o:=2*(a+b);
P=ab у програму ћемо написати овако: p:=a*b;
Пошто у овим обрасцима учествују обе странице правоугаоника, а у условима задатака је
дата једна страница и дијагонала, извешћемо другу страницу на основу познатих параметара:
b= d 2  a 2 у програму ћемо написати овако: b:=Sqrt(d*d-a*a);
Даље можемо да се понашамо на два начина:

1. као математичари:
добијену формулу за другу страницу уврстићемо у обрасце за површину и обим правоугаоника
и добити формуле за израчунавање обима и површине помоћу странице и дијагонале:
O=2(a+ d 2  a 2 ) у програму ћемо написати овако: o:=2*(a+Sqrt(d*d-a*a));
P=a d 2  a 2 у програму ћемо написати овако: p:=a*Sqrt(d*d-a*a);
2. као програмери:
добијену формулу написаћемо испред формула за израчунавање површине и обима:
b:=Sqrt(d*d-a*a);
o:=2*(a+b);
p:=a*b;
Уносом улазних параметара a, d добићемо и по једном и по другом методу исте резултате
за O, P које ћемо затим исписати. У првом случају имамо једну променљиву мање, па је утрошак
меморије ефикаснији, у другом случају формуле су једноставније за разумевање и за унос. У
другом случају имамо једну мање операцију кореновања, па је процес добијања резултата
бржи (мада се ради о делићима милисекунде јер је проблем прилично једноставан, много је
већа уштеда у времену за извођење и исписивање формула).
• Синтакса израза
• Семантика израза
• Правила за формирање израза
• Врсте израза по типу података
• Подела наредби
• Просте наредбе
• Празна наредба
• Наредба додељивања
• Процедуралне наредбе
• Структурисане наредбе
• Наредба састављања
• Конверзија типова података
• Компоненте за унос података
• Компоненте за приказивање података
• Алгоритам замене вредности две променљиве
• Исписивање математичких формула у програмима
Уводни задаци
Први задаци су примери реаговања објеката у делфију на спољашне догађаје. Основна функција им је да
читаоци ових редова схвате да се у програмирању можемо понашати слободно и опуштено, односно, да
програмирање може бити и забава, али да и за тако нешто морамо имати некакво знање о програмском
језику. Урађени су на најједноставнији начин јер у овом тренутку немамо довољно програмерског
искуства да лепршамо непрегледним пространствима и поигравајући се заводљиво освајамо свет.
• Саставити програм који са тастатуре прихвата име и исписује га уз поздрав.
Отварањем делфи окружења отворили смо празан пројекат. Активни прозор требало би да буде форма.
У случају да је, из неког разлога, активни прозор делфи програм едитор на форму се прелази кликом
мишем на било који део форме или, једноставније, притиском на функцијски тастер Ф12 на тастатури.
Прилагодићемо форму према својој замисли, на пример овако:
BorderIcons = [biSystemMenu], BorderStyle = bsSingle, Caption = МОЈ ПРВИ ПРОГРАМ, ClientHeight = 360,
ClientWidth = 380, Color = clMoneyGreen
Кад год је могуће, у подешавањима ћемо користити ћирилично писмо. Искошеним словима су исписане
карактеристике које ћемо подешавати на листићу Properties прозора ObjectInspector. У зависности од
карактеристике која се подешава, вредност ћемо уписивати, изабрати мишем из падајућег менија који
се отвара кликом на поље вредности карактеристике или на тастер у облику стрелице на доле или
подесити у прозору за дијалог који се отвори кликом мишем на одговарајући тастер у облику три тачке.
На форму ћемо поставити три лабеле, едит и три тастера и

распоредити их на следећи начин:
Лабела за наслов:
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Мој
први програм; Font.Name = Palatino Linotype; Font.Size = 22;
Font.Style = [fsBold, fsItalic]; Layout = tlCenter; Height = 80.
Лабела за комуникацију са корисником:
Caption =Упишите своје име; Font.Name = Palatino Linotype;
Font.Size = 16; Font.Style = [fsBold, fsItalic]; Height = 28; Left = 20;
Top = 100; Width = 190.
Лабела за испис резултата:
Align = alBottom; Alignment = taCenter; AutoSize = False; Caption = ;
Font.Name = Palatino Linotype; Font.Size = 22; Font.Style = [fsBold,
fsItalic]; Layout = tlCenter; Height = 28.
Едит за унос података:
Font.Name = Palatino Linotype; Font.Size = 14; Font.Style = [fsBold];
Left = 20; TabOrder = 0; Text = ; Top = 130; Width = 200
Тастер за потврду уноса:
Caption =Унеси; Font.Name = Palatino Linotype; Font.Size = 16; Font.Style = [fsBold]; Height = 40; Left = 240;
Top = 127; Width = 120
Тастер за поништавање уноса:
Caption =Поништи; Font.Name = Palatino Linotype; Font.Size = 16; Font.Style = [fsBold]; Height = 40; Left =
240; Top = 177; Width = 120
Тастер за крај рада:
Caption =Крај; Font.Name = Palatino Linotype; Font.Size = 16; Font.Style = [fsBold]; Height = 40; Left = 240;
Top = 227; Width = 120
Када смо подесили форму, сачуваћемо урађено на следећи начин:
Из менија File изабраћемо команду Save As. Отворићемо фолдер Libraries, па затим фолдер Documents
и у њему направити нови фолдер са именом Pozdrav, а затим сачувати јунит кликом на тастер Save.
Из менија File изабраћемо команду Save Project As и сачувати пројекат кликом на тастер Save.
Код сложенијих форми, у каснијим задацима овај поступак треба спровести много раније, чим урадимо
нешто што не бисмо хтели да радимо поново ако се из неког разлога програм изненада прекине. Затим,
када год урадимо још нешто сачуваћемо урађено избором команде Save All из менија File или кликом на
истоимени екрански тастер. Ова чувања не шкоде нашем програму, а посебно пријатно делују на нашу
психу, нарочито ако је рачунар на коме радимо нестабилан или радимо у ризичној околини када је
могуће да изгубимо урађено и на тај начин себи непотребно отежамо решавање проблема.
Сада је већ могуће тестирати програм. Можемо уписати податак у едит и кликнути на неки од тастера,
али, будући да нисмо написали никакав програмски код, ништа се неће десити. Зато ћемо, пре тестирања
програма дефинисати реакције на клик мишем на неки од тастера. Ове реакције се дефинишу двокликом
мишем на одговарајући тастер или, можемо у прозору ObjectInspector кликнути на листић Events и
изабрати догађај на који желимо да тастер реагује двокликом у поље вредности десно од назива
догађаја (у овом случају то је догађај OnClick).
Двоклик на тастер за потврду уноса:
procedure TForm1.Button1Click(Sender: TObject);
begin Label3.Caption:=Edit1.Text+' је ту.'; // исписује поруку у лабели за испис резултата
end;
Двоклик на тастер за поништавање уноса:
begin Edit1.Clear; // празни едит за унос података
Label3.Caption:=''; // брише исписану поруку у лабели за испис резултата
Edit1.SetFocus; // поставља курсор у едит за унос података
end;
Двоклик на тастер за крај рада:
begin Application.Terminate; // прекида извршавање програма
end;
Сада ћемо сачувати урађено и тестирати програм избором команде Run из менија Run, кликом мишем
на екрански тастер у облику зеленог троуглића (плеј дугме) или притиском функцијског тастера Ф9 на
тастатури.
У наредним задацимо нећемо поступке описивати овако детаљно, осим ако се ради о некој посебној
радњи коју до тада нисмо користили и коју треба посебно и додатно објаснити. Ради краћег записа
карактеристика подешавања фонта ћемо записивати као једну сложену карактеристику, тј.
уместо:
Font.Name = Palatino Linotype; Font.Size = 16; Font.Style = [fsBold]
писаћемо:
Font = Palatino Linotype, 16, Bold
Ако се неке од карактеристика фонта преносе са другог објекта на коме су већ подешене, онда их нећемо
понављати као ни подразумеване вредности неких карактеристика.

• Саставити програм који приказује два тастера на форми који нестају и појављују се
наизменично, на клик мишем на неки од тастера.
Идеја је да се на форми прикаже један тастер на који треба кликнути мишем. У том тренутку овај тастер
нестаје и појављује се други тастер на некој другој позицији на форми на који сада треба кликнути. Сада
тај тастер нестаје, а појављује се поново први и тако у круг све док се не кликне на тастер за крај. Да би
се тастери појављивали и нестајали, користићемо њихову карактеристику Visible. Ова карактеристика
може имати две вредности: True - тастер је видљив и False - тастер је невидљив. Примена подешене
карактеристике не види се у фази дизајнирања, већ само у фази извршења програма.
Подесићемо карактеристике форме на следећи начин:
BorderIcons = [biSystemMenu]; BorderStyle = bsSingle; Caption = ИГРА
СА ДВА ТАСТЕРА; ClientHeight = 360; ClientWidth = 380; Color = clMoney
Green; Font =PalatinoLynotype, Bold, 18; Position = poScreenCenter.
На форму ћемо поставити три тастера и, затим, подесити њихове
карактеристике на следећи начин:
Caption = Кликни ме; Height = 40; Left = 50; Top = 50; Visible = False;
Width = 150;
Caption = Кликни ме; Height = 40; Left = 190; Top = 270; Visible = Truе;
Width = 150.
Caption = Х; Font = Courier New, 22; Height = 40; Left = 340; Top = 0;
Width = 40.
Сачуваћемо дизајнирану форму у креирани фолдер DvaTastera, а
затим дефинисати реакције на клик сваког од тастера.
Двоклик на први тастер:
begin Button1.Visible:=false;
Button2.Visible:=true;
end;
Двоклик на други тастер:
begin Button1.Visible:=true;
Button2.Visible:=false;
end;
Двоклик на трећи тастер:
begin Application.Terminate;
end;
• Саставити програм који приказује тастера на форми који не дозвољава да се на њега

кликне мишем.
Идеја је да се на форми прикаже један тастер на који треба кликнути мишем, али када се миш постави
на њега он се помери на неку другу позицију пре него се кликне на било који тастер на мишу. Овакав
ефекат ћемо остварити користећи реакцију тастера на догађај OnMouseMove. Такође, треба дефинисати
и тастер за излазак из програма као у претходном задатку.
BorderIcons = [biSystemMenu]; BorderStyle = bsSingle; Caption =
ИГРА СА ЈЕДНИМ ТАСТЕРОМ; ClientHeight = 360; ClientWidth =
380; Color = clMoneyGreen; Font = PalatinoLynotype, Bold, 18;
Position = poScreenCenter.
На форму ћемо поставити два тастера и, затим, подесити њихове
карактеристике на следећи начин:
Caption = Кликни ме; Height = 40; Left = 50; Top = 50; Visible = False;
Width = 150;
Caption = Х; Font = Courier New, 22; Height = 40; Left = 340; Top = 0;
Width = 40.
Сачуваћемо дизајнирану форму у креирани фолдер JedanTaster, а
затим дефинисати реакције на клик сваког од тастера. Кликом
ћемо селектовати први тастер, а затим у прозору ObjectInspector
на листићу Events пронаћи догађај OnMouseMove и двокликом у
поље вредности дефинисати следећу процедуру (за дефинисање
произвољне позиције овог тастера искористићемо функцију
Random(n)+m која ће бити детаљније објашњена касније):
procedure TForm1.Button1MouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer);
begin Button1.Left:=Random(200)+20;
Button1.Top :=Random(260)+50;
end;
Двокликом на други тастер дефинисаћемо процедуру за крај рада са програмом:
end;

• Саставити програм који кружић у центру екрана помера за две тачке у правцу
стрелице на притиснутом тастеру.
Да бисмо решили овај задатак потребно нам је елементарно сналажење у Декартовом координатном
систему. Координатни почетак у делфију је горњи леви угао форме, а координатне осе су Left -
растојање од левог и Top - растојање од горњег руба форме.
BorderIcons = [biSystemMenu]; BorderStyle = bsSingle;
Caption = ИГРА - ПОМЕРАЊЕ КРУЖИЋА; ClientHeight
= 800; ClientWidth = 1000; Color = clMoneyGreen; Font
= Wingdings 3, Bold, 28; Position = poScreenCenter.
На форму ћемо поставити лабелу за кружић који ће
се кретати, девет тастера са стрелицама и тастер за
крај рада. Почетне координате лабеле ћемо добити
када од координата центра форме (половина ширине
и висине радног прозора) одузмемо половину ширине
и висине лабеле након подешавања фонта. Тастере
ћемо поређати у доњем десном углу форме како би
мање ометали доживљај. Координате одговарајућих
тастера се добијају тако што се редом узимају један
број из left и један број из top карактеристике (сваки
са сваким), а стрелице се добијају уносом редом по
једног слова са листе.
Лабела:
Caption = o; Font =Arial Black, Bold, 9; Left = 495; Top =
392.
Стрелице:
Caption = j, h, k, f, P, g, l, i, m; Height = 40; Left = (875, 915, 955); Top = (635, 675, 715); Width = 40.
Крај рада:
Caption = Крај рада; Font =PalatinoLynotype, Bold, 16; Height = 40; Left = 875; Top = 745; Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер Tackica, а затим, двокликом редом на сваки од
тастера са стрелицама, дефинисаћемо процедуре којима се лабела помера у правцу стрелице на тастеру
за две тачке, односно, враћа се на почетни положај, ако се кликне на средњи тастер. У прве четири
процедуре једна координата је константна, па је нисмо користили.
begin Label1.Left:=Label1.Left-2; // тастер лево
end;
begin Label1.Left:=Label1.Left+2; // тастер десно
end;
begin Label1.Top:=Label1.Top-2; // тастер горе
end;
begin Label1.Top:=Label1.Top+2; // тастер доле
end;
begin Label1.Top:=Label1.Top-2; // тастер горе-лево
Label1.Left:=Label1.Left-2;
end;
begin Label1.Top:=Label1.Top+2; // тастер доле-десно
Label1.Left:=Label1.Left+2;
end;
begin Label1.Top:=Label1.Top-2; // тастер горе-десно
Label1.Left:=Label1.Left+2;
end;
begin Label1.Top:=Label1.Top+2; // тастер доле-лево
Label1.Left:=Label1.Left-2;
end;
begin Label1.Top:=392; // тастер за повратак
Label1.Left:=495;
end;
Двокликом на тастер за крај рада дефинисаћемо процедуру којом се излази из програма:
end;

Следе нешто мање занимљиви, али релативно лагани задаци. Помоћу њих ћемо увежбавати коришћење
различитих типова података и писање стандардних операција са њима у делфију и још боље се упознати
са простом линијском алгоритамском структуром. Објаснићемо и неке карактеристике објеката.
• Саставити програм који за унети карактер исписује претходни и следећи.
BorderIcons = [] - карактеристика дефинише који ће се тастери
приказивати у траци са називом; кликом на плус испред назива
карактеристике отвара се подмени са називима икона; треба за
сваку од четири иконе: системски мени - biSystemMenu (сличица
испред назива и тастер за затварање прозора), тастери за
минимизацију - biMinimize, максимизацију - biMaximize и помоћ
- biHelp изабрати false.
BorderStyle = bsSingle - карактеристика дефинише да ли је
кориснику дозвољено мењање величине прозора хватањем за
рубове и повлачењем лево-десно, горе-доле; овако дефинисана
карактеристика забрањује кориснику измену величине прозора.
Caption = КАРАКТЕР ТИП; ClientHeight = 400; ClientWidth = 430;
Color = Teal; Font = Palatino Linotype, BoldItalic, 16, Aqua;
FormStyle = fsStayOnTop - дефинише понашање прозора у односу
на остале отворене прозоре; овако дефинисана карактеристика
одређује да ће прозор апликације увек бити на врху свих отворених
прозора; у фази тестирања програма ову карактеристику не би
требало користити јер у случају грешке у програму дијалошки
прозор са описом те грешке биће испод прозора апликације, па
нећемо видети шта смо погрешили.
Position = poScreenCenter - дефинише како ће се прозор распоредити на десктопу, овако дефинисана
карактеристика говори да ће прозор апликације бити центриран на екрану.
На форму ћемо ставити лабелу за наслов, три лабеле за комуникацију са корисником, едит за унос, два
едита за испис резултата и три тастера за управљање апликацијом.
Align = alTop - лабела ће се поставити на врх форме од левог до десног руба.
Alignment = taCenter - текст исписан у лабели биће центриран.
AutoSize = False - у случају промене текста или фонта лабела неће аутоматски мењати димензије.
Caption = Претходни и наредни; Font = 22, Lime; Height = 50;
Layout = tlCenter - текст у лабели ће бити вертикално центриран.
Едит за унос:
Font = Bold, Black; Left = 300; MaxLength = 1 - максимална дужина податка који се уноси;
Top = 100; Width = 50.
Едити за испис:
Font = Bold, Black; Left = 300; ReadOnly = True - дефинише да корисник нема права да мења садржај едита;
Top = (240, 310); Width = 50.
Лабеле за комуникацију са корисником:
AutoSize = False; Caption = (Упишите карактер, Претходни карактер, Наредни карактер); Height = 36;
Layout = tlCenter; Left = 80; Top = (100, 240, 310); Width = 220.
Тастери за управљање:
Caption = (Одреди, Обриши, Крај рада); Font = Bold; Height = 40; Left = (10, 150, 190);Top = 170; Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер PredSucc, а затим, двокликом мишем на тастере
редом дефинисаћемо све неопходне процедуре.
Двоклик на тастер Крај рада:
end;
Двоклик на тастер Обриши:
begin Edit1.Clear;Edit1.ReadOnly:=false;
Edit2.Clear;Edit3.Clear;
Edit1.SetFocus;
end;
Двоклик на тастер Одреди:
var k,p,n:char;
begin k:=Edit1.Text[1];
p:=Pred(k);Edit2.Text:=p;
n:=Succ(k);Edit3.Text:=n;
Edit1.ReadOnly:=true;
Button2.SetFocus;
end;
Командом Edit1.Text[1] из текста унетог у оквир узима се само прво слово. Овако смо решили и проблем
са типом података, на левој страни је променљива типа карактер, а Edit1.Text је стринг, па додељивање
не би било могуће.
• Саставити програм који за унето мало слово исписује велико и њихове редне бројеве у
ASCII табели.
BorderIcons = []; BorderStyle = bsSingle; Caption = КАРАКТЕР ТИП;
ClientHeight = 400; ClientWidth = 430; Color = Teal; Font = Palatino
Linotype, BoldItalic, 16, Aqua; FormStyle = fsStayOnTop; Position =
poScreenCenter.
На форму ћемо ставити лабелу за наслов, четири лабеле за
комуникацију са корисником, едит за унос, три едита за испис
резултата и три тастера за управљање апликацијом.
Align = alTop; Alignment = taCenter; AutoSize = False; Caption =
ASCII кодови; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = 300; MaxLength = 1;Top = 100; Width = 50;
CharCase = ecLowerCase - велика слова уноси као мала.
Font = Bold, Black; Left = 300; ReadOnly = True; Top = (220, 280, 340);
Width = (70, 50, 70).
AutoSize = False; Caption = (Упишите мало слово, ASCII код малог слова, Велико слово, ASCII код
великог слова); Height = 36; Layout = tlCenter; Left = 50; Top = (100, 220, 280, 340); Width = 250.
Caption = (Одреди, Обриши, Крај рада); Font = Bold; Height = 40; Left = (10, 150, 290); Top = 160; Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер OrdUpCase, а затим, двокликом мишем на тастере
end;
begin Edit1.Clear;Edit2.Clear;
Edit1.ReadOnly:=false;
Edit1.SetFocus;
end;
var a,b:char;
begin a:=Edit1.Text[1];
Edit2.Text:=IntToStr(Ord(a));
b:=UpCase(a);Edit3.Text:=b;
Edit4.Text:=IntToStr(Ord(b));
Button2.SetFocus;
end;
• Саставити програм који одређује збир, разлику и производ два цела броја.
BorderIcons = []; BorderStyle = bsSingle; Caption = ЦЕЛОБРОЈНИ ТИП;
poScreenCenter.
На форму ћемо ставити лабелу за наслов, пет лабела за кому-
никацију са корисником, два едита за унос, три едита за испис
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Арит
метичке операције; Font = 22, Lime; Height = 50; Layout = tlCenter.
Едити за унос:
Font = Bold, Black; Left = (90, 280);Top = 100; Width = 100.
Font = Bold, Black; Left = 180; ReadOnly = True; Top = (220, 280, 340);
Width = 150.
AutoSize = False; Caption = (a =, b =, a + b =, a - b =, a * b =); Height = 36;
Layout = tlCenter; Left = (50, 240, 100, 100, 100); Top = (100, 100, 220, 280, 340); Width = (40, 40, 80, 80, 80).

Сачуваћемо дизајнирану форму у креирани фолдер AOper, а затим, двокликом мишем на тастере редом
дефинисаћемо све неопходне процедуре.
end;
Edit2.Clear;Edit2.ReadOnly:=false;
Edit3.Clear;Edit4.Clear;Edit5.Clear;
Edit1.SetFocus;
end;
procedure TForm1.Button1Click(Sender: TObject); // тастер одреди
var a,b,z,r,p:integer;
begin a:=StrToIntDef(Edit1.Text,0);Edit1.Text:=IntToStr(a);
b:=StrToIntDef(Edit2.Text,0);Edit2.Text:=IntToStr(b);
z:=a+b;Edit3.Text:=IntToStr(z);
r:=a-b;Edit4.Text:=IntToStr(r);
p:=a*b;Edit5.Text:=IntToStr(p);
Edit1.ReadOnly:=true;Edit2.ReadOnly:=true;
Button2.SetFocus;
end;
• Саставити програм који одређује количник и остатак при целобројном дељењу два
уписана цела броја.
poScreenCenter.
На форму ћемо ставити лабелу за наслов, четири лабеле за кому-
никацију са корисником, два едита за унос, два едита за испис
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Арит
метичке операције; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = (90, 280);Top = 100; Width = 100.
Font = Bold, Black; Left = 180; ReadOnly = True; Top = (240, 310);
Width = 150.
AutoSize = False; Caption = (a =, b =, a div b =, a mod b =); Height = 36;
Layout = tlCenter; Left = (50, 240, 80, 80); Top = (100, 100, 240, 310); Width = (40, 40, 100, 100).
Сачуваћемо дизајнирану форму у креирани фолдер AOper, а затим, двокликом мишем на тастере редом
end;
Edit1.SetFocus;
end;
procedure TForm1.Button1Click(Sender: TObject); // тастер одреди
var a,b,k,o:integer;
k:=a div b;Edit3.Text:=IntToStr(k);
o:=a mod b;Edit4.Text:=IntToStr(o);
Button2.SetFocus;
end;

• Саставити програм који одређује обим и површину квадрата странице а.

Применићемо математичке формуле за израчунавање обима и површине квадрата: O = 4a и P = a2.
poScreenCenter.
На форму ћемо ставити лабелу за наслов, три лабеле за комуника-
цију са корисником, едит за унос, два едита за испис резултата и
три тастера за управљање апликацијом.
Квадрат; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = 100; Top = 100; Width = 120.
Едити за испис резултата:
Width = 120.
AutoSize = False; Caption = (a =, O =, P =); Height = 36; Layout = tlCenter; Left = 50; Top = (100, 150, 200);
Width = 50.
Caption = (Одреди, Обриши, Крај рада); Font = Bold; Height = 40; Left = 250; Top = (150, 170, 260); Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер Kvadrat, а затим, двокликом мишем на тастере редом
end;
Edit1.SetFocus;
end;
var a,o,p:integer;
o:=4*a;Edit2.Text:=IntToStr(o);
p:=a*a;Edit3.Text:=IntToStr(p);
Button2.SetFocus;
end;
• Саставити програм који одређује површину и запремину коцке са основицом а.

Применићемо математичке формуле за израчунавање површине и запремине коцке: P = 6a2 и V = a3.
poScreenCenter.
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Коцка;
Font = 22, Lime; Height = 50; Layout = tlCenter.
Width = 120.
AutoSize = False; Caption = (a =, P =, V =); Height = 36; Layout = tlCenter; Left = 50; Top = (100, 150, 200);
Width = 50.
Сачуваћемо дизајнирану форму у креирани фолдер Kocka, а затим, двокликом мишем на тастере редом

end;
Edit1.SetFocus;
end;
var a,v,p:integer;
p:=6*a*a;Edit2.Text:=IntToStr(p);
v:=a*a*a;Edit3.Text:=IntToStr(v);
Button2.SetFocus;
end;
• Саставити програм који одређује површину и запремину квадра са основицама а, б и ц.

Применићемо математичке формуле за израчунавање површине и запремине квадра:
P = 2(ab + bc + ca) и V = abc.
poScreenCenter.
На форму ћемо ставити лабелу за наслов, пет лабеле за комуника-
цију са корисником, три едита за унос, два едита за испис резултата
и три тастера за управљање апликацијом.
Квадар; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = 100; Top = (100, 150, 200); Width = 120.
Width = 120.
AutoSize = False; Caption = (a =, b =, c =, P =, V =); Height = 36; Layout = tlCenter; Left = 50; Top = (100, 150,
200, 250, 300); Width = 50.
Сачуваћемо дизајнирану форму у креирани фолдер Kvadar, а затим, двокликом мишем на тастере редом
end;
Edit1.SetFocus;
end;
var a,b,c,p,v:integer;
c:=StrToIntDef(Edit3.Text,0);Edit3.Text:=IntToStr(c);
p:=2*(a*b+b*c+c*a);Edit4.Text:=IntToStr(p);
v:=a*b*c;Edit5.Text:=IntToStr(v);
Button2.SetFocus;
end;

• Саставити програм који одређује површину квадрата над хипотенузом правоуглог

троугла са катетама а и б.
Применићемо Питагорину теорему за израчунавање хипотенузе правоуглог троугла: c2 = a2 + b2.
poScreenCenter.
цију са корисником, два едита за унос, едит за испис резултата и
Питагорина теорема; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = 100; Top = (100, 150); Width = 120.
Едит за испис резултата:
Font = Bold, Black; Left = 100; ReadOnly = True; Top = 200; Width = 120.
AutoSize = False; Caption = (a =, b =, Pc =); Height = 36; Layout = tlCenter; Left = 50; Top = (100, 150, 200);
Width = 50.
Сачуваћемо дизајнирану форму у креирани фолдер Hipotenuza, а затим, двокликом мишем на тастере
end;
Edit3.Clear;
Edit1.SetFocus;
end;
var a,b,p:integer;
p:=a*a+b*b;Edit3.Text:=IntToStr(p);
Button2.SetFocus;
end;
• Саставити програм који одређује збир цифара унетог троцифреног броја.

Сваки природни број може се написати као збир производа одговарајуће цифре и броја 10 степенованог са
редним бројем цифре умањеним за 1, тј. c1 + 10*c2 + 100*c3 + .... То значи да се прва цифра броја добија
са mod 10, a брише се дељењем са десет (div 10). Ако водимо рачуна о томе лако је написати програм.
poScreenCenter.
цију са корисником, едит за унос, едит за испис резултата и три
тастера за управљање апликацијом.
Троцифрени број; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = 120; MaxLength = 3; Top = 100; Width = 100.
AutoSize = False; Caption = (број =, збир =); Height = 36; Layout = tlCenter; Left = 50; Top = (100, 175); Width = 70.
Сачуваћемо дизајнирану форму у креирани фолдер Trocifren, а затим, двокликом мишем на тастере редом
end;
Edit2.Clear;
Edit1.SetFocus;
end;
var n,s,p,d,t:integer;
begin n:=StrToIntDef(Edit1.Text,0);Edit1.Text:=IntToStr(n);
p:=n mod 10; // цифра јединица
d:=n div 10 mod 10; // цифра десетица
t:=n div 100; // цифра стотица
s:=p+d+t;Edit2.Text:=IntToStr(s);
Button2.SetFocus;
end;
• Саставити програм који унети четвороцифрени број исписује са цифрама у

обрнутом поретку.
Сваки четвороцифрени број се може написати овако: 1000*c + 100*t + 10*d + p, а број са обрнутим
редоследом цифара је 1000*p + 100*d + 10*t + c. Сада jе лако написати програм.
poScreenCenter.
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Чет
вороцифрени број; Font = 22, Lime; Height = 50; Layout = tlCenter.
AutoSize = False; Caption = (број1 =, број2 =); Height = 36; Layout = tlCenter; Left = 50; Top = (100, 175);
Width = 80.
Сачуваћемо дизајнирану форму у креирани фолдер Cetvorocifren, а затим, двокликом мишем на тастере
end;
Edit2.Clear;
Edit1.SetFocus;
end;
var n,s,p,d,t,c:integer;
p:=n mod 10; // цифра јединица
d:=n div 10 mod 10; // цифра десетица
t:=n div 100 mod 10; // цифра стотина
c:=n div 1000; // цифра хиљада
s:=1000*p+100*d+10*t+c;Edit2.Text:=IntToStr(s);
Button2.SetFocus;
end;
• Саставити програм који одређује збир два угла датог у степенима минутима и
секундама.
Да би се коректно решио задатак потребно је увести контролу уноса минута и секунди. За ове контроле
потребно је знати наредбе гранања. Зато ћемо претпоставити да је унос коректан. Углове ћемо
претворити у секунде, сабрати их и затим секунде претворити у степене, минуте и секунде.
poScreenCenter.
На форму ћемо ставити лабелу за наслов, три лабеле за комуни-
кацију са корисником, шест едита за унос, три едита за испис
Сабирање углова; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = (200, 260, 310); MaxLength = (3, 2, 2); Top =
(100, 150); Width = (50, 40, 40).
Font = Bold, Black; Left = (200, 260, 310); ReadOnly = True; Top = 200; Width = (50, 40, 40).
AutoSize = False; Caption = (Први угао :, Други угао :, Збир углова :); Height = 36; Layout = tlCenter; Left =
60; Top = (100, 150, 200); Width = 140.
Сачуваћемо дизајнирану форму у креирани фолдер ZbirUglova, а затим, двокликом мишем на тастере
end;
Edit1.SetFocus;
end;
var a1,a2,a3,b1,b2,b3,c1,c2,c3:integer;
begin a1:=StrToIntDef(Edit1.Text,0);Edit1.Text:=IntToStr(a1);
a2:=StrToIntDef(Edit2.Text,0);Edit2.Text:=IntToStr(a2);
a3:=StrToIntDef(Edit3.Text,0);Edit3.Text:=IntToStr(a3);
b1:=StrToIntDef(Edit4.Text,0);Edit4.Text:=IntToStr(b1);
c3:=a1*3600+a2*60+a3+b1*3600+b2*60+b3;
c1:=c3 div 3600;Edit7.Text:=IntToStr(c1);
c2:=c3 mod 3600 div 60;Edit8.Text:=IntToStr(c2);
c3:=c3 mod 60; Edit9.Text:=IntToStr(c3);
Edit1.ReadOnly:=true;Edit2.ReadOnly:=true;Edit3.ReadOnly:=true;
Button2.SetFocus;
end;
• Саставити програм који одређује збир првих н природних бројева.

Пример:
За n  100 Sn  1  2  3 98  99 100  (100 1)  (99  2)  (98  3)  (100 1)* (100 / 2)
Формирали смо низ бројева од 1 до n, а затим груписали парове бројева стално узимајући први и
последњи број из низа. Јасно је да таквих парова има n/2, а да је збир сваког пара n+1. Формула која
представља решење овог задатка гласи: s:=n*(n+1) div 2. Сада је лако написати програм.
BorderIcons = []; BorderStyle = bsSingle; Caption = ЦЕЛОБРОЈНИ ТИП; ClientHeight = 350; ClientWidth = 430;
Color = Teal; Font = Palatino Linotype, BoldItalic, 16, Aqua; FormStyle = fsStayOnTop; Position =
poScreenCenter.

На форму ћемо ставити лабелу за наслов, две лабеле за комуника-

Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Збир
првих н природних; Font = 22, Lime; Height = 50; Layout = tlCenter.
AutoSize = False; Caption = (n =, Sn =); Height = 36; Layout = tlCenter;
Left = 50; Top = (100, 170); Width = 50.
Caption = (Одреди, Обриши, Крај рада); Font = Bold; Height = 40; Left =
250; Top = (150, 175, 260); Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер NParnih, а затим, двокликом мишем на тастере редом
end;
Edit1.SetFocus;
end;
var n,s:integer;
s:=n*(n+1) div 2;Edit2.Text:=IntToStr(s);
Button2.SetFocus;
end;
• Саставити програм који одређује збир првих н парних бројева.

Пример:
За n  50 Sn  2  4  6 96  98 100  2 (1  2  348  49  50)  2 * (50 1)* (50 / 2)
Формираћемо низ првих бројева n парних бројева. Сваки број ћемо написати као 2*к, а затим испред
заграде издвојити 2, у загради ће бити збир првих n природних бројева. Ако применимо формулу из
претходног задатка добићемо формулу: s:=2 * n*(n+1) div 2 = n*(n+1). Сада је лако написати програм.
poScreenCenter.
првих н парних; Font = 22, Lime; Height = 50; Layout = tlCenter.
AutoSize = False; Caption = (n =, Sn =); Height = 36; Layout = tlCenter; Left = 50; Top = (100, 170); Width = 50.
Сачуваћемо дизајнирану форму у креирани фолдер NParnih, а затим, двокликом мишем на тастере редом

end;


Edit1.SetFocus;
end;
var n,s:integer;
s:=n*(n+1);Edit2.Text:=IntToStr(s);
Button2.SetFocus;
end;
• Саставити програм који одређује збир првих н непарних бројева.

Пример:
За n  50 Sn  1  3  595  97  99  2 1  4 1  6 1 96 1  98 1 100 1 
 (2  4  696  98 100)  50  (50 1)* 50  50  50 * 50
Формираћемо низ првих бројева n парних бројева. Сваки број ћемо написати као 2*к-1, а затим испред
заграде издвојити 2, у загради ће бити збир првих n природних бројева и резултат умањити за n. Ако
применимо формулу из претходног задатка добићемо формулу: s:=n*(n+1)-n = n*n. Сада је лако
написати програм.
BorderIcons = []; BorderStyle = bsSingle; Caption = ЦЕЛОБРОЈНИ
ТИП; ClientHeight = 350; ClientWidth = 430; Color = Teal; Font =
Palatino Linotype, BoldItalic, 16, Aqua; FormStyle = fsStayOnTop;
На форму ћемо ставити лабелу за наслов, две лабеле за комуни-
кацију са корисником, едит за унос, едит за испис резултата и
првих н непарних; Font = 22, Lime; Height = 50; Layout = tlCenter.
AutoSize = False; Caption = (n =, Sn =); Height = 36; Layout = tlCenter;
Left = 50; Top = (100, 170); Width = 50.
Сачуваћемо дизајнирану форму у креирани фолдер NNeparnih, а затим, двокликом мишем на тастере
end;
Edit1.SetFocus;
end;
var n,s:integer;
s:=n*n;Edit2.Text:=IntToStr(s);
Button2.SetFocus;
end;
• Саставити програм који одређује збир парних бројева до н.

Пример:
За n  100 Sn  2  4  696  98 100  2 * (1  2  348  49  50 
 2 * ((100 / 2 1)* 100 / 2)/ 2  (100 / 2 1)* 100 / 2
Формираћемо низ пaрних бројева до n. Сваки број ћемо написати као 2*к, а затим испред заграде
издвојити 2, у загради ће бити збир првих n/2 природних бројева. Ако применимо формулу за збир
првих n природних добићемо формулу: s:= n div 2*(n div 2 + 1). Сада је лако написати програм.

poScreenCenter.
парних до н; Font = 22, Lime; Height = 50; Layout = tlCenter.
Сачуваћемо дизајнирану форму у креирани фолдер ParniDoN, а затим, двокликом мишем на тастере
end;
Edit1.SetFocus;
end;
var n,s:integer;
s:=(n div 2)*(n div 2+1);Edit2.Text:=IntToStr(s);
Button2.SetFocus;
end;
• Саставити програм који одређује збир непарних бројева до н.

Пример:
За n  100 Sn  1  3  595  97  99  2 1  4 1  6 196 1  98 1 100 1 
 (2  4  696  98 100)  50  (100 / 2 1)* 100 / 2 100 / 2  100 / 2 * 100 / 2
Формираћемо низ првих n непарних бројева. Сваки број ћемо написати као 2*к - 1, а затим испред
заграде издвојити 2, у загради ће бити збир првих n/2 природних бројева. Није тешко закључити да је
тражена формула мора бити (јер n може бити и паран и непаран број, па ако је паран можемо
применити формулу из примера, али ако је непаран та формула не сабира број n):
s:=((n+1) div 2)*((n+1) div 2). Сада је лако написати програм.
poScreenCenter.
парних до н; Font = 22, Lime; Height = 50; Layout = tlCenter.
Сачуваћемо дизајнирану форму у креирани фолдер NeparniDoN, а затим, двокликом мишем на тастере

end;
Edit1.SetFocus;
end;
var n,s:integer;
s:=Sqr((n+1) div 2);Edit2.Text:=IntToStr(s);
Button2.SetFocus;
end;
• Саставити програм који одређује збир природних бројева од m до n.

Најједноставнији начин да се реши овај задатак је да саберемо првих n и од тог збира одузмемо збир
првих m-1 природних бројева, па је формула за решење: s:=n*(n+1) div 2-(m-1)*m div 2.
poScreenCenter.
цију са корисником, два едита за унос, едит за испис резултата и
природних од м до н; Font = 22, Lime; Height = 50; Layout = tlCenter.
AutoSize = False; Caption = (n =, m =, Sn =); Height = 36; Layout =
tlCenter; Left = 50; Top = (100, 150, 200); Width = 50.
Сачуваћемо дизајнирану форму у креирани фолдер OdMDoN, а затим, двокликом мишем на тастере
end;
begin Edit1.Clear;Edit2.Clear;Edit3.Clear;
Edit1.ReadOnly:=false;Edit2.ReadOnly:=false;
Edit1.SetFocus;
end;
var m,n,s:integer;
m:=StrToIntDef(Edit2.Text,0);Edit2.Text:=IntToStr(m);
s:=n*(n+1) div 2-(m-1)*m div 2;Edit3.Text:=IntToStr(s);
Button2.SetFocus;
end;
• Саставити програм који на случајан начин формира број мањи од 100, заокругљује га
на две децимале, а затим замењује целобројни и разломљени део.
Задатак не захтева никакав унос података јер се почетни број формира на случајан начин, зато би на
почетку требало да у жижи буде тастер Одреди. То се постиже тако што се на форму као први објекат
постави тај тастер или се пре извршења програма карактеристика TabOrder овог објекта постави на 0.
BorderIcons = []; BorderStyle = bsSingle; Caption = РЕАЛНИ ТИП; ClientHeight = 370; ClientWidth = 430;
poScreenCenter.

На форму ћемо ставити лабелу за наслов, пет лабела за комуника-

цију са корисником, пет едита за испис резултата и три тастера за
управљање апликацијом.
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Заокр
угљивање бројева; Font = 22, Lime; Height = 50; Layout = tlCenter.
Едити за почетни број:
Font = Bold, Black; Left = 190; ReadOnly = True; Top = (150, 200, 250,
300); Width = 60.
AutoSize = False; Caption = (Број, Заокругљени, Целобројни,
Разломљени, Нови број); Height = 36; Layout = tlCenter; Left = 40;
Top = (100, 150, 200, 250, 300); Width = 150.
Сачуваћемо дизајнирану форму у креирани фолдер Zaokrug, а затим, двокликом мишем на тастере редом
end;
Button1.SetFocus;
end;
var b,z,c,r,n:real;
begin Randomize;
b:=Random*100; Edit1.Text:=Format('%12.9f',[b]);
z:=Round(b*100)/100;Edit2.Text:=FloatToStr(z);
c:=Int(z); Edit3.Text:=FloatToStr(c);
r:=Round(Frac(z)*100)/100;Edit4.Text:=FloatToStr(r);
n:=r*100+c/100; Edit5.Text:=FloatToStr(n);
Button2.SetFocus;
end;
Процедура Randomize за промену основе за генерисање случајних бројева, мора се употребити бар једном
пре функције Random да не бисмо приликом сваког покретања програма добили исти случајни број.
Функција Random даје случајан број између 0 и 1, па када се помножи са 100 даје број између 0 и 100.
Израз Round(Frac(z)*100)/100 изгледа бесмислено јер се број са две децимале заокругљује на две
децимале, али је неопходан због тога што процесор памти више децимала него што се исписује на екрану,
па када се обрише целобројни део, тај вишак децимала се прикаже (ово се дешава само код неких бројева).
Први пут смо употребили функцију Format за уређење исписа. Објаснићемо њену основну употребу.
Општи облик функције је:
Format('opis',[sadrzaj])
- opis је текстуални податак који почиње ознаком % која означава да оно што следи није обичан текст,
већ формат који желимо да применимо, затим следи број места која желимо да искористимо за испис целог
податка, ако се ради о реалном броју следи . (тачка) и број децималних места податка, на крају је слово
које дефинише тип податка који се исписује (поменућемо само најчешће ознаке: d - цео број, f - реалан број,
n - реалан са раздвојеним хиљадама, m - новац, као n само још и са ознаком валуте s - текст)
- sadrzaj је променљива или конкретна вредност која се форматизује. Број података у угластим
заградама мора се слагати са бројем ознака формата. Свака грешка у формату укида испис податка.
• Саставити програм који на случајан начин формира пет бројева, заокругљије их на
две децимале, а затим одређује аритметичке средине за сваку групу бројева посебно и
одступања сваког од бројева од одговарајуће аритметичке средине.
Задатак не захтева никакав унос података јер се почетни број формира на случајан начин, зато би на
почетку требало да у жижи буде тастер Одреди. То се постиже тако што се на форму као први објекат
постави тај тастер или се пре извршења програма карактеристика TabOrder овог објекта постави на 0.
Color = Teal; Font = Palatino Linotype, BoldItalic, 16, Aqua; FormStyle = fsStayOnTop; Position = poScreenCenter.
На форму ћемо ставити лабелу за наслов, три лабеле за комуникацију са корисником, двадесетдва
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Одступање од средине; Font = 22, Lime;
Height = 50; Layout = tlCenter.
Едити за испис бројева:

Font = Bold, Black; Left = (20, 145, 300, 375); ReadOnly = True; Top =
(100, 135, 170, 205, 240); Width = (125, 140, 75, 85).
Едити за испис средина:
Font = Bold, Black; Left = (145, 375); ReadOnly = True; Top = 290;
Width = (140, 85).
AutoSize = False; Caption = (Случајни бројеви, Заокругљени,
Средине); Height = 29; Layout = tlCenter; Left = (20, 300, 20); Top =
(70, 70, 290); Width = (265, 160, 125).
(20, 165, 340); Top = 340; Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер Odstup, а затим,
двокликом мишем на тастере редом дефинисаћемо све неопходне
процедуре.
end;
begin Edit1.Clear;Edit2.Clear;Edit3.Clear;Edit4.Clear;Edit5.Clear;
Edit6.Clear;Edit7.Clear;Edit8.Clear;Edit9.Clear;Edit10.Clear;
Edit11.Clear;Edit12.Clear;Edit13.Clear;Edit14.Clear;
Button1.SetFocus;
end;
var a1,a2,a3,a4,a5,oa1,oa2,oa3,oa4,oa5,asa,
z1,z2,z3,z4,z5,oz1,oz2,oz3,oz4,oz5,asz:real;
begin randomize;
a1:=Random*1000;Edit1.Text:=Format('%11.7f',[a1]);
asa:=(a1+a2+a3+a4+a5)/5;Edit6.Text:=Format('%12.8f',[asa]);
oa1:=Abs(asa-a1);Edit13.Text:=Format('%12.8f',[oa1]);
z1:=Round(a1*100)/100;Edit7.Text:=Format('%6.2f',[z1]);
asz:=(z1+z2+z3+z4+z5)/5;Edit12.Text:=Format('%7.3f',[asz]);
oz1:=Abs(asz-z1);Edit18.Text:=Format('%7.3f',[oz1]);
Button2.SetFocus;
end;
• Саставити програм који исписује таблицу вредности тригонометријских функција

углова од 5, 15, 25, 35 и 45 степени. Дозволити промену вредности углова.
BorderIcons = []; BorderStyle = bsSingle; Caption = РЕАЛНИ ТИП;
poScreenCenter.
На форму ћемо ставити лабелу за наслов, лабелу за комуникацију
са корисником, пет едита за унос, мемо поље за испис резултата и
Таблица вредности; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = (200, 270, 340, 410, 480); MaxLength = 3;
Top = 60; Width = 50.

Мемо поље за испис резултата:

Font = Courier New, Bold, 16, Black; Height = 170; Left = 10; ReadOnly = True; Top = 100; Width = 520.
AutoSize = False; Caption = Унесите углове :; Height = 36; Layout = tlCenter; Left = 10; Top = 60; Width = 170.
Caption = (Одреди, Обриши, Крај рада); Font = Bold; Height = 40; Left = (10, 170, 410); Top = 300; Width =
120.
Сачуваћемо дизајнирану форму у креирани фолдер Tablica, а затим, двокликом мишем на тастере редом
end;
Edit4.Clear;Edit5.Clear;Memo1.Clear;
Edit1.SetFocus;
end;
var u:integer;
s,c:real;
begin Memo1.Lines.Add(Format('%3s%9s%9s%8s%10s',['a','sin(a)','cos(a)','tg(a)','ctg(a)']));
u:=StrToIntDef(Edit1.Text, 5);Edit1.Text:=IntToStr(u);
s:=sin(u*pi/180);c:=cos(u*pi/180);
Memo1.Lines.Add(Format('%3d%9.5f%9.5f%9.5f%9.5f',[u,s,c,s/c,c/s]));
u:=StrToIntDef(Edit2.Text,15);Edit2.Text:=IntToStr(u);
Button2.SetFocus;
end;
Будући да за извршење програма није неопходан унос углова дефинисаћемо процедуру FormActivate
која ће симулирати клик на први тастер када форма први пут постане активна. У прозору Object Inspector
на листићу Events пронаћи ћемо догађај OnActivate и двокликом у његово поље вредности декларисати
ову процедуру:
procedure TForm1.FormActivate(Sender: TObject);
begin Button1.Click;
end;
• Саставити програм који одређује обим и површину круга полупречника r.

poScreenCenter.
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Круг;
Width = 120.
AutoSize = False; Caption = (r =, O =, P =); Height = 36; Layout = tlCenter; Left = 50; Top = (100, 170, 220);
Width = 50.
Caption = (Одреди, Обриши, Крај рада); Font = Bold; Height = 40; Left = 250; Top = (100, 170, 260); Width =
120.
Сачуваћемо дизајнирану форму у креирани фолдер Krug, а затим, двокликом мишем на тастере редом

end;
Edit1.SetFocus;
end;
var r,p,o:real;
begin r:=StrToFloatDef(Edit1.Text,5);
Edit1.Text:=FloatToStr(r);
o:=2*r*pi;Edit2.Text:=Format('%1.2f',[o]);
p:=r*r*pi;Edit3.Text:=Format('%1.2f',[p]);
Button2.SetFocus;
end;
• Саставити програм који одређује периферијски угао који одговара тетиви t

кружнице са полупречником r.
poScreenCenter.
кацију са корисником, два едита за унос, три едита за испис
Периферијски угао; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = (90, 150, 200); ReadOnly = True; Top = 220;
Width = (50, 40, 40).
AutoSize = False; Caption = (r =, t =); Height = 36; Layout = tlCenter; Left = 40; Top = (100, 150); Width = 50.
Лабела за угао:
AutoSize = False; Caption = a =; Font = Symbol, BoldItalic, 16, Aqua; Height = 36; Layout = tlCenter; Left = 40;
Top = 220; Width = 50.
Сачуваћемо дизајнирану форму у креирани фолдер Periferijski, а затим, двокликом мишем на тастере
end;
Edit1.SetFocus;
end;
var t,r,h:real;
a1,a2,a3:integer;
begin r:=StrToFloatDef(Edit1.Text,5);Edit1.Text:=FloatToStr(r);
t:=StrToFloatDef(Edit2.Text,5);Edit2.Text:=FloatToStr(t);
h:=Sqrt(r*r-t*t/4);
a3:=Round(ArcTan(t/2/h)*180/pi*3600); //ugao u sekundama
a1:=a3 div 3600; Edit3.Text:=IntToStr(a1);
a2:=a3 div 60 mod 60;Edit4.Text:=IntToStr(a2);
a3:=a3 mod 60; Edit5.Text:=IntToStr(a3);
Button2.SetFocus;
end;

• Саставити програм који одређује дијагоналу коцке са основицом а.

poScreenCenter.
Дијагонала коцке; Font = 22, Lime; Height = 50; Layout = tlCenter.
AutoSize = False; Caption = (r =, D =); Height = 36; Layout = tlCenter;
Left = 50; Top = (100, 200); Width = 50.
Сачуваћемо дизајнирану форму у креирани фолдер Dijagonala, а затим, двокликом мишем на тастере
end;
Edit2.Clear;
Edit1.SetFocus;
end;
var a,d:real;
begin a:=StrToFloatDef(Edit1.Text,5);Edit1.Text:=FloatToStr(a);
d:=a*Sqrt(3);Edit2.Text:=Format('%1.3f',[d]);
Button2.SetFocus;
end;
• Саставити програм који одређује површину, запремину квадра и површину дијагоналног

пресека квадра са основицама а и b и дијагоналом D.
poScreenCenter.
На форму ћемо ставити лабелу за наслов, осам лабела за комуни-
кацију са корисником, три едита за унос, пет едита за испис
Дијагонални пресек; Font = 22, Lime; Height = 50; Layout =
tlCenter.
Font = Courier New, Bold, Black; Left = 230; ReadOnly = True; Top =
(80, 125, 170, 215, 260); Width = 140.
AutoSize = False; Caption = (a =, b =, D =, c =, d = , P =, V =, Pd =); Height = 36; Layout = tlCenter; Left = (30, 30,
30, 180, 180, 180, 180, 180); Top = (80, 125, 170, 80, 125, 170, 215, 260); Width = 50.
Caption = (Одреди, Обриши, Крај рада); Font = Bold; Height = 40; Left = (30, 30, 250); Top = (220, 270, 320);
Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер DPresek, а затим, двокликом мишем на тастере редом


end;
Edit1.SetFocus;
end;
var a,b,d,c,d1,p,v,pd:real;
b:=StrToFloatDef(Edit2.Text,4);Edit2.Text:=FloatToStr(b);
d:=StrToFloatDef(Edit3.Text,13);Edit3.Text:=FloatToStr(d);
d1:=Sqrt(a*a+b*b); Edit5.Text:=Format('%9.2f',[d1]);
c :=Sqrt(d*d-d1*d1);Edit4.Text:=Format('%9.2f',[c]);
p :=2*(a*b+b*c+c*a);Edit6.Text:=Format('%9.2f',[p]);
v :=a*b*c; Edit7.Text:=Format('%9.2f',[v]);
pd:=d1*c; Edit8.Text:=Format('%9.2f',[pd]);
Button2.SetFocus;
end;
• Саставити програм који одређује површину и запремину правилне тростране пирамиде

са основицом а и бочном ивицом s.
poScreenCenter.
На форму ћемо ставити лабелу за наслов, шест лабела за комуни-
кацију са корисником, два едита за унос, четири едита за испис
Тространа пирамида; Font = 22, Lime; Height = 50; Layout = tlCenter.
(80, 130, 180,230); Width = 140.
AutoSize = False; Caption = (a =, s =, h =, H = , P =, V =); Height = 36;
Layout = tlCenter; Left = (30, 30, 180, 180, 180, 180); Top = (80, 130, 80, 130, 180, 230); Width = 50.
Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер TPiramida, а затим, двокликом мишем на тастере
end;
Edit1.SetFocus;
end;
var a,s,p,v,h,h1:real;
s:=StrToFloatDef(Edit2.Text,4);Edit2.Text:=FloatToStr(s);
h1:=Sqrt(s*s-a*a/4); Edit3.Text:=Format('%9.3f',[h1]);
h:=Sqrt(s*s-a*a/3); Edit4.Text:=Format('%9.3f',[h]);

p:=a*a*Sqrt(3)/4+3*a*h1/2;Edit5.Text:=Format('%9.3f',[p]);
v:=a*a*Sqrt(3)/4*h/3; Edit6.Text:=Format('%9.3f',[v]);
Button2.SetFocus;
end;
• Саставити програм који одређује површину и запремину правилне четворостране

пирамиде са основицом а и бочном ивицом s.
poScreenCenter.
кацију са корисником, два едита за унос, четири едита за испис
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Четво
ространа пирамида; Font = 22, Lime; Height = 50; Layout = tlCenter.
(80, 130, 180,230); Width = 140.
AutoSize = False; Caption = (a =, s = , h =, H =, P =, V =); Height = 36; Layout = tlCenter; Left = (30, 30, 180, 180,
180, 180); Top = (80, 130, 80, 130, 180, 230); Width = 50.
Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер CPiramida, а затим, двокликом мишем на тастере
end;
Edit1.SetFocus;
end;
h1:=Sqrt(s*s-a*a/4);Edit3.Text:=Format('%9.3f',[h1]);
h:=Sqrt(s*s-a*a/2); Edit4.Text:=Format('%9.3f',[h]);
p:=a*a+2*a*h1; Edit5.Text:=Format('%9.3f',[p]);
v:=a*a*h/3; Edit6.Text:=Format('%9.3f',[v]);
Button2.SetFocus;
end;
• Саставити програм који одређује површину и запремину правилне шестостране

пирамиде са основицом а и бочном ивицом s.
poScreenCenter.
На форму ћемо ставити лабелу за наслов, шест лабела за комуникацију са корисником, два едита за
унос, четири едита за испис резултата и три тастера за управљање апликацијом.
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Шесто страна пирамида; Font = 22, Lime;


(80, 130, 180,230); Width = 140.
AutoSize = False; Caption = (a =, s = , h =, H =, P =, V =); Height = 36;
Layout = tlCenter; Left = (30, 30, 180, 180, 180, 180); Top = (80, 130,
80, 130, 180, 230); Width = 50.
Caption = (Одреди, Обриши, Крај рада); Font = Bold; Height = 40;
Left = (30, 30, 250); Top = (220, 270, 320); Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер SPiramida, а
затим, двокликом мишем на тастере редом дефинисаћемо све
неопходне процедуре.
end;
Edit1.SetFocus;
end;
h1:=Sqrt(s*s-a*a/4); Edit3.Text:=Format('%9.3f',[h1]);
h:=Sqrt(s*s-a*a); Edit4.Text:=Format('%9.3f',[h]);
p:=3*a*a*Sqrt(3)/2+3*a*h1;Edit5.Text:=Format('%9.3f',[p]);
v:=a*a*Sqrt(3)/2*h; Edit6.Text:=Format('%9.3f',[v]);
Button2.SetFocus;
end;
• Саставити програм који одређује висину хипотенузе и оштре углове (у степенима,

минутима и секундама) правоуглог троугла са катетама a и b.
poScreenCenter.
кацију са корисником, два едита за унос, осам едита за испис
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Право
угли троугао; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = (230, 230, 230, 285, 330, 230, 285, 330);
ReadOnly = True; Top = (80, 130, 180, 180, 180, 230, 230, 230);
Width = (95, 95, 50, 40, 40, 50, 40, 40).
AutoSize = False; Caption = (a =, b = , c =, h =); Height = 36; Layout = tlCenter; Left = (30, 180); Top = (80, 130);
Width = 50.
Лабеле за угао:
AutoSize = False; Caption = (a =, b =); Font = Symbol, BoldItalic, 16, Aqua; Height = 36; Layout = tlCenter; Left
= 180; Top = (180, 230); Width = 50.
Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер Pravougli, а затим, двокликом мишем на тастере
end;


Edit1.SetFocus;
end;
var a,b,c,h:real;
a1,a2,a3,b1,b2,b3:integer;
c:=Sqrt(a*a+b*b);Edit3.Text:=Format('%6.2f',[c]);
h:=a*b/c; Edit4.Text:=Format('%6.2f',[h]);
a3:=Round(ArcTan(a/b)/pi*180*3600); //alfa u sekundama
b3:=90*3600-a3; // beta u sekundama kao komplement
a2:=a3 mod 3600 div 60;Edit6.Text:=IntToStr(a2);
b1:=b3 div 3600; Edit8.Text:=IntToStr(b1);
b2:=b3 mod 3600 div 60;Edit9.Text:=IntToStr(b2);
b3:=b3 mod 60; Edit10.Text:=IntToStr(b3);
Button2.SetFocus;
end;
• Саставити програм који одређује спољашне углове (у степенима, минутима и

секундама) правоуглог троугла са катетом а и хипотенузином висином h.
Катета a, висина h и одсечак x на хипотенузи чине правоугли троугао сличан великом. Спољашни угао
је суплемент унутрашњем. Збир спољашних углова троугла је 360о, а један од њих је прав. Из свега овог
следе једноставне математичке формуле које лако можемо написати у духу програмског језика и
решити овај задатак. Треба водити рачуна о томе да тригонометријске функције раде са радијанима, па
ове формуле треба допунити конверзијом радијана у степене, минуте и секунде.
poScreenCenter.
никацију са корисником, два едита за унос, шест едита за испис
Спољашњи углови; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = (130, 185, 330); ReadOnly = True; Top =
(180, 230); Width = (50, 40, 40, 50, 40, 40).
AutoSize = False; Caption = (a =, b =); Height = 36; Layout = tlCenter;
Left = 30; Top = (80, 130); Width = 50.
AutoSize = False; Caption = (a =, b =); Font = Symbol, BoldItalic, 16, Aqua; Height = 36; Layout = tlCenter; Left
= 80; Top = (180, 230); Width = 50.
Сачуваћемо дизајнирану форму у креирани фолдер SUglovi, а затим, двокликом мишем на тастере редом
end;
Edit1.SetFocus;
end;


var a,h,x:real;
a1,a2,a3,b1,b2,b3:integer;
h:=StrToFloatDef(Edit2.Text,2.4);Edit2.Text:=FloatToStr(h);
x:=Sqrt(a*a-h*h);
a3:=180*3600-Trunc(ArcTan(x/h)*180/pi*3600); //alfa u sekundama
b3:=270*3600-a3; //beta u sekundama
b2:=b3 div 60 mod 60;Edit7.Text:=IntToStr(b2);
Button2.SetFocus;
end;
• Саставити програм који одређује истиносну вредност формуле pqr, где су p, q и r

искази дате истиносне вредности.
BorderIcons = []; BorderStyle = bsSingle; Caption = ЛОГИЧКИ ТИП;
poScreenCenter.
На форму ћемо ставити три лабеле за наслов, четири лабеле за
комуникацију са корисником, три комбобокса за унос, едит за
испис резултата и три тастера за управљање апликацијом.
Лабеле за наслов:
Истиносна вредност формуле; Font = 22, Lime; Height = 65; Layout
= tlCenter.
Alignment = taCenter; AutoSize = False; Caption = ; Font =
Symbol, 18; Height = 30; Left = 130; Top = 30; Transparent = true;
Width = 125.
Alignment = taCenter; AutoSize = False; Caption = (p q) r; Font = 18;
Height = 30; Left = 165; Top = 30; Transparent = true; Width = 108.
Комбобоксови за унос:
AutoCloseUp = true; AutoDropDown = true; Font = Bold, Black; Left = 70; ItemIndex = -1; Items = (True, False); Top
= (90, 130, 170); Width = 100;
Поставили смо три лабеле једну преко друге да бисмо решили немогућност комбиновања два или више
фонтова у Caption. Прва лабела је на дну и обојена, остале су провидне (Transparent = true). Слово тау и
ознаке операција пронашли смо у фонту Symbol и уметнули у лабелу коришћењем програма Character
Map. Дозвољене вредности у комбобоксовима смо уписали у Items, двокликом на вредност TStrings.
Ставке у Items се могу додавати и програмски. Избор се врши тако што се кликне на стрелицу са десне
стране и из отвореног менија кликом изабере одговарајућа вредност која се преноси у Text
карактеристику. Програмски се може дефинисати да Text карактеристика има или нема почетну,
предефинисану вредност карактеристиком ItemIndex, ако је вредност -1 нема почетну вредност, а ако
је 0, 1, ... почетна вредност је први, други, ... ред из датотеке. Овим објектом се кориснику онемогућава
погрешан унос података, али га није могуће увек користити. Карактеристикама AutoCloseUp и
AutoDropDown дефинише се да ли ће се оквир са вредностима аутоматски отварати и затварати.
Едит за испис резултата
Лабеле за комуникацију
AutoSize = False; Caption = (p =, q =, r =, t =); Height = 33; Layout = tlCenter; Left = 20; Top = (90, 130, 170, 220);
Width = 50.
Лабела за црту:
AutoSize = False; Caption = ; Color = clBlack; Height = 3; Left = 10; Top = 210; Width = 180.
Сачуваћемо дизајнирану форму у креирани фолдер Logika1, а затим, двокликом мишем на тастере
end;
begin ComboBox1.Text:='';ComboBox2.Text:='';ComboBox3.Text:='';
Edit1.Clear; Button1.SetFocus;
end;


var p,q,r,t:boolean;
begin p:=StrToBoolDef(ComboBox1.Text,false);ComboBox1.Text:=BoolToStr(p,true);
q:=StrToBoolDef(ComboBox2.Text,false);ComboBox2.Text:=BoolToStr(q,true);
r:=StrToBoolDef(ComboBox3.Text,false);ComboBox3.Text:=BoolToStr(r,true);
t:=(p or q)and r;Edit1.Text:=BoolToStr(t,true);
Button2.SetFocus;
end;
• Саставити програм који одређује истиносну вредност исказа: Број а је дељив бројем б,
где су а и б дати цели бројеви.
poScreenCenter.
кацију са корисником, два едита за унос, едит за испис резултата
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Дељи
вост бројева; Font = BoldItalic, 22; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = 70; Top = (100, 150); Width = 120;
Font = Bold, Black; Left = 70; ReadOnly = True; Top = 200; Width =
120.
AutoSize = False; Caption = (a =, b =, t =); Height = 34; Layout = tlCenter; Left = 30; Top = (100, 150, 200);
Width = 40.
Сачуваћемо дизајнирану форму у креирани фолдер Logika2, а затим, двокликом мишем на тастере
end;
Edit3.Clear;
Edit1.SetFocus;
end;
var t:boolean;
a,b:integer;
t:=a mod b = 0;Edit3.Text:=BoolToStr(t,true);
Button2.SetFocus;
end;
• Саставити програм који са тастатуре прихвата једну реч и једно слово, а затим
одређује дужину уписане речи и редни број уписаног слова ако је у речи.
BorderIcons = []; BorderStyle = bsSingle; Caption = ЛОГИЧКИ ТИП; ClientHeight = 320; ClientWidth = 360;
poScreenCenter.
На форму ћемо ставити лабелу за наслов, четири лабеле за комуникацију са корисником, два едита за
унос, два едита за испис резултата и три тастера за управљање апликацијом.
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Дужина речи и позиција; Font = BoldItalic,
22; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = 180; Top = (80, 130); Width = (170, 40);
Font = Bold, Black; Left = 180; ReadOnly = True; Top = (200, 250); Width = 40.
AutoSize = False; Caption = (Упишите реч, Упишите слово, Број
слова у речи, Редни број слова); Height = 34; Layout = tlCenter; Left
= 10; Top = (80, 130, 200, 250); Width = 170.
230; Top = (130, 190, 270); Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер String1, а
end;
Edit1.SetFocus;
end;
var a,b:string;
c,d:integer;
begin a:=Edit1.Text;
b:=Edit2.Text;
c:=Length(a);Edit3.Text:=IntToStr(c);
d:=Pos(b,a); Edit4.Text:=IntToStr(d);
Button2.SetFocus;
end;
• Саставити програм који са тастатуре прихвата једну реч и цео број, а затим из
унете речи издваја са почетка и са краја речи унети број слова.
poScreenCenter.
Издвајање подстрингова; Font = BoldItalic, 22; Height = 50; Layout =
tlCenter.
Font = Bold, Black; Left = 180; Top = (80, 120); Width = (170, 40);
Width = 170.
AutoSize = False; Caption = (Упишите реч, Упишите број, Слова с почетка, Слова с краја); Height = 34;
Layout = tlCenter; Left = 10; Top = (80, 130, 200, 250); Width = 170.
Caption = (Издвоји, Обриши, Крај рада); Font = Bold; Height = 40; Left = (230, 50, 230); Top = (130, 270, 270);
Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер String2, а затим, двокликом мишем на тастере
end;
Edit1.SetFocus;
end;


var a,b:string;
n:integer;
n:=StrToIntDef(Edit2.Text,0);Edit2.Text:=IntToStr(n);
b:=Copy(a,1,n); Edit3.Text:=b;
Delete(a,1,Length(a)-n);Edit4.Text:=a;
// b:=Copy(a,Length(a)-n+1,n);Edit4.Text:=b;
Button2.SetFocus;
end;
• Саставити програм који са тастатуре прихвата једну реч и два слова, а затим у
унетој речи на клик тастера прво уписано слово (ако постоји у речи) замењује другим
уписаним словом.
poScreenCenter.
никацију са корисником, три едита за унос, едит за испис
Издвајање подстрингова; Font = BoldItalic, 22; Height = 50; Layout
= tlCenter.
Font = Bold, Black; Left = 180; Top = (70, 120, 170); Width = (170, 40, 40);
AutoSize = False; Caption = (Упишите реч, Мења се слово, Мења се слово, Нова реч); Height = 34; Layout =
tlCenter; Left = 10; Top = (80, 130, 200, 250); Width = 170.
Caption = (Замени, Обриши, Крај рада); Font = Bold; Height = 40; Left = 230; Top = (120, 170, 270); Width =
120.
end;
Edit1.SetFocus;
end;
Двоклик на тастер Замени:
var b,c:string;
n,m:integer;
begin b:=Edit2.Text;c:=Edit3.Text;
m:=Length(a); n:=Pos(b,a);
Delete(a,n,1);Insert(c,a,n);
a:=Copy(a,length(a)-m+1,m);Edit4.Text:=a;
Button2.SetFocus;
end;
Реч a мора да се чита изван радне процедуре, иначе ће се само прво појављивање
изабраног слова мењати другим словом. То ћемо остварити процедуром која представља
реакцију на излазак из првог едита - Edit1Exit, кликнемо једном на први едит, па у прозору
Object Inspector на листићу Events пронађемо догађај OnExit. Двокликом у поље вредности
дефинисаћемо процедуру:
procedure TForm1.Edit1Exit(Sender: TObject);
end;

Да би се вредност променљиве a преносила из процедуре у процедуру она мора бити глобална, тј. на
почетку програма у делу за декларације који почиње службеном речи Var треба да додамо декларацију:
a:string;
• Саставити програм који са тастатуре прихвата једну реч, а затим на клик тастера
у унетој речи прво слово премешта на крај речи.
poScreenCenter.
На форму ћемо ставити лабелу за наслов, лабелу за комуни-
кацију са корисником, едит за унос и испис резултата и три
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Пре
мештање слова; Font = BoldItalic, 22; Height = 50; Layout = tlCenter.
Едит за унос и испис:
Font = Bold, Black; Left = 180; Top = 70; Width = 170;
AutoSize = False; Caption = Упишите реч; Height = 34; Layout = tlCenter; Left = 10; Top =70; Width = 170.
Caption = (Премести, Обриши, Крај рада); Font = Bold; Height = 40; Left = (60, 230, 230); Top = (120, 120, 180);
Width = 120.
end;
Edit1.SetFocus;
end;
Двоклик на тастер Премести:
var a:string;
a:=Copy(a,2,length(a)-1)+Copy(a,1,1);
Edit1.Text:=a;
Button2.SetFocus;
end;
• Саставити програм који са тастатуре прихвата једну реч, а затим је исписује са

свим малим и свим великим словима (наизменично на клик тастера).
poScreenCenter.
кацију са корисником, едит за унос, едит за испис резултата и
четири тастера за управљање апликацијом.
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Пре
мештање слова; Font = BoldItalic, 22; Height = 50; Layout = tlCenter.
AutoSize = False; Caption = Упишите реч; Height = 34; Layout = tlCenter; Left = 20; Top =(80, 180); Width = 170.
Caption = (Промени, Промени, Обриши, Крај рада); Font = Bold; Height = 40; Left = (160, 160, 40, 240);
Top = (130, 130, 240, 240); Width = 120.
У овом задатку се играмо мађионичара. Кликом на тастер Промени, слова постају мала или велика. Трик
је у постављању два истоветна тастера један преко другога и игрању са њиховом карактеристиком
Visible. Ако су слова мала видљиви тастер је онај који их претвара у велика и обрнуто.

end;
Edit2.Clear;
Label3.Caption:='Сва велика';
Edit1.SetFocus;
end;
Двоклик на тастер Button1 у прозору ObjectTreeView (јер је овај тастер можда преклопљен другим):
var a:string;
a:=UpperCase(a);Edit2.Text:=a;
Label3.Caption:='Сва велика';
Button3.SetFocus;
end;
Двоклик на тастер Button2 у прозору ObjectTreeView (јер је овај тастер можда преклопљен првим):
procedure TForm1.Button2Click(Sender: TObject); // тастер одреди2
var a:string;
a:=LowerCase(a);Edit2.Text:=a;
Label3.Caption:='Сва мала';
Button3.SetFocus;
end;
Задаци за самосталан рад

• Саставити програм који за унети редни број у ASCII табели исписује карактер.
• Саставити програм који одређује збир парних бројева од m до n.
• Саставити програм који одређује збир непарних бројева од m до n.
• Саставити програм који у унетом четвороцифреном броју мења редослед парних и
непарних цифара (прва и трећа цифра мењају места, а друга и четврта).
• Саставити програм који у унетом четвороцифреном броју мења редослед
узастопних цифара (прву са другом и трећу са четвртом).
• Саставити програм који за два оштра угла дата у степенима минутима и
секундама одређује трећи тако да они буду углови једног троугла.
• Саставити програм који одређује збир, разлику, производ и количник два реална броја.
• Саставити програм који одређује катету, висину и оштре углове правоуглог троугла
ако је дата једна катета и хипотенуза.
• Саставити програм који одређује катете и оштре углове правоуглог троугла ако је
дата висина и хипотенуза.
• Саставити програм који одређује обим, површину и углове троугла ако су дате две
странице и висина на трећу.
• Дијагонални пресек квадра је квадрат. Основице квадра су у односу 2:1. Саставити
програм који одређује запремину квадра ако је дата површина.
• Саставити програм који одређује површину и запремину праве, правилне тростране
призме ако је дата површина основе и дијагонала бочне стране призме.
• Саставити програм који одређује површину и запремину коцке ако је дата
дијагонала.
• Саставити програм који одређује површину и запремину праве, правилне
четворостране призме ако су дате дијагонале основе и бочне стране.
• Саставити програм који одређује површину и запремину праве, правилне
шестостране призме ако је дата дијагонала призме и мања дијагонала основе.

Наредбе гранања
Под гранањем у програмирању подразумевамо ситуацију када се једна или више наредби
може, али и не мора извршити у зависности од неког услова.
Наредбе гранања се, често, зову и наредбама преласка, па у том смислу, оне могу бити
условне и безусловне. Ако извршење неке наредбе или групе наредби зависи од неког услова
онда је то наредба условног преласка, у противном је то наредба безусловног преласка.
Наредба безусловног преласка је GOTO наредба, али она није структурисана.
Наредбе условног преласка су структурисане и могу бити:
• If наредба
• Case наредба
If наредба је наредба гранања са највише две гране, док Case наредба може имати
највише 256 грана. Наредба If је општија, односно, сваки задатак са гранањем може се решити
њеним коришћењем. Обрнуто не важи, тј. постоје задаци који се могу решити коришћењем If
наредбе, а не могу се решити помоћу Case наредбе. IF наредба се користи када у зависности од
неког услова треба извршити један од највише два посла.
Синтакса наредбе If
Наредба If може бити потпуна и непотпуна. Потпуна је ако
има обе гране, а непотпуна ако има само једну грану.
Општи облик потпуне If наредбе је:
IF <uslov> THEN <naredba>
ELSE <naredba>;
Општи облик непотпуне If наредбе је:
IF <uslov> THEN <naredba>;
Ако је потребно да се изврши група наредби иза службене речи Then и/или иза службене
речи Else онда је обавезно употребити наредбу састављања за спајање те групе наредби,
односно:
IF <uslov>
THEN Begin <naredbe>
End
ELSE Begin <naredbe>
End;
или
IF <uslov>
THEN Begin <naredbe>
End;
У случају да је услов испуњен извршава се наредба или група наредби иза службене речи
Then, а ако услов није испуњен извршава се наредба или група наредби иза службене речи
Else. Ако нема потребе да се изврши нека наредба у случају неиспуњења услова иза службене
речи Else стоји празна наредба или се овај део наредбе изоставља. Ако нема потребе да се
изврши нека наредба у случају испуњења услова иза службене речи Then обавезно стоји
празна наредба или се услов преформулише тако да изостане потреба за службеном речи Else.
Другим речима грана која почиње службеном речи Then је обавезна, тј. не може се изоставити,
док се грана која почиње службеном речи Else може изоставити, ако се тиме не утиче на даљи
ток програма.
Непосредно пре резервисане речи Else не сме се употребити граничник ; већ се као
граничник наредбе употребљава размак.
Након извршења наредбе или групе наредби иза службене речи Then прелази се на прву
наредбу испод IF наредбе, тј. не постоји начин да се изврши наредба или група наредби које
стоје иза Then, а затим и наредба или група наредби која стоји иза Else.
У оквиру наредби било које од грана IF наредбе може се наћи друга или више других IF
наредби. У том случају треба водити рачуна о томе да се програмски преводилац, када наиђе
на службену реч Else, враћа све до прве претходне службене речи IF и затвара је. Ако су све IF
наредбе потпуне неће бити проблема са ужљебљењем. Али ако су неке од наредби непотпуне,
(код програмера) може доћи до забуне (што може довести до алгоритамске грешке или до
добијања чудних, неочекиваних резултата у раду програма). У таквим случајевима,
ужљебљене непотпуну IF наредбу у Then грани, обавезно, треба писати у оквиру наредбе
састављања (без обзира на то што се, можда, у тој грани извршава само једна наредба):
IF <uslov1>
THEN Begin IF <uslov2>
THEN <naredba1>;
End
ELSE <naredba2>;
<naredba3>;
Ако би се изоставила наредба састављања у случају да није испуњен <услов2> извршила
би се <наредба2> иза службене речи Else, а у случају неиспуњења првог услова извршила би се
прва наредба испод службене речи Else што би било логичка грешка и довело би до грешке у
неким резултатима програма, овако, у случају да тај <услов2> није испуњен, прелази се на
<наредбу3>.
У случају да се непотпуна IF наредба налази иза службене речи Else наредба састављања
није неопходна (али се може користити), јер је онда сасвим јасно која се наредба извршава у
случају да неки од услова није испуњен:
IF <uslov>
THEN <naredba1>
ELSE IF <uslov2>
THEN <naredba2>;
<naredba3>;
Синтакса наредбе Case

Када је услов за гранање сложенији, тј. када захтева
неколико грана (више од две) јер има више случајева који
захтевају извршење различитих наредби, проблем се
може решити вишеструком употребом IF наредбе уз
преформулисање самог услова у неколико једноставнијих
услова, али је, увек, много лакше, практичније и
једноставније употребити наредбу CASE.
Општи облик ове наредбе је:
CASE <izraz> OF
<slucaj1> : <naredba>;
<slucaj3>, <slucaj4>, ... , <slucajK> : <naredba>;
<slucajK+1> .. <slucajK+M> : <naredba>;
:
<slucajN> : <naredba>;
ELSE <naredba>;
END;
Службена реч End, на крају CASE наредбе је обавезна и не сме се изоставити. Број
случајева зависи од броја вредности селектора које захтевају различите активности (наредбе), а
највише их може бити 255. У случају да селектор <izraz> може имати више од 255 вредности
морамо комбиновати две или више CASE наредби.
У CASE наредби селектор <izraz> мора бити простог, уређеног типа (boolean, char, integer),
а случајеви тј. вредности <izraz>-а могу бити задате као
• појединачне вредности (<slucaj1> или <slucaj2>),
• групе (<slucaj3>, <slucaj4>, ... , <slucajK>) или
• интервали вредности (<slucajK+1> .. <slucajK+M>).
Код групних случајева морају се навести све вредности које захтевају извршење исте
наредбе. Код интервала се подразумева да се наредба извршава за све вредности од почетне
до крајње вредности интервала, тј. не могу се изузимати неке врдности из унетог интервала.
Else грана обухвата све случајеве који нису претходно поменути. Важно је поменути да
вредности у случајевима не морају бити уређени у растући или опадајући поредак, али није
дозвољено да се нека вредност појављује у два или више случајева.

Ако у неким од случајева (појединачним, групама или интервалима) треба извршити

више од једне наредбе онда те наредбе, обавезно, групишемо наредбом састављања:
CASE <izraz> OF
<slucaj2> : Begin <naredbe>;
End;
<slucaj3>, <slucaj4>, ... , <slucajK> : Begin <naredbe>;
End;
.
:
<slucajN> : <naredba>;
ELSE Begin <naredbe>;
End
END;
Ако потребе алгоритма захтевају, може се у оквиру једне CASE наредбе наћи још једна
или више CASE наредби, но како свака од ових наредби има своје END не може доћи до забуне
који случај припада којем изразу.
До забуне (код програмера) може доћи само код комбиноване употребе CASE и
непотпуне IF наредбе у последњем случају CASE наредбе, када се Else грана може схватити као
део CASE наредбе или као део IF наредбе. Проблем се разрешава тако што се пре Else гране које
припада CASE наредби обавезно ставља као граничник ; што у IF наредби није дозвољено, а
може се и непотпуна IF наредба писати у оквиру наредбе састављања:
CASE <izraz> OF
<slucaj1> : CASE <izraz> OF
<slucaj1> : <naredbe>;
...
<slucajN> : <naredbe>;
ELSE <naredbe>;
END;
...
<slucajM> : If <uslov>
then <naredba>
else <naredba>;
...
<slucajN> : If <uslov>
then <naredba>;
ELSE <naredbe>;
END;
Алгоритми са гранањем
• одређивање минимума и максимума два и три броја
Одређивање већег или мањег од два уписана броја је најједноставнији пример употребе
If наредбе. Може се решити коришћењем додатне променљиве min (max) или без ње.
Једноставније је објаснити пример са додатном променљивом.
• Одређивање већег од два броја:
If a>b
then max:=a
else max:=b;
• Одређивање мањег од два броја:
If a<b
then min:=a
else min:=b;
Ако треба одредити и мањи и већи од два броја онда ћемо спојити ове две наредбе у једну:
If а>b
then begin max:=a;min:=b;
end
else begin min:=a;max:=b;
end;
Нешто је тежи случај када треба одредити најмањи или највећи од три уписана броја јер
се морају упоређивати три броја сваки са сваким. То значи да у овом случају имамо најмање
две If наредбе. И овде ћемо користити додатну променљиву јер је поступак једноставније
објаснити.
• Одређивање највећег од три броја:
If а>b // већи од бројева a и b проглашавамо највећим
then max:=a
else max:=b;

If c>max // проверавамо да ли је трећи број већи од највећег

then max:=c;
• Одређивање најмањег од три броја:

If a<b // мањи од бројева a и b проглашавамо најмањим
then min:=a
else min:=b;
If c<min // проверавамо да ли је трећи број мањи од најмањег
then min:=c;
• Ако треба одредити и најмањи и највећи од три броја онда ћемо то урадити на следећи
начин:
If а>b // већи од бројева a и b проглашавамо највећим, а мањи најмањим
then begin max:=a;min:=b;
end
else begin min:=a;max:=b;
end;
If c>max // проверавамо да ли је трећи број већи од највећег
then max:=c
else If c<min // проверавамо да ли је трећи број мањи од најмањег
then min:=c;
Могући су и неки другачији алгоритми, али, чини се, да је овај врло једноставан и
прилично разумљив.
• уређивање два и три броја у монотоно неопадајући или нерастући поредак
Ако је потребно три броја уредити по величини онда није довољно само упоредити сваки
са сваким, већ се морају и размењивати вредности између променљивих које нису у жељеном
поретку. Зато је овај пример комбинација одређивања максимума и минимума и размене
вредности два броја. Проблем ћемо решити тако што ћемо, најпре, упоређивати два броја и
наместити да први буде мањи од другог, а затим ћемо трећи број упоређивати са сваким од
претходна два и, по потреби, размењивати вредности. Записаћемо то овако:
If a>b
then begin pom:=a;a:=b;b:=pom;
end;
If a>c
then begin pom:=a;a:=c;c:=pom;
end;
If b>c
then begin pom:=b;b:=c;c:=pom;
end;
Овакво уређење чини растући (прецизније, неопадајући поредак јер нико не гарантује да
неки од ова три броја нису једнаки). Посматрајмо то на једноставном, конкретном примеру у
табели у којој сваки ред представља један алгоритамски корак:
a b c шта се дешава
7 3 6
3 7 6 упоређујемо прва два броја и пошто је први већи мењамо им места
3 7 5 упоређујемо први и трећи број и пошто је трећи већи ништа се не мења
3 5 7 упоређујемо други и трећи број и пошто је други већи мењамо им места
Ако би требало бројеве уредити у опадајући (односно, нерастући) поредак, једина измена
била би промена релације веће у мање (или се бројеви уреде као у претходном примеру, а
исписују се обрнутим редоследом). Следећи низ наредби уређује бројеве у такав поредак:
If a<b
then begin pom:=a;a:=b;b:=pom;
end;
If a<c
then begin pom:=a;a:=c;c:=pom;
end;
If b<c
then begin pom:=b;b:=c;c:=pom;
end;
• одређивање сутрашњег и јучерашњег датума

Код задатака са датумима мора се водити рачуна о томе да немају сви месеци једнак број
дана и да је број дана у години ограничен на 365, односно, 366 код преступне године.
Максимални број дана у месецу сви знамо, зато ћемо се подсетити правила која дефинишу да
ли је година преступна. Већина би сваку четврту годину прогласила преступном, односно, ако је
година дељива са четири она је преступна. Међутим то је погрешно, јер је познато да је 1900.
година број који је дељив са 4, али та година није била преступна. Зато није довољно
проверити да ли је година дељива са 4 да би се утврдило да ли је преступна, већ не сме бити

последња година века, тј. не сме бити дељива са 100. Но и то није комплетан услов јер је 2000.
година дељива са 100, а била је преступна. Зато, комплетан услов, да би нека година била
преступна, гласи:
година је преступна ако је дељива са 4 и није дељива са 100 или ако је дељива са 400.
Када смо ово утврдили можемо одредити сутрашњи датум ако је дат данашњи. У већини
случајева, сутрашњи датум је за један дан већи од данашњег. Ово правило не важи само ако је
данас последњи дан у месецу. У том случају сутра је први дан следећег месеца. Да бисмо знали
да ли је последњи дан у месецу морамо тестирати редни број месеца и редни број дана из
данашњег датума. Редни број месеца може да се повећа за један само ако данашњи датум није
31.12. неке године. У том случају сутрашњи датум је 1.1. следеће године. Сада ћемо написати,
уз објашњења у коментарима, главни део програма који прати описани алгоритам:
If (g mod 4=0)and(g mod 100<>0) // ако је година дељива са 4 и ако није дељива са 100
or(g mod 400=0) // или ако је дељива са 400
then p:=1 // година је преступна
else p:=0; // у противном година није преступна
Case m of // сада одређујемо максимални број дана у месецу
2 : bd:=28+p; // ако је фебруар има 28 или 29 дана
4,6,9,11 : bd:=30; // четири месеца у години имају по 30 дана
else bd:=31; // остали месеци имају по 31 дан
end;
d:=d+1; // сутрашњи датум је за 1 већи
If d>bd // ако је редни број дана већи од максималног броја дана
then begin d:=1; // прешли смо у други месец, односно, датум је 1.
m:=m+1; // у том случају месец је за 1 већи
end;
If m>12 // ако смо добили редни број месеца већи од 12
then begin m:=1; // прешли смо у другу годину, односно, месец је 1.
g:=g+1; // у том случају година је за 1 већа
end;
Сада треба исписати сутрашњи датум : d, m, g.
Алгоритам за одређивање јучерашњег датума ћемо исписати без објашњења јер је
прилично јасан, ако смо овај претходни добро разумели:
If (g mod 4=0)and(g mod 100<>0)or(g mod 400=0)
then p:=1
else p:=0;
Case m-1 of
2 : bd:=28+p;
4,6,9,11 : bd:=30;
else bd:=31;
end;
d:=d-1;
If d<1
then begin d:=bd;m:=m-1;
end;
If m<1
then begin m:=12;g:=g-1;
end;
Case наредбу коју смо користили у оба алгоритма, лако смо могли заменити са две If
наредбе, али је овакво решење ефектније. У проблемима са датумима требало би, пре извршења
приказаних и сличних алгоритама, тестирати унете податке. Било би бесмислено тражити
сутрашњи или јучерашњи ако је унети датум 33.13. било које године.
• приказ назива дана у недељи на основу учитаног редног броја дана
Овај пример је демонстрација предности Case у односу на If наредбу (у сличним
ситуацијама). Редни број дана у недељи једнозначно одређује назив дана. Будући да је ово
врло једноставан пример, нећемо се задржавати на непотребним објашњењима, али ћемо
навести прво решење са Case, а затим и са If наредбом ради упоређења.
Case rb of
1 : ime:='Prvi dan u nedelji je ponedeljak.';
2 : ime:='Drugi dan u nedelji je utorak.';
3 : ime:='Treci dan u nedelji je sreda.';
4 : ime:='Cetvrti dan u nedelji je cetvrtak.';
5 : ime:='Peti dan u nedelji je petak.';
6 : ime:='Sesti dan u nedelji je subota.';
7 : ime:='Sedmi dan u nedelji je nedelja.';
else ime:='Pogresan unos rednog broja dana u nedelji.';
end;

If rb = 1
then ime:='Prvi dan u nedelji je ponedeljak.'
else If rb = 2 then ime:='Drugi dan u nedelji je utorak.'
else If rb = 3 then ime:='Treci dan u nedelji je sreda.'
else If rb = 4 then ime:='Cetvrti dan u nedelji je cetvrtak.'
else If rb = 5 then ime:='Peti dan u nedelji je petak.'
else If rb = 6 then ime:='Sesti dan u nedelji je subota.'
else If rb = 7 then ime:='Sedmi dan u nedelji je nedelja.'
else ime:='Pogresan unos rednog broja dana u nedelji.';
end;
• приказ назива дана у недељи на основу учитаног редног броја дана

Овај пример је још једна демонстрација предности Case у односу на If наредбу. Редни број
месеца у години једнозначно одређује назив месеца. Будући да је ово врло једноставан
пример, нећемо се задржавати на непотребним објашњењима, али ћемо и овде навести прво
решење са Case, а затим и са If наредбом ради упоређења.
Case rb of
1 : ime:='Prvi mesec u godini je januar.';
2 : ime:='Drugi mesec u godini je februar.';
3 : ime:='Treci mesec u godini je mart.';
4 : ime:='Cetvrti mesec u godini je april.';
5 : ime:='Peti mesec u godini je maj.';
6 : ime:='Sesti mesec u godini je jun.';
7 : ime:='Sedmi mesec u godini je jul.';
8 : ime:='Osmi mesec u godini je avgust.';
9 : ime:='Deveti mesec u godini je septembar.';
10: ime:='Deseti mesec u godini je oktobar.';
11: ime:='Jedanaesti mesec u godini je novembar.';
12: ime:='Dvanaesti mesec u godini je decembar.';
else ime:='Pogresan unos rednog broja meseca u godini.';
end;
If rb = 1
then ime:='Prvi mesec u godini je januar.'
else If rb = 2 then ime:='Drugi mesec u godini je februar.'
else If rb = 3 then ime:='Treci mesec u godini je mart.'
else If rb = 4 then ime:='Cetvrti mesec u godini je april.'
else If rb = 5 then ime:='Peti mesec u godini je maj.'
else If rb = 6 then ime:='Sesti mesec u godini je jun.'
else If rb = 7 then ime:='Sedmi mesec u godini je jul.'
else If rb = 8 then ime:='Osmi mesec u godini je avgust.';
else If rb = 9 then ime:='Deveti mesec u godini je septembar.';
else If rb = 10 then ime:='Deseti mesec u godini je oktobar.';
else If rb = 11 then ime:='Jedanaesti mesec u godini je novembar.';
else If rb = 12 then ime:='Dvanaesti mesec u godini je decembar.';
else ime:='Pogresan unos rednog broja meseca u godini.';
end;
У примерима са редним бројевима дана и месеца, тестирали смо и исправност унетих
података.

• Шта је гранање?
• Врсте гранања.
• Синтакса If наредбе
• Ужљебљене If наредбе
• Непотпуна If наредба
• Else грана у If наредби
• Синтакса Case наредбе
• Селектор у Case наредби
• Случајеви у Case наредби
• Else грана у Case наредби
• Case наредба у Case наредби
• If наредба у Case наредби

Задаци са гранањем
• Саставити програм који испитује да ли је уписани број паран.

BorderIcons = []; BorderStyle = bsSingle; Caption = НАРЕДБЕ
ГРАНАЊА; ClientHeight = 310; ClientWidth = 350; Color = Teal; Font =
Palatino Linotype, BoldItalic, 16, Aqua; FormStyle = fsStayOnTop;
са корисником, едит за унос, лабелу за испис резултата и три
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Да ли је
број паран?; Font = 22, Lime; Height = 50; Layout = tlCenter.
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = ;
AutoSize = False; Caption = Упишите цео број; Height = 36; Layout = tlCenter; Left = 20; Top = 80; Width = 190.
Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер Paran, а затим, двокликом мишем на тастере редом
Двокликом на тастер Крај рада дефинисаћемо процедуру којом се прекида извршење програма.
Label3.Caption:=' ';
Edit1.SetFocus;
end;
var a:string;
b:integer;
begin b:=StrToIntDef(Edit1.Text,0);Edit1.Text:=IntToStr(b);
If Odd(b)
then a:='Број '+IntToStr(b)+' је непаран.'
else a:='Број '+IntToStr(b)+' је паран.';
Label3.Caption:=a;
Button2.SetFocus;
end;
• Саставити програм који испитује да ли су два уписана броја дељива.

За два броја кажемо да су дељива ако један од њих при дељењу другим даје остатак 0.
ГРАНАЊА; ClientHeight = 350; ClientWidth = 350; Font = Palatino
poScreenCenter.
са корисником, два едита за унос, лабелу за испис резултата и три
Дељивост бројева; Font = 22, Lime; Height = 50; Layout = tlCenter.
AutoSize = False; Caption = (Први број, Други број); Height = 36;
Layout = tlCenter; Left = 60; Top = (80, 130); Width = 190.
Caption = (Одреди, Обриши, Крај рада); Font = Bold; Height = 40; Left = (50, 190, 190); Top = (180, 180,
230); Width = 120.

Сачуваћемо дизајнирану форму у креирани фолдер Paran, а затим, двокликом мишем на тастере редом
Edit1.SetFocus;
end;
var a:string;
b,c:integer;
begin b:=StrToIntDef(Edit1.Text,0); Edit1.Text:=IntToStr(b);
c:=StrToIntDef(Edit2.Text,0); Edit2.Text:=IntToStr(c);
If b mod c=0
then a:='Број '+IntToStr(b)+' је дељив бројем '+IntToStr(c)+'.'
else If c mod b=0
then a:='Број '+IntToStr(c)+' је дељив бројем '+IntToStr(b)+'.'
else a:='Бројеви нису дељиви.';
Label4.Caption:=a;
Button2.SetFocus;
end;
• Саставити програм који тестира да ли је на тастатури притиснуто слово, цифра

или знак.
На тастатури је велики број тастера, да не бисмо користили јако сложене if наредбе или велики број
наредби у решењу овог задатка користићемо предности скуповног типа. Тастере ћемо груписати у
скуп слова (при чему ћемо користити само велика слова да бисмо поједноставили запис решења), скуп
цифара и остале.
Linotype, 22; FormStyle = fsStayOnTop; Position = poScreenCenter.
На форму ћемо ставити лабелу за наслов, лабелу за испис
резултата и тастер за управљање апликацијом.
Притисните неки тастер; Height = 50; Layout = tlCenter.
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = ; Height = 90; Layout = tlCenter.
Тастер за управљање:
Caption = Крај рада; Font = Bold; Height = 40; Left = (50, 190, 190); Top = (180, 180, 230); Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер Taster, а затим, двокликом мишем на тастер Крај
рада дефинисаћемо процедуру којом се прекида извршење програма.
У прозору Object Inspector, најпре треба селектовати форму (објекат Form1), а затим прећи на листић
Events и двокликом на догађај OnKeyPress декларисати и дефинисати следећу процедуру:
procedure TForm1.FormKeyPress(Sender: TObject; var Key: Char);
var a:string;
begin If UpCase(key) in ['A'..'Z']
then a:='Притиснуто је слово '+key
else if key in ['0'..'9']
then a:='Притиснута је цифра '+key
else a:='Притиснут је знак '+key;
Label2.Caption:=a;
end;
• Саставити програм који за унету годину одређује да ли је година преступна.

Година је преступна ако је дељива са 4 и није дељива са 100 или ако је дељива са 400. То значи да је 2000.
била преступна, 1900. није, свака четврта између је била преступна, а 2100. неће бити.
BorderIcons = []; BorderStyle = bsSingle; Caption = НАРЕДБЕ ГРАНАЊА; ClientHeight = 310; ClientWidth =
350; Color = Teal; Font = Palatino Linotype, BoldItalic, 16, Aqua; FormStyle = fsStayOnTop; Position =
poScreenCenter.
На форму ћемо ставити лабелу за наслов, лабелу за комуникацију са корисником, едит за унос, лабелу
за испис резултата и три тастера за управљање апликацијом.
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Преступна година; Font = 22, Lime; Height
= 50; Layout = tlCenter.

AutoSize = False; Caption = Упишите цео број; Height = 36; Layout =
tlCenter; Left = 20; Top = 80; Width = 190.
Left = (20, 210, 210); Top = (150, 150, 210); Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер Prestupna, а
Двокликом на тастер Крај рада дефинисаћемо процедуру којом
се прекида извршење програма.
Edit1.SetFocus;
end;
var a:string;g:integer;
begin g:=StrToIntDef(Edit1.Text,0);Edit1.Text:=IntToStr(g);
then a:=IntToStr(g)+'. година'+#13+'је преступна.'
else a:=IntToStr(g)+'. година'+#13+'није преступна.';
Label3.Caption:=a;
Button2.SetFocus;
end;
• Саставити програм који одређује решење линеарне једначине са једном непознатом.

Линеарну једначину можемо решити на следећи начин:
Ако је линеарни коефицијент једначине различит од нуле онда
једначина има јединствено решење: b
a  x  b  0 a  x  b x
Ако је линеарни коефицијент једнак нули онда имамо овакву :a  0 a
ситуацију 0 x + b = 0 и два случаја:
- ако је слободни члан b = 0 решење једначине је било који број, односно једначина је неодређена,
- ако је слободни члан b  0 различит од нуле једначина нема решења, односно, једначина је немогућа.
Значи, након уноса коефицијената, најпре тестирамо линеарни члан, а затим слободни члан, па затим
исписујемо одговарајући коментар и решење једначине.
poScreenCenter.
са корисником, два едита за унос, лабелу за испис резултата и три
Линеарна једначина; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = (70, 220); Top = 80; Width = 100.
AutoSize = False; Caption = (a =, b =); Height = 36; Layout = tlCenter; Left = (30, 180); Top = 80; Width = 40.
180); Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер Linearna, а затим, двокликом мишем на тастере

Edit1.SetFocus;
end;
var a:string;
b,c:real;
begin b:=StrToFloatDef(Edit1.Text,1);Edit1.Text:=FloatToStr(b);
c:=StrToFloatDef(Edit2.Text,2);Edit2.Text:=FloatToStr(c);
a:=Format('%-27s'+#13+'%1.2f',['Једначина',b])+#183+'х';
If c>=0 then a:=a+' + ';
a:=a+Format('%1.2f',[Abs(c)])+' = 0'+#13;
If b=0
then If c=0
then a:=a+'је неодређена.'
else a:=a+'је немогућа.'
else a:=a+'има решење х = '+Format('%1.2f',[-c/b]);
Label4.Caption:=a;
end;
У испису решењу смо користили ASCII кодове #13, за прелазак у нови ред и #183 за ознаку множења.
као и формат '%-30s' за лево уређење стринга.
• Саставити програм који одређује решење система од две линеарне једначине са две
непознате.
Посматраћемо систем од две линеарне једначине са две непознате у општем  a1  x  b1  y  c1
облику. За налажење решења применићемо методу детерминанти (исте 
формуле за решење добијају се и применом неке друге методе, али је овако a 2  x  b 2  y  c 2
једноставније објаснити поступак решавања система). a1 b1
Ако је детерминанта система различита од нуле (D0) D  a1  b 2  a 2  b1
a2 b2
систем има јединствено решење: x = Dx / D и y = Dy / D.
Ако је детерминанта система једнака нули (D = 0) и бар једна од детерминанти c1 b1
Dx   c1  b 2  c2  b1
по х или по у је различита од нуле (Dx  0 или Dy 0) c2 b2
систем је немогућ, односно, нема решења, у противном систем је
неодређен, односно, има бесконачно много решења. a1 c1
Dy   a1  c2  a 2  c1
Подесићемо карактеристике форме на следећи начин: a 2 c2
poScreenCenter.
кацију са корисником, шест едита за унос, лабелу за испис
Линеарни систем; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = (65, 190, 315); Top = (80, 120); Width = 70.
AutoSize = False; Caption = (a1 =, b1 =, c1 =, a2 =, b2 =, c2 =); Height = 36;
Layout = tlCenter; Left = (20, 145, 270); Top = (80, 120); Width = 40.
Сачуваћемо дизајнирану форму у креирани фолдер Sistem, а затим, двокликом мишем на тастере редом
Edit1.SetFocus;
end;


var s:string;
a1,b1,c1,a2,b2,c2,d,dx,dy:real;
begin a1:=StrToFloatDef(Edit1.Text,1);Edit1.Text:=FloatToStr(a1);
b1:=StrToFloatDef(Edit2.Text,2);Edit2.Text:=FloatToStr(b1);
c1:=StrToFloatDef(Edit3.Text,3);Edit3.Text:=FloatToStr(c1);
a2:=StrToFloatDef(Edit4.Text,4);Edit4.Text:=FloatToStr(a2);
s:=Format('%-27s'#13'%1.2f'#183'?',['Линеарни систем',a1]);
If b1>=0 then s:=s+'+';
s:=s+Format('%1.2f'#183'y=%1.2f'#13,[b1,c1]);
s:=s+Format('%1.2f'#183'?',[a2]);
If b2>=0 then s:=s+'+';
s:=s+Format('%1.2f'#183'y=%1.2f'#13,[b2,c2]);
d:=a1*b2-a2*b1;
dx:=c1*b2-c2*b1;
dy:=a1*c2-a2*c1;
If d=0
then If (dx=0)and(dy=0)
then s:=s+' је неодређен.'
else s:=s+' је немогућ.'
else s:=s+Format('%-27s'#13'?=%-11.2f'#13'y=%-11.2f',['има решење:',dx/d,dy/d]);
Label8.Caption:=s;
Button2.SetFocus;
end;
• Саставити програм који одређује решење система од три линеарне једначине са три
непознате.
Посматраћемо систем од три линеарне једначине са три непознате  a1  x  b1  y  c1  z  d1

у општем облику: a2  x  b2  y  c2  z  d 2
За налажење решења система применићемо методу детерминанти. a  x  b  y  c  z  d
 3 3 3 3
Одредићемо детерминанту система и детерминанте променљивих. a1 b1 c1
Ако је детерминанта система различита од нуле (D 0) систем b c b c b c
D  a2 b2 c2  a1  2 2  a2  1 1  a3  1 1
има јединствено решење. b3 c3 b3 c3 b2 c2
a3 b3 c3
Ако је детерминанта система једнака нули (D = 0) и бар једна од
детерминанти Dx, Dy и Dz је различита од нуле (Dx 0, Dy 0 или d1 b1 c1
b c b c b c
Dz  0) систем је немогућ. Dx  d 2 b2 c2  d1  2 2  d2  1 1  d3  1 1
b3 c3 b3 c3 b2 c2
Ако је детерминанта система једнака нули (D = 0) и ако су све d3 b3 c3
детерминанте променљивих једнаке нули (Dx = 0, Dy = 0 и Dz = 0) a1 d1 c1
онда се мора применити метода елиминације (Гаусова или нека d c d c d c
Dy  a2 d2 c2  a1  2 2  a2  1 1  a3  1 1
друга) да би смо утврдили да ли систем има бесконачно решења a3 d3 c3
d3 c3 d3 c3 d 2 c2
или нема решења. Овај део анализе је (у овом тренутку за нас)
мало теже испрограмирати, па ћемо у том случају само исписати a1 b1 d1
b d2 b d b d
поруку да систем нема једнозначно решење, односно, да је можда Dz  a2 b2 d 2  a1  2  a2  1 1  a3  1 1
b3 d3 b3 d3 b2 d 2
неодређен или немогућ. a3 b3 d3
poScreenCenter.
На форму ћемо ставити лабелу за наслов, дванаест лабела за
комуникацију са корисником, дванаест едита за унос, лабелу за
Линеарни систем; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = (55, 160, 265, 370); Top = (80, 120, 160);
Width = 50.
Font = Lime; Height = 150; Layout = tlCenter.
AutoSize = False; Caption = (a1 =, b1 =, c1 =, d1 =, a2 =, b2 =, c2 =, d2 =, a3 =, b3 =, c3 =, d3); Height = 36; Layout
= tlCenter; Left = (10, 115, 220, 315); Top = (80, 120, 160); Width = 45.
Caption = (Одреди, Обриши, Крај рада); Font = Bold; Height = 40; Left = (15, 140, 265); Top = 170; Width =
120.

Сачуваћемо дизајнирану форму у креирани фолдер Sistem, а затим, двокликом мишем на тастере редом
Label14.Caption:='';
Edit1.SetFocus;
end;
var s:string;
a1,b1,c1,d1,a2,b2,c2,d2,a3,b3,c3,d3,d,dx,dy,dz:real;
begin a1:=StrToFloatDef(Edit1.Text,1); Edit1.Text:=FloatToStr(a1);
b1:=StrToFloatDef(Edit2.Text,2); Edit2.Text:=FloatToStr(b1);
c1:=StrToFloatDef(Edit3.Text,3); Edit3.Text:=FloatToStr(c1);
d1:=StrToFloatDef(Edit4.Text,4); Edit4.Text:=FloatToStr(d1);
a2:=StrToFloatDef(Edit5.Text,5); Edit5.Text:=FloatToStr(a2);
b2:=StrToFloatDef(Edit6.Text,6); Edit6.Text:=FloatToStr(b2);
c2:=StrToFloatDef(Edit7.Text,7); Edit7.Text:=FloatToStr(c2);
d2:=StrToFloatDef(Edit8.Text,8); Edit8.Text:=FloatToStr(d2);
a3:=StrToFloatDef(Edit9.Text,9); Edit9.Text:=FloatToStr(a3);
d3:=StrToFloatDef(Edit12.Text,3);Edit12.Text:=FloatToStr(d3);
s:=Format('%-30s'+#13+'%1.2f',['Линеарни систем',a1])+#183+'х';
If b1>=0 then s:=s+'+';
s:=s+Format('%1.2f'#183'y',[b1]);
If c1>=0 then s:=s+'+';
s:=s+Format('%1.2f'#183'z=%1.2f'#13'%1.2f'#183'х',[c1,d1,a2]);
If b2>=0 then s:=s+'+';
s:=s+Format('%1.2f'#183'y',[b2]);
If c2>=0 then s:=s+'+';
s:=s+Format('%1.2f'#183'z=%1.2f'#13'%1.2f'#183'х',[c2,d2,a3]);
If b3>=0 then s:=s+'+';
s:=s+Format('%1.2f'#183'y',[b3]);
If c3>=0 then s:=s+'+';
s:=s+Format('%1.2f'#183'z=%1.2f'#13,[c3,d3]);
d:=a1*b2*c3-a1*b3*c2-a2*b1*c3+a2*b3*c1+a3*b1*c2-a3*b2*c1;
dx:=d1*b2*c3-d1*b3*c2-d2*b1*c3+d2*b3*c1+d3*b1*c2-d3*b2*c1;
dy:=a1*d2*c3-a1*d3*c2-a2*d1*c3+a2*d3*c1+a3*d1*c2-a3*d2*c1;
dz:=a1*b2*d3-a1*b3*d2-a2*b1*d3+a2*b3*d1+a3*b1*d2-a3*b2*d1;
If d=0
then If (dx<>0)or(dy<>0)or(dz<>0)
then s:=s+'је немогућ.'
else s:=s+'је неодређен или немогућ.'
else s:=s+Format('%-30s'#13'х=%1.2f'#13'y=%1.2f'#13'z=%1.2f',
['има решење',dx/d,dy/d,dz/d]);
Label3.Caption:=s;
end;
• Саставити програм који одређује решење квадратне једначине са једном непознатом.

Одредићемо дискриминанту и на основу њеног знака одредити врсту решења, а затим ћемо одредити
решење квадратне једначине. Комплексна решења ћемо исписати као збир реалног и имагинарног дела.
poScreenCenter.
кацију са корисником, три едита за унос, лабелу за испис
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Квад-
ратна једначина; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = (70, 180, 290); Top = 80; Width = 50.
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = ; Font
= Lime; Height = 110; Layout = tlCenter.
AutoSize = False; Caption = (a =, b =, c =); Height = 36; Layout = tlCenter; Left = (30, 140, 250); Top = 80; Width
= 40.
180); Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер Kvadratna, а затим, двокликом мишем на тастере
Edit1.SetFocus;
end;
var s:string;
a,b,c,d,x:real;
begin a:=StrToFloatDef(Edit1.Text,1); Edit1.Text:=FloatToStr(a);
b:=StrToFloatDef(Edit2.Text,2); Edit2.Text:=FloatToStr(b);
c:=StrToFloatDef(Edit3.Text,1); Edit3.Text:=FloatToStr(c);
s:=Format('%-27s'#13'%1.2f'#183'х2',['Решења једначине',a]);
If b>=0 then s:=s+'+';
s:=s+Format('%1.2f'#183'x',[b]);
If c>=0 then s:=s+'+';
s:=s+Format('%1.2f = 0'#13,[c]);
d:=b*b-4*a*c; x:=Sqrt(Abs(d));
If d=0
then s:=s+Format('%-27s'#13'%-10s%1.2f',['су реална и једнака:','х1 = x2 =',-b/2/a])
else If d>0
then s:=s+'су реална и различита: '+#13+' х1 = '
+Format('%1.2f'#13' х2 = %1.2f',[(-b+x)/2/a,(-b-x)/2/a])
else s:=s+'су коњуговано комплексна: '+#13+' х1 = '
+Format('%1.2f+%1.2f'#183'i'#13' х2 = ',[-b/2/a,x/2/a])
+Format('%1.2f-%1.2f'#183'i',[-b/2/a,x/2/a]);
Label5.Caption:=s;
Button2.SetFocus;
end;
• Саставити програм који одређује квадрант у коме се налази дата тачка у равни.
Раван је двема ортогоналним правама подељена на четири дела, квадранта. У зависности од знака
координата тачке пронаћи ћемо њен положај.
poScreenCenter.
кацију са корисником, два едита за унос, лабелу за испис
Координатна раван; Font = 22, Lime; Height = 50; Layout = tlCenter.
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = ; Font = Lime; Height = 70; Layout = tlCenter.
AutoSize = False; Caption = (х =, у =); Height = 36; Layout = tlCenter; Left = 30; Top = (80, 130); Width = 40.
180); Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер Kvadranti, а затим, двокликом мишем на тастере
Label3.Caption:='';
Edit1.SetFocus;
end;


var s:string;
x,y:real;
begin x:=StrToFloatDef(Edit1.Text,1);Edit1.Text:=FloatToStr(x);
y:=StrToFloatDef(Edit2.Text,2);Edit2.Text:=FloatToStr(y);
s:=Format('%1s(%1.2f;%1.2f)'#13'%11s',['Тачка A',x,y,'налази се ']);
If (x=0)and(y<>0)
then s:=s+'на x-оси.'
else If (x<>0)and(y=0)
then s:=s+'на y-оси.'
else If (x=0)and(y=0)
then s:=s+'у координатном почетку.'
else If y>0
then If x>0
then s:=s+'у првом квадранту.'
else s:=s+'у другом квадранту.'
else If x>0
then s:=s+'у четвртом квадранту.'
else s:=s+'у трећем квадранту.';
Label4.Caption:=s;
Button2.SetFocus;
end;
• Саставити програм који одређује октант у коме се налази дата тачка у простору.
Простор је трима ортогоналним равнима подељен на осам делова, октанта. У пресеку сваке две равни
налазе се координатне осе. У зависности од знака координата тачке одредићемо и записати њен положај
у координатном простору.
poScreenCenter.
кацију са корисником, три едита за унос, лабелу за испис
Координатни простор; Font = 22, Lime; Height = 50; Layout = tlCenter.
AutoSize = False; Caption = (х =, у =, z =); Height = 36; Layout = tlCenter; Left = 30; Top = (80, 130, 180); Width
= 40.
180); Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер Oktanti, а затим, двокликом мишем на тастере редом
Label5.Caption:='';
Edit1.SetFocus;
end;
var a:string;
x,y,z:real;
begin x:=StrToFloatDef(Edit1.Text,1); Edit1.Text:=FloatToStr(x);
y:=StrToFloatDef(Edit2.Text,2); Edit2.Text:=FloatToStr(y);
z:=StrToFloatDef(Edit3.Text,3); Edit3.Text:=FloatToStr(z);
a:=Format('Тачка А(%1.2f;%1.2f;%1.2f)'#13'налази се ',[x,y,z]);
If x=0
then If y=0
then If z=0
then a:=a+'у координатном почетку.'
else a:=a+'на z-оси.'

else If z=0
then a:=a+'на у-оси.'
else a:=a+'у y-z равни.'
else If y=0
then If z=0
then a:=a+'на x-оси.'
else a:=a+'у x-z равни.'
else If z=0
then a:=a+'у x-y равни.'
else If z>0
then If x>0
then If y>0
then a:=a+'у првом октанту.'
else a:=a+'у другом октанту.'
else If у>0
then a:=a+'у четвртом октанту.'
else a:=a+'у трећем октанту.'
else If x>0
then If y>0
then a:=a+'у петом октанту.'
else a:=a+'у шестом октанту.'
else If у>0
then a:=a+'у осмом октанту.'
else a:=a+'у седмом октанту.';
Label5.Caption:=s;
Button2.SetFocus;
end;
• Саставити програм који три унета броја уређује у неопадајући (нерастући) поредак.
Да бисмо решили овај задатак одредићемо најпре најмањи од унетих бројева, а затим ћемо преостала
два уредити по величини. Идеја је да најмањи број буде први, зато ћемо упоређивати први и други, па, ако
је први већи од другог, заменићемо им места. Затим ћемо упоређивати први и трећи и, ако је први већи,
заменићемо им место. Сада је први број са најмањи (јер је мањи и од другог и од трећег), па сада треба
упоређивати други и трећи број и, ако је други већи од трећег, заменићемо им места. За размену
вредности две променљиве користићемо помоћну променљиву која ће привремено чувати вредност
прве променљиве да би она могла преузети вредност друге, а да се при томе не изгуби њена првобитна
вредност. То значи да се замена вредности две променљиве обавља кроз три наредбе: (помоћна
променљива узима вредност прве променљиве) p:=a; (прва променљива узима вредност друге
променљиве) a:=b; (друга променљива узима вредност помоћне променљиве, тј. претходну вредност
прве променљиве) b:=p; Ово је стандардна процедура замене вредности две променљиве.
poScreenCenter.
цију са корисником, три едита за унос, лабелу за испис резултата
Сортирање; Font = 22, Lime; Height = 50; Layout = tlCenter.
AutoSize = False; Caption = (a =, b =, c =); Height = 36; Layout = tlCenter; Left = 30; Top = (80, 130, 180); Width
= 40.
180); Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер Rastuci, а затим, двокликом мишем на тастере редом
Label5.Caption:='';
Edit1.SetFocus;
end;


var s:string;
a,b,c,p:integer;
s:='Неопадајући поредак'+#13;
If a>b
then begin p:=a;a:=b;b:=p;
end;
If a>c
then begin p:=a;a:=c;c:=p;
end;
If b>c
then begin p:=b;b:=c;c:=p;
end;
Label5.Caption:=s+Format('%2d, %2d, %2d',[a,b,c]);
Button2.SetFocus;
end;
Ако желимо да бројеве уредимо у нерастући поредак потребно је неједнакост > у све три if наредбе
променити у <, или код исписа резултата наредбу Format написати овако Format('%2d, %2d,
%2d',[c,b,a]).
• Саставити програм који одређује дужину трајања емисије у минутима, ако је дато
време почетка и краја емисије у сатима и минутима.
Да би се задатак коректно решио требало би увести контролу уноса времена и водити рачуна о преласку
у нови дан. Време почетка и краја емисије претворићемо у минуте и одузети да бисмо добили решење.
ГРАНАЊА; ClientHeight = 330; ClientWidth = 360; Color = Teal; Font
= Palatino Linotype, BoldItalic, 16, Aqua; FormStyle = fsStayOnTop;
цију са корисником, четири едита за унос, едит за испис резултата
Сабирање времена; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = (230, 280); MaxLength = 2; Top = (80, 130);
Width = 40.
AutoSize = False; Caption = (Почетак емисије :, Завршетак емисије :,
Трајање емисије :); Height = 36; Layout = tlCenter; Left = 60; Top = (100, 150, 200); Width = 210.
280); Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер Emisija, а затим, двокликом мишем на тастере редом
Edit5.Clear;
Edit1.SetFocus;
end;
begin If sp>sk
then sk:=sk+24;
t:=sk*60+mk-(sp*60+mp);Edit5.Text:=IntToStr(t);
Button2.SetFocus;
end;

Све променљиве које смо употребили декларисане су као глобалне у заглављу програма:
var
Form1: TForm1;
sp,mp,sk,mk,t:integer;
Контролу уноса времена остварили смо у процедурама које су реакција на излазак из одговарајућег едита
(селектујемо сваки едит, у прозору ObjectInspector на листићу Events двоклик на поље вредности догађаја
OnExit декларише одговарајућу процедуру коју дефинишемо):
begin sp:=StrToIntDef(Edit1.Text,0);
If (sp<0)or(sp>23)
then begin Edit1.Clear;Edit1.SetFocus;
end
else Edit1.Text:=IntToStr(sp);
end;
begin mp:=StrToIntDef(Edit2.Text,0);
If (mp<0)or(mp>59)
end
else Edit2.Text:=IntToStr(mp);
end;
begin sk:=StrToIntDef(Edit3.Text,0);
If (sk<0)or(sk>23)
end
else Edit3.Text:=IntToStr(sk);
end;
begin mk:=StrToIntDef(Edit4.Text,0);
If (mk<0)or(mk>59)or(sp=sk)and(mp>mk)
end
else Edit4.Text:=IntToStr(mk);
end;
Уведене контроле нису толерантне. Податак који се уноси мора бити логично исправан у односу на
претходно унете, чак и ако је претходни податак погрешно унет. Тек када се унесе исправан податак
може се променити претходни.
• Саставити програм који одређује комплемент и суплемент угла датог у степенима
минутима и секундама.
Да би се коректно решио задатак потребно је увести контролу уноса угла (мора бити мањи или једнак
90 степени да би се могао наћи комплемент). Угао ћемо претворити у секунде, а затим ћемо комплемент
добити као допуну до 90*3600 секунди. Суплемент је за 90 степени већи.
кацију са корисником, три едита за унос, шест едита за испис
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Комп
лемент и суплемент; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = (170, 230, 270); MaxLength =2; Top = 80;
Width = (50, 40, 40).
(130, 180); Width = (50, 40, 40).
AutoSize = False; Caption = (Угао :, Комплемент :, Суплемент :); Height = 36; Layout = tlCenter; Left = 20;
Top = (80, 130, 180); Width = 150.
280); Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер KompSup, а затим, двокликом мишем на тастере


Edit1.SetFocus;
end;
var c1,c2,c3:integer;
begin c3:=90*3600-(а1*3600+a2*60+a3);
c1:=c3 div 3600;
c2:=c3 div 60 mod 60;
c3:=c3 mod 60;
Edit4.Text:=IntToStr(c1);
Edit7.Text:=IntToStr(c1+90);
Button2.SetFocus;
end;
Променљиве за унос угла декларисане су као глобалне у заглављу програма:
var
Form1: TForm1;
a1,a2,a3:integer;
Контролу уноса угла остварили смо у процедурама које су реакција на излазак из одговарајућег едита
(селектујемо сваки едит, у прозору ObjectInspector на листићу Events двоклик на поље вредности догађаја
OnExit декларише одговарајућу процедуру коју дефинишемо):
begin a1:=StrToIntDef(Edit1.Text,0);
If (a1<0)or(a1>90)
end
else Edit1.Text:=IntToStr(a1);
end;
If (a2<0)or(a2>59)or(a1=90)and(a2>0)
end
end;
If (a3<0)or(a3>59)or(a1=90)and(a3>0)
end
end;
• Дата су три угла у степенима минутима и секундама. Саставити програм који одређује
да ли они могу бити углови троугла и ако могу да ли је троугао оштроугли, правоугли
или тупоугли.
Први услов који три угла морају испуњавати је да им је збир 180
степени, али то није довољно. Да би био оштроугли троугао сва
три угла морају бити оштра. Да би троугао био правоугли један
угао мора бити прав, а остала два оштра. Да би троугао био
тупоугли један угао мора бити туп, а остала два оштра. Код уноса
углова није потребно уводити претходну контролу уноса јер је
садржана у каснијим условима.
кацију са корисником, девет едита за унос, лабелу за испис

Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Три угла; Font = 22, Lime; Height = 50;
Layout = tlCenter.
Font = Bold, Black; Left = (170, 230, 270); MaxLength = (3, 2, 2); Top = (80, 130, 180); Width = (50, 40, 40).
AutoSize = False; Caption = (a =, b =, g =); Font = Symbol; Height = 36; Layout = tlCenter; Left = 20; Top = (80,
130, 180); Width = 50.
Сачуваћемо дизајнирану форму у креирани фолдер Uglovi, а затим, двокликом мишем на тастере редом
Label5.Caption:='';
Edit1.SetFocus;
end;
var s:string;
a1,b1,c1,a2,b2,c2,a3,b3,c3:integer;
a2:=StrToIntDef(Edit2.Text,0); Edit2.Text:=IntToStr(a2 mod 60);
b2:=StrToIntDef(Edit5.Text,0); Edit5.Text:=IntToStr(b2 mod 60);
c1:=StrToIntDef(Edit7.Text,60);Edit7.Text:=IntToStr(c1);
c2:=StrToIntDef(Edit8.Text,0); Edit8.Text:=IntToStr(c2 mod 60);
c3:=StrToIntDef(Edit9.Text,0); Edit9.Text:=IntToStr(c3 mod 60);
a3:=a1*3600+a2*60+a3;
b3:=b1*3600+b2*60+b3;
c3:=c1*3600+c2*60+c3;
s:='Не могу бити углови троугла.';
If a3+b3+c3=180*3600
then If (a3=90*3600)and(b3<90*3600)and(c3<90*3600)xor
(a3<90*3600)and(b3=90*3600)and(c3<90*3600)xor
(a3<90*3600)and(b3<90*3600)and(c3=90*3600)
then s:='Могу бити углови троугла,'+#13+'- правоугли.'
else If (a3>90*3600)and(b3<90*3600)and(c3<90*3600)xor
(a3<90*3600)and(b3>90*3600)and(c3<90*3600)xor
(a3<90*3600)and(b3<90*3600)and(c3>90*3600)
then s:='Могу бити углови троугла,'+#13+'- тупоугли.'
else If (a3<90*3600)and(b3<90*3600)and(c3<90*3600)
then s:='Могу бити углови троугла,'+#13+'- оштроугли.';
Label5.Caption:=s;
Button2.SetFocus;
end;
• Дата су два угла у степенима минутима и секундама. Саставити програм који

одређује да ли постоји угао који са ова два чини троугао и ако постоји одређује да ли је
троугао оштроугли, правоугли или тупоугли.
Услови су слични као и у претходном задатку, једино што по услову задатка збир углова мора бити 180
степени, па тај услов не морамо проверавати. Овде ће и остали услови бити нешто једноставнији јер
ћемо пре одређивања трећег угла проверити да ли је збир прва два мањи од 180 степени и да ли су оба
угла позитивно оријентисана.
370; Color = Teal; Font = Palatino Linotype, BoldItalic, 16, Aqua; FormStyle = fsStayOnTop; Position =
poScreenCenter.


кацију са корисником, шест едита за унос, три едита и лабелу за
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Три
угла; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = (170, 230, 270); MaxLength =(3, 2, 2); Top =
(80, 130); Width = (50, 40, 40).
200; Width = (50, 40, 40).
AutoSize = False; Caption = (a =, b =, g =); Font = Symbol; Height = 36; Layout = tlCenter; Left = 20; Top = (80,
130, 200); Width = 50.
Сачуваћемо дизајнирану форму у креирани фолдер Trougao, а затим, двокликом мишем на тастере
Label5.Caption:='';
Edit1.SetFocus;
end;
var s:string;
a1,b1,c1,a2,b2,c2,a3,b3,c3:integer;
a3:=a1*3600+a2*60+a3;
b3:=b1*3600+b2*60+b3;
If (a3+b3<180*3600)and(a3>0)and(b3>0)
then begin c3:=180*3600-a3-b3;
If (a3=90*3600)or(b3=90*3600)or(c3=90*3600)
then s:='Могу бити углови троугла,'+#13+'- правоугли.'
else If (a3>90*3600)or(b3>90*3600)or(c3>90*3600)
then s:='Могу бити углови троугла,'+#13+'- тупоугли.'
else s:='Могу бити углови троугла,'+#13+'- оштроугли.';
c1:=c3 div 3600; Edit7.Text:=IntToStr(c1);
c2:=c3 div 60 mod 60;Edit8.Text:=IntToStr(c2);
end
else begin s:='Не могу бити углови троугла.';
end;
Label5.Caption:=s;
Button2.SetFocus;
end;
• Саставити програм који одређује да ли три уписана броја могу бити мерни бројеви
страница троугла и ако могу, какав је тај троугао.
350; Font = Palatino Linotype, BoldItalic, 16, Aqua; FormStyle = fsStayOnTop; Position = poScreenCenter.
На форму ћемо ставити лабелу за наслов, три лабеле за комуникацију са корисником, три едита за унос,
лабелу за испис резултата и три тастера за управљање апликацијом.

Сортирање; Font = 22, Lime; Height = 50; Layout = tlCenter.
AutoSize = False; Caption = (a =, b =, c =); Height = 36; Layout =
tlCenter; Left = 40; Top = (80, 130, 180); Width = 40.
Left = 200; Top = (80, 130, 180); Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер Stranice, а
Label5.Caption:='';
Edit1.SetFocus;
end;
var a:string;
b,c,d,p:real;
begin b:=StrToFloatDef(Edit1.Text,1);Edit1.Text:=FloatToStr(b);
d:=StrToFloatDef(Edit3.Text,2);Edit3.Text:=FloatToStr(d);
If (b+c>d)and(c+d>b)and(d+b>c)
then begin If b>c
then begin p:=c;c:=b;b:=p;
end;
If c>d
then begin p:=c;c:=d;d:=p;
end;
If d*d<c*c+b*b
then a:='Ово су странице оштроуглог троугла.'
else If d*d=c*c+b*b
then a:='Ово су странице правоуглог троугла.'
else a:='Ово су странице тупоуглог троугла.';
end
else a:='Не могу бити странице троугла.';
Label3.Caption:=a;
Button2.SetFocus;
end;
• Саставити програм који одређује углове (у степенима, минутима и секундама)

троугла ако су дате странице a, b и c.
2 2 2
Искористићемо косинусну теорему да одредимо два угла јер имамо све a  b  c  2  b  c  cos 
странице троугла. Трећи угао ћемо добити као допуну до 180о. Ове b2  c2  a2
једноставне математичке формуле лако можемо написати у духу нашег cos  
2 b c
програмског језика и решити задатак. Треба водити рачуна о томе да све
тригонометријске функције раде са угловима у радијанима, па ове формуле sin   1  cos 2 
треба допунити конверзијом радијана у степене, минуте и секунде. sin 
  ArcT g ( )
cos 
BorderIcons = []; BorderStyle = bsSingle; Caption = РЕАЛНИ ТИП; ClientHeight b 2  c 2  a 2  2  c  a  cos 
= 370; ClientWidth = 400; Color = Teal; Font = Palatino Linotype, BoldItalic, 16, c2  a2  b2
Aqua; FormStyle = fsStayOnTop; Position = poScreenCenter. cos  
На форму ћемо ставити лабелу за наслов, шест лабела за комуникацију са 2c a
корисником, три едита за унос, девет едита за испис резултата и три sin   1  cos 2 
тастера за управљање апликацијом. sin 
Лабела за наслов:   ArcTg ( )
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Углови троугла; cos 
Font = 22, Lime; Height = 50; Layout = tlCenter.   180 o    
Font = Bold, Black; Left = (65, 185, 305); Top = 80; Width = 70.


(200, 240, 280); Width = (50, 40, 40).
AutoSize = False; Caption = (a =, b =, c =); Height = 36; Layout =
tlCenter; Left = (30, 150, 270); Top = 80; Width = 35.
AutoSize = False; Caption = (a =, b =, g =); Font = Symbol, BoldItalic,
16, Aqua; Height = 36; Layout = tlCenter; Left = 30; Top = (200, 240,
280); Width = 50.
Left = (65, 200, 260); Top = (140, 140, 310); Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер SveStranice, а
Edit1.SetFocus;
end;
var a,b,c,p:real;
a1,a2,a3,b1,b2,b3,c1,c2,c3:integer;
If (a+b>c)and(b+c>a)and(c+a>b)
then begin p:=(b*b+c*c-a*a)/(2*b*c);
If p=0
then a3:=0
else a3:=Round(ArcTan(Sqrt(1-p*p)/p)/pi*180*3600);
p:=(a*a+c*c-b*b)/(2*a*c);
If p=0
then b3:=0
else b3:=Round(ArcTan(Sqrt(1-p*p)/p)/pi*180*3600);
c3:=180*3600-(a1*3600+b1*3600+a2*60+b2*60+a3+b3);
Button2.SetFocus;
end
else begin Application.MessageBox('Не могу бити странице троугла!','ГРЕШКА У УНОСУ',0);
Button2.Click;
end;
end;
• Саставити програм који одређује трећу страницу, два висине и углове троугла ако су
дате две странице и висина на једну од њих.
Применићемо Питагорину теорему за два правоугла троугла на које почетни троугао дели висина и
добићемо трећу страницу. Одредићемо висине троугла из обрасца за површину. а затим и обим и
површину троугла. За углове ћемо прво одредити sin и cos, а затим помоћу ArcTan углове у секундама.
Color = Teal; Font = Palatino Linotype, BoldItalic, 16, Aqua; FormStyle = fsStayOnTop; Position = poScreenCenter.
На форму ћемо ставити лабелу за наслов, четрнаест лабела за комуникацију са корисником, три едита
за унос, седамнаест едита за испис резултата и три тастера за управљање апликацијом.
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Решавање троугла; Font = 22, Lime; Height

Едити за испис страница и висина:
Font = Bold, Black; Left = (215, 345); ReadOnly = True; Top = (70,
110, 150); Width = 70.
Едити за испис обима и површине:
Font = Bold, Black; Left = (215, 335); ReadOnly = True; Top = 190;
Width = 80.
Едити за испис углова:
(230, 270, 310); Width = (50, 40, 40).
AutoSize = False; Caption = (a =, b =, ha =, a =, b =, c =, ha =, hb =, hc =,
O =, P =); Height = 36; Layout = tlCenter; Left = (75, 150, 270); Top =
(70, 110, 150, 70, 110, 150, 70, 110, 150, 190, 190); Width = 35.
Лабеле углова:
AutoSize = False; Caption = (a =, b =, g =); Font = Symbol, BoldItalic, 16, Aqua; Height = 36; Layout = tlCenter;
Left = 180; Top = (230, 270, 310); Width = 35.
Сачуваћемо дизајнирану форму у креирани фолдер DveStranice, а затим, двокликом мишем на тастере
Edit9.Clear; Edit10.Clear;Edit11.Clear;Edit12.Clear;
Edit1.SetFocus;;
end;
var a,b,c,h1,h2,h3,p,o,x,y:real;
h1:=StrToFloatDef(Edit3.Text,3);Edit3.Text:=FloatToStr(h1);
If b<h1 // страница b је хипотенуза у помоћном троуглу и мора бити већа од катета
then begin Application.MessageBox('Не може бити троугао!','ГРЕШКА У УНОСУ',0);
Button2.Click;
end
else begin x:=Sqrt(b*b-h1*h1); // одсечци на које висина дели страницу a
y:=a-x;
Edit4.Text:=Format('%7.3f',[a]);
Edit5.Text:=Format('%7.3f',[b]);
c:=Sqrt(y*y+h1*h1);Edit6.Text:=Format('%7.3f',[c]);
Edit7.Text:=Format('%7.3f',[h1]);
h2:=a*h1/b;Edit8.Text:=Format('%7.3f',[h2]);
h3:=a*h1/c;Edit9.Text:=Format('%7.3f',[h3]);
o:=a+b+c;Edit10.Text:=Format('%7.3f',[o]);
p:=a*h1/2;Edit11.Text:=Format('%7.3f',[p]);
If y=0 // странице a и b су нормалне, угао  је прав
then b3:=90*3600
else b3:=Round(ArcTan(h1/y)/pi*180*3600);
If x=0 // странице a и c су нормалне, угао  је прав
then c3:=90*3600
else c3:=Round(ArcTan(h1/x)/pi*180*3600);
a3:=180*3600-b3-c3;
a1:=a3 div 3600; Edit12.Text :=IntToStr(a1);
Button2.SetFocus;
end;
end;

• Саставити програм који одређује две странице, висину и углове троугла ако су дате
две висине и трећа страница троугла
poScreenCenter.
На форму ћемо ставити лабелу за наслов, четрнаест лабела за
комуникацију са корисником, три едита за унос, седамнаест едита
Решавање троугла; Font = 22, Lime; Height = 50; Layout = tlCenter.
110, 150); Width = 70.
Font = Bold, Black; Left = (215, 335); ReadOnly = True; Top = 190; Width = 80.
Font = Bold, Black; Left = (215, 270, 315); ReadOnly = True; Top = (230, 270, 310); Width = (50, 40, 40).
AutoSize = False; Caption = (a =, hb =, hc =, a =, b =, c =, ha =, hb =, hc =, O =, P =); Height = 36; Layout = tlCenter; Left =
(75, 150, 270); Top = (70, 110, 150, 70, 110, 150, 70, 110, 150, 190, 190); Width = 35.
Left = 180; Top = (230, 270, 310); Width = 35.
Сачуваћемо дизајнирану форму у креирани фолдер DveVisine, а затим, двокликом мишем на тастере
Edit1.SetFocus;;
end;
If (a<h3)or(a<h2) // a је хипотенуза у помоћним троугловима и мора бити већа од катета
Button2.Click;
end
else begin x:=Sqrt(a*a-h3*h3); // одсечак на страници c
y:=Sqrt(a*a-h2*h2); // одсечак на страници b
If x=0 // странице a и c су нормалне, угао  је прав
then begin p:=pi/2-ArcTan(h2/y);
b3:=90*3600;
c3:=Round(ArcTan(h2/y)/pi*180*3600);
end
else If y=0 // странице a и b су нормалне, угао  је прав
then begin p:=pi/2-ArcTan(h3/x);
b3:=Round(ArcTan(h3/x)/pi*180*3600);
c3:=90*3600;
end
else begin p:=pi-ArcTan(h3/x)-ArcTan(h2/y);
b3:=Round(ArcTan(h3/x)/pi*180*3600);
c3:=Round(ArcTan(h2/y)/pi*180*3600);
end;
b:=h3/sin(p);Edit5.Text:=Format('%7.3f',[b]);
c:=h2/sin(p);Edit6.Text:=Format('%7.3f',[c]);

h1:=b*h2/a;Edit7.Text:=Format('%7.3f',[h1]);
o:=a+b+c;Edit10.Text:=Format('%7.3f',[o]);
a3:=180*3600-c3-b3;
Button2.SetFocus;
end;
end;
• Саставити програм који одређује странице, две висине и трећи угао троугла ако су
дата два угла и висина из трећег темена троугла.
poScreenCenter.
На форму ћемо ставити лабелу за наслов, дванаест лабела за
комуникацију са корисником, седам едита за унос, једанаест
Едит за унос висине:
Font = Bold, Black; Left = 255; ReadOnly = True; Top = (70, 110, 150,
190, 230, 270); Width = 70.
Font = Bold, Black; Left =380; ReadOnly = True; Top = (70, 110); Width = 80.
Едити за унос и испис углова:
Font = Bold, Black; Left = (65, 115, 155, 65, 115, 155, 215, 270, 315); ReadOnly = True; Top = (70, 70, 70, 110,
110, 110, 310, 310, 310); Width = (50, 40, 40, 50, 40, 40, 50, 40, 40).
AutoSize = False; Caption = (hc =, a =, b =, c =, ha =, hb =, hc =, O =, P =); Height = 36; Layout = tlCenter; Left = (20, 210,
335); Top = (150, 70, 110, 150, 190, 230, 270, 70, 110); Width = 45.
Left = (20, 20, 210); Top = (70, 110, 310); Width = 45.
Сачуваћемо дизајнирану форму у креирани фолдер DvaUgla, а затим, двокликом мишем на тастере редом
Edit9.Clear; Edit10.Clear;Edit11.Clear;Edit12.Clear;Edit13.Clear;
Edit1.SetFocus;;
end;
var a,b,c,h1,h2,h3,p,o:real;
begin a1:=StrToIntDef(Edit1.Text,9);Edit1.Text:=IntToStr(a1 mod 180);
a2:=StrToIntDef(Edit2.Text,0);Edit2.Text:=IntToStr(a2 mod 60);
a3:=StrToIntDef(Edit3.Text,0);Edit3.Text:=IntToStr(a3 mod 60);
a3:=a1*3600+a2*60+a3;
b1:=StrToIntDef(Edit4.Text,9);Edit4.Text:=IntToStr(b1 mod 180);

b3:=b1*3600+b2*60+b3;
c3:=180*3600-b3-a3;
If (c3<0)or(a3<=0)or(c3<=0)// збир два унутрашња угла троугла je мањи од 180 степени
Button2.Click;
end
else begin a:=h3/Sin(b3/180/3600*pi);Edit8.Text:=Format('%7.3f',[a]);
b:=h3/Sin(a3/180/3600*pi);Edit9.Text:=Format('%7.3f',[b]);
c:=Sqrt(b*b-h3*h3)+Sqrt(a*a-h3*h3);Edit10.Text:=Format('%7.3f',[c]);
h1:=c*Sin(b3/180/3600*pi);Edit11.Text:=Format('%7.3f',[h1]);
h2:=c*Sin(a3/180/3600*pi);Edit12.Text:=Format('%7.3f',[h2]);
o:=a+b+c; Edit14.Text:=Format('%7.3f',[o]);
Button2.SetFocus;
end;
end;
• Саставити програм који одређује странице и углове троугла ако су дате све три
висине троугла
poScreenCenter.
На форму ћемо ставити лабелу за наслов, четрнаест лабела за
комуникацију са корисником, три едита за унос, седамнаест едита
110, 150); Width = 70.
Едити за испис обима и површину:
Font = Bold, Black; Left = (215, 335); ReadOnly = True; Top = 190; Width = 80.
Font = Bold, Black; Left = (215, 270, 315); ReadOnly = True; Top = (230, 270, 310); Width = (50, 40, 40).
AutoSize = False; Caption = (ha =, hb =, hc =, a =, b =, c =, ha =, hb =, hc =, O =, P =); Height = 36; Layout = tlCenter; Left
= (75, 150, 270); Top = (70, 110, 150, 70, 110, 150, 70, 110, 150, 190, 190); Width = 35.
Left = 180; Top = (230, 270, 310); Width = 35.
Сачуваћемо дизајнирану форму у креирани фолдер TriVisine, а затим, двокликом мишем на тастере редом
Edit1.SetFocus;;
end;
var a,b,c,h1,h2,h3,p,o:real;
begin h1:=StrToFloatDef(Edit1.Text,5);Edit1.Text:=FloatToStr(h1);Edit7.Text:=Format('%7.3f',[h1]);
h2:=StrToFloatDef(Edit2.Text,5);Edit2.Text:=FloatToStr(h2);Edit8.Text:=Format('%7.3f',[h2]);
a:=1/h1;b:=1/h2;c:=1/h3; // странице троугла су обрнуто пропорционалне висинама

If (a+b>c)and(b+c>a)and(c+a>b) // збир сваке две мора бити већи од треће странице

then begin p:=Sqrt((a+b+c)*(-a+b+c)*(a-b+c)*(a+b-c))/2;
a:=a/p;Edit4.Text:=Format('%7.3f',[a]);
b:=b/p;Edit5.Text:=Format('%7.3f',[b]);
c:=c/p;Edit6.Text:=Format('%7.3f',[c]);
p:=(b*b+c*c-a*a)/(2*b*c);
If p=0 then a3:=90*3600 // b*b+c*c=a*a, угао  је прав
else If p<0 // троугао је тупоугли са теменом тупог угла у B
then a3:=Round((pi+ArcTan(Sqrt(1-p*p)/p))/pi*180*3600)
else a3:=Round(ArcTan(Sqrt(1-p*p)/p)/pi*180*3600);
p:=(c*c+a*a-b*b)/(2*a*c);
If p=0 then b3:=90*3600 // c*c+a*a=b*b, угао  је прав
else If p<0 // троугао је тупоугли са теменом тупог угла у B
then b3:=Round((pi+ArcTan(Sqrt(1-p*p)/p))/pi*180*3600)
else b3:=Round(ArcTan(Sqrt(1-p*p)/p)/pi*180*3600);
c3:=180*3600-b3-a3;
Button2.SetFocus;
end
else begin Application.MessageBox('Не постоји такав троугао!','ГРЕШКА У УНОСУ',0);
Button2.Click;
end;
end;
Или овако:
begin h1:=StrToFloatDef(Edit1.Text,5);Edit1.Text:=FloatToStr(h1);Edit7.Text:=Format('%7.3f',[h1]);
If (1/h1+1/h2>1/h3)and(1/h2+1/h3>1/h1)and(1/h3+1/h1>1/h2)
{ ако изразимо странице троугла помоћу површине и одговарајућих висина и сетимо се да је збир
сваке две странице већи од треће, заменом страница и проширењем неједнакости са 2Р добијамо ове
неједнакости које морају да важе за висине сваког троугла.
2 2 2 2 h h 2 2 h h
како је ah1 bh 2 ch3 /: h 1 h 2  ha2  hb1  h1ch 2 , па је cos (b c a )/2bc (h 1 ( h1 3 2 ) h 2 )/2h1 h1 3 2 }
h3
then begin y:=h1*h2/h3; x:=(h1*h1+y*y-h2*h2)/(2*h1*y); // х је косинус угла 

b:=h3/Sqrt(1-x*x);Edit5.Text:=Format('%7.3f',[b]);
c:=h2/Sqrt(1-x*x);Edit6.Text:=Format('%7.3f',[c]);
a:=b*h2/h1;Edit4.Text:= Format('%7.3f',[a]);
p:=a*h1/2; Edit10.Text:=Format('%7.3f',[p]);
If x=0
then a3:=90*3600
else If x<0
then a3:=Round((pi+ArcTan(Sqrt(1-x*x)/x))*180/pi*3600)
else a3:=Round(ArcTan(Sqrt(1-x*x)/x)*180/pi*3600);
p:=(h2*h2+y*y-h1*h1)/(2*h2*y); // косинус угла 
If p=0
then b3:=90*3600
else If p<0
then b3:=Round((pi+ArcTan(Sqrt(1-p*p)/p))*180/pi*3600)
else b3:=Round(ArcTan(Sqrt(1-p*p)/p)*180/pi*3600);
c3:=180*3600-a3-b3;
Button2.SetFocus;
end
else begin Application.MessageBox('Не постоји такав троугао!','ГРЕШКА У УНОСУ',0);
Button2.Click;
end;
end;

• Саставити програм који за унети редни број дана у недељи одређује његов назив.
Користићемо делфи функцију LowerCase да бисмо поједноставили тестирање уписаног стринга.
кацију са корисником, едит за унос, лабелу за испис резултата и
Дани у недељи; Font = 22, Lime; Height = 50; Layout = tlCenter.
AutoSize = False; Caption = Редни број; Height = 36; Layout = tlCenter; Left = 20; Top = 90; Width = 120.
Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер ImeDana, а затим, двокликом мишем на тастере редом
Label3.Caption:='';
Edit1.SetFocus;
end;
Двоклик на тастер Одреди (варијанта са If-наредбом):
var s:string;
b:integer;
If b=1 then s:='Први дан у недељи је понедељак.'
else If b=2 then s:='Други дан у недељи је уторак.'
else If b=3 then s:='Трећи дан у недељи је среда.'
else If b=4 then s:='Четврти дан у недељи је четвртак.'
else If b=5 then s:='Пети дан у недељи је петак.'
else If b=6 then s:='Шести дан у недељи је субота.'
else If b=7 then s:='Седми дан у недељи је недеља.'
else s:=IntToStr(b)+'. није редни број дана у недељи.';
Label3.Caption:=s;
Button2.SetFocus;
end;
Двоклик на тастер Одреди (варијанта са Case-наредбом):
var s:string;
b:integer;
Case b of
1 : s:='Први дан у недељи је понедељак.'
2 : s:='Други дан у недељи је уторак.'
3 : s:='Трећи дан у недељи је среда.'
4 : s:='Четврти дан у недељи је четвртак.'
5 : s:='Пети дан у недељи је петак.'
6 : s:='Шести дан у недељи је субота.'
7 : s:='Седми дан у недељи је недеља.'
else s:=Edit1.Text+'. није редни број дана у недељи.';
Label3.Caption:=s;
Button2.SetFocus;
end;
Двоклик на тастер Одреди (варијанта са скупом и низом константи):
const d:array[1..7]of string=('понедељак','уторак','среда','четвртак','петак','субота','недеља');
var s:string;
b:integer;
If b in [1..7]
then s:=Edit1.Text+'. дан у недељи је '+d[b]+'.'

else s:=Edit1.Text+'. није редни број дана у недељи.';

Label3.Caption:=s;
Button2.SetFocus;
end;
Решење је комплетније ако се уведе контрола уноса. Кориснику нећемо дозволити да унесе број који
није редни број неког дан у недељи. Контролу уноса ћемо увести као процедуру која се извршава када
се напусти едит за унос података. Селектујемо едит за унос, у прозору ObjectInspector на листићу Events
двоклик на поље вредности догађаја OnExit декларише одговарајућу процедуру коју дефинишемо:
begin If not (StrToIntDef(Edit1.Text,0) in [1..7])
then begin MessageBox(0,'Морате унети број од 1 до 7.','ГРЕШКА',MB_ICONERROR);
Edit1.Clear;Edit1.SetFocus;
end;
end;
• Саставити програм који за унет назив дана у недељи одређује његов редни број.
кацију са корисником, едит за унос, лабелу за испис резултата и
Дани у недељи; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = 140; CharCase = ecLowerCase; Top = 90;
Width = 120.
AutoSize = False; Caption = Назив дана; Height = 36; Layout = tlCenter; Left = 20; Top = 90; Width = 120.
Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер RBDana, а затим, двокликом мишем на тастере редом
Label3.Caption:='';
Edit1.SetFocus;
end;
Двоклик на тастер Одреди (варијанта са If-наредбом):
var a,s:string;
begin s:=Edit1.Text;a:=LowerCase(s);
If a='понедељак' then s:=s+' је први дан у недељи.'
else If a='уторак' then s:=s+' је други дан у недељи.'
else If a='среда' then s:=s+' је трећи дан у недељи.'
else If a='четвртак' then s:=s+' је четврти дан у недељи.'
else If a='петак' then s:=s+' је пети дан у недељи.'
else If a='субота' then s:=s+' је шести дан у недељи.'
else If a='недеља' then s:=s+' је седми дан у недељи.'
else s:=s+' није дан у недељи.';
Label3.Caption:=s;
Button2.SetFocus;
end;
напомена:
Функција LowerCase не ради са ћириличним словима, па овај програм неће радити ако дане у недељи
исписујемо малим и великим словима иако је алгоритамски коректан, зато смо поставили CharCase =
ecLowerCase што би требало да помогне да се називи дана могу да уписују само малим словима (зависи
од инсталираног оперативног система). Ако ово не ради, а желимо да направимо програм који ће коректно
тестирати низ унетих ћириличних слова да би се утврдио дан у недељи, морамо направити сами
одговарајућу функцију која ће сва велика ћирилична слова претворити у мала. Са знањем које у овом
тренутку поседујемо, то нисмо у могућности. Делимично решење проблема је да се уместо едита, за
унос података користи комбиновани оквир (ComboBox) из кога би се бирао назив дана. У том случају

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

и такво решење. У дизајнирању форме измене су незнатне.
Додајемо комбиновани оквир за унос података:
AutoCloseUp = true; AutoDrop Down = true; Items = (понедељак,
уторак, среда, четвртак, петак, субота, недеља); Left = 130; Style
= csOwner DrawVariable; Top = 90; Width = 125.
Испред оквира је иста лабелa за комуникацију. Делимично се
мењају и процедуре за тастере Обриши и Одреди.
begin ComboBox1.ItemIndex:=-1;
Label3.Caption:='';
ComboBox1.Enabled:=true;
ComboBox1.SetFocus;
end;
var s:string;
begin s:=ComboBox1.Text;
If s='понедељак'
then s:=s+' је први дан у недељи.'
else If s='уторак' then s:=s+' је други дан у недељи.'
else If s='среда' then s:=s+' је трећи дан у недељи.'
else If s='четвртак' then s:=s+' је четврти дан у недељи.'
else If s='петак' then s:=s+' је пети дан у недељи.'
else If s='субота' then s:=s+' је шести дан у недељи.'
else s:=s+' је седми дан у недељи.';
Label3.Caption:=s;
ComboBox1.Enabled:=false;
Button2.SetFocus;
end;
Ова процедура записана са Case наредбом је једноставнија:
var s:string;
begin s:=ComboBox1.Text;
Case ComboBox1.ItemIndex of
0 : s:=s+' је први дан у недељи.';
1 : s:=s+' је други дан у недељи.';
2 : s:=s+' је трећи дан у недељи.';
3 : s:=s+' је четврти дан у недељи.';
4 : s:=s+' је пети дан у недељи.';
5 : s:=s+' је шести дан у недељи.';
6 : s:=s+' је седми дан у недељи.';
end;
Label3.Caption:=s;
Button2.SetFocus;
end;
AutoCloseUp = true аутоматски затвара контејнер када се изабере нека од понуђених ставки;
AutoDropDown = true аутоматски отвара контејнер када објекат постане активан;
Items = (понедељак, уторак, среда, четвртак, петак, субота, недеља) је садржај контејнера, ако желимо
да садржај буде ћириличан, ставке се уписују у Notepad, а затим копирају у StringListEditor који се отвара
када се кликне на карактеристику Items;
Style = csOwnerDrawVariable забрањује да се у оквир упише било шта осим ставки из контејнера (зато
нема поруке - није дан у недељи).
У наредним задацима алгоритме ћемо описивати и са If и са Case када је то могуће, а у компликованијим

задацима комбиноваћемо ове наредбе тако да програм буде што једноставнији за читање.
Следећа два задатка су готово истоветна са претходна два, зато ћемо, без велике буке само написати све
варијанте процедуре за тастер Одреди.
• Саставити програм који за унети редни број месеца исписује име месеца.
Label3.Caption:='';
Edit1.SetFocus;
end;
Са If
var s:string;b:integer;
s:=Edit1.Text+'. месец у години је ';
If b=1 then s:=s+'јануар'
else If b=2 then s:=s+'фебруар'
else If b=3 then s:=s+'март'
else If b=4 then s:=s+'април'
else If b=5 then s:=s+'мај'

else If b=6 then s:=s+'јун'

else If b=7 then s:=s+'јул'
else If b=8 then s:=s+'август'
else If b=9 then s:=s+'септембар'
else If b=10 then s:=s+'октобар'
else If b=11 then s:=s+'новембар'
else If b=12 then s:=s+'децембар'
else s:=Edit1.Text+'. није редни број'+#13+'месеца у години';
Label3.Caption:=s;
Button2.SetFocus;
end;
Са Case
var s:string;b:integer;
s:=Edit1.Text+'. месец у години је ';
Case b of
1 : s:=s+'јануар';
2 : s:=s+'фебруар';
3 : s:=s+'март';
4 : s:=s+'април';
5 : s:=s+'мај';
6 : s:=s+'јун';
7 : s:=s+'јул';
8 : s:=s+'август';
9 : s:=s+'септембар';
10: s:=s+'октобар';
11: s:=s+'новембар';
12: s:=s+'децембар';
else s:=Edit1.Text+'. није редни број'+#13+'месеца у години';
end;
Label3.Caption:=s;
Button2.SetFocus;
end;
Са скуповним типом и контролом уноса
Edit1.Clear;
Edit1.SetFocus;
end;
end;
const d:array[1..12] of string =('јануар', 'фебруар', 'март', 'април', 'мај', 'јун', 'јул',
'август', 'септембар', 'октобар', 'новембар', 'децембар');
var s:string;
b:integer;
s:=Edit1.Text+'. месец у години је '+d[b]+'.'
Label3.Caption:=s;
Button2.SetFocus;
end;
• Саставити програм који за унети редни број месеца и годину исписује број дана у месецу.
Овде само треба водити рачуна о преступним годинама. За сада
важи, година је преступна ако је дељива са 4 и није последња
година века, односно, није дељива са 100 или ако је дељива са 400.
Label3.Caption:='';
Edit1.SetFocus;
end;
Са If и Case
var s:string;
m,g,p,b:integer;
begin m:=StrToIntDef(Edit1.Text,10);
Edit1.Text:=IntToStr(m);
g:=StrToIntDef(Edit2.Text,2000);
Edit2.Text:=IntToStr(g);
If (m<1) or (m>12)
then s:='Погрешан унос месеца у години.'
else begin If (g mod 4=0)and(g mod 100<>0)or(g mod 400=0)
then p:=1
else p:=0;

Case m of
2 : b:=28+p;
4,6,9,11 : b:=30;
else b:=31;
end;
s:=IntToStr(b);
Case m of
1 : s:='Jaнуар има '+s+' дан.';
2 : s:='Фебруар има '+s+' дана.';
3 : s:='Март има '+s+' дан.';
4 : s:='Април има '+s+' дана.';
5 : s:='Мај има '+s+' дан.';
6 : s:='Jун има '+s+' дана.';
7 : s:='Jул има '+s+' дан.';
8 : s:='Август има '+s+' дан.';
9 : s:='Септембар има '+s+' дана.';
10: s:='Октобар има '+s+' дан.';
11: s:='Новембар има '+s+' дана.';
12: s:='Децембар има '+s+' дан.';
end;
end;
Label3.Caption:=s;
Button2.SetFocus;
end;
Обе Case наредбе у претходној процедури могу се заменити групом If наредби.
Са скуповним типом и контролом уноса
end;
end;
const d:array[1..12] of string =('јануар', 'фебруар', 'март', 'април', 'мај', 'јун', 'јул',
'август', 'септембар', 'октобар', 'новембар', 'децембар');
var s:string;
m,g,p,b:integer;
begin m:=StrToIntDef(Edit1.Text,10); Edit1.Text:=IntToStr(m);
g:=StrToIntDef(Edit2.Text,1960);Edit2.Text:=IntToStr(g);
then p:=1
else p:=0;
Case m of
2 : b:=28+p;
4,6,9,11 : b:=30;
else b:=31;
end;
s:=d[m]+'има '+IntToStr(b)+' дана.';
Label3.Caption:=s;
Button2.SetFocus;
end;
• Саставити програм који за унети датум одређује сутрашњи датум.

Променљива р биће преступни дан (0 ако година није преступна, 1 ако јесте). Ради лакше контроле
датума, увешћемо још једну променљиву bd која ће представљати број дана у месецу (28, 29, 30 или 31).
Након уноса датума прво ћемо извршити контролу унетог, а затим, ако је датум коректан, одредити
сутрашњи датум.
poScreenCenter.
са корисником, три едита за унос, лабелу за испис резултата и
Сутрашњи датум; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = (200, 250, 300); MaxLength = (2, 2, 4); Top = 80; Width = (40, 40, 60).
AutoSize = False; Caption = Унесите датум; Height = 36; Layout = tlCenter; Left = 30; Top = 80; Width = 170.

Сачуваћемо дизајнирану форму у креирани фолдер Sutra, а затим, двокликом мишем на тастере редом
Label3.Caption:='';
Edit1.SetFocus;
end;
var s:string;
d,m,g,p,bd:integer;
begin d:=StrToIntDef(Edit1.Text,31); Edit1.Text:=IntToStr(d);
m:=StrToIntDef(Edit2.Text,12); Edit2.Text:=IntToStr(m);
then p:=1
else p:=0;
Case m of
2 : bd:=28+p;
4,6,9,11 : bd:=30;
else bd:=31;
end;
If (d>bd)or(d<1)or(m>12)or(m<1)
then begin MessageBox(0,'Погрешан унос датума.','ГРЕШКА',0);
Button2.Click;
end
else begin If d<bd
then d:=d+1
else begin d:=1;
If m<12
then m:=m+1
else begin m:=1; g:=g+1;
end;
end;
s:=Format('Сутрашњи датум је: %1d.%1d.%4d.',[d,m,g]);
Label3.Caption:=s;
Button2.SetFocus;
end;
end;
Case наредба за одређивање броја дана у месецу може се једноставно заменити двема If наредбама.
• Саставити програм који за унети датум одређује јучерашњи датум.
Променљива р биће преступни дан (0 ако година није преступна, 1 ако јесте). Ради лакше контроле
датума, увешћемо још једну променљиву bd која ће представљати број дана у месецу (28, 29, 30 или 31).
Након уноса датума прво ћемо извршити контролу унетог, а затим, ако је датум коректан, одредити
јучерашњи датум.
poScreenCenter.
Јучерашњи датум; Font = 22, Lime; Height = 50; Layout = tlCenter.
Сачуваћемо дизајнирану форму у креирани фолдер Juce, а затим, двокликом мишем на тастере редом

Label3.Caption:='';
Edit1.SetFocus;
end;
var s:string;
d,m,g,p,b:integer;
then p:=1
else p:=0;
If m=2
then bd:=28+p
else If m in [4,6,9,11]
then bd:=30
else bd:=31;
then s:='Погрешан унос датума.'
else begin If d>1
then d:=d-1
else begin m:=m-1;
If m=0
then begin m:=12; g:=g-1;
end;
Case m of
2 : d:=28+p;
4,6,9,11 : d:=30;
else d:=31;
end;
end;
s:=Format('Јучерашњи датум је: %1d.%1d.%4d.',[d,m,g]);
end;
Label3.Caption:=s;
Button2.SetFocus;
end;
Две If наредбe за одређивање броја дана у месецу може се једноставно заменити Case наредбом.
• Саставити програм који за унети датум одређује редни број дана у години.
poScreenCenter.
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Редни
број дана у години; Font = 22, Lime; Height = 50; Layout = tlCenter.
Сачуваћемо дизајнирану форму у креирани фолдер RBDanaUG, а затим, двокликом мишем на тастере
Label3.Caption:='';

Edit1.SetFocus;
end;
var s:string;
d,m,g,p,b:integer;
p:=0;
If (g mod 4=0)and(g mod 100<>0)or(g mod 400=0) then p:=1
If m=2
then b:=28+p
else If m in [4,6,9,11]
then b:=30
else b:=31;
If (d>b)or(d<1)or(m>12)or(m<1)
else begin If m>1 then d:=d+31;
If m>2 then d:=d+28+p;
If m>3 then d:=d+31;
s:='Уписани датум је '+IntToStr(d)+'. дан у години.';
end;
Label3.Caption:=s;
Button2.SetFocus;
end;
Процедура за тастер Одреди може се написати и овако:
var s:string;
d,m,g,p,bd:integer;
then p:=1
else p:=0;
Case m of
2 : bd:=28+p;
4,6,9,11 : bd:=30;
else bd:=31;
end;
else begin Case m of
2 : d:=d+31; // прошао је јануар, додајемо 31 дан
3 : d:=d+31+28+p; // прошли су јануар и фебруар
4 : d:=d+31+28+p+31; // прошли су јануар, фебруар и март ...
5 : d:=d+31+28+p+31+30;
6 : d:=d+31+28+p+31+30+31;
7 : d:=d+31+28+p+31+30+31+30;
8 : d:=d+31+28+p+31+30+31+30+31;
9 : d:=d+31+28+p+31+30+31+30+31+31;
10 : d:=d+31+28+p+31+30+31+30+31+31+30;
11 : d:=d+31+28+p+31+30+31+30+31+31+30+31;
12 : d:=d+31+28+p+31+30+31+30+31+31+30+31+30;
end;
s:='Уписани датум је '+IntToStr(d)+'. дан у години.';
end;
Label3.Caption:=s;
Button2.SetFocus;
end;
• Саставити програм који за унети редни број дана и годину одређује датум.
На форму ћемо ставити лабелу за наслов, лабелу за комуникацију са корисником, два едита за унос,
лабелу за испис резултата и три тастера за управљање апликацијом.

Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Датум

према редном броју; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = (270, 320); MaxLength = (3, 4); Top = 80;
Width = (40, 60).
AutoSize = False; Caption = Редни број дана и година; Height = 36;
Layout = tlCenter; Left = 20; Top = 80; Width = 250.
Сачуваћемо дизајнирану форму у креирани фолдер DatumRB, а затим, двокликом мишем на тастере
Label3.Caption:='';
Edit1.SetFocus;
end;
var s:string;
d,m,g,p:integer;
g:=StrToIntDef(Edit2.Text,2011); Edit2.Text:=IntToStr(g);
then p:=1
else p:=0;
If (d>365+p)or(d<1)
then s:='Погрешан унос редног броја дана.'
else begin If(p=1)and(d=60)
then begin m:=2;d:=29;
end
else begin If d>59 then d:=d-p;
Case d of
1..31 : m:= 1;
32..59 : begin d:=d-31;m:=2;end;
60..90 : begin d:=d-59;m:=3;end;
91..120: begin d:=d-90;m:=4;end;
121..151: begin d:=d-120;m:=5;end;
152..181: begin d:=d-151;m:=6;end;
182..212: begin d:=d-181;m:=7;end;
213..243: begin d:=d-212;m:=8;end;
244..273: begin d:=d-243;m:=9;end;
274..304: begin d:=d-273;m:=10;end;
305..334: begin d:=d-304;m:=11;end;
else begin d:=d-334;m:=12;end;
end;
end;
s:=Format('Тражени датум је: %1d.%1d.%4d.',[d,m,g]);
end;
Label3.Caption:=s;
Button2.SetFocus;
end;
Процедура за тастер Одреди може се написати, можда јасније и једноставније, овако:
var s:string;
d,m,g,p:integer;
g:=StrToIntDef(Edit2.Text,2011); Edit2.Text:=IntToStr(g);
then p:=1
else p:=0;
If (d>365+p)or(d<1)
then s:='Погрешан унос редног броја дана.'
else begin m:= 1;
If d>31 then begin m:=2;d:=d-31; end;
If d>28+p then begin m:=3;d:=d-28-p; end;


s:=Format('Тражени датум је: %1d.%1d.%4d.',[d,m,g]);
end;
Label3.Caption:=s;
Button2.SetFocus;
end;
Сачуваћемо програм и извршити га.
• Саставити програм који одређује разлику између два датума у истој години.
Година нам је потребна само због преступног дана у фебруару,
иначе је довољно само унети дан и месец у оба датума. Зато ћемо
уносити годину само код првог датума, а она ће се преписивати у
други. Задатак ћемо решити тако што ћемо одредити редне
бројеве дана у години првог и другог датума, а затим апсолутну
вредност њихове разлике.
poScreenCenter.
На форму ћемо ставити лабелу за наслов, шест едита за унос, две
лабеле за комуникацију са корисником, лабелу за испис резултата
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Одузимање датума; Font = 22, Lime; Height
Font = Bold, Black; Left = (190, 240, 290); MaxLength = (2, 2, 4); Top = (80, 130); Width = (40, 40, 60).
AutoSize = False; Caption = Редни број дана и година; Height = 36; Layout = tlCenter; Left = 50; Top = (80,
130); Width = 140.
Сачуваћемо дизајнирану форму у креирани фолдер RazlikaDD, а затим, двокликом мишем на тастере
Label3.Caption:='';
Edit1.SetFocus;
end;
var s:string;
d1,m1,g,d2,m2,p,b:integer;
begin d1:=StrToIntDef(Edit1.Text,1);Edit1.Text:=IntToStr(d1);
m1:=StrToIntDef(Edit2.Text,1);Edit2.Text:=IntToStr(m1);
g:=StrToIntDef(Edit3.Text,2013);Edit3.Text:=IntToStr(g);Edit6.Text:=IntToStr(g);
d2:=StrToIntDef(Edit4.Text,31);Edit4.Text:=IntToStr(d2);
m2:=StrToIntDef(Edit5.Text,12);Edit5.Text:=IntToStr(m2);
g:=StrToIntDef(Edit6.Text,2013);Edit3.Text:=IntToStr(g);Edit6.Text:=IntToStr(g);
then p:=1
else p:=0;
Case m1 of
2 : b:=28+p;
4,6,9,11 : b:=30;
else b:=31;
end;
If (d1>b)or(d1<1)or(m1>12)or(m1<1)

then s:='Погрешно унет први датум.'

else begin Case m2 of
2 : b:=28+p;
4,6,9,11 : b:=30;
else b:=31;
end;
If (d2>b)or(d2<1)or(m2>12)or(m2<1)
then s:='Погрешно унет други датум.'
else begin Case m1 of
2 : d1:=d1+31;
3 : d1:=d1+31+28+p;
4 : d1:=d1+31+28+p+31;
5 : d1:=d1+31+28+p+31+30;
6 : d1:=d1+31+28+p+31+30+31;
7 : d1:=d1+31+28+p+31+30+31+30;
8 : d1:=d1+31+28+p+31+30+31+30+31;
9 : d1:=d1+31+28+p+31+30+31+30+31+31;
10 : d1:=d1+31+28+p+31+30+31+30+31+31+30;
11 : d1:=d1+31+28+p+31+30+31+30+31+31+30+31;
12 : d1:=d1+31+28+p+31+30+31+30+31+31+30+31+30;
end;
If m2> 1 then d2:=d2+31;
If m2> 2 then d2:=d2+28+p;
If m2> 3 then d2:=d2+31;
If m2> 4 then d2:=d2+30;
If m2> 5 then d2:=d2+31;
If m2> 6 then d2:=d2+30;
If m2> 7 then d2:=d2+31;
If m2> 8 then d2:=d2+31;
If m2> 9 then d2:=d2+30;
If m2>10 then d2:=d2+31;
If m2>11 then d2:=d2+30;
s:='Разлика у данима је '+IntToStr(Abs(d2-d1));
end;
end;
Label3.Caption:=s;
Button2.SetFocus;
end;
Ако се погрешно унесе један датум морају се поново уписати оба датума, ово је могло бити боље
решено. Редни бројеви дана код првог и другог датума одређивани су различитим начинима само да би
се приказале обе могућности. Уместо уноса датума помоћу три едита, може се искористити компонента
DateTimePicker (десета компонента на листићу Win32). У том
случају нема потребе вршити контролу уноса датума, јер ће
датум бити сигурно исправно унет из календара, већ треба само
проверити да ли су године у оба датума исте. Функције DayOf,
MonthOf и YearOf за издвајање дана, месеца и године из унетог
датума, нису стандардне, већ се налазе у посебној библиотеци
DataUtils, па ову библиотеку треба прикључити програму у
одељку uses да би се могле користити. Такође, у овој библиотеци
постоји и функција DaysBetween(dat1, dat2) која одређује разлику
између два датума , али ми је нећемо користити јер овај задатак
користимо за увежбавање наредби гранања, а овом функцијом
би оне биле потпуно непотребне.
Приказаћемо само процедуру за тастер Одреди:
var s:string;
d1,m1,g1,d2,m2,g2,p:integer;
begin d1:=DayOf(DateTimePicker1.Date);
m1:=MonthOf(DateTimePicker1.Date);
g1:=YearOf(DateTimePicker1.Date);
d2:=DayOf(DateTimePicker2.Date);
m2:=MonthOf(DateTimePicker2.Date);
g2:=YearOf(DateTimePicker2.Date);
If g1<>g2
then s:='Погрешно унети датуми.'
else begin If (g1 mod 4=0)and(g1 mod 100<>0)or(g1 mod 400=0)
then p:=1
else p:=0;
If m1> 1 then d1:=d1+31;
If m1> 2 then d1:=d1+28+p;
If m1> 3 then d1:=d1+31;
If m1> 4 then d1:=d1+30;
If m1> 5 then d1:=d1+31;
If m1> 6 then d1:=d1+30;
If m1> 7 then d1:=d1+31;

If m1> 8 then d1:=d1+31;

If m1> 9 then d1:=d1+30;
If m1>10 then d1:=d1+31;
If m1>11 then d1:=d1+30;
If m2> 1 then d2:=d2+31;
If m2> 2 then d2:=d2+28+p;
If m2> 3 then d2:=d2+31;
If m2> 4 then d2:=d2+30;
If m2> 5 then d2:=d2+31;
If m2> 6 then d2:=d2+30;
If m2> 7 then d2:=d2+31;
If m2> 8 then d2:=d2+31;
If m2> 9 then d2:=d2+30;
If m2>10 then d2:=d2+31;
If m2>11 then d2:=d2+30;
s:='Разлика у данима је '+IntToStr(Abs(d2-d1));
end;
Label3.Caption:=s;
end;
• Саставити програм који за унета два броја и рачунску операцију одређује резултат.
poScreenCenter.
цију са корисником, три едита за унос, лабелу за испис резултата
Калкулатор; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = (60, 140, 170); MaxLength = (0, 1, 0); Top =
(80, 120, 160); Width = (120, 30, 120).
AutoSize = False; Caption = (a =, Операција, b =); Height = 36; Layout = tlCenter; Left = (20, 30, 130); Top =
(80, 120, 160); Width = (20, 120, 20).
Сачуваћемо дизајнирану форму у креирани фолдер Kalkulator, а затим, двокликом мишем на тастере
Label3.Caption:='';
Edit1.SetFocus;
end;
var s:string;
a,b:real;
o:char;
o:=Edit2.Text[1];
s:=Edit1.Text+o+Edit3.Text+'=';
Case o of
'+':s:=s+FloatToStr(a+b);
'-':s:=s+FloatToStr(a-b);
'*':s:=s+FloatToStr(a*b);
'/':If b<>0
then s:=s+FloatToStr(a/b)
else s:='није дефинисано';
else s:='непозната операција';
end;
Button2.SetFocus;
end;
Следеће три процедуре кориснуку олакшавају употребу програма анализом притиснутог тастера у
одговарајући едит. У првом и трећем дозвољено је користити тастере са цифрама, BackSpace, Delete и
Enter што је дефинисано скупом. У другом едиту дозвољено је користити тастере +, -, *, /, BackSpace и
Enter што је такође, дефинисано скупом. Ако се употреби било који други тастер оквири ће се понашати
као да је притиснут тастер Esc, односно, неће се десити ништа.
procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char);
begin If key=#13
then Edit2.SetFocus
else If not (key in ['0'..'9',#8,#128])
then key:=#27;
end;
begin If key=#13
then Edit3.SetFocus
else If not (key in ['+','-','*','/',#8])
then key:=#27;
end;
begin If key=#13
then Button1.Click
else If not (key in ['0'..'9',#8,#128])
then key:=#27;
end;
Задатак се може решити и коришћењем комбобокса за унос
операција (на овај начин можемо додати и још неке једноставне
двочлане операције). Форма се незнатно мења, а као и програм,
па ћемо приказати само процедуру за тастер Одреди:
var s:string;
a,b:real;
begin a:=StrToFloatDef(Edit1.Text,1);
Edit1.Text:=FloatToStr(a);
b:=StrToFloatDef(Edit2.Text,3);
Edit2.Text:=FloatToStr(b);
s:=Edit1.Text+ComboBox1.Text+Edit2.Text+'=';
Case ComboBox1.ItemIndex of
1:s:=s+FloatToStr(a+b);
2:s:=s+FloatToStr(a-b);
3:s:=s+FloatToStr(a*b);
4:If b<>0
then s:=s+FloatToStr(a/b)
else s:='није дефинисано';
else s:='непозната операција';
end;
Label3.Caption:=a;
Button2.SetFocus;
end;
Било би занимљивије направити верзију овог програма где би се и цифре бројева и
ознака рачунске операције уносили кликом на одговарајуће тастере - мало реалнија
симулација рада са калкулатором. Форма би могла бити дизајнирана као на слици.
Сви улазни и излазни подаци приказују се у едиту коме је кориснику забрањен
приступ (ReadOnly := true). Али, пошто је ово мало компликованије и алгоритамски и
за описивање, нека то буде задатак за оне који желе, могу и знају више.
• Бројна права је трима тачкама подељена на четири дела. Саставити
програм који одређује у ком делу се налази уписани број.
poScreenCenter.
На форму ћемо ставити лабелу за наслов, лабелу за комуника-
цију са корисником, едит за унос, лабелу за испис резултата и три
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Бројна
права и тачка; Font = 22, Lime; Height = 50; Layout = tlCenter.
AutoSize = False; Caption = Т =; Height = 36; Layout = tlCenter; Left = 90; Top = 80; Width = 40.

Сачуваћемо дизајнирану форму у креирани фолдер BPrava, а затим, двокликом мишем на тастере редом
Label3.Caption:='';
Edit1.SetFocus;
end;
const a=-3; b=1; c=7;
var s:string;
d:integer;
begin d:=StrToIntDef(Edit1.Text,4);Edit1.Text:=IntToStr(d);
s:='Тачка '+Edit1.Text+' ';
Case d of
-maxint..a-1:s:=s+'је испред тачке '+IntToStr(a);
a: s:=s+'се поклапа са тачком '+IntToStr(a);
a+1..b-1: s:=s+'је између тачака '+IntToStr(a)+' и '+IntToStr(b);
b: s:=s+'се поклапа са тачком '+IntToStr(b);
b+1..c-1: s:=s+'је између тачака '+IntToStr(b)+' и '+IntToStr(c);
c: s:=s+'се поклапа са тачком '+IntToStr(c);
c+1..maxint:s:=s+'је иза тачке '+IntToStr(c);
end;
Label3.Caption:=s;
Button2.SetFocus;
end;
Уместо Case наредбе могли смо употребити и комбинацију од
неколико If наредби, али је овако решење читљивије.
Подеоне тачке морају бити претходно дефинисане константе да
бисмо смели да употребимо Case наредбу. Ако желимо да се
подеоне тачке мењају у програму, онда се овај задатак може
решити само помоћу If наредбе. У том случају, најпре се подеоне
тачке морају уредити у растући поредак, а затим се одређује
положај унете тачке на бројној правој.
Приказаћемо само процедуру за тастер Одреди у оваквом случају.
var s:string;
a,b,c,d,p:integer;
begin a:=StrToIntDef(Edit2.Text,-3);Edit2.Text:=IntToStr(a);
If a>b
end;
If a>c
then begin p:=a;a:=c;c:=p;
end;
If b>c
then begin p:=b;b:=c;c:=p;
end;
d:=StrToIntDef(Edit1.Text,4); Edit1.Text:=IntToStr(d);
s:='Тачка '+Edit1.Text+'';
If d=a
then s:=s+' се поклапа са тачком '+IntToStr(a)
else If d=b
then s:=s+' се поклапа са тачком '+IntToStr(b)
else If d=c
then s:=s+' се поклапа са тачком '+IntToStr(c)
else If d<a
then s:=s+' је испред тачке '+IntToStr(a)
else If d<b
then s:=s+' је између тачака '+IntToStr(a)+' и '+IntToStr(b)
else If d<c
then s:=s+' је између тачака '+IntToStr(b)+' и '+IntToStr(c)
else s:=s+' је иза тачке '+IntToStr(c);
Label3.Caption:=s;
Button2.SetFocus;
end;

• Саставити програм који одређује површину и запремину правилне тростране пирамиде

ако су дате висина пирамиде и висина бочне стране.
poScreenCenter.
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Тро
страна пирамида; Font = 22, Lime; Height = 50; Layout = tlCenter.
AutoSize = False; Caption = (H =, h =, P =, V =); Height = 36; Layout = tlCenter; Left = (20, 100); Top = (80, 130,
180, 230); Width = 40.
250); Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер TPiramida, а затим, двокликом мишем на тастере
Edit3.Clear;Edit4.Clear;Edit1.SetFocus;
end;
var h,h1,a,p,v:real;
begin h:=StrToFloatDef(Edit1.Text,1); Edit1.Text:=FloatToStr(h); // висина пирамиде
h1:=StrToFloatDef(Edit2.Text,3);Edit2.Text:=FloatToStr(h1); // висина бочне стране
a:=2*Sqrt(3*(h1*h1-h*h)); // основица
p:=a*a*Sqrt(3)/4+3*a*h1/2;Edit3.Text:=Format('%8.2f',[p]);
v:=a*a*Sqrt(3)/4*h/3; Edit4.Text:=Format('%8.2f',[v]);
Button2.SetFocus;
end;
Да би све било коректно, морамо обезбедити да подаци буду исправно унети. То ћемо урадити помоћу
следеће две процедуре за контролу уноса података у прва два едита:
begin If StrToFloatDef(Edit1.Text,0)=0
then begin MessageBox(0,'Висина пирамиде мора бити'+#13+
'већа од нуле','ГРЕШКА У УНОСУ',0);
end;
end;
begin If StrToFloatDef(Edit2.Text,0)<=StrToFloatDef(Edit1.Text,0)
then begin MessageBox(0,'Висина бочне стране мора бити'+#13+
'већа од висине пирамиде','ГРЕШКА У УНОСУ',0);
end;
end;
• Саставити програм који одређује површину и запремину правилне четворостране

пирамиде ако је дате висина пирамиде и бочна ивица.
На форму ћемо ставити лабелу за наслов, четири лабеле за комуникацију са корисником, два едита за
унос, два едита за испис резултата и три тастера за управљање апликацијом.
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Четворострана пирамида; Font = 22, Lime;

AutoSize = False; Caption = (H =, s =, P =, V =); Height = 36; Layout =
tlCenter; Left = (20, 100); Top = (80, 130, 180, 230); Width = 40.
Left = (140, 140, 250); Top = (80, 130, 250); Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер CPiramida, а
end;
var h,s,a,p,v:real;
begin h:=StrToFloatDef(Edit1.Text,1);Edit1.Text:=FloatToStr(h); // висина пирамиде
s:=StrToFloatDef(Edit2.Text,3);Edit2.Text:=FloatToStr(s); // бочна ивица
a:=Sqrt(2*(s*s-h*h)); // основица
p:=a*a+4*Sqrt((s+a/2)*(s-a/2)*a*a/4);Edit3.Text:=Format('%1.2f',[p]);
v:=a*a*h/3; Edit4.Text:=Format('%1.2f',[v]);
Button2.SetFocus;
end;
end;
end;
then begin MessageBox(0,'Бочна ивица пирамиде мора бити'+#13+
'већа од висине пирамиде','ГРЕШКА У УНОСУ',0);
end;
end;
• Саставити програм који одређује површину и запремину правилне шестостране

пирамиде ако су дате бочна ивица и висина.
poScreenCenter.
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Шест
острана пирамида; Font = 22, Lime; Height = 50; Layout = tlCenter.
AutoSize = False; Caption = (s =, h =, P =, V =); Height = 36; Layout = tlCenter; Left = (20, 100); Top = (80, 130,
180, 230); Width = 40.
250); Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер SPiramida, а затим, двокликом мишем на тастере

end;
var h,s,a,p,v:real;
begin s:=StrToFloatDef(Edit1.Text,1);Edit1.Text:=FloatToStr(s); // бочна ивица
h:=StrToFloatDef(Edit2.Text,3);Edit2.Text:=FloatToStr(h); // бочна висина
a:=2*Sqrt(s*s-h*h); // основица
p:=3*a*a*Sqrt(3)/2+3*a*h; Edit3.Text:=Format('%1.2f',[p]);
v:=3*a*a*Sqrt(3)/2*Sqrt(s*s-a*a)/3;Edit4.Text:=Format('%1.2f',[v]);
Button2.SetFocus;
end;
end;
end;
var a,s,h:real;
begin s:=StrToFloatDef(Edit1.Text,0);
h:=StrToFloatDef(Edit2.Text,0);
a:=4*h*h-3*s*s;
If StrToFloatDef(Edit2.Text,0)<=0
then begin MessageBox(0,'Бочна висина мора бити'+#13+
end
else If s<=h
then begin MessageBox(0,'Бочна висина мора бити'+#13+
'мања од бочне ивицe','ГРЕШКА У УНОСУ',0);
end
else If a<=0
then begin MessageBox(0,'Бочна висина мора бити већа од уписане',
'ГРЕШКА У УНОСУ',0);
end;
end;
• Саставити програм који одређује површину и запремину ваљка уписаног у купу ако је
дата изводница и полупречник основе купе, а висина ваљка и висина купе су у односу н:м.
poScreenCenter.
кацију са корисником, четири едита за унос, два едита за испис
Ваљак у купи; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = (60, 180); Top = (80, 130); Width = (70, 60).
AutoSize = False; Caption = (s =, r =, n =, m =, P =, V =); Height = 36; Layout = tlCenter; Left = (20, 20, 140, 140,
100, 100); Top = (80, 130, 80, 130, 180, 230); Width = 40.
Сачуваћемо дизајнирану форму у креирани фолдер Valjak, а затим, двокликом мишем на тастере редом


end;
var h,r,s,m,n,p,v:real;
begin s:=StrToFloatDef(Edit1.Text,4);Edit1.Text:=FloatToStr(s); // изводница
r:=StrToFloatDef(Edit2.Text,3);Edit2.Text:=FloatToStr(r); // полупречник основе купе
n:=StrToFloatDef(Edit3.Text,3);Edit3.Text:=FloatToStr(n);
m:=StrToFloatDef(Edit4.Text,4);Edit4.Text:=FloatToStr(m);
h:=Sqrt(s*s-r*r); // висина купе
h:=h*n/m; // висина ваљка
r:=r*(m-n)/m; // полупречник основе ваљка
p:=2*r*pi*(r+h);Edit5.Text:=Format('%1.2f',[p]);
v:=r*r*pi*h; Edit6.Text:=Format('%1.2f',[v]);
Button2.SetFocus;
end;
следеће четири процедуре за контролу уноса података у прва четири едита:
then begin MessageBox(0,'Изводница купе мора бити'+#13+
end;
end;
then begin MessageBox(0,'Полупречник основе купе мора бити'+#13+
'мањи од изводнице','ГРЕШКА У УНОСУ',0);
end;
end;
begin If StrToFloatDef(Edit3.Text,0)<=0
then begin MessageBox(0,'n мора бити веће од нуле','ГРЕШКА У УНОСУ',0);
end;
end;
then begin MessageBox(0,'m мора бити веће од n','ГРЕШКА У УНОСУ',0);
end;
end;
• Саставити програм који одређује да ли су три тачке у равни колинеарне, па ако јесу
одређује тачку у средини, а ако нису израчунава висине троугла који оне формирају.
poScreenCenter.
Колинеарне; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = (70, 180); Top = (80, 130, 180); Width = 50.
AutoSize = False; Caption = (x1 =, y1 =, x2 =, y2 =, x3 =, y3 =); Height = 36; Layout = tlCenter; Left = (20, 130);
Top = (80, 130, 180); Width = 50.

Сачуваћемо дизајнирану форму у креирани фолдер Kolinearne, а затим, двокликом мишем на тастере
Label8.Caption:='';Edit1.SetFocus;
end;
var x1,x2,x3,y1,y2,y3,p,h1,h2,h3:real;
a,b,c:string;
begin x1:=StrToFloatDef(Edit1.Text,1);Edit1.Text:=FloatToStr(x1);
y1:=StrToFloatDef(Edit2.Text,3);Edit2.Text:=FloatToStr(y1);
x2:=StrToFloatDef(Edit3.Text,5);Edit3.Text:=FloatToStr(x2);
{ тачке су на истој правој ако су апсцисе или ординате све три тачке једнаке или ако су на
истом краку угла са теменом у једној од тачака. Услов у If обухвата све те случајеве јер:
ако су им једнаке апсцисе x1-x3=0=x1-x2; ако су им једнаке ординате y1-y2=0=y1-y3;
ако су на истом краку тангенс угла (теме у првој тачки) је (y1-y2)/(x1-x2)=(y1-y3)/(x1-x3) }
If Abs((y1-y2)*(x1-x3))=Abs((y1-y3)*(x1-x2))
then begin If (x1=x2)and(x2=x3) // уређујемо тачке према растојању од коо-почетка
then begin If y1>y2 then begin p:=y1;y1:=y2;y2:=p;end;
If y1>y3 then begin p:=y1;y1:=y3;y3:=p;end;
If y2>y3 then begin p:=y3;y3:=y2;y2:=p;end;
end
else begin If x1>x2 then begin p:=x1;x1:=x2;x2:=p;end;
If x1>x3 then begin p:=x1;x1:=x3;x3:=p;end;
If x2>x3 then begin p:=x3;x3:=x2;x2:=p;end;
end;
a:='('+FloatToStr(x1)+','+FloatToStr(y1)+')'; // координате прве тачке
b:='('+FloatToStr(x2)+','+FloatToStr(y2)+')'; // координате друге тачке
c:='('+FloatToStr(x3)+','+FloatToStr(y3)+')'; // координате треће тачке
Label8.Caption:='Тачка '+b+' је између'+#13+'тачака '+a+' и '+c+'.'
end
else begin h1:=Sqrt(Sqr(x1-x2)+Sqr(y1-y2)); // дужина прве странице троугла
h2:=Sqrt(Sqr(x2-x3)+Sqr(y2-y3)); // дужина друге странице троугла
h3:=Sqrt(Sqr(x3-x1)+Sqr(y3-y1)); // дужина треће странице троугла
p:=Sqrt((h1+h2+h3)*(h1+h2-h3)*(h2+h3-h1)*(h3+h1-h2))/4; // површина - Херон
a:=Format('%1.3f',[2*p/h1]); // висина на прву страницу
b:=Format('%1.3f',[2*p/h2]); // висина на другу страницу
c:=Format('%1.3f',[2*p/h3]); // висина на трећу страницу
Label8.Caption:='Висине троугла су '+#13+a+'; '+b+' и '+c+'.'
end;
Button2.SetFocus;
end;
• Саставити програм који одређује да ли су три тачке у равни колинеарне, па ако нису
одређује тачку која са ове три чини темена паралелограма.
poScreenCenter.
Паралелограм; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = (70, 180); Top = (80, 130, 180); Width = 50.


AutoSize = False; Caption = (x1 =, y1 =, x2 =, y2 =, x3 =, y3 =); Height = 36; Layout = tlCenter; Left = (20, 130);
Top = (80, 130, 180); Width = 50.
Сачуваћемо дизајнирану форму у креирани фолдер Paralelogram, а затим, двокликом мишем на тастере
Label8.Caption:='';
Edit1.SetFocus;
end;
var x1,x2,x3,x4,x5,x6,y1,y2,y3,y4,y5,y6,k1,k2,k3,n1,n2,n3:real;
a,b,c:string;
begin x1:=StrToFloatDef(Edit1.Text,1);Edit1.Text:=FloatToStr(x1);
If Abs((y1-y2)*(x1-x3))=Abs((y1-y3)*(x1-x2))
then Label8.Caption:='Тачке се налазе на једној правој.'
else begin If x1=x2
then begin x4:=x3; y4:=y3+(y1-y2); // у3 померено за наспрамну страницу
x5:=x3; y5:=y3-(y1-y2); // горе или доле, два темена троугла
x6:=2*x1-x3;y6:=y1+y2-y3; // треће теме трогла
end
else If x2=x3
then begin x4:=x1; y4:=y1+(y2-y3);
x5:=x1; y5:=y1-(y2-y3);
x6:=2*x2-x1;y6:=y2+y3-y1;
end
else If x3=x1
then begin x4:=x2; y4:=y2+(y3-y1);
x5:=x2; y5:=y2-(y3-y1);
x6:=2*x3-x2;y6:=y3+y1-y2;
end
else If y1=y2
then begin y4:=y3; x4:=x3+(x1-x2); // х3 померено за наспрамну страницу
y5:=y3; x5:=x3-(x1-x2); // горе или доле, два темена троугла
y6:=2*y1-y3;x6:=x1+x2-x3; // треће теме трогла
end
else If y2=y3
then begin y4:=y1; x4:=x1+(x2-x3);
y5:=y3; x5:=x1-(x2-x3);
y6:=2*y2-y1;x6:=x2+x3-x1;
end
else If y3=y1
then begin y4:=y2; x4:=x2+(x3-x1);
y5:=y3; x5:=x2-(x3-x1);
y6:=2*y3-y2;x6:=x3+x1-x2;
end
else begin k1:=(y2-y1)/(x2-x1);n1:=y3-k1*x3; // права паралелна првој дужи
k2:=(y3-y1)/(x3-x1);n2:=y2-k2*x2; // права паралелна другој дужи
k3:=(y2-y3)/(x2-x3);n3:=y1-k3*x1; // права паралелна трећој дужи
x4:=(n1-n2)/(k2-k1);y4:=k1*x4+n1; // пресек прве и друге праве
x5:=(n1-n3)/(k3-k1);y5:=k1*x5+n1; // пресек прве и треће праве
x6:=(n2-n3)/(k3-k2);y6:=k3*x6+n3; // пресек друге и треће праве
end;
a:='('+FloatToStr(x4)+','+FloatToStr(y4)+')';
b:='('+FloatToStr(x5)+','+FloatToStr(y5)+')';
c:='('+FloatToStr(x6)+','+FloatToStr(y6)+')';
Label8.Caption:='Тачке '+a+' ; '+b+' и '+c+' могу бити'+#13+
'четврто теме паралелограма.'
end;
Button2.SetFocus;
end;

Ако неке две тачке имају исту апсцису или ординату врло једноставно се одређују координате четврте
тачке. Представимо тачке у координатном систему и јасно видимо два решења, треће решење захтева
допуњавање слике до великог троугла, али није тешко открити га. Значи, постоје три тачке које
задовољавају услов задатка. Ако, међутим, никоје две тачке немају исту ни апсцису ни ординату онда
морамо применити мало аналитичке геометрије у равни. Нацртаћемо све три дужи које су одређене са
ове три тачке, а затим поставити праве паралелне са тим дужима које пролазе кроз трећу тачку (која
није на дужи). Таквих правих има три, секу се у три тачке које су решење задатка. Наравно, задатак је
изузетно тежак, ако немамо довољно знања из области аналитичке геометрије.
• Саставити програм који прихвата цену и количину производа и начин плаћања помоћу
радио групе, а затим одређује износ за плаћање. Ако се плаћа готовином одобрава се
попуст 10%, плаћање чековима је без попуста, а за куповину на кредит рачуна се
камата 15%. Предвидети да се проценти могу мењати.
poScreenCenter.
кацију са корисником, четири едита за унос, радио групу за избор
врсте плаћања, лабелу за испис резултата и три тастера за
Обрачун плаћања; Font = 22, Lime; Height = 50; Layout = tlCenter.
Font = Bold, Black; Left = (160, 290, 115, 115); Top = (80, 80, 130, 184);
Width = (50, 120, 35, 35).
Радио група:
Caption = Плаћање; Columns = 1; Font = 12; Height = 110; Items = [готовина, чекови, кредит]; Left = 5; Top
= 110; Width = 105.
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = ; Font = 22, Lime; Height = 80; Layout = tlCenter.
AutoSize = False; Caption = (Количина, Цена); Height = 36; Layout = tlCenter; Left = (50, 230); Top = 80;
Width = (110, 60).
180); Width = 120.
Сачуваћемо дизајнирану форму у креирани фолдер Naplata, а затим, двокликом мишем на тастере редом
RadioGroup1.ItemIndex:=0;
Label4.Caption:='';
Edit1.SetFocus;
end;
var kol,cena,pl:real;
p,k:integer;
begin kol:= StrToFloatDef(Edit1.Text,1);Edit1.Text:=FloatToStr(kol);
cena:=StrToFloatDef(Edit2.Text,3);Edit2.Text:=FloatToStr(cena);
p:=StrToIntDef(Edit3.Text,5);Edit3.Text:=IntToStr(p);
k:=StrToIntDef(Edit4.Text,2);Edit4.Text:=IntToStr(k);
{ ставке у радио групи броје се од 0, па је: 0 - готовина, 1 - чекови, 2 - кредит }
Case RadioGroup1.ItemIndex of
0 : pl:=kol*cena*(1-p/100); // 10% значи 10/100, а 1 је 100/100, па 1-10% даје 0,9
1 : pl:=kol*cena;
else pl:=kol*cena*(1+k/100); // 15% значи 15/100, а 1 је 100/100, па 1+15% даје 1,15
end;
Label4.Caption:='За плаћање '+Format('%1.0m',[pl]);
{ %1.0m (m - money) у формату дефинише испис реалног броја без децимала (.0) са поделом на
хиљаде и додатом ознаком валуте која је предефинисана у оперативном систему. Ако не желимо
ознаку валуте у испису резултата, онда уместо m треба ставити ознаку n (n - number) да бисмо
задржали поделу на хиљаде или f ( f - float) ако желимо да у испису буде само реалан број }
Button2.SetFocus;
end;

• Саставити програм који за унету брзину и угао одређује време лета, највећу висину и
удаљеност пада пројектила код косог хица. Брзину задавати у m/s или km/h, а угао у
степенима или у радијанима,
Да би се задатак што једноставније решио увешћемо радио групе
којима ће се дефинисати јединице за брзину и угао. Затим ћемо,
када је то потребно, конвертовати брзину у m/s и/или угао у
радијанима да не бисмо имали више формула него што нам је
потребно. Улазни подаци ће се, најпре, уносити у едите, а касније
ћемо показати и коришћење неких других компоненти којима се
олакшава унос података.
Linotype, BoldItalic, 13; FormStyle = fsStayOnTop; Position =
poScreenCenter.
кацију са корисником, два едита за унос, две радио групе за избор
типа података, три едита за испис резултата и три тастера за
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Коси хитац; Font = 22, Lime; Height = 50;
Layout = tlCenter.
Font = Bold, Black; Left = 270; Top = (75, 145); Width = 110;
Едити за исписивање резултата:
Font = Bold, Black; Left = 150; Text = ; ReadOnly = True; Top = (210, 255, 300); Width = 110.
Радио групe:
Caption = (Почетна брзина, Угао); Columns = 3; Height = 65; ItemIndex = 1; Items = ([km/h, m/s], [Степени,
Радијани]); Left = 5; Top = (55, 125); Width = 385.
AutoSize = False; Caption = (Време лета, Даљина, Највећа висина); Height = 31; Layout = tlCenter. Left =
15; Top = (210, 255, 300); Width = 135.
Додаћемо три тастера са следећим карактеристикама:
Caption = (Одреди, Обриши, Крај рада); Font = Bold; Height = 40; Left = 270; Top = (200, 250, 300); Width =
120.
Резултати су уоквирени бевелом:
Height = 140; Left = 5; Shape = bsFrame; Style = bsRaised; Top = 200; Width = 260.
Сачуваћемо дизајнирану форму у креирани фолдер KosiHitac, а затим, двокликом мишем на тастере
begin Edit1.Clear;Edit1.ReadOnly:=true;
Edit2.Clear;Edit2.ReadOnly:=true;
RadioGroup1.Enabled:=true;
RadioGroup2.Enabled:=true;
Edit1.SetFocus;
end;
procedure Button1Click(Sender: TObject);
const g = 9.8062;
var V, Fi, T: Real;
begin V := StrToFloatDef(Edit1.Text,0);Edit1.Text:=FloatToStr(V);
Fi:= StrToFloatDef(Edit2.Text,0);Edit2.Text:=FloatToStr(Fi);
If RadioGroup1.ItemIndex=0
then V:=V/3.6;
If RadioGroup2.ItemIndex=0
then Fi:=Fi*Pi/180;
T:=2*V/g*Sin(Fi);Edit3.Text:=FloatToStr(T)+' s';
Edit4.Text:=FloatToStr(T*V*Cos(Fi))+' m';
Edit4.Text:=FloatToStr(T*V/4*Sin(Fi)) + ' m'
Edit1.ReadOnly:=true;RadioGroup1.Enabled:=false;
Edit2.ReadOnly:=true;RadioGroup2.Enabled:=false;
Button2.SetFocus;
end;
Избором јединица из радио група мора се извршити и конверзија података који су претходно унети у
одговарајуће едите. За то ћемо написати две процедуре које ће реаговати на клик мишем на радио групу:
procedure TForm1.RadioGroup1Click(Sender: TObject);
var V:real;
begin V:=StrToFloatDef(Edit1.Text,0);

If (V<>0)and(RadioGroup1.ItemIndex=1)
then Edit1.Text:=FloatToStr(V/3.6)
else Edit1.Text:=FloatToStr(V*3.6);
end;
procedure TForm1.RadioGroup2Click(Sender: TObject);
var Fi:real;
begin Fi:=StrToFloatDef(Edit2.Text,0);
If (Fi<>0)and(RadioGroup2.ItemIndex=1)
then Edit2.Text:=FloatToStr(Fi*Pi/180)
else Edit2.Text:=FloatToStr(Fi/Pi*180);
end;
За уношење почетне брзине и угла можемо користити
компоненту TrackBar (пета компонента на листићу Win32).
Компонента је мало сложенија, па ћемо навести само решење
проблема помоћи ње, а оставићемо за додатну активност
детаљније упознавање и употребу компоненте.
procedure TForm1.Odredi(Sender: TObject);
const g = 9.8062;
var V, Fi, T: Real;
begin V:=TrackBar1.Position;
If RadioButton1.Checked then V:=V/3.6;
If RadioButton4.Checked
then Fi:=TrackBar2.Position/100000
else Fi:=TrackBar2.Position*Pi/180;T:=2*V/g*Sin(Fi);
Edit3.Text:=Format('%5.2f s',[T]);
Edit4.Text:=Format('%5.2f m',[T*V*Cos(Fi)]);
Edit5.Text:=Format('%5.2f m',[T*V/4*Sin(Fi)]);
end;
procedure TForm1.TrackBar1Change(Sender: TObject);
begin Label2.Caption:=IntToStr(TrackBar1.Position);
Odredi(Sender);
end;
procedure TForm1.TrackBar2Change(Sender: TObject);
begin if RadioButton4.Checked
then Label3.Caption:=FloatToStr(TrackBar2.Position/100000)
else Label3.Caption:=IntToStr(TrackBar2.Position);
Odredi(Sender);
end;
procedure TForm1.RadioButton1Click(Sender: TObject);
var P: Integer;
begin if Label4.Caption='m/s' then
begin Label4.Caption:='km/h';
P:=Round(TrackBar1.Position*3.6);
TrackBar1.Max :=360;TrackBar1.Frequency:=50;
TrackBar1.Position:=P; TrackBar1Change(Sender);
end;
end;
var P: Integer;
begin if Label4.Caption = 'km/h' then
begin Label4.Caption := 'm/s';
P:=Round(TrackBar1.Position/3.6);
end;
end;
var P: Integer;
begin if Label5.Caption='st' then
begin Label5.Caption:='rad';
P:=Round(TrackBar2.Position*Pi/0.00180);
TrackBar2.PageSize:=10000; TrackBar2.LineSize :=1000;
TrackBar2.Position:=P; TrackBar2Change(Sender)
end;
end;
var P: Integer;
begin if Label5.Caption='rad' then
begin Label5.Caption:='st';
P:=Round(TrackBar2.Position/Pi*0.00180);
TrackBar2.PageSize:=5; TrackBar2.LineSize :=1;
end;
end;

Неке занимљиве компоненте

Написаћемо програм који користи компоненте које могу бити јако занимљиве, али се код решавања
школских задатака ретко користе јер никада нема довољно времена за играње са програмима.
Искористићемо три већ урађена задатка, али сада упакована у занимљивије окружење.
Отворићемо нов пројекат и подесити параметре форме на следећи начин:
BorderIcons = []; BorderStyle = bsSingle; Caption = ВИЗУЕЛНО ПРОГРАМИРАЊЕ; ClientHeight = 800;
ClientWidth = 600; Font = Palatino Linotype, 14; FormStyle = fsStayOnTop; Position = poScreenCenter.
На форму ћемо ставити компоненту MainMenu, то је друга
компонента на листићу Standard. Компонента се користи за
креирање главног менија апликације и невидљива је када се
програм покрене, зато није битно где смо је поставили, али
нека буде у левом горњем углу форме где ће најмање сметати
даљем уређивању форме. Ставке менија се додају двокликом на
ову компоненту. Отвара се мени едитор у који ћемо уписати
систем менија и подменија селектовањем ставке и уписивањем
одговарајућег текста у њену Caption карактеристику.
Дефинисаћемо три ставке менија: Задаци, Помоћ и Крај. Мени
Задаци имаће подмени са ставкама: 1. задатак, 2. задатак и 3.
задатак. Мени Помоћ имаће подмени са две стаке: Упутство и
Аутор. Мени Крај нема подменије. Свака ставка има своје име помоћу кога ће бити идентификована
приликом извршавања апликације. Име се може променити уносом карактеристике Name. Када смо
креирали жељени систем менија затварамо овај едитор. На врху радне површине прозора појавила се
трака са менијем. Сада треба ставке менија повезати са одговарајућим процедурама и функцијама.
Кликом на Крај дефинисаћемо процедуру којом се прекида рад апликације:
procedure TForm1.N3Click(Sender: TObject);
end;
Додаћемо статусну линију (StatusBar, петнаеста компонента на листићу Win32) и двокликом на њу
отворити едитор у коме ћемо додати три панела кликом на прво дугме у тулбар траци са карактеристикама:
Alignment = taCenter; Width = (220, 360, 220), Text = ( , ДЕМОНСТРАЦИЈА НЕКИХ ВИЗУЕЛНИХ
КОМПОНЕНТИ, ).
Први и трећи панел имају празну текст карактеристику зато што ће се она попуњавати програмски. На
првом панелу ће писати шта се тренутно дешава у апликацији, а трећи панел ће приказивати датум и
време.
Додаћемо и компоненту тајмер (Timer, прва компонента на листићу System), дефинисаћемо промене
на сваких 100 милисекунди (Interval = 100) и двокликом декларисати и дефинисати процедуру која
исписује датум и време на трећем панелу статусне линије:
procedure TForm1.Timer1Timer(Sender: TObject);
var d,t:string;
begin t:=TimeToStr(time);
d:=FormatDateTime('dddd, DD.MM.YYYY. ',date);
StatusBar1.Panels[2].Text:=d+' '+t;
end;
Постављањем миша на ставку Помоћ отвара се подмени. Кликом на
ставку Аутор дефинисаћемо процедуру којом се представља аутор
апликације:
begin MessageBox(0,'ДЕМО програм'+#13+
'Аутор програма: Мирослав Илић'+#13+#13+
' © 2014.'+#13+
' ® All Rights Reserved',
'Аутор',MB_TASKMODAL+MB_ICONASTERISK+MB_OK);
end;
Команда MessageBox(0,<порука>, <наслов>, <врста>) има различите облике, а ово је један од њих.
- први параметар одређује власника прозора са поруком (0 - припада форми са које смо га отворили),
- <порука> је текст који се исписује у прозору, при чему #13 означава прелазак у нови ред, чиме је
омогућено да се порука исписује у више редова,
- <наслов> је текст који се исписује у траци са називом прозора
- <врста> одређује карактеристике поруке (могуће вредности су: MB_APPLMODAL, MB_SYSTEMMODAL,
MB_TASKMODAL - ниво зависности дијалога; MB_ABORTRETRYIGNORE, MB_OK, MB_OKCANCEL, MB_RETRYCANCEL,
MB_YESNO, MB_YESNOCANCEL - тастери који ће бити приказани у дијалошком прозору; MB_ICONEXCLAMATION,
MB_ICONWARNING, MB_ICONINFORMATION, MB_ICONASTERISK, MB_ICONQUESTION, MB_ICONSTOP, MB_ICONERROR,
MB_ICONHAND сличица која ће пратити текст у поруци. Дозвољено је комбиновати по једну вредност из
сваке групе, вредности се раздвајају +, а редослед није битан. Вредност коју даје затварање овог
дијалога, у зависности од тога који су тастери видљиви, може бити: IDOK, IDCANCEL, IDABORT, IDRETRY,
IDIGNORE, IDYES, IDNO - овде нисмо користили јер је дијалог само информативан).

Кликом на ставку Упутство дефинисаћемо процедуру којом

се исписује упутство за употребу апликације (овде је приказана
процедура која отвара панел са упутством, а упутство је текст
датотека коју треба уписати помоћу неког екстерног програма
и уградити у мемо поље на панелу):
begin Panel1.Visible:=true;
Panel1.BringToFront;
end;
Да би ова процедура имала смисла, претходно ћемо додати
неколико компоненти на форму:
- панел (Panel, петнаеста компонента на листићу Standard):
Align = alClient; BevelInner = bvLowered; BevelOuter = bvLowered;
BevelWidth = 4; BorderStyle = bsSingle; BorderWidth = 2, Caption = ;
Color = clTeal;Visible = false.
- лабелу за наслов:
Align = alTop; Alignment = taCenter; AutoSize = False; Caption = Упутство за употребу програма; Font =
BoldItalic, 22; Height = 50; Layout = tlCenter
- битбатон (BitBtn, прва компонента на листићу Additional):
Caption = ; Height = 40; Glyph = (двокликом се отвара дијалог за избор сличице); Left = 741; Top = 15;
Width = 40
- мемо поље (Memo, шеста компонента на листићу Standard):
Align = alClient; BevelInner = bvLowered; BevelKind = bkSoft; BevelOuter = bvLowered; Color =
clMoneyGreen; Font = Italic, 14; Lines = (двокликом се отвара едитор у који треба уписати упутство);
ReadOnly = true.
Lines карактеристику можемо попунити садржајем екстерне текстуалне датотеке Упутство командом
на почетку, приликом креирања апликације или у тренутку отварања панела са упутством):
Memo1.Lines.LoadFromFile('Uputstvo.txt');
Двокликом на битбатон дефинисаћемо процедуру којом се напушта упутство за употребу:
procedure TForm1.BitBtn1Click(Sender: TObject);
begin Panel1.Visible:=false;
end;
Сада смо учинили све припремне радње којима је апликација динамизирана. Додаћемо сада три
панела, за сваки задатак по један, и копираћемо све објекте и процедуре које су везане за те задатке.
Наравно, мораћемо да начинимо неке ситне преправке у карактеристикама копираних објеката, пре
свега у положају и величини, али и у називима, а тиме и у именима процедура које извршавају неки
задатак.
Копираћемо већ постојећи панел тако што ћемо поставити показивач миша на руб панела, кликнути
десним тастером и изабрати команду Edit -> Copy. Затим ћемо поставити показивач миша на тајмер
компоненту, кликнути десним тастером и изабрати команду Edit -> Paste (на овај начин се избегава да
се нови панел постави на претходни панел, већ се поставља на форму). Обрисаћемо мемо поље са новог
панела и дефиницију процедуре на клик на битбатон (у објект инспектору на листићу догађаја
обрисаћемо BitBtn1Click), а двокликом дефинисати BitBtn2Click и променити име процедуре у Povratak,
а затим ћемо копирати овај панел још два пута, на исти начин. Да бисмо, осим именом, разликовали ова
три панела један од другог поставићемо им различите боје: clMaroon, clNavy, clPurple. Одмах можемо
дефинисати процедуре које приказују и уклањају ове панеле тако што ћемо из менија Задаци бирати једну
по једну ставку:
Panel3.Visible:=false;
StatusBar1.Panels[0].Text:='Први задатак';
end;
StatusBar1.Panels[0].Text:='Други задатак';
end;
StatusBar1.Panels[0].Text:='Трећи задатак ';
end;
procedure TForm1.Povratak(Sender: TObject);
begin Panel4.Visible:=false;
StatusBar1.Panels[0].Text:=' ';
end;

Овако изгледају панели са задацима:
Оквир за резултате у првом и трећем задатку је компонента Bevel (осма компонента на листићу
Additional), а листићи са варијантама трећег задатка су делови компоненте PageControl (друга
компонента на листићу Win32). Листићи на PageControl компоненти додају се десним кликом на мишу
и избором команде New Page из отвореног менија, а називи листића се уписују у Caption
карактеристику. На насловној страни колекције трећег задатка су три сличице троугла у три
компоненте Image (шеста компонента на листићу Additional), а сличице се додају кликом на
карактеристику Picture, отвара се едитор на коме треба кликнути на дугме Load, a затим, на уобичајен
начин, изабрати одговарајућу сличицу из отвореног дијалошког прозора. За прекривање основне боје
листића искоришћена jе лабела у белој боји која је постављена иза сличица и раширена по целом
листићу (Align = alClient). За унос логичких података у другом задатку коришћен је комбиновани оквир
(ComboBox, једанаеста компонента са листића Standard) да би се избегла потреба за коришћењем
услова за проверу исправности уноса. Логичка формула у наслову истог задатка исписана је са две
лабеле, основна је са нормалним фонтом, а преко ње је провидна лабела са фонтом Symbol. Код
решавања троугла, да би задатак био коректно решен, коришћена је If наредба код израчунавања
углова да би се избегло дељење нулом, ако је угао прав. Задатак би радио и без ове наредбе, осим ако је
један од углова  или  прав. Следи комплетан радни део програма.
// Збир природних бројева у низу
procedure TForm1.Button1Click(Sender: TObject); // Тастер одреди
var n,s:integer;
begin n:=StrToIntDef(Edit1.Text,9); Edit1.Text:=IntToStr(n);
s:=n*(n+1) div 2; Edit2.Text:=IntToStr(s);
s:=n*(n+1); Edit3.Text:=IntToStr(s);
s:=n*n; Edit4.Text:=IntToStr(s);
s:=Sqr(n div 2)+n div 2; Edit5.Text:=IntToStr(s);
s:=Sqr((n+1) div 2); Edit6.Text:=IntToStr(s);
Edit1.ReadOnly:=true; Button2.SetFocus;
end;
procedure TForm1.Button2Click(Sender: TObject); // Тастер обриши
begin Edit1.Clear; Edit2.Clear; Edit3.Clear;
Edit4.Clear; Edit5.Clear; Edit6.Clear;
Edit1.ReadOnly:=false; Edit1.SetFocus;
end;

// Истиносна вредност логичке формуле

procedure TForm1.Button3Click(Sender: TObject); // Тастер одреди
var p,q,r,t:boolean;
begin p:=StrToBoolDef(ComboBox1.Text,false); ComboBox1.Text:=BoolToStr(p,true);
q:=StrToBoolDef(ComboBox2.Text,false); ComboBox2.Text:=BoolToStr(q,true);
r:=StrToBoolDef(ComboBox3.Text,false); ComboBox3.Text:=BoolToStr(r,true);
t:=(p or q) and r; Edit7.Text:=BoolToStr(t,true);
Button4.SetFocus;
end;
procedure TForm1.Button4Click(Sender: TObject); // Тастер обриши
begin ComboBox1.Text:=''; ComboBox2.Text:='';
ComboBox3.Text:=''; Edit1.Clear;
ComboBox1.SetFocus;
end;
// Решавање произвољног троугла
procedure TForm1.Button5Click(Sender: TObject); // Тастер одреди a,b,c
var a,b,c,h1,h2,h3,t1,t2,t3,p,o:real;
p:=Sqrt((a+b+c)*(-a+b+c)*(a-b+c)*(a+b-c))/4;
h1:=2*p/a; Edit11.Text:=Format('%7.3f',[a]);
h2:=2*p/b; Edit12.Text:=Format('%7.3f',[b]);
h3:=2*p/c; Edit13.Text:=Format('%7.3f',[c]);
Edit29.Text:=Format('%7.3f',[p]);
p:=(a*a+b*b-c*c)/(2*a*b);
t1:=Sqrt(b*b+a*a/4-a*b*p); Edit17.Text:=Format('%7.3f',[t1]);
t2:=Sqrt(b*b/4+a*a-a*b*p); Edit18.Text:=Format('%7.3f',[t2]);
If p=0
then c3:=90*3600
else c3:=Abs(Round(ArcTan(Sqrt(1-p*p)/p)/pi*180*3600));
p:=(a*a-b*b+c*c)/(2*a*c);
t3:=Sqrt(a*a+c*c/4-a*c*p); Edit19.Text:=Format('%7.3f',[t3]);
If p=0
then b3:=90*3600
else b3:=Abs(Round(ArcTan(Sqrt(1-p*p)/p)/pi*180*3600));
a3:=180*3600-b3-c3;
a2:=a3 mod 3600 div 60; Edit21.Text:=IntToStr(a2);
b2:=b3 mod 3600 div 60; Edit24.Text:=IntToStr(b2);
c2:=c3 mod 3600 div 60; Edit27.Text:=IntToStr(c2);
Edit8.ReadOnly:=true; Edit10.ReadOnly:=true;
end;
procedure TForm1.Button6Click(Sender: TObject); // Тастер обриши a,b,c
Edit29.Clear; Edit30.Clear;
Edit8.ReadOnly:=false; Edit10.ReadOnly:=false;
end;
procedure TForm1.Button7Click(Sender: TObject); // Тастер одреди a,b,ha
p:=a*h1/2; h2:=2*p/b;
c:=b-Sqrt(a*a-h2*h2); c:=Sqrt(c*c+h2*h2);

p:=(a*a+b*b-c*c)/(2*a*b);
If p=0
then c3:=90*3600
p:=(a*a-b*b+c*c)/(2*a*c);
If p=0
then b3:=90*3600
a3:=180*3600-b3-c3;
end;
procedure TForm1.Button8Click(Sender: TObject); // Тастер обриши a,b,ha
end;
procedure TForm1.Button9Click(Sender: TObject); // Тастер одреди a,ha,hb
p:=a*h1/2; b:=2*p/h2;
c:=b-Sqrt(a*a-h2*h2); c:=Sqrt(c*c+h2*h2);
p:=(a*a+b*b-c*c)/(2*a*b);
If p=0
then c3:=90*3600
p:=(a*a-b*b+c*c)/(2*a*c);
If p=0
then b3:=90*3600
a3:=180*3600-b3-c3;
end;
procedure TForm1.Button10Click(Sender: TObject); // Тастер обриши a,ha,hb


end;
procedure TForm1.Button11Click(Sender: TObject); // Тастер одреди ha,hb,hc
begin h1:=StrToFloatDef(Edit77.Text,4); Edit77.Text:=FloatToStr(h1);
h2:=StrToFloatDef(Edit78.Text,3); Edit78.Text:=FloatToStr(h2);
h3:=StrToFloatDef(Edit79.Text,2.4); Edit79.Text:=FloatToStr(h3);
a:=1/h1; b:=1/h2; c:=1/h3; p:=Sqrt((a+b+c)*(-a+b+c)*(a-b+c)*(a+b-c))/4;
a:=a/p/2; Edit80.Text:=Format('%7.3f',[a]);
b:=b/p/2; Edit81.Text:=Format('%7.3f',[b]);
c:=c/p/2; Edit82.Text:=Format('%7.3f',[c]);
p:=a*h1/2; Edit99.Text:=Format('%7.3f',[p]);
p:=(a*a+b*b-c*c)/(2*a*b);
If p=0
then c3:=90*3600
p:=(a*a-b*b+c*c)/(2*a*c);
If p=0
then b3:=90*3600
a3:=180*3600-b3-c3;
end;
procedure TForm1.Button12Click(Sender: TObject); // Тастер обриши ha,hb,hc
end;
У понуди програмског окружења са којим радимо има још јако пуно занимљивих, а једноставних
компоненти, али њихова примена захтева познавање многих наредби које још нисмо научили и много
жеље и осећаја, али и времена проведеног уз рачунар на остварењу идеја. Неке од њих ћемо приказати
касније, када још нешто научимо и када се ослободимо страха и неверице или на додатној настави.
Следе задаци различите тежине које треба урадити да бисмо схватили где смо, на ком нивоу су наше
могућности, знање, интересовање .


• Саставити програм који од два уписана броја исписује мањи и за колико је он мањи.
• Саставити програм који одређује да ли је уписани број дељив са 13.
• Саставити програм који за два уписана цела броја одређује да ли је њихова разлика
делилац њиховог збира.
• Саставити програм који одређује да ли je уписани троцифрени број дељив збиром
својих цифара.
• Саставити програм који одређује да ли је уписани цео број квадрат неког целог броја и
ако јесте исписати тај број, а ако није исписати њему најближи квадрат целог броја.
• Саставити програм који за уписани цео број исписује најближи куб неког целог броја.
• Саставити програм који одређује да ли се уписани број а налази између уписаних
бројева b и c.
• Саставити програм који одређује количник већег од бројева a и b са мањим од бројева
c и d.
• Саставити програм који два уписана реална броја a и b прво помножи, а затим
подели, па исписује мањи резултат.
• Саставити програм који за три уписана броја одређује аритметичку средину и који је
од та три броја њој најближи. Ако су два броја једнако близу исписати мањи.
• Саставити програм који од уписаног четвороцифреног броја формира нови тако
што цифре које су парне дели са два, а непарне умањује за један.
• Дате су странице a и b и дијагонала d1 паралелограма. Саставити програм који
одређује који је то паралелограм (квадрат, правоугаоник, ромб, ромбоид).
• Саставити програм који ће за унети цели број a испитати да ли је већи, мањи или
једнак броју b и да ли је дељив бројем c.
• Саставити програм који за унети број од 3 до 6 исцртава одговарајући правилан
многоугао.
• Саставити програм који одређује обим, површину и углове троугла ако су дате
страница и висина која јој одговара и још једна висина.
страница, висине која јој одговара и један од налеглих углова.
страница и висине и тежишна линија које одговарају тој страници.
• Саставити програм који одређује обим, површину и висине троугла ако су дата два
угла и страница насупрот једног од њих.
• Саставити програм који одређује тежишне линије троугла ако су дате све странице.
• Саставити програм који одређује обим и површину троугла ако су дате страница и
висина и тежишна линија које јој одговарају.
• Саставити програм који одређује обим и површину троугла ако су дати обими
уписаног и описаног круга и једна страница му је двапута већа од разлике друге две.
• Саставити програм који одређује обим и површину круга описаног око троугла са
страницама а, б, ц.
• Саставити програм који одређује обим и површину круга уписаног у троугао са
страницама а, б, ц.
• Саставити програм који на основу унетих странице и дијагонале паралелограма
одређује да ли се ради о ромбу, ромбоиду, квадрату или правоугаонику.
• Уноси се четвороцифрени број, а затим се од његових цифара формирају најмањи и
највећи могући број. Саставити програм који одређује да ли је већи број целобројни
умножак мањег.
• Уноси се четвороцифрени број, а затим се од његових цифара формирају најмањи и
највећи могући број. Саставити програм који одређује да ли мањи број може бити
целобројни количник већег.
• Уноси се троцифрени број. Саставити програм који од његових цифара формира све
могуће двоцифрене бројеве код којих прва цифра није мања од друге и уређује их у
неопадајући поредак.

• Уносе се три цела броја a, b и c . Саставити програм који одређује највећи и да ли је

најмањи делилац бар једног од остала два.
• Уносе се три цела броја a, b и c. Саставити програм који их уређује у неопадајући
поредак, а затим одређује да ли је двоструки средњи мањи, већи или једнак збиру
крајњих бројева.
• Уносе се три цела броја a, b и c. Саставити програм који одређује најмањи и да ли је
највећи дељив бар једним од остала два.
• Уносе се три цела броја a, b и c. Саставити програм који их уређује у нерастући
поредак, а затим одређује да ли је аритметичка средина крајњих мања, већа или
једнака средњем броју.
• Саставити програм који одређује која је од две тачке у координатној равни ближа
координатном почетку.
• Саставити програм који одређује која је од две тачке у координатном простору
ближа координатном почетку.
• Саставити програм који проверава да ли три унете дужине могу бити странице
троугла, па ако могу одређује најдужу, површину или обим троугла. Избор резултата
се врши помоћу радио групе.
• Саставити програм који за дати угао у степенима одређује квадрант у коме се
налази.
• Саставити програм који за сваки унети број од 0 до 9 исписује име тог броја.
• Саставити програм који за унету нумеричку исписује описну оцену.
• Направите програм који за унету вредност времена (0-24) одређује доба дана
(0-поноћ, 1-12 - пре подне, 12 - подне, 13 - 20 после подне, 21-0 вече)
• Хороскопски знаци слажу се са следећим датумима : Водолија (20.1 - 18.2); Рибе (19.3 –
20.3); Ован (21.3 – 19.4); Бик (20.4 – 20.5); Близанци (21.5-21.6) ; Рак (22.6-22.7); Лав
(23.7-22.8) ; Девица (23.8-22.9); Вага (23.9-22.10); Шкорпија (23.10-22.11); Стрелац
(23.11-21.12) ; Јарац (22.12-19.1). Саставити програм који на основу унетог датума
рођења (дан и месец) исписује ком хороском знаку особа припада.
• Уносе се бројеви све док се не унесе 0. Саставити програм који исписује број унетих
бројева и колико је било позитивних.
• Уносе се бројеви све док се не унесе 0. Саставити програм који одређује број унетих
парних бројева и њихову аритметичку средину
• Саставити програм који прихвата дужину дужи, а затим, избором помоћу радио
групе, одређује обим и површину: круга, једнакостраничног троугла, квадрата или
шестоугла.
• Саставити програм који који уз помоћ два чекбокса, који дозвољавају или забрањују
упис дужина страница a и b, одређује обим и површину квадрата или правоугаоника.
• Саставити програм који помоћу чекбокса одређује која два од четири податка (а, ha,
H, s) се уписује да би се одредиле површина и запремина праве правилне тростране
пирамиде.

Наредбе за организацију циклуса
Када у алгоритму за решавање неког проблема имамо потребу да се нека наредба изврши
више пута са променом почетних вредности или са истим вредностима онда имамо потребу за
наредбама циклуса (вишеструког извршавања). У зависности од тога да ли унапред знамо број
извршења циклуса или тај број зависи од неког услова разликујемо:
• бројачке циклусе и
• циклусе са условом
Бројачки циклус је For циклус. Код њега се тачно зна колико пута ће се извршити нека
наредба или група наредби. Циклус извршења наредби се не може прекинути пре извршења
унапред задатог броја понављања.
Циклуси са условом се извршавају произвољан број пута, а извршење циклуса наредби се
прекида када се постигне неки услов. Циклуси са условом могу бити:
• циклуси са условом на крају (Repeat ... until <uslov>) и
• циклуси са условом на почетку (While <uslov> do ...)
Синтакса наредби за организацију циклуса.

• Циклус For ... do ...
Циклус For ... do ... је најједноставнија наредба циклуса. Користи
се када је број понављања извршења наредбе или групе наредби
унапред познат, односно, тачно одређен.
Ова наредба има два општа облика:
FOR <promenljiva> := <n1> TO <n2> DO <naredba>;
и
FOR <promenljiva> := <n1> DOWNTO <n2> DO <naredba>;
<promenljiva> је бројач, односно, бројачка променљива циклуса, а број извршења циклуса
је разлика између бројева <n1> и <n2>, тачније, број извршења циклуса добија се по формули
|n1-n2|+1. Иза службене речи do никада не стоји тачка-зарез јер ту није крај наредбе циклуса.
Ако се, ипак, стави онда се подразумева да је циклус празан, односно, у циклуси се неће
извршити ни једна наредба. Бројачка променљива циклуса мора бити простог типа, односно,
типа boolean, integer или char (или неког од њих изведеног), а <n1> и <n2> морају се по типу
слагати са бројачком променљивом циклуса. Ако је вредност променљиве <n1> мања
употребљава се службена реч to, а ако је вредност променљиве <n2> мања службена реч
downto.
Ако иза службене речи do треба да стоји више од једне наредбе оне се повезују наредбом
састављања, односно:
FOR <promenljiva> := <n1> TO <n2> DO
Begin <naredbe>;
End;
FOR <promenljiva> := <n1> DOWNTO <n2> DO
Begin <naredbe>;
End;
У случају када је иза do само једна наредба, наредба састављања није обавезна, али је
дозвољена, односно, може се употребити ако то желимо, али је синтаксно непотребна.
• REPEAT - циклус са условом на крају
Када неки посао треба обавити више пута, али се не зна тачан број понављања већ тај број
зависи од неког услова може се употребити For наредба. Међутим, њена употреба би
захтевала и употребу комбинације наредби условног и безусловног преласка, чиме би
структура програма била јако оштећена. Да би се и овакви задаци могли једноставније решити

уведена је наредба Repeat ... until ... која се извршава све док се услов
који одређује број понављања не испуни.
REPEAT <naredba1>;
<naredba2>;
...
<naredbaN>;
UNTIL <uslov>;
Број наредби унутар циклуса није ограничен, тј. у случају да у циклусу треба да се изврши
више од једне наредбе нема потребе за писањем наредбе састављања, али је она дозвољена
(уколико неко баш воли да је пише може је додати и то ће бити без последица и без
нарушавања структуре програма само ће се програм, непотребно, компликовати).
Сваки задатак решен наредбом For може се решити исто тако једноставно наредбом
Repeat. Обрнуто не важи. Тачније, сваки задатак решен Repeat наредбом може се решити и For
наредбом, али то није увек и једноставно.
Услов који одређује број извршавања циклуса може бити прост или сложен, односно,
састављен од неколико простих услова повезаних логичким операцијама. У случају сложеног
услова важе сва правила логичког закључивања, а сваки од простих услова, из којих се он
састоји, пише се између посебних заграда:
REPEAT <naredbe>;
UNTIL (uslov1)or(uslov2)and(uslov3);
Да би се изашло из циклуса мора бити испуњен први услов или истовремено друга два
услова (могу бити испуњена и сва три услова).
REPEAT <naredbе>;
UNTIL ((uslov1)or(uslov2))and(uslov3);
Да би се изашло из циклуса мора бити испуњен бар један од прва два услова и трећи услов
(могу бити испуњена и сва три услова).
У оквиру једне repeat наредбе може бити других repeat наредби или других наредби
циклуса. У таквим случајевима мора се водити рачуна да не дође до нарушавања структуре
програма. Наиме, није дозвољено да се неки циклус делимично налази унутар другог циклуса,
а делимично изван њега. Циклус може бити у другом циклусу с тим да му и почетак и крај буду
унутар тог другог циклуса или су циклуси један за другим, тј. почетак другог је иза краја првог
циклуса.
У циклусу може бити гранања, при чему не сме доћи до нарушавања структуре, тј. не
може се десити да једна грана if наредбе (на пример then грана) буде у циклусу, а друга изван
циклуса, нити неки случајеви case наредбе могу бити у циклусу, а други изван њега.
• WHILE - циклус са условом на почетку
Ако број извршавања циклуса одређује услов који треба да се
испуни користи се наредба Repeat. Међутим, врло често број
извршавања наредби циклуса зависи од услова који је већ испуњен. У
том случају циклус се извршава све док је тај услов испуњен. Тада је
природније употребити While ... do ... наредбу.
WHILE <uslov> DO <naredba>;
односно:
WHILE <uslov> DO
Begin <naredbe>;
End;
Ако иза службене речи do треба да стоји више од једне наредбе, оне се обавезно везују
наредбом састављања, јер ако се то не уради у циклусу ће се извршавати само прва у том низу
наредби што може довести до формирања бесконачног циклуса (ако се у тој првој наредби
вредност услова не мења) или до проласка кроз циклус потребан број пута, али без резултата,
ако се услов мења у првој наредби, а остале радње извршавају у наредним. И у једном и у
другом случају циклус није оправдао своје постојање, па зато треба водити рачуна о овоме. У
случају када иза до треба да стоји само једна наредба, наредба састављања није обавезна, али
је дозвољена, односно, може се употребити, али за њом нема потребе.
Сваки задатак који подразумева циклус може се једноставно решити овом наредбом, тј.
While наредба може да замени и For и Repeat наредбу. Обрнуто не важи. Тачније, не може се
сваки задатак са циклусом једноставно решити без коришћења наредбе While.
Услов који одређује број извршавања циклуса може бити прост или сложен, тј. састављен
од неколико простих услова. У случају сложеног услова важе правила логичког закључивања,
а сваки од простих услова пише се између посебних заграда:
WHILE (uslov1)or(uslov2)and(uslov3) DO <naredba>;
да би се изашло из циклуса не сме бити испуњен први услов и бар један од друга два
услова.
WHILE ((uslov1)or(uslov2))and(uslov3) DO <naredba>;
да би се изашло из циклуса не сме бити испуњен ниједан од прва два услова или трећи
услов.
Примена наредби break и continue у циклусима

Наредба break користи се за превремени завршетак циклуса for, while и repeat. Ова
наредба се мора налазити у границама тела циклуса. У случају њеног извршења, прекида се
извршавање циклуса који је непосредно обухвата и предаје контрола наредби која следи
непосредно иза циклуса.
Наредба break омогућава излазак само из текућег циклуса, а не и из свих циклуса унутар
којих се налази, ако је текући угњежден у неки други циклус.
Наредба continue прекида извршавање текуће итерације (прескакањем преосталих
наредби тела циклуса) оног циклуса који је непосредно обухвата и обавља прелазак на
следећу итерацију, ако су задовољени услови за њено извршавање (провером вредности
излазних критеријума наредбе циклуса); у противном, циклус се прекида. Continue наредба
присиљава прескакање преосталих наредби унутар циклуса и прелазак на почетак циклуса, на
следећу итерацију циклуса.
Continue наредба скаче само на почетак текућег циклуса, а не и на почетак свих циклуса
унутар којих се налази, ако је текући угњежен у неки други циклус.
• Важно:
Наредбе break и continue нису у духу структурног програмирања јер ломе структуру
програма и као такве их треба избегавати. Добар програмер увек може организовати
циклус тако да коришћење ових наредби није потребно. Зато, у задацима које будемо
решавали нећемо користити ове наредбе.
Неки алгоритми са циклусима

Следи неколико примера урађених уз коришћење циклуса while, а затим и repeat
циклуса. Обратите пажњу код преласка са решења са циклусом repeat на решење са циклусом
while услов у задатку мора бити супротан, тј. < прелази у , > прелази у ,  прелази у >, 
прелази у <, or прелази у and, а and прелази у or.
• табелирање вредности функција
Ако је потребно израчунати вредности неких функција за серију почетних вредности
аргумената онда се за то могу користити циклуси. Који циклус ће се користити зависи од
односа између вредности аргумената. Ако постоји неко правило на основу којег се аргументи
мењају и то тако да се унапред зна број вредности аргумената можемо користити било коју
врсту циклуса. Ако се не може унапред знати колико пута ће се рачунати вредност функције
онда ћемо користити неки од циклуса са условом.
Нека треба исписати вредности тригонометријских функција sin и cos на интервалу од ao
до b степени са кораком од co. Задатак ћемо решити применом циклуса while. Као почетну
o
вредност аргумента функције узећемо број a, одредити вредност функције и исписати је, а
затим повећавати аргумент док не стигнемо до броја b. Потребно је водити рачуна о томе да
тригонометријске функције раде са угловима у радијанима.
ug:=a/180*pi; // претварамо степене у радијане
While ug<=b/180*pi do // проверавамо да ли је угао у интервалу који приказујемо
begin vred:=sin(ug); // одређујемо вредност функције синус
vred:=cos(ug); // одређујемо вредност функције косинус
ug:=ug+c/180*pi; // одређујемо нову вредност аргумента
end;

Задатак је једноставно могуће решити и коришћењем циклуса repeat уз услов да

корисник упише да је a<b, а ако није, пре примене решења, треба заменити вредности
променљивих. Решење помоћу циклуса for није тако једноставно.
ug:=a/180*pi; // претварамо степене у радијане
Repeat vred:=sin(ug); // одређујемо вредност функције синус
vred:=cos(ug); // одређујемо вредност функције косинус
ug:=ug+c/180*pi; // одређујемо нову вредност аргумента
until ug>b/180*pi; // проверавамо да ли је угао у интервалу који приказујемо
• израчунавање сума и производа

Ако је потребно рачунати суме или производе неке групе бројева који имају неку
функционалну зависност, углавном могу се користити све врсте циклуса, али се најчеђће
користи циклус for јер је такво решење најједноставније (осим у неким специфичним
случајевима).
Нека треба сабрати све парне бројеве од a до b. Најједноставније решење је:
suma:=0; // почетна вредност за збир је 0 јер не утиче на коначан резултат
For i:=(a+1)div 2 to b div 2 do
{ треба сабирати само парне бројеве pa je почетна вредност бројае половина броја а, користимо
операцију div јер се ради о целим бројевима, а (а+1) због тога што а може бити непаран број,
па је у том случају 2*(а div 2)<а, тј. не сабира се број а, крај сабирања је када број буде
половина броја b јер је 2*(b div 2)<=b}
suma:=suma+2*i;// сабирамо све парне бројеве зато i множимо са 2
Овакав задатак је лакше решити помоћу циклуса са условом:
suma:=0; // почетна вредност је иста
a:=(a+1)div 2*2; // намештамо да а буде паран број
While a<=b do // крај сабирања је када број a буде једнак броју b
begin suma:=suma+а; // сабирамо паран број а са претходнима
а:=а+2; // узимамо следећи паран број
end;
Наравно, постављање почетног броја на паран број већи или једнак броју a могло се
извести и помоћу једне овакве If наредбе:
If Odd(a) then a:=a+1;
али то је већ ствар укуса програмера:
suma:=0; // почетна вредност је иста
a:=(a+1)div 2*2; // намештамо да а буде паран број
If a<=b then // проверавамо да ли је а мање или једнако b
Repeat suma:=suma+а; // сабирамо паран број а са претходнима
а:=а+2; // узимамо следећи паран број
until a>b; // крај сабирања је када број a буде једнак броју b
end;
На исти начин би се решавали и задаци са производом бројева. Ако би требало сабирати
или множити бројеве који нису цели, онда би требало користити циклусе са условом јер је
решење једноставније него са бројачким циклусима (а понекад и једино могуће).
• испитивање својстава целих бројева
Проблеми типа: одредити да ли је број прост, исписати све просте делиоце броја,
исписати савршене бројеве до n, исписати Армстронгове бројеве до n и слични, могу се
решавати било којом врстом циклуса, а често се користи и комбиновање различитих врста, да
би се решење поједноставило.
Приказаћемо први алгоритам. Број је прост ако осим 1 и самог себе нема других делиоца,
зато ћемо избројати такве делиоце:
bd:=0; // број делиоца различитих од 1 и самог броја је на почетку 0
For del:=2 to broj-1 do // почињемо тестирање од 2 до првог мањег броја
If broj mod del=0 then bd:=bd+1; // ако је број дељив увећавамо број делилаца за 1
If bd>0 then // исписати број није прост
else // исписати број је прост
У алгоритму има пуно непотребних тестирања, па је неефикасан и не треба га користити.
Било који број, осим самог себе, нема делиоца који су већи од његове половине. Број није прост
ако има бар једног делиоца различитог од 1 и самог себе, па нема потребе тражити све такве
делиоце. Бољи алгоритам се прекида чим се пронађе први такав делилац:
del:=2; // за првог делиоца узимамо 2
While (broj mod del<>0) // проверавамо да ли је број дељив њиме
and(del<=Sqrt(broj)) do // проверавамо да ли је делилац већи од корена броја
del:=del+1; // увећавамо делиоца за 1
If del>Sqrt(broj) then // исписати број није прост
del:=1; // за првог делиоца узимамо 2

Repeat del:=del+1; // увећавамо делиоца за 1

until (broj mod del=0) // проверавамо да ли је број дељив њиме
or(del>Sqrt(broj)); // проверавамо да ли је делилац већи од корена броја
If del>Sqrt(broj) then // исписати број није прост
Први услов у циклусу је јасан. Објаснићемо други. Алгоритам је замишљен да се циклус
прекида чим се наиђе на првог делиоца који је већи од 1. То значи, ако је број дељив са 2 нема
потребе проверавати да ли је дељив са својом половином; ако је број дељив са 3 нема потребе
проверавати да ли је дељив својом трећином и тако даље до неког броја n. Да бисмо пронашли
који је то број формирамо низ парова делилаца који као производ дају тај број, односно: 2 *
broj/2, 3 * broj/3, 4 * broj/4, ... Први делилац стално расте, други се стално смањује и први је увек
мањи од другог. Јасно је да први делилац не може бити већи од корена тог броја (јер ако је већи
мора се помножити са бројем који је мањи од њега да би се добио broj). Значи, последњи
делилац у овом низу је корен почетног броја, зато је то последњи број за који проверавамо да
ли може бити делилац почетног и ако је del већи од корена броја значи да нисмо нашли
ниједног делиоца, па је почетни број прост.

• Шта је циклус
• Врсте циклуса
• Синтакса бројачког циклуса
• Број извршења бројачког циклуса
• Тип бројача циклуса
• Циклуси са условом
• Синтакса циклуса са условом
• Примена циклуса
• Сложени услов у циклусима
• Наредба састављања у циклусима
Задаци са циклусима
Пошто смо до сада већ научили да дизајнирамо лепе форме у примерима који следе нећемо описивати
креирање форме, а нећемо ни писати процедуре за тастере Крај рада и Обриши, већ ћемо сву пажњу
посветити алгоритамском решењу проблема и приказивати само процедуре које описују алгоритам.
• Саставити програм који одређује збир првих n природних бројева.
Код задатака са циклусима важно је схватити механизам, односно, начин извршавања. На овом
примеру ћемо покушати да уђемо у штос. Од нас се тражи да саберемо неколико узастопних бројева.
Природно је овакво размишљање: сума = а1 + а2 + а3 + ... + аn, односно, напишемо све сабирке и затим два
по два сабирамо до коначног резултата. На рачунару се тако не може. Наиме, чак и када бисмо унапред
знали колико је бројева потребно сабрати не можемо овај природни запис превести у програм који ће
ефикасно радити. Овако ћемо размишљати: сума = (((...(а1) + а2) + а3) + ... + аn), а затим ћемо се
ослобађати заграда и сваки пут ћемо вредност заграде означавати неким симболом:
s1:=а1
s2:=а1+а2:=s1+а2
s3:=а1+а2+а3:=s2+а3
...
sn:=а1+а2+а3+...аn:=sn-1+а3
овај низ једнакости можемо поједностављено посматрати (приказати) и овако:
s1:=а1
s2:=s1+а2
s3:=s2+а3
...
sn:=sn-1+аn
сада замислимо да смо, грешком, испустили редне бројеве сума и добићемо:
s:=а1
s:=s+а2
s:=s+а3
...
s:=s+аn
односно, свака сума се израчунава тако што се претходној суми дода следећи елемент. Ако уместо
непознатих бројева а узмемо редом природне бројеве од 1 до n добићемо:
s:=1
s:=s+2
s:=s+3
...
s:=s+n
Овакав низ израза може заменити изразом:
s:=1;
for i:=2 to n do s:=s+i;
Тако смо, коначно, дошли до решења овог задатка. Битно је
схватити да у изразу s:=s+i имамо s са леве стране знака
додељивања које представља променљиву којој се додељује
вредност и s са десне стране знака додељивања које представља
променљиву која има своју вредност добијену у претходном
кораку. Тако да, условно речено, ова два слова s не представљају
исту ствар, само се на исти начин записују. Код исписивања
програма изведену формулу ћемо модификовати због могућности
да корисник програма за n упише негативан број или нулу. Зато
ће почетна вредност за суму бити 0, а бројач i у циклусу ће
почети од 1. Контролу уноса смо могли остварити и на други
начин, на пример ако корисник унесе негативан број или 0 могли
смо дефинисати n као 1 или неки други природан број (ово је,
наравно, ствар избора програмера). Направимо сада форму за
овај задатак као на слици и напишимо комплетан програм.
begin If not (key in ['0'..'9',#8,#13,#128])
then key:=#27
else If key=#13
then Button1.Click;
end;
var n,i,s:integer;
s:=0;
For i:=1 to n do
s:=s+i;
Edit2.Text:=IntToStr(s);
Button2.SetFocus;
end;
Edit2.Clear;
Edit1.SetFocus;
end;
end;
Написаћемо сада другу процедуру помоћу наредби repeat и while:
var n,s:integer;
begin n:=StrToIntDef(Edit1.Text,1);
If n<1
then n:=1; // контрола је неопходна због почетне вредности суме
Edit1.Text:=IntToStr(n);
s:=n;
Repeat n:=n-1; // циклус for аутоматски мења вредност бројача, а repeat не
s:=s+n;
Until n<=1;
Button2.SetFocus;
end;
var n,s:integer;
// If n<1 then n:=1; ова контрола овде није неопходна јер је садржана у услову циклуса
s:=n;
While n>1 do
begin n:=n-1; // циклус for аутоматски мења вредност бројача, а while не
s:=s+n;
end;
Edit1.ReadOnly:=true;‚
Button2.SetFocus;
end;
Приметили смо да је начин извршавања друга два циклуса нешто измењен. Наиме, сабирање се
извршава уназад, тј. од n до 1. Ово је учињено да би се уштедела једна променљива и то не би требало
битно да утиче на разумевање решења.
• Саставити програм који одређује збир првих n парних бројева.
Разлика између овог и претходног задатака је само у томе што
ћемо овде редом сабирати бројеве помножене са 2 да би били
парни.
end;
Edit2.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var n,s,i:integer;
s:=0;
For i:=1 to n do
s:=s+2*i;
Button2.SetFocus;
end;
Написаћемо сада другу процедуру помоћу наредби repeat и while:
var n,s:integer;
If n<1 then n:=1; // контрола је неопходна због почетне вредности суме
s:=2*n;
Repeat n:=n-1;
s:=s+2*n;
Until n<=1;
Button2.SetFocus;
end;
var n,s:integer;
// If n<1 then n:=1; ова контрола овде није неопходна јер је садржана у циклусу
s:=2*n;
While n>1 do
begin n:=n-1;
s:=s+2*n;
end;
Button2.SetFocus;
end;
На сличан начин бисмо решили и сабирање првих n непарних бројева. Уместо s:=s+2*i, односно,
s:=s+2*n писали бисмо s:=s+2*i-1, односно, s:=s+2*n-1 и, наравно, у решењима са repeat и while почетна
вредност за суму била би s:=2*n-1.
• Саставити програм који одређује збир непарних бројева до n.
Разлика између овог и претходног задатака је у томе што ћемо овде сабирати сваки други број, почев од
броја један. Помоћу циклуса For пре сабирања броја треба проверити да ли је непаран, па ако јесте онда
ћемо га сабирати са претходним непарним. У циклусима са repeat и while немамо потребу за овим
тестирањем, већ ћемо подесити да корак буде 2, а почетна вредност бројача биће 1. Ако желимо решење
као у претходном задатку, тј. без променљиве бројача, онда треба наместити да n буде непаран број, а
затим сабирати уназад, сваки други број.
end;


Edit2.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var n,s,i:integer;
s:=0;
For i:=2 to n do
If Odd(i)
then s:=s+i;
Button2.SetFocus;
end;
Написаћемо процедуре за непарне бројеве помоћу наредби repeat и while:
var n,s:integer;
If n<1 then n:=1; // контрола је неопходна због изабране наредбе циклуса
If not Odd(n) then n:=n-1; // намештамо да граница за збир буде непарна
s:=0;
Repeat s:=s+n; n:=n-2;
Until n<1;
Button2.SetFocus;
end;
var n,s:integer;
If n<1 then n:=1; // контрола је неопходна због почетне вредности суме
If not Odd(n) then n:=n-1; // намештамо да граница за збир буде непарна
s:=n;
While n>1 do
begin n:=n-2; s:=s+n;
end;
Button2.SetFocus;
end;
Обратимо пажњу на разлику између решења са repeat и са while. Први циклус мора да се изврши бар
једном и зато смо као почетну вредност узели 0, а у циклусу прво сабирали, па умањили вредност
бројача. Други циклус прво тестира услов, па се тек ако треба извршава, зато је он ефикаснији (има
једно извршење мање).
На сличан начин бисмо решили и сабирање парних до n. У циклусу For у услову треба додати not, а у
решењима са repeat и while, пре уласка у циклус треба наместити да n буде паран број, тј. избрисати not.
• Саставити програм који одређује факторијел броја n.
Факторијел неког броја је производ тог броја са свим природним
бројевима мањим од њега. Формула за израчунавање факторијела
може да се напише аналогно првом задатку: факторијел = а1 * а2 *
а3 * ... * аn, односно, факторијел = 1 * 2 * 3 * ... * n, па ћемо и решење
задатка написати аналогно решењу првог задатка, само ћемо
уместо сабирања имати множење. Почетна вредност производа
може бити 1 или сам тај број (а не сме бити 0 због множења јер би
у том случају факторијел био увек 0), зависно од наредбе
циклуса. По дефиницији факторијел броја 0 је 1, па и о томе треба
водити рачуна. Код тестирања програма треба водити рачуна о
граници целих бројева, па треба унети n<18. Граница се може
померити ако уместо целих користимо реалну променљиву f,
али не превише, јер факторијел пребрзо расте и прелази сва
ограничења на рачунару. Направићемо форму за овај задатак
као на слици и написати комплетан програм:


end;
Edit2.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var n,f,i:integer;
If n<0 then n:=0;
f:=1;
For i:=2 to n do
f:=f*i;
Edit2.Text:=IntToStr(f);
Button2.SetFocus;
end;
Написаћемо другу процедуру помоћу наредби repeat и while:
var n,f:integer;
If n<0 then n:=0;
f:=1;
Repeat f:=f*n; n:=n-1;
Until n<1;
Button2.SetFocus;
end;
var n,f:integer;
If n<0 then n:=0;
f:=1;
While n>1 do
begin n:=n-1; f:=f*n;
end;
Button2.SetFocus;
end;
• Саставити програм који одређује n-ти степен броја b.

Степеновање броја целобројним експонентом није ништа друго
до производа, па решење овог задатка личи на факторијел с тим
што је чинилац константа - основа степена:
степен = а * а * а * ... * а.
Најпре ћемо креирати форму као на слици (степен an добија се
комбиновањем две лабеле, на једној пише а, а друга је провидна
и на њој пише n, друга лабела је са ситнијим фонтом, мало
подигнута и померена на десно), а затим написати комплетан
програм:
end;
Edit3.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13 then Edit2.SetFocus;
end;

then key:=#27
else If key=#13
then Button1.Click;
end;
var n,i:integer;
b,s:real;
If n<0 then n:=0;
s:=1;
For i:=1 to n do
s:=s*b;
Edit3.Text:=FloatToStr(s);
Button2.SetFocus;
end;
Написаћемо ову процедуру помоћу repeat (мада је разлика само формалне природе, али имамо и додатан
проблем, треба извршавати циклус само ако је експонент већи од 0, ово је код циклуса for било системски
решено, па о томе нисмо морали да бринемо) и помоћу наредбе while (где разлике готово да и нема):
var n:integer;
b,s:real;
If n<0 then n:=0;
s:=1;
If n>0 then // контрола је обавезна због начина извршавања циклуса
Repeat s:=s*b;n:=n-1;
Until n<1;
Button2.SetFocus;
end;
var n:integer;
b,s:real;
If n<0 then n:=0;
s:=1;
While n>0 do
begin n:=n-1;s:=s*b;
end;
Button2.SetFocus;
end;
• Саставити програм који израчунава збир природних бројева између m и n, где су m и n

цели позитивни бројеви.
Задатак ћемо решити као и први, с тим што почетна вредност
бројача неће бити 0, већ мањи од два уписана броја. То значи да
морамо, пре уласка у циклус наместити да m буде мањи од
уписаних бројева. Најпре ћемо креирати форму као на слици, а
затим написати комплетан програм:
end;
Edit3.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Edit2.SetFocus;
end;


then key:=#27
else If key=#13
then Button1.Click;
end;
var m,n,s,i:integer;
begin m:=StrToIntDef(Edit1.Text,1);Edit1.Text:=IntToStr(m);
If m>n
then begin s:=m;m:=n;n:=s; // замена вредности две променљиве
end;
s:=0;
For i:=m to n do
s:=s+i;
Button2.SetFocus;
end;
Исту процедуру написаћемо и помоћу циклуса repeat и while. Погледајмо их и још једном уочимо
разлику у начину размишљања код различитих врста циклуса. Наравно, могли смо и са ова два циклуса
применити исти принцип као и код бројачког циклуса, али је занимљивије избећи алгоритам замене
вредности две променљиве када се то може. Израз (n-m) div Abs(n-m) може имати вредност +1 или -1 у
зависности од тога који је од два унета броја већи.
var m,n,s:integer;
s:=n;
If m<>n
then Repeat s:=s+m;
m:=m+(n-m)div Abs(n-m);
Until m=n;
Button2.SetFocus;
end;
var m,n,s:integer;
s:=n;
While m<>n do
begin s:=s+m;
m:=m+(n-m)div Abs(n-m);
end;
Button2.SetFocus;
end;
Могли смо увести и помоћну променљиву која добија вредност p:=(n-m) div Abs(n-m) пре уласка у
циклус, а у циклусу уместо m:=m+(n-m)div Abs(n-m) онда стоји m:=m+p тада би се алгоритам мало
убрзао или, уместо овог израза, могли смо користити наредбу: If n>m then p:= -1 else p:=1;
• Саставити програм који израчунава збир квадрата парних и збир кубова непарних
бројева између m и n, где су m и n цели позитивни бројеви.
За разлику од претходног задатка, овде ћемо имати две променљиве
које представљају резултат. Почетна вредност ће за обе бити 0, а
у циклусу ће се тестирати да ли је број паран или непаран и у
зависности од тога ће се одређивати збир. Најпре ћемо креирати
форму као на слици, а затим написати комплетан програм:
end;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
end;

then key:=#27
else If key=#13
then Button1.Click;
end;
var m,n,p,q,i:integer;
If m>n then
begin s:=m;m:=n;n:=s;
end;
p:=0;q:=0;
For i:=m to n do
If Odd(i)
then q:=q+i*i*i
else p:=p+i*i;
Edit3.Text:=IntToStr(p);
Edit4.Text:=IntToStr(q);
Button2.SetFocus;
end;
Исту процедуру написаћемо и помоћу циклуса repeat и while. Погледајмо их и још једном уочимо
разлику у начину размишљања код различитих врста циклуса.
var m,n,p,q,r:integer;
p:=0;q:=0;
If m>n
then r:=-1
else r:=1;
If Odd(n)
then q:=n*n*n
else p:=n*n;
If m<>n then
Repeat If Odd(m)
then q:=q+m*m*m
else p:=p+m*m;
m:=m+r;
Until m=n;
Button2.SetFocus;
end;
var m,n,p,q,r:integer;
p:=0;q:=0;
r:=(n-m) div Abs(n-m);
If Odd(n)
then q:=n*n*n
else p:=n*n;
While m<>n do
begin If Odd(m)
then q:=q+m*m*m
else p:=p+m*m;
m:=m+r;
end;
Button2.SetFocus;
end;
• Саставити програм који израчунава збир реципрочних вредности бројева између m и

n, где су m и n цели позитивnи бројеви.
Пошто треба сабирати реципрочне вредности, јасно је да је сума реалан број. Даље је лако. Треба
наместити да први број буде мањи, а затим, редом, сабирати реципрочне бројеве од првог до другог.
Најпре ћемо креирати форму као на слици, а затим написати комплетан програм:
end;

Edit3.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var m,n,i:integer;
s:real;
begin m:=Abs(StrToIntDef(Edit1.Text,1)); // Искључујемо негативне бројеве
n:=Abs(StrToIntDef(Edit2.Text,1)); // Искључујемо негативне бројеве
If m>n
then begin s:=m;m:=n;n:=s;
end;
If m=0 // Контролом мањег броја искључујемо могућност дељења нулом
then m:=1;
s:=0;
For i:=m to n do
s:=s+1/i;
Edit3.Text:=Format('%15.13f',[s]);
Button2.SetFocus;
end;
Функцијом Abs искључили смо негативне вредности граничних бројева, а дефинисали смо и да
границе не могу бити 0. Прво ограничење није неопходно, јер се могу сабирати и негативни бројеви,
али се поставља питање математичке исправности сабирања ако су границе супротног знака, а дељење
нулом се изостави из коначног резултата (На пример: ако се сабирају реципрочне вредности бројева од
-3 до 5 треба сабрати реципрочне вредности свих бројева, тј. не може се прескочити 0, а реципрочна
вредност за 0 није дефинисана). Функцијом Format дефинисали смо да се резултат испише на 15 места
као реалан број са 13 децимала. Исту процедуру написаћемо и помоћу циклуса repeat и while.
Погледајмо их и још једном уочимо разлику у начину размишљања код различитих врста циклуса.
var m,n,p:integer;
s:real;
begin m:=Abs(StrToIntDef(Edit1.Text,1));
If m=0
then m:=1;
n:=Abs(StrToIntDef(Edit2.Text,1));
If n=0
then n:=1;
s:=1/n;
p:=(n-m)div Abs(n-m);
If m<>n then
Repeat s:=s+1/m;m:=m+p;
Until m=n;
Button2.SetFocus;
end;
var m,n,p:integer;
s:real;
begin m:=Abs(StrToIntDef(Edit1.Text,1));
If m=0
then m:=1;
n:=Abs(StrToIntDef(Edit2.Text,1));
If n=0
then n:=1;
s:=1/n;
p:=(n-m)div Abs(n-m);
While m<>n do
begin s:=s+1/m;m:=m+p;

end;
Button2.SetFocus;
end;
• Саставити програм који исписује све троцифрене бројеве који су дељиви производом
својих цифара (водити рачуна да не дође до дељења са нулом).
Код овог задатака нећемо имати унос улазних података јер треба
проверити услов за све троцифрене бројеве. Зато ће и форма
бити нешто другачија, једноставнија. Комплетан програм ће се
аутоматски извршавати, без тастера Одреди и Обриши. За испис
резултата користићемо мемо поље које ће бити само за читање.
Тестирање ћемо започети од броја 111 јер сви претходни
троцифрени бројеви садрже цифру 0 и не могу бити дељиви
производом својих цифара, који је 0, па дељење нема смисла. У
прозору Object Tree View ћемо двокликом селектовати објекат
Form1 (или једним кликом на форму селектовати објекат, а
затим у Object Inspector-у на листићу Events два пута кликнути у
поље вредности догађаја OnCreate и написати процедуру:
procedure TForm1.FormCreate(Sender: TObject);
var i,c1,c2,c3,p:integer;
begin Memo1.Clear;
For i:=111 to 999 do
begin c1:=i mod 10;
c2:=i div 10 mod 10;
c3:=i div 100;
p:=c1*c2*c3;
If (p>0)and(i mod p=0) then Memo1.Text:=Memo1.Text+IntToStr(i)+' ';
end;
end;
end;
Ако желимо да се бројеви исписују један испод другог, уместо команде:
Memo1.Text:=Memo1.Text+IntToStr(i)+' ';
унос у мемо поље остварићемо командом:
Memo1.Lines.Add(IntToStr(i)); или Memo1.Lines.Append(IntToStr(i));
Написаћемо ову процедуру и помоћу наредби repeat и while, али разлика је готово безначајна:
begin Memo1.Clear; i:=111;
Repeat c1:=i mod 10;
c3:=i div 100;
p:=c1*c2*c3;
If (p>0)and(i mod p=0) then Memo1.Lines.Text:=Memo1.Lines.Text+IntToStr(i)+' ';
i:=i+1;
until i=1000;
end;
begin Memo1.Clear; i:=111;
While i<1000 do
begin c1:=i mod 10;
c3:=i div 100;
p:=c1*c2*c3;
If (p>0)and(i mod p=0) then Memo1.Lines.Text:=Memo1.Lines.Text+IntToStr(i)+' ';
i:=i+1;
end;
end;
• Саставити програм који одређује да ли је број прост (број је прост ако осим себе самог
и јединице нема других делилаца).
Пошто су сви бројеви дељиви са 1 и самим собом те делиоце нећемо ни проверавати. У решавању задатка
можемо користити бројач делилаца - целобројну променљиву која ће се увећавати за 1 кад год нађемо
неки број који је делиоц уписаног броја. Ако је тај број различит од 0 број није прост. Друга могућност је
логичка променљива. Уписани број ћемо делити бројевима од 2 до половине уписаног броја, ако је неки
од бројева дели уписани број логичка променљива р ће добити вредност false, односно, број није прост
(почетна вредност променљиве р је true). Најпре ћемо креирати форму као на слици, а затим, написати
комплетан програм:


end;
Label3.Caption:='';
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var n,i:integer;
p:boolean;
p:=true;
For i:=2 to n div 2 do
If n mod i=0
then p:=false;
If p
then Label3.Caption:=Edit1.Text+' је прост.'
else Label3.Caption:=Edit1.Text+' није прост.';
Button2.SetFocus;
end;
Овај алгоритам је неефикасан јер, на пример, ако је број паран и већи је од 2 не може бити прост, а ми
ћемо, свеједно, делити са свим бројевима до половине унетог броја, да бисмо на крају написали да број
није прост. Али то је проблем бројачких циклуса који се не могу прекидати пре извршења задатог броја
циклуса. Написаћемо процедуре за одређивање простог броја помоћу наредби repeat и while
коришћењем бржег алгоритма:
Ако је број мањи од 4 он је прост, ако је број паран он није прост, у осталим случајевима
тестираћемо потенцијалне делиоце све док не нађемо на првог или док не стигнемо до
корена броја који се тестира.
Корен унетог броја је највећи потенцијални делилац који тестирамо јер сваки делилац већи корена, да
би се добио почетни број, треба помножити неким мањим од корена, а њега смо већ тестирали. Овим
смо убрзали излазак из процедуре и ако је број прост и ако није јер има много мање проверавања него са for.
var d,n:integer;
Label3.Caption:='Broj nije prost';
If n<4
then Label3.Caption:='Broj je prost'
else If Odd(n) then
begin d:=1;
Repeat d:=d+2;
until (d>Sqrt(n))or(n mod d=0);
If d>Sqrt(n)
then Label3.Caption:='Broj je prost';
end;
Edit1.ReadOnly:=true;Button2.SetFocus;
end;
или:
var d,n:integer;
Label3.Caption:='Broj nije prost';
If n<4
then Label3.Caption:='Broj je prost'
else If Odd(n) then
begin d:=3;
While (d<=Sqrt(n))and(n mod d<>0) do d:=d+2;
If d>Sqrt(n)
then Label3.Caption:='Broj je prost';
end;
end;
• Саставити програм који одређује све просте бројеве до n.

У решавању овог задатка ћемо искористити претходни задатак тако што ћемо у циклусу од 1 до
уписаног броја проверавати да ли је број прост и уместо да исписујемо поруку уписиваћемо просте
бројеве у мемо поље. За исписивање простих бројева користићемо формат наредбу, ако желимо да
резултат буде прегледан. Најпре ћемо креирати форму, а затим ћемо написати комплетан програм:


end;
Memo1.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var n,i,b:integer;
p:boolean;
For b:=1 to n do
begin p:=true;
For i:=2 to b div 2 do
p:=b mod i=0;
If p then Memo1.Lines.Add(Format('%5d',[b]));
end;
Button2.SetFocus;
end;
Ако желимо да се бројеви исписују један поред другог, уместо:
Memo1.Lines.Add(Format('%5d',[b]));
унос у мемо поље остварићемо командом:
Memo1.Text:=Memo1.Text+Format('%5d ',[b]);
И овде стоји примедба да алгоритам са два for циклуса није ефикасан, с тим да се то овде још више осећа
јер се не тестира један већ n бројева, па је разлика у брзини извршења овог алгоритма у односу на
алгоритам са циклусима са условом много приметнија. Први циклус for је мања сметња ефикасности.
Написаћемо ову процедуру помоћу наредби циклуса repeat и for:
var d,n,b:integer;
For b:=1 to n do
begin d:=1;
Repeat d:=d+1;
until (d>Sqrt(b))or(b mod d=0);
If d>Sqrt(b)
then Memo1.Lines.Add(Format('%5d',[b]));
end;
Button2.SetFocus;
end;
или са двe наредбe циклуса repeat:
var d,n,b:integer;
If n>0
then Memo1.Lines.Add(Format('%5d',[1]));
If n>1
If n>2
then begin b:=3;
Repeat d:=1;
Repeat d:=d+1;
If d>Sqrt(b)
b:=b+2;
Until b>n;
end;
Button2.SetFocus;
end;
или помоћу наредби циклуса while и for:
var d,n,b:integer;
For b:=1 to n do
begin d:=2;
While (d<=Sqrt(b))and(b mod d<>0) do
d:=d+1;
If d>Sqrt(b)
end;
Button2.SetFocus;
end;
или са двe наредбе циклуса while:
var d,n,b:integer;
If n>0
If n>1
If n>2
then begin b:=3;
While b<=n do
begin d:=2;
While (d<=Sqrt(b))and(b mod d<>0) do
d:=d+1;
If d>Sqrt(b)
b:=b+2;
end;
end;
Button2.SetFocus;
end;
• Саставити програм који одређује прост број најближи уписаном броју.

Овај задатак је мало теже решити помоћу циклус for (али није
немогуће). Зато ће овде бити приказана решења са друга два
циклуса. Идеја је да се нађе први прост број мањи и већи од
уписаног броја, а затим да се одреди који је од њих ближи
уписаном броју. Ово се може урадити на више различитих
начина, али најефикаснији и најефектнији је:
полазимо од уписаног броја, тестирамо да ли је прост, ако
јесте то је тражени број, а ако није
смањимо га за 1 и повећамо га за 1, па оба овако добијена
броја тестирамо, ако је један од њих
прост - то је тражени број, ако су оба броја проста у том
случају потпуно је исправно исписати
мањи или већи од њих или исписати оба броја, ако се у
задатку не каже прецизно, ако ниједан није
прост понављамо поступак све док не нађемо бар један
прост број.
У решењу које ћемо приказати исписиваће се оба броја ако су прости. Најпре ћемо креирати форму, а
затим написати комплетан програм:
end;
Label3.Caption:='';
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var a,b,d,n:integer;
r:string;
a:=n-1; b:=n+1; r:='';
Repeat d:=1;a:=a+1;
Repeat d:=d+1;
until (d>Sqrt(a))or(a mod d=0);
If d>Sqrt(a) // већи број је прост
then r:=IntToStr(a);
d:=1;b:=b-1;
Repeat d:=d+1;

If d>Sqrt(b) // мањи број је прост

then If (Length(r)>0)and(a<>b) // и мањи и већи број је прост
then r:='Најближи прости су '+IntToStr(b)+' i '+r
else r:='Најближи прост је '+IntToStr(b) // уписани или мањи број је прост
else If Length(r)>0
then r:='Најближи прост је '+r; // мањи број је прост
until Length(r)>0;
Label3.Caption:=r;
Button2.SetFocus;
end;
или:
var a,b,d,n:integer;
r:string;
a:=n-1;b:=n+1;r:='';
While Length(r)=0 do
begin d:=2;a:=a+1;
While (d<=Sqrt(n))and(n mod d<>0) do
d:=d+1;
If d>Sqrt(a)
then r:=IntToStr(a);
d:=2;b:=b-1;
While (d<=Sqrt(n))and(n mod d<>0) do
d:=d+1;
If d>Sqrt(b) // мањи број је прост
then If (Length(r)>0)and(a<>b) // и мањи и већи број је прост
then r:='Најближи прости су '+IntToStr(b)+' i '+r
else r:='Најближи прост је '+IntToStr(b) // уписани или мањи број је прост
else If Length(r)>0
then r:='Најближи прост је '+r; // мањи број је прост
end;
Label3.Caption:=r;
Button2.SetFocus;
end;
Јасно је да је ово само један од начина да се дође до решења. Пробајте да задатак решите и другачије.
• Саставити програм који одређује највећи број чији је квадрат мањи од уписаног броја.
Пустићемо циклус од 1 до уписаног броја и тестирати да ли је
квадрат бројача мањи од уписаног броја и ако јесте исписаћемо
га. Последњи уписани број је тражени. Решење са циклусом for
није програмерски сасвим коректно јер, у ствари, исписује све
квадрате мање од уписаног броја, а на крају се види само
последњи (који јесте највећи и тражени) јер се сви они исписују у
исту лабелу. Коректно решење може да се добије без примене
циклуса по формули:
i:=Trunc(Sqrt(n));
Међутим, овде се трудимо да схватимо циклусе, па отуда и
овакво решење. Решења са циклусима repeat и while су
коректнија. Најпре ћемо креирати форму, а затим написати и
end;
Label3.Caption:='';
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var n,i:integer;
For i:=1 to n do
If i*i<n then
Label3.Caption:='Trazeni broj je '+IntToStr(i);
Button2.SetFocus;
end;

var n,i:integer;
i:=n+1;
Repeat i:=i-1
until i*i<n;
Button2.SetFocus;
end;
или:
var n,i:integer;
i:=n;
While i*i>=n do i:=i-1;
Button2.SetFocus;
end;
• Саставити програм који одређује најмањи број чији је куб већи од уписаног броја.
Пустићемо циклус од уписаног броја до 1 и тестирати да ли је куб
бројача већи од уписаног броја и ако јесте исписаћемо га.
Последњи уписани број је тражени. Решење са циклусом for није
програмерски сасвим коректно јер, у ствари, исписује све кубове
веће од уписаног броја, а на крају се види само последњи (који
јесте најмањи и тражени) јер се сви они исписују у исту лабелу.
Коректно решење може да се добије без примене циклуса по
формули:
i:=Round(Exp(1/3*log(n)+0.51);
Међутим овде се трудимо да схватимо циклусе, па отуда и
овакво решење. Решења са циклусима repeat и while су коректна.
Најпре ћемо креирати форму, а затим написати и комплетан
програм:
end;
Label3.Caption:='';
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var n,i:integer;
For i:=n downto 1 do
If i*i*i>n then Label3.Caption:='Trazeni broj je '+IntToStr(i);
Button2.SetFocus;
end;
var n,i:integer;
i:=0;
Repeat i:=i+1;
Until i*i*i>n;
Button2.SetFocus;
end;
или:
var n,i:integer;
i:=0;

While i*i*i<=n do
i:=i+1;
Button2.SetFocus;
end;
• Саставити програм који исписује све делиоце уписаног броја

У циклусу for од 1 до уписаног броја тестираћемо да ли је неки од
бројача делилац уписаног броја и ако јесте уписаћемо га у мемо
поље. Најпре ћемо креирати форму, а затим написати и
end;
Memo1.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var n,i:integer;
For i:=1 to n do
If n mod i=0
then Memo1.Lines.Add(IntToStr(i));
Button2.SetFocus;
end;
Много брже се долази до решења ако се исписују парови делилаца, али онда они нису уређени у растући
поредак. Ако нам то не смета, онда је ово сасвим прихватљиво решење:
var n,i:integer;
For i:=1 to Trunc(Sqrt(n)) do
If n mod i=0
then Memo1.Lines.Add(Format('%5d,%5d',[i,n div i]));
Button2.SetFocus;
end;
Решење се може добити и применом неког од циклуса са условом мада је решење са for најефикасније:
var n,i:integer;
i:=1;
Repeat If n mod i=0
i:=i+1;
Until i>=n;
Button2.SetFocus;
end;
или:
var n,i:integer;
i:=0;
While i<n do
begin i:=i+1;
If n mod i=0
end;
end;
или:
var n,i:integer;
i:=0;
While i<Sqrt(n) do

begin i:=i+1;
If n mod i=0
then Memo1.Lines.Add(Format('%5d,%5d',[i,n div i]));
end;
Button2.SetFocus;
end;
• Саставити програм који исписује све просте делиоце уписаног броја.

Задатак је јако тешко решити само помоћу циклуса for циклуса,
зато ћемо га решавати уз помоћ два циклуса са условом. Као у
претходном задатку треба одредити делиоце уписаног броја у
првом циклусу, а затим проверити да ли су они прости бројеви у
другом циклусу, па ако јесу исписати их у мемо поље. Међутим,
овакво решење није ефикасно. Уместо провере да ли је делилац
прост, можемо унети број делити делиоцем све док је он њиме
дељив. На тај начин елиминишемо све оне делиоце који су
целобројни умножак било ког другог делиоца, односно,
елиминишемо све делиоце који нису прости бројеви. Најпре
ћемо креирати форму, а затим написати и комплетан програм:
end;
Memo1.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var n,d:integer;
Memo1.Lines.Add('1');
d:=2;
Repeat If n mod d=0 then
begin Memo1.Lines.Add(IntToStr(d));
Repeat n:=n div d;
until n mod d<>0;
end;
d:=d+1;
Until d>n;
Button2.SetFocus;
end;
или:
var n,d:integer;
Memo1.Lines.Add('1');
d:=2;
While d<=n do
If n mod d=0
then begin Memo1.Lines.Add(IntToStr(d));
While n mod d=0 do n:=n div d;
end
else d:=d+1;
Button2.SetFocus;
end;
• Саставити програм који уписани број исписује као производ простих делилаца.
Задатак је јако тешко решити помоћу циклуса for зато ћемо га решити само помоћу циклуса са условом,
прво уз помоћ циклуса repeat. У претходном задатку користили смо метод одређивања простих
делилаца дељењем док је број дељив са тим делиоцем, а исписивали смо га само једном. Сада ћемо,
сваки пут када се уписани број дели исписивати делилац све док је могуће делити број. Да би све то
личило на производ додаћемо * између сваког исписа делиоца. Резултат ћемо исписати у лабели на дну
форме. У решењу је коришћена стринг променљива р која се могла изоставити ако би се уместо ње
писало Label3.Caption, али овако је решење лепше. Најпре ћемо креирати форму, а затим написати и


end;
Label3.Caption:='';
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var b,d:integer;
p:string;
p:=IntToStr(b)+' = 1';
If b>1 then
begin d:=2;
Repeat If b mod d=0 then
Repeat b:=b div d;
p:=p+' * '+IntToStr(d);
Until b mod d<>0;
d:=d+1;
Until b=1;
end;
Label3.Caption:=p;
end;
Једноставније и елегантније решење је помоћу циклуса while:
var b,d:integer;
Label3.Caption:=IntToStr(b)+' = 1';
d:=2;
While b<>1 do
begin While b mod d=0 do
begin b:=b div d;
Label3.Caption:=Label3.Caption+' * '+IntToStr(d);
end;
d:=d+1;
end;
Button2.SetFocus;
end;
• Саставити програм који одређује све Армстронгове бројеве до n.

Неки број је Армстронгов ако је збир свих његових цифара
степенованих бројем цифара једнак том броју. Решење које овде
приказујемо важи само за троцифрене бројеве, тј. овде ћемо
Армстронговим звати троцифрене бројеве који су једнаки збиру
кубова својих цифара. Зато ћемо едит ограничити на дужину 3.
Касније ћемо, још једном, решавати овај задатак и тада ће бити
приказано решење које се може применити на све бројеве. За
сваки број у циклусу ћемо одредити цифре, њихове кубове и
проверити да ли је збир кубова једнак почетном броју. Ако јесте
додаћемо тај број у мемо поље. Најпре ћемо креирати форму, а
затим написати и комплетан програм:
end;
Memo1.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var n,b,c1,c2,c3,z:integer;

If n<100
then n:=999;
For b:=100 to n do
begin c1:=b mod 10;
c2:=b div 10 mod 10;
c3:=b div 100;
z:=c1*c1*c1+c2*c2*c2+c3*c3*c3;
If b=z
then Memo1.Lines.Add(IntToStr(b));
end;
Button2.SetFocus;
end;
Јасно је да је овакво решење коректно, али су решења са циклусима са условом неупоредиво лепша и
ефектнија:
var n,b,p,c,z:integer;
If n<100
then n:=999;
b:=100;
Repeat p:=b;z:=0;
Repeat c:=p mod 10;
z:=z+c*c*c;
p:=p div 10;
until p=0;
If b=z
b:=b+1;
until b=n;
Button2.SetFocus;
end;
или:
var n,b,p,c,z:integer;
If n<100
then n:=999;
b:=1;
While b<>n do
begin p:=b;z:=0;
While p<>0 do
begin c:=p mod 10;
z:=z+c*c*c;
p:=p div 10;
end;
If b=z
b:=b+1;
end;
Button2.SetFocus;
end;
• Саставити програм који одређује Питагорине бројеве мање од n.

Три броја су Питагорина ако могу бити мерни бројеви страница
правоуглог троугла. То значи да ћемо за три броја проверити да
ли важи Питагорина теорема. Ако важи исписаћемо ту тројку у
мемо поље. Приликом формирања сваког од три циклуса морамо
водити рачуна да је хипотенуза највећа, а да катете не могу бити
целобројне и једнаке. Такође треба водити рачуна и да не дође до
понављања тројки, тј. тројка 3, 4, 5 је иста као и тројка 4, 3, 5 и
треба да се испише само једна од њих. Најпре ћемо креирати
форму, а затим написати и комплетан програм:
end;
Memo1.Clear;
Edit1.SetFocus;
end;


then key:=#27
else If key=#13
then Button1.Click;
end;
var n,a,b,c:integer;
For a:=1 to n-2 do
For b:=a+1 to n-1 do
For c:=b+1 to n do
If a*a+b*b=c*c
then Memo1.Lines.Add(Format('%3d %3d %3d',[a,b,c]));
Button2.SetFocus;
end;
Овакво решење је коректно и најједноставније, али написаћемо и решења са циклусима са условом:
a:=1;
Repeat b:=a+1;
Repeat c:=b+1;
Repeat If a*a+b*b=c*c
c:=c+1;
until c>n;
b:=b+1;
until b>n-1;
a:=a+1;
until a>n-2;
Button2.SetFocus;
end;
или:
a:=1;
While a<=n-2 do
begin b:=a+1;
While b<=n-1 do
begin c:=b+1;
While c<=n do
begin If a*a+b*b=c*c
c:=c+1;
end;
b:=b+1;
end;
a:=a+1;
end;
end;
• Саставити програм који одређује све савршене бројеве до n.

Савршени бројеви су бројеви који су једнаки збиру својих правих
делилаца. То значи, да бисмо решили овај задатак треба
одредити све праве делиоце неког броја (делиоце који су
различити од самог тог броја) и проверити да ли је њихов збир
једнак почетном броју. Ако јесте исписаћемо га у мемо поље.
програм:
end;
Memo1.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;

end;
var n,b,d,s:integer;
For b:=1 to n do
begin s:=1;
For d:=2 to b div 2 do
If b mod d=0
then s:=s+d;
If s=b
end;
end;
b:=1;
Repeat s:=1;d:=2;
Repeat If b mod d=0
then s:=s+d;
d:=d+1;
until d>n div 2;
If s=b
b:=b+1;
until b>n;
end;
или:
b:=1;
While b<=n do
begin s:=1;d:=2
While d<=b div 2 do
begin If b mod d=0
then s:=s+d;
d:=d+1;
end;
If s=b
b:=b+1;
end;
Button2.SetFocus;
end;
• Саставити програм који одређује парове пријатељских бројева до n.

Два броја су пријатељска ако је збир правих делилаца сваког
једнак оном другом броју. Да бисмо решили овај задатак
пустићемо да један број буде слободно изабран. Затим ћемо
одредити његов збир правих делилаца и њега прогласити
потенцијалним бројем пријатељем првог броја. Да би он стварно
то и био одредићемо његов збир правих делилаца и проверити
да ли је једнак почетном броју. Ако јесте то су два пријатељска
броја. Код исписивања треба водити рачуна да се парови не
понављају. То ћемо урадити додавањем услова да први број буде
мањи од другог. Најпре ћемо креирати форму, а затим написати
и комплетан програм:
end;
Memo1.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;


var n,a,d,s,b:integer;
For a:=1 to n do
begin b:=1;
For d:=2 to a div 2 do
If a mod d=0 then b:=b+d;
s:=1;
If b mod d=0 then s:=s+d;
If (s=a)and(a<b) then Memo1.Lines.Add(Format('%5d %5d',[a,b]));
end;
Button2.SetFocus;
end;
a:=1;
Repeat b:=1;d:=2;
Repeat If a mod d=0 then b:=b+d;
d:=d+1;
until d>a div 2;
s:=1;d:=2;
Repeat If b mod d=0 then s:=s+d;
d:=d+1;
until d>b div 2;
a:=a+1;
until a>n;
Button2.SetFocus;
end;
или:
a:=1;
While a<=n do
begin b:=1;d:=2;
While d<=a div 2 do
begin If a mod d=0 then b:=b+d;
d:=d+1;
end;
s:=1;d:=2;
While d<=b div 2 do
begin If b mod d=0 then s:=s+d;
d:=d+1;
end;
a:=a+1;
end;
end;
• Саставити програм који одређује количник и остатак при целобројном дељењу два
уписана цела броја користећи само операције сабирања и одузимања.
Од првог броја одузимаћемо други. Сваки пут када одузмемо
други број, количник ћемо увећати за један. Када више не буде
могло да се одузима, односно, када први број постане мањи од
другог, број који је остао од почетног представља остатак при
целобројном дељењу. Задатак је немогуће решити помоћу
циклуса for јер треба од првог броја одузимати други све док се не
добије резултат који је мањи од првог броја, број одузимања је
непознат, па се не може поставити граница за бројач. Зато следе
само решења са циклусима repeat и while. Најпре ћемо креирати
end;
Edit1.SetFocus;
end;


then key:=#27
else If key=#13
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var a,b,c:integer;
c:=0;
If a>b
then Repeat a:=a-b;c:=c+1;
until a<b;
Edit3.Text:=IntToStr(c);
Edit4.Text:=IntToStr(a);
Button2.SetFocus;
end;
или:
var a,b,c:integer;
c:=0;
While a>=b do
begin a:=a-b;c:=c+1;
end;
Edit3.Text:=IntToStr(c);
Button2.SetFocus;
end;
• Саставити програм који исписује све просте бројеве мање од 1000 са две исте цифре.
Јасно је да, осим 11, нема двоцифрених простих бројева са две
исте цифре јер су сви такви дељиви баш са 11. Зато ћемо
тестирање почети од 101, а 11 ћемо исписати као почетну
вредност садржаја мемо поља. Задатак ћемо проширити тако да
граница не буде број 1000, већ да се може изабрати било која
граница. Јасно је да се до решења може доћи на више различитих
начина, а овде ће бити приказано једно од њих. За сваки број
већи од 100 проверићемо да ли је прост, па ако јесте одредићемо
његове цифре и од њих формирати скуп цифара. Код сваког
додавања цифре у скуп, прво ћемо проверити да ли се цифра
налази у скупу. Ако је цифра у скупу онда је испуњен услов
задатка, па ћемо га додати у мемо поље и одмах прелазимо на
тестирање следећег простог броја. Задатак ћемо решити
комбиновањем различитих наредби циклуса јер се тако добија
најефикасније решење. Циклусом repeat ћемо проћи кроз
непарне бројеве од 100 до уписаног броја, а циклусима while
ћемо одређивати да ли је број прост и да ли има бар две исте цифре. Задатак нећемо решавати помоћу
бројачког циклуса јер је спорији (зато што не можемо да искључимо из тестирања парне бројеве).
Најпре ћемо креирати форму, а затим написати и комплетан програм:
end;
Memo1.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;


var n,a,b,c,d:integer;
p:boolean;
sc:set of 1..9;
If n>10 then Memo1.Lines.Add('11');
If n>100
then begin b:=101
Repeat d:=2;a:=b;
While (a mod d<>0)and(d<=Sqrt(a)) do d:=d+1;
If d>Sqrt(a)
then begin c:=a mod 10;
a:=a div 10;
sc:=[c];
p:=false;
While (a<>0)and(not p) do
begin c:=a mod 10;
a:=a div 10;
If c in sc
then p:=true
else sc:=sc+[c];
end;
If p then Memo1.Lines.Add(IntToStr(b));
end;
b:=b+2;
until b>n;
end;
Button2.SetFocus;
end;
• Саставити програм који исписује све просте бројеве мање од 1000 са свим различитим
цифрама.
Јасно је да, осим 11, сви други прости бројеви до 100 не могу
имати исте цифре. Зато ћемо тестирање почети од 101, а све
претходне просте ћемо исписати као почетну вредност садржаја
мемо поља. Задатак ћемо проширити тако да граница не буде
број 1000, већ да се може изабрати било која граница. Јасно је да
се до решења може доћи на више различитих начина, а овде ће
бити приказано једно од њих. За сваки број већи од 100
проверићемо да ли је прост, па ако јесте одредићемо његове
цифре и од њих формирати скуп цифара. Код сваког додавања
цифре у скуп, прво ћемо проверити да ли се цифра налази у
скупу. Ако је цифра у скупу онда није испуњен услов задатка, па
га нећемо додати у мемо поље, већ тражимо следећи прост број.
Задатак ћемо решити са три while циклуса јер се тако добија
најефикасније решење. Првим циклусом ћемо проћи кроз
непарне бројеве од 3 до уписаног броја. Другим циклусом ћемо
одређивати да ли је број прост, а трећим да ли има истих цифара.
Задатак нећемо решавати помоћу бројачког циклуса јер је спорији (зато што не можемо да искључимо
из тестирања парне бројеве). Најпре ћемо креирати форму, а затим написати и комплетан програм:
end;
Memo1.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var n,a,b,c,d:integer;
p:boolean;
sc:set of 1..9;
If n>0 then Memo1.Lines.Add(IntToStr(1));
If n>1 then Memo1.Lines.Add(IntToStr(2));
b:=3;
While b<=n do
begin d:=2;a:=b;
While (a mod d<>0)and(d<=Sqrt(a)) do d:=d+1;
If d>Sqrt(a)
then If (b<100)and(b<>11)
then Memo1.Lines.Add(IntToStr(b))
else begin c:=a mod 10;
a:=a div 10;
sc:=[c];
p:=true;
While (a<>0)and(p) do
begin c:=a mod 10;
a:=a div 10;
If c in sc
then p:=false
else sc:=sc+[c];
end;
If p then Memo1.Lines.Add(IntToStr(b));
end;
b:=b+2;
end;
Button2.SetFocus;
end;
• Саставити програм који бинарни број претвара у декадни.

Задатак ћемо решити тако што ћемо сваку цифру бинарног броја
множити бројем 2 степенованим редним бројем места бинарне
цифре и сабирати тако добијене резултате. Да не бисмо стално
понављали операцију степеновања користићемо променљиву
која ће се у сваком кораку циклуса множити са 2 (практично то је
степен броја 2, али се не рачуна сваки пут када нам треба већ се
само претходна вредност увећава 2 пута и тако се добија на
ефикасности програма). Подразумева се да ћемо бинарне цифре
читати са десна у лево, односно, од цифре најнижег реда. Најпре
ћемо креирати форму, а затим написати и комплетан програм:
end;
Edit2.Clear;
Edit1.SetFocus;
end;
begin If not (key in ['0','1',#8,#13,#128])
then key:=#27
else If key=#13
then Button1.Click;
end;
var a:string;
b,s,i:integer;
s:=1;b:=0;
For i:=Length(a) downto 1 do
begin b:=b+StrToInt(a[i])*s;
s:=s*2;
end;
Edit2.Text:=IntToStr(b);
Button2.SetFocus;
end;
или:
var a:string;
b,s,i:integer;
s:=1;b:=0;
i:=Length(a);
If i>0 then
Repeat b:=b+StrToInt(a[i])*s;
s:=s*2;
i:=i-1;
until i<1;
Button2.SetFocus;
end;
или:


var a:string;
b,s,i:integer;
s:=1;b:=0;
i:=Length(a);
While i>0 do
begin b:=b+StrToInt(a[i])*s;
s:=s*2;
i:=i-1;
end;
Button2.SetFocus;
end;
• Саставити програм који декадни број претвара у бинарни.

Задатак ћемо решити тако што ћемо декадни број делити са 2 и
бележити остатке све док количник у неком кораку не постане 0.
Када се добијени низ остатака прочита с десна у лево добија се
бинарни број - решење. Јасно је да се овај задатак не може
решити уз помоћ циклуса for јер не можемо знати колико пута ће
се делити. Најпре ћемо креирати форму, а затим написати и
end;
Edit2.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var a:string;
b:integer;
a:='';
If b>0 then
Repeat a:=IntToStr(b mod 2)+a;
b:=b div 2;
until b<1;
Edit2.Text:=a;
Button2.SetFocus;
end;
или:
var a:string;
b:integer;
a:='';
While b>0 do
begin a:=IntToStr(b mod 2)+a;
b:=b div 2;
end;
Edit2.Text:=a;
Button2.SetFocus;
end;
• Саставити програм који одређује збир два цела броја са двадесет и више цифара.
Из услова задаткавиди се да ћемо сабирке унети као стрингове и затим карактер по карактер с десна у
лево претварати у бројеве, сабирати и формирати цифре резултата водећи при томе рачуна о
евентуалном преносу (када је збир две цифре већи од 9). Цифре резултата ћемо, такође, претварати у
стринг и тако памтити резултат. Да бисмо добили најједноставније решење најпре ћемо одредити која
реч је краћа (ако нису исте дужине), а затим ћемо ту реч допунити нулама са леве стране (да се збир не
би променио) тако да се добију две речи једнаке дужине. Задатак се може решити применом било које
наредбе циклуса, а најефикаснији је са for. Најпре ћемо креирати форму, а затим написати и комплетан
програм:


end;
Edit3.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var a,b,c:string;
i,d,p:integer;
b:=Edit2.Text;
If Length(a)>Length(b)
then begin c:=a;a:=b;b:=c;
end;
For i:=1 to Length(b)-Length(a) do a:='0'+a;
c:='';p:=0;
begin d:=StrToInt(a[i])+StrToInt(b[i])+p;
c:=IntToStr(d mod 10)+c;
p:=d div 10;
end;
If p>0 then c:=IntToStr(p)+c;
Edit3.Text:=c;
Button2.SetFocus;
end;
или:
var a,b,c:string;
i,d,p:integer;
b:=Edit2.Text;
If Length(a)>Length(b)
then Repeat b:='0'+b;
until Length(b)=Length(a);
else If Length(b)>Length(a)
then Repeat a:='0'+a;
until Length(b)=Length(a);
c:='';p:=0;
i:=Length(a);
Repeat d:=StrToInt(a[i])+StrToInt(b[i])+p;
p:=d div 10;
i:=i-1;
until i=0;
Edit3.Text:=c;
Button2.SetFocus;
end;
или:
var a,b,c:string;
i,d,p:integer;
b:=Edit2.Text;
While Length(a)>Length(b) do b:='0'+b;
While Length(b)>Length(a) do a:='0'+a;
c:='';p:=0;
i:=Length(a);
While i>0 do
begin d:=StrToInt(a[i])+StrToInt(b[i])+p;
p:=d div 10;
i:=i-1;

end;
Edit3.Text:=c;
Button2.SetFocus;
end;
Занимљиво би било одредити разлику и производ оваквих бројева.
• Саставити програм који одређује количник два броја на најмање педесет децимала.
Да бисмо могли да испишемо број са педесет децимала морамо
резултат дељења да конвертујемо у стринг. Почетна вредност за
количник биће целобројни количник унетих бројева конвертован
у стринг, а затим ћемо у тај стринг додати децимални зарез и
целобројне количнике остатка при дељењу помноженог са десет
и другог броја. Поступак понављамо све док не добијемо
одговарајући број децимала. Најпре ћемо креирати форму, а
затим написати и комплетан програм:
end;
Edit3.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var c:string;
a,b,i,n:integer;
n:=50;
c:=IntToStr(a div b)+'.';
For i:=1 to n do
begin a:=a mod b*10;
c:=c+IntToStr(a div b);
end;
Edit3.Text:=c;
Button2.SetFocus;
end;
или:
var c:string;
a,b,n:integer;
n:=50;
Repeat a:=a mod b*10;
n:=n-1;
until n=0;
Edit3.Text:=c;
Button2.SetFocus;
end;
или:
var c:string;
a,b,n:integer;
n:=50;


While n>0 do
begin a:=a mod b*10;
n:=n-1;
end;
Edit3.Text:=c;
Button2.SetFocus;
end;
У задатку је дефинисано да количник има 50 децимала (n:=50;), променом вредности променљиве n
лако се може дефинисати жељени број децимала. Програмерски боље решење је додати нови едит у који
ће се уписивати вредност променљиве n, односно, колико децимала желимо. Такође, да би задатак био
коректно решен, требало би проверити да други уписани број није 0 (јер делити нулом нема смисла).
• Саставити програм који одређује к-ти биномни коефицијент степена n.
У решењу задатка користићемо формулу у развијеном облику.
Да бисмо добили мало уштеде на времену и меморији, количник
на десној страни једнакости разбићемо на низ чинилаца који
чини један елемент изнад разломачке црте подељен једним
елементом испод разломачке црте (и то редом који су написани),
односно, применићемо формулу:
 n  n  (n  1)  (n  2)  ...  (n  k  1) к n  i  1
    .
k  k  (k  1)  (k  2)  ...  3  2 1 i 1 i
Најпре ћемо креирати форму (формулу ен над ка смо
исписали у три лабеле), а затим написати и комплетан
програм:
end;
Edit3.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var n,k,i:integer;
b:real;
k:=StrToIntDef(Edit2.Text,0);
If k>n then k:=n;
Edit2.Text:=IntToStr(k);
b:=1;
For i:=1 to k do b:=b*(n-i+1)/i;
Edit3.Text:=IntToStr(Trunc(b));
Button2.SetFocus;
end;
или:
var n,k,i:integer;
b:real;
If k>n
then k:=n;
b:=1;i:=0;
If k>0 then
Repeat i:=i+1;

b:=b*(n-i+1)/i;
until i>=k;
Memo1.Lines.Add(IntToStr(Trunc(b)));
Button2.SetFocus;
end;
или:
var n,k,i:integer;
b:real;
If k>n
then k:=n;
b:=1;i:=0;
While i<k do
begin i:=i+1;
b:=b*(n-i+1)/i;
end;
Memo1.Lines.Add(IntToStr(Trunc(b)));
Button2.SetFocus;
end;
• Саставити програм који исписује биномне коефицијенте степена n.

Сваки појединачни биномни коефицијент ћемо одређивати као
у претходном задатку, при чему ћемо променљиву к мењати у
циклусу од нуле до унетог степена. Исписивање коефицијената
ћемо решити помоћу стринг променљиве која ће се мењати у
циклусу по к слепљивањем управо одређеног коефицијента на
претходне. На крају ћемо стринг исписати у лабели. Најпре ћемо
креирати форму, а затим написати и комплетан програм:
end;
Label3.Caption:='';
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var n,k,i:integer;
b:real;
a:string;
a:='';
For k:=0 to n do
begin b:=1;
a:=a+IntToStr(Trunc(b))+' ';
end;
Label3.Caption:=a;
Button2.SetFocus;
end;
или:
var n,k,i:integer;
b:real;
a:string;
a:='';k:=0;
Repeat b:=1;i:=0;
If k>0 then
Repeat i:=i+1;
b:=b*(n-i+1)/i;
until i>=k;
k:=k+1;
until k>n;
Label3.Caption:=a;
Button2.SetFocus;
end;
или:
var n,k,i:integer;
b:real;
a:string;
a:='';k:=0;
While k<=n do
begin b:=1;i:=0;
While i<k do
begin i:=i+1;
b:=b*(n-i+1)/i;
end;
k:=k+1;
end;
Label3.Caption:=a;
Button2.SetFocus;
end;
• Саставити програм који исписује Паскалов троугао до реда n.

Разлика између овог и претходног задатка је у томе што се у
претходном унето n односи на један ред Паскаловог троугла који
треба исписати (коефицијенти н-тог степена бинома), а овде се
односи на број редова троугла које треба исписати, односно,
треба одредити и исписати редове (коефицијенте бинома
степенованог бројевима) од 0 до n. Навешћемо без детаљног
објашњавања решење помоћу свих наредби циклуса. Најпре ћемо
креирати форму, а затим написати и комплетан програм:
end;
Memo1.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var n,p,k,i:integer;
b:real;
a:string;
begin p:=StrToIntDef(Edit1.Text,0);Edit1.Text:=IntToStr(p);
For n:=0 to p do
begin a:='1';
For k:=1 to n do
begin b:=1;
a:=a+Format('%4.0f',[b]);
end;
Memo1.Lines.Add(a);
end;
Button2.SetFocus;
end;
или:
b:real;
a:string;
n:=0;
Repeat a:='1';k:=1;
Repeat b:=1;i:=0;
If k>0 then
Repeat i:=i+1;
b:=b*(n-i+1)/i;
until i>=k;

k:=k+1;
until k>n;
Memo1.Lines.Add(a);
n:=n+1;
until n>p;
Button2.SetFocus;
end;
или:
b:real;
a:string;
n:=0;
While n<=p do
begin a:='1';k:=1;
While k<=n do
begin b:=1;i:=0;
While i<k do
begin i:=i+1;
b:=b*(n-i+1)/i;
end;
k:=k+1;
end;
Memo1.Lines.Add(a);
n:=n+1;
end;
Button2.SetFocus;
end;
• Саставити програм који на случајан начин формира n бројева, а затим одређује највећи
и најмањи број, њихове редне бројеве и аритметичку средину.
Задатак демонстрира рад са низом бројева, када није потребно
чувати вредности свих елемената низа. Генерисаћемо први број
и прогласити га највећим и најмањим, а затим ћемо формирати
остале бројеве и упоређивати са вредностима највећег и најмањег.
Кад год наиђемо на већи, прогласићемо нови највећи. Кад год
наиђемо на мањи, прогласићемо нови најмањи. Чуваћемо редне
бројеве највећег и најмањег елемента. Без обзира на величину
сабраћемо генерисани број са свим претходним. Аритметичку
средину ћемо одредити дељењем збира са n. Најпре ћемо креирати
end;
Memo1.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var x,m,rx,rm,s,b,n,i:integer;
Randomize;
If n>0 then
begin b:=Random(1000);
Memo1.Lines.Add(Format('%2d.%4d',[1,b]));
s:=b;
x:=b;rx:=1;
m:=b;rm:=1;
For i:=2 to n do
begin b:=Random(1000);s:=s+b;
If b>x
then begin x:=b;rx:=i;
end;

If b<m
then begin m:=b;rm:=i;
end;
Memo1.Lines.Add(Format('%2d.%4d',[i,b]));
end;
Edit2.Text:=IntToStr(x);Edit3.Text:=IntToStr(rx);
Edit4.Text:=IntToStr(m);Edit5.Text:=IntToStr(rm);
Edit6.Text:=FloatToStr(s/n);
end;
Button2.SetFocus;
end;
Циклус се користи само за бројање формираних елемената зато задатак нећемо решавати циклусима са
условом.
• Саставити програм који за два уписана броја одређује најмањи заједнички садржалац.
Постоји неколико алгоритама за одређивање најмањег заједничког
садржалца. Овде су приказана три:
- за нзс - бројач узимамо први број, а затим у циклусу
проверавамо да ли је бројач дељив са оба броја, ако јесте то је нзс,
ако није повећавамо бројач за један .
- за нзс узимамо један од уписаних бројева и проверавамо
да ли је други број његов делилац, ако јесте то је нзс, ако није
потенцијални нзс увећавамо за први број све док не нађемо прави.
- за нзс узимамо производ уписаних бројева, а затим тај
производ смањујемо за један све до једног од уписаних бројева и
проверавамо да ли је дељив са оба уписана броја, па ако јесте то
је нови нзс који исписујемо. Последњи исписани нзс је заиста то.
Други алгоритам је најефикаснији и њега треба запамтити.
Ако знамо нзд, онда нзс добијамо из формуле: nzs * nzd = a * b.
програм:
end;
Edit3.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
procedure TForm1.Button1Click(Sender: TObject); // први алгоритам
var a,b,nzs,p:integer;
If a>b
end;
nzs:=b;
While (nzs mod a<>0)or(nzs mod b<>0) do nzs:=nzs+1;
Edit3.Text:=IntToStr(nzs);
Button2.SetFocus;
end;
procedure TForm1.Button1Click(Sender: TObject); // други алгоритам
If a>b
end;
nzs:=b; // ако пођемо од већег броја добијамо на ефикасности алгоритма
While nzs mod a<>0 do

nzs:=nzs+b;
Button2.SetFocus;
end;
procedure TForm1.Button1Click(Sender: TObject); // трећи алгоритам
p:=a*b+1;
Repeat p:=p-1;
If (p mod a=0)and(p mod b=0) then nzs:=p;
until nzs=b;
Button2.SetFocus;
end;
• Саставити програм који за два уписана броја одређује највећи заједнички делилац.
Постоји неколико алгоритама за одређивање највећег заједничког
делиоца. Овде су приказана три:
- за нзд узимамо број 1, а затим у циклусу повећавамо бројач
до једног од два унета броја и проверавамо да ли је делилац оба
броја, па ако јесте постављамо њега за нови нзд. Последњи од
таквих бројева је тражени нзд.
- за нзд узимамо један од уписаних бројева и проверавамо
да ли је делилац другог броја, па ако јесте то је нзд, а ако није
потенцијални нзд смањујемо га за један све док не нађемо број
који је делилац оба броја.
- за нзд узимамо мањи од уписаних бројева и проверавамо
да ли је делилац већег, ако није од већег одузимамо мањи и мањи
проглашавамо потенцијалим нзд и поступак понављамо све док
не добијемо делилац већег броја који представља нзд.
Трећи алгоритам је најефикаснији, па га треба запамтити.
Ако знамо нзс, онда нзд добијамо из формуле: nzs * nzd = a * b.
Најпре ћемо креирати форму, а затим написати и комплетан програм:
end;
Edit3.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
procedure TForm1.Button1Click(Sender: TObject); // први алгоритам
var a,b,nzd,p:integer; // i:integer;
If a>b
end;
p:=0;
Repeat p:=p+1;
If (a mod p=0)and(b mod p=0) then nzd:=p;
until p=b;
// решење са for је нешто мало једноставније, али су оба решења прилично неефикасна
// For i:=1 to a do
// If (a mod i=0)and(b mod i=0)
// then nzd:=i;
Edit3.Text:=IntToStr(nzd);
Button2.SetFocus;
end;
procedure TForm1.Button1Click(Sender: TObject); // други алгоритам

var a,b,nzd:integer;
nzd:=a;
If b mod nzd<>0
then Repeat nzd:=nzd-1;
until (a mod nzd=0)and(b mod nzd=0);
Edit3.Text:=IntToStr(nzd);
Button2.SetFocus;
end;
procedure TForm1.Button1Click(Sender: TObject); // трећи алгоритам
var a,b,p:integer;
If a<>b then
Repeat If a>b
then a:=a-b
else b:=b-a;
until a=b;
Button2.SetFocus;
end;
• Саставити програм који исписује све симпатичне бројеве од a до b.

За природан број n кажемо да је симпатичан ако важи:
S(n2) = S(n)*S(n), где је S(x) збир цифара природног броја x.
Задатак ћемо решити комбинацијом циклуса for и repeat, а на
сличан начин би се могло решити и неком другом комбинацијом
наредби циклуса. Одредићемо збир цифара неког броја, а затим
и збир цифара квадрата тог броја и проверити услов задатка, тј.
да ли је збир цифара квадрата броја једнак квадрату збира
цифара тог броја. Најпре ћемо креирати форму, а затим написати
и комплетан програм:
end;
Memo1.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var a,b,c,i,p,z1,z2:integer;
Memo1.Clear;
For i:=a to b do
begin z1:=0; p:=i;
Repeat c:=p mod 10;z1:=z1+c;
p:=p div 10;
until p=0;
z2:=0; p:=i*i;
Repeat c:=p mod 10;z2:=z2+c;
p:=p div 10;
until p=0;
If z2=z1*z1
then Memo1.Lines.Add(Format('%4d',[i]));
end;
Button2.SetFocus;
end;

• Саставити програм који за текст написан у MemoBox-у одређује број речи дужине 5
карактера.
Граничник речи може бити размак, зарез, тачка, знак узвика или
знак питања, али и ознака краја реда (#13) и ознака прекида
реда (#10) и све ове карактер (ова последња два нису видљива)
треба пронаћи у тексту, а граница речи је први од њих.
Функцијом Pos() ћемо одредити позицију сваког од њих и
пронаћи најмањи број који представља крај речи. Овај поступак
ћемо користити у свим задацима где се траже речи са неким
карактеристикама, а мало модификован ће бити користан и за
одређивање реченице или неког специјалног низа карактера.
Променљивој r ћемо доделити ту реч и проверити да ли она има
одговарајућу дужину. У задатку се траже речи са 5 карактера,
али решење које приказујемо је општије и корисник може да
упише дужину коју жели, тако да је алгоритамски коректније.
Бројач d се увећава када је пронађена реч одговарајуће дужине и
исписује се на крају програма. Услов за крај претраживања је да
је остатак текста дужине 0 карактера и да има размака у тексту.
Овај други услов обезбеђује рад програма и у случају када се
текст састоји из само једне речи, па нема ниједног од карактера који ограничавају реч. Процедуром
Edit1KeyPress() смо заштитили први едит од уноса слова и знакова, а процедуром Edit1Enter() смо
дефинисали да се садржај оба едита брише када се курсор постави у први. Зато процедуру која се
извршава када се кликне тастер Обриши не треба користити ако желимо само да променимо дужину речи
да бисмо проверили колико има речи те друге дужине. Након креирања форме написаћемо комплетан
програм:
end;
begin Memo1.Clear;Memo1.ReadOnly:=false;
Edit1.Clear;
Edit2.Clear;
Memo1.SetFocus;
end;
procedure TForm1.Edit1Enter(Sender: TObject);
begin Edit1.Clear;
Edit2.Clear;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var s,r:string;
a,b,d,n:integer;
s:=Memo1.Text+' ';
d:=0;
While (Length(s)>0)and(Pos(' ',s)<>0) do
begin a:=Pos(' ',s);
b:=Pos(#13,s);
If (a>0)and(b>0)and(b<a) then a:=b;
b:=Pos(#10,s);
b:=Pos(',',s);
b:=Pos('.',s);
b:=Pos('!',s);
b:=Pos('?',s);
r:=Copy(s,1,a-1); // формира реч
Delete(s,1,a); // брише реч из текста
If a=n+1 // проверава да ли је реч жељене дужине
then d:=d+1; // броји речи жељене дужине
end;
If Length(s)=n+1 // проверава да ли је остатак текста реч жељене дужине
then d:=d+1; // ако јесте убраја и њу
Edit2.Text:=IntToStr(d);// исписује резултат
Memo1.ReadOnly:=true;
end;

• Саставити програм који за текст написан

у MemoBox-у одређује број речи које почињу великим
словом А.
Одређиваћемо речи као и у претходном задатку, а затим ћемо
проверити да ли је прво слово изабрани карактер. У задатку се
тражи број речи које почињу великим словом А, а приказано
решење је општије и дозвољава кориснику да упише било који
карактер и провери да ли и колико има речи које почињу тим
карактером. Решење је Case Sensitive, односно разликује мала и
велика слова. Лако се може укинути ово ограничење заменом
услова r[1]=c условом UpCase(r[1])=UpCase(c). Услов за
престанак претраживања је да се задато слово више не налази у
тексту. Након креирања форме написаћемо комплетан програм:
end;
Memo1.SetFocus;
end;
end;
begin If key=#13 then Button1.Click;
end;
var s,r:string;
c:char;
a,b,d:integer;
begin c:=Edit1.Text[1];Label4.Caption:='Број речи на '+c+':';
s:=Memo1.Text+' ';d:=0;
While Pos(c,s)<>0 do
b:=Pos(#13,s);
b:=Pos(#10,s);
b:=Pos(',',s);
b:=Pos('.',s);
b:=Pos('!',s);
b:=Pos('?',s);
r:=Copy(s,1,a-1);Delete(s,1,a);
If (Length(r)>0)and(r[1]=c) then d:=d+1;
end;
Edit2.Text:=IntToStr(d);
end;
• Саставити програм који за текст написан у MemoBox-у одређује прву реч која завршава
малим словом а.
Разлика између овог и претходног задатка је у томе што се овде
тражи само прва реч која завршава задатим карактером. То
значи да треба увести променљиву показивач која ће променити
вредност оног тренутка када нађемо реч која задовољава услов
задатка. Ова променљива мора да учествује у услову циклуса
који претражује речи јер претраживање мора да се прекине чим
се реч пронађе. Други услов је да је комплетан текст претражен,
тј. да је остатак текста дужине 0 карактера. Услови да нешто
буде реч су они исти као у и претходним задацима. Након
креирања форме написаћемо комплетан програм:
end;
Memo1.SetFocus;
end;


end;
end;
var s,r:string;
c:char;
a,b,d:integer;
begin c:=Edit1.Text[1];
s:=Memo1.Text+' ';d:=0;
While (Pos(c,s)<>0)and(d=0) do
begin a:=Pos(' ',s); b:=Pos(#13,s);
b:=Pos(#10,s);
b:=Pos(',',s);
b:=Pos('.',s);
b:=Pos('!',s);
b:=Pos('?',s);
r:=Copy(s,1,a-1);Delete(s,1,a);
If (Length(r)>0)and(r[Length(r)]=c)and(d=0) then d:=1;
end;
If d=0
then Edit2.Text:='Nema reci.'
else Edit2.Text:=r;
end;
• Саставити програм који за текст написан у MemoBox-у одређује број појављивања

симбола * у првих пет речи.
Треба одредити првих пет речи и видети да ли и колико пута се у
њима појављује симбол *. Решење које се приказује је општије и
кориснику дозвољава да упише карактер по избору и број речи у
којима се тражи уписани карактер. Променљива која броји речи
мора да учествује у услову циклуса за претраживање да би се он
прекинуо када се изврши тестирање задатог броја речи. Други
услов је да је комплетан текст претражен, тј. да је остатак текста
дужине 0 карактера. Након креирања форме написаћемо
end;
Memo1.SetFocus;
end;
end;
begin If key=#13 then Edit2.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var s,r:string;
c:char;
a,b,d,n,i:integer;
begin c:=Edit1.Text[1];
d:=StrToIntDef(Edit2.Text,5);Edit2.Text:=IntToStr(d);
s:=Memo1.Text+' ';n:=0;
While (Length(s)>0)and(d>0) do
b:=Pos(#13,s);
b:=Pos(#10,s);
b:=Pos(',',s);
b:=Pos('.',s);
b:=Pos('!',s);
b:=Pos('?',s);
r:=Copy(s,1,a-1);Delete(s,1,a);d:=d-1;
If (Length(r)>0)and(Pos(c,r)>0)
then For i:=1 to Length(r) do
If r[i]=c then n:=n+1;
end;
end;
• Саставити програм који за текст написан у MemoBox-у одређује број реченица у

тексту (крај реченице се означава симболима . ! ?).
Задатак је нешто једноставнији од претходних јер је скуп
карактера који дефинишу крај реченице, а чије постојање треба
утврдити, мањи. Једино о чему треба водити рачуна је да не
прогласимо реченицом и вишеструко узастопно понављање
знакова интерпункције. Променљива a само на почетку има
вредност дужине текста, а надаље, кроз циклус, њена вредност је
позиција краја реченице. Након креирања форме написаћемо
end;
Edit1.Clear;
Memo1.SetFocus;
end;
var s,r:string;
a,b,d:integer;
begin s:=Memo1.Text+' ';
a:=Length(s);d:=0;
While (Length(s)>0)and(a<>0) do
begin a:=Pos('.',s);
b:=Pos('?',s);
b:=Pos('!',s);
r:=Copy(s,1,a);Delete(s,1,a);
If Length(r)>0 then d:=d+1; // не броје се дуплирани граничници
end;
end;
• Саставити програм који за текст написан у MemoBox-у у други MemoBox исписује све
речи које не садрже симбол *.
Као и у неким ранијим задацима, одређиваћемо речи, затим
проверавати да ли се задати карактер налази у њима. Решење
које је приказано је општије од траженог условима задатка јер
дозвољава кориснику да изабере карактер који ће се тражити у
речима. Мемо поље у које исписујемо пронађене речи се брише
чим се промени карактер који се тражи. Након креирања форме
написаћемо комплетан програм:
end;
Edit1.Clear;Memo2.Clear;
Memo1.SetFocus;
end;
begin Edit1.Clear;Memo2.Clear;
end;
end;


var s,r:string;
c:char;
a,b:integer;
c:=Edit1.Text[1];
While Length(s)>0 do
b:=Pos(#13,s);
b:=Pos(#10,s);
b:=Pos(',',s);
b:=Pos('.',s);
b:=Pos('!',s);
b:=Pos('?',s);
r:=Copy(s,1,a-1);
Delete(s,1,a);
If (Length(r)>0)and(Pos(c,r)=0)
then Memo2.Lines.Add(r);
end;
end;
• Саставити програм који за текст написан у MemoBox-у у други MemoBox исписује све
речи које имају дужину више од три слова.
Као у неким ранијим задацима одређиваћемо речи, а онда ћемо
проверавати да ли су задате дужине. Решење које је приказано
општије је од траженог у условима задатка јер дозвољава
кориснику да изабере дужину речи које ће се тражити. Мемо
поље у које исписујемо пронађене речи се празни чим се
промени дужина речи које се траже. Након креирања форме
end;
Memo1.SetFocus;
end;
begin Edit1.Clear;Memo2.Clear;
end;
begin If key=#13
then Button1.Click;
end;
var s,r:string;
a,b,n:integer;
b:=Pos(#13,s);
b:=Pos(#10,s);
b:=Pos(',',s);
b:=Pos('.',s);
b:=Pos('!',s);
b:=Pos('?',s);
r:=Copy(s,1,a-1);
Delete(s,1,a);
If Length(r)>n
then Memo2.Lines.Add(r);
end;
end;

• Саставити програм који за текст написан у MemoBox-у у други MemoBox исписује

првих пет речи које почињу великим словом А.
Већ смо показали како се у тексту траже речи које почињу
задатим карактером, сада ћемо то решење проширити додатним
условима. Уместо да бројимо речи, исписујемо их. У приказаном
решењу бира се слово којима речи треба да почињу и, такође,
колико таквих речи се тражи. Подразумева се да може да се деси
и да нема таквих речи. Након креирања форме написаћемо
end;
Edit1.Clear;Edit2.Clear;Memo2.Clear;
Memo1.SetFocus;
end;
begin Edit1.Clear;Edit2.Clear;Memo2.Clear;
end;
begin If key=#13 then Edit2.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var s,r:string;
c:char;
a,b,n:integer;
c:=Edit1.Text[1];
While (Length(s)>0)and(n>0) do
b:=Pos(#13,s);
b:=Pos(#10,s);
b:=Pos(',',s);
b:=Pos('.',s);
b:=Pos('!',s);
b:=Pos('?',s);
r:=Copy(s,1,a-1);
Delete(s,1,a);
If (Length(r)>0)and(r[1]=c)
then begin n:=n-1;Memo2.Lines.Add(r);
end;
end;
end;
• Саставити програм који у уписаном стрингу одређује најдужи подниз који се састоји
само из цифара.
Овде нам нису потребне речи. Потребно је наћи низ узастопних
цифара и одредити његову дужину. Може се десити да у тексту има
више низова цифара и у том случају треба одредити који је најдужи,
или да цифара нема у тексту који анализирамо, у том случају
исписујемо одговарајућу поруку. Низ цифара може да почне
било којом цифром, па је услов почетка низа је компликованији.
Зато смо услов за одређивање почетка низа цифара представили
бројачким циклусом. Да бисмо утврдили да у тексту нема
цифара увели смо бројач n који је на почетку бројачког циклуса
0, тј. претпостављамо да цифре постоје у тексту, а затим, кад год
утврдимо да нека цифра не постоји, бројач увећавамо за један.
Ако је n=10 значи да нисмо пронашли ниједну цифру у тексту и
треба испразнити текст да бисмо изашли из претраживања. У

противном одређујемо дужину низа и проверавамо да ли је он најдужи. Након креирања форме

end;
Edit1.Clear;
Memo1.SetFocus;
end;
var s,r:string;
c:char;
a,b,n,m:integer;
m:=0;r:='';
begin a:=Length(s);
n:=0;
For c:='0' to '9' do
begin b:=Pos(c,s);
If (b>0)and(b<a) then a:=b;
If b=0 then n:=n+1;
end;
If n=10
then Delete(s,1,a)
else begin Delete(s,1,a-1);
n:=1;
While s[n] in ['0'..'9'] do n:=n+1;
If n-1>m
then begin m:=n-1;
r:=Copy(s,1,n-1);
end;
Delete(s,1,n-1);
end;
end;
If m>0
then Edit1.Text:=r
else Edit1.Text:='Не постоји низ.';
end;
• Саставити програм који у уписаном стрингу одређује најдужу реч (низ карактера
ограничен размацима).
Задатак је само наизглед сличан претходном. Међутим, овде
прво треба одредити реч (као у неким претходним решењима), а
затим и њену дужину, па онда треба проверити и да ли је она
најдужа реч. Такође, треба предвидети и могућност да текст
буде празан, тј. да уопште нема речи. Након креирања форме
end;
Edit1.Clear;
Memo1.SetFocus;
end;
var s,r:string;
a,b,n:integer;
n:=0;r:='';
b:=Pos(#13,s);
b:=Pos(#10,s);
b:=Pos(',',s);
b:=Pos('.',s);
b:=Pos('!',s);
b:=Pos('?',s);

If a-1>n
then begin n:=a-1;
r:=Copy(s,1,a-1);
end;
Delete(s,1,a);
end;
If n>0
then Edit1.Text:=r
else Edit1.Text:='Не постоји реч.';
end;
• Саставити програм који израчунава вредност суме:

s=0-1+2-3+...+(-1)n n, где је број n уписани природни број.
Задаци са одређивањем вредности неког израза су, углавном,
једноставни. У овом случају, ради се о наизменичном сабирању и
одузимању природних бројева до n. Решићемо задатак као да се
ради о сабирању, а промену знака дефинисаћемо помоћу
променљиве z која ће се у сваком кораку циклуса множити са -1.
Након креирања форме написаћемо комплетан програм:
end;
Edit2.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var n,s,i,z:integer;
s:=0; z:=1;
For i:=1 to n do
begin z:=-z;
s:=s+z*i;
end;
Button2.SetFocus;
end;

s=sin(x)+sin2(x)+sin3(x)+...+sinn(x), где је број n уписани природни број.
Број х може бити реалан. Вредност функције sin(x) израчунаћемо
испред циклуса и сачувати у некој променљивој, а у циклусу
ћемо радити само са том променљивом коју ћемо множити
потребан број пута и сабирати. Након креирања форме
end;
Edit3.Clear;
Edit1.SetFocus;
end;
then key:=#27
else If key=#13
end;
begin If not (key in ['0'..'9',',','.',#8,#13,#128])
then key:=#27
else If key=#13
then Button1.Click;
end;

var n,i:integer;
s,p,z,x:real;
x:=StrToFloatDef(Edit2.Text,1);
Edit2.Text:=FloatToStr(x);
s:=0; z:=1;
p:=sin(x);
For i:=1 to n do
begin z:=z*p; s:=s+z;
end;
Button2.SetFocus;
end;

S n  x00!  1x1!  x22!  xnn! , где је n  N иn  16, x  Rи 1 x  n.
По дефиницији 0! је 1. За израчунавање факторијела и степена
користићемо помоћне променљиве да бисмо задатак решили
коришћењем само једног циклуса. Обавезна је контрола уноса
броја n због ограничења целобројног типа података (факторијел
много брзо расте и прелази границу за целе бројеве). Након
end;
Edit3.Clear;
Edit1.SetFocus;
end;
var p:integer;
begin p:=StrToIntDef(Edit1.Text,5);
If p>16
then begin Edit1.Clear;
Edit1.SetFocus;
end;
end;
var p:integer;
r:real;
r:=StrToFloatDef(Edit2.Text,1);
If (r<1)or(r>p)
Edit2.SetFocus;
end;
end;
then key:=#27
else If key=#13
end;
begin If not (key in ['0'..'9',',','.',#8,#13,#128])
then key:=#27
else If key=#13
then Button1.Click;
end;
var n,i,f:integer;
s,p,x:real;
x:=StrToFloatDef(Edit2.Text,1);Edit2.Text:=FloatToStr(x);
s:=1; f:=1; p:=1;
For i:=1 to n do
begin f:=f*i; // одређује факторијел
p:=p*x; // одређује степен
s:=s+f/p; // израчунава суму
end;
Button2.SetFocus;
end;

Много је ефектније и ефикасније следеће решење (јер не рачуна ни факторијеле и ни степене; идеја је
да се они напишу у развијеном облику, па се онда формирају производи количника):
var n,i:integer;
s,p,x:real;
x:=StrToFloatDef(Edit2.Text,1);Edit2.Text:=FloatToStr(x);
s:=1; p:=1;
For i:=1 to n do
begin p:=p*i/x;
s:=s+p;
end;
Button2.SetFocus;
end;
• Саставити програм који израчунава вредност израза:

m 2  ( m  1 )2  ( m  2 )2    ( n  2 )2  ( n  1 )2  n 2
a , где су m, n, природни бројеви.
12  22  32    ( p  2 )2  ( p  1 )2  p 2
Јасно је да мора бити m < n и p > 0. То се мора обезбедити када
корисник уноси податке. Задатак је најједноставније решити са
два независна циклуса (мада је могуће користити и циклусе са
условом). У првом се рачуна вредност бројиоца, а у другом
вредност имениоца. Затим се та два резултата поделе. Након
end;
Edit4.Clear;
Edit3.SetFocus;
end;
then key:=#27
else If key=#13
end;
then key:=#27
else If key=#13
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var p:integer;
If p<=0
Edit1.SetFocus;
end;
end;
var a,b,c,i,n,s:integer;
m:=StrToIntDef(Edit2.Text,2);
n:=StrToIntDef(Edit3.Text,3);
If m>n
then begin a:=m;m:=n;n:=a;
end;
a:=0;
For i:=m to n do a:=a+i*i;
b:=0;
For i:=1 to p do b:=b+i*i;

Edit4.Text:=FloatToStr(a/b);
Button2.SetFocus;
end;
• Саставити програм који израчунава суму првих n елемената Фибоначијевог низа

(Фибоначијев низ почиње са f0=0 и f1=1, а сваки следећи елемент се израчунава као збир
претходна два).
Фибоначијев низ је један од значајнијих феномена у математици
који је нашао примену и у уметности и у физици, а може се
пронаћи и у хемији, биологији, архитектури и готово у свим
областима људског деловања. Ово је само један од примера
употребе низа. Задатак је решен тако да корисник може
променити почетне вредности за формирање низа. Након
end;
Edit1.Text:='0';Edit2.Text:='1';
Edit3.SetFocus;
end;
then key:=#27
else If key=#13
end;
then key:=#27
else If key=#13
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
var a,b,c,i,n,s:integer;
Memo1.Lines.Add(Format('%2d.%3d',[0,a]));
Memo1.Lines.Add(Format('%2d.%3d',[1,b]));
s:=a+b;
For i:=2 to n do
begin c:=a+b;
Memo1.Lines.Add(Format('%2d.%3d',[i,c]));
a:=b;b:=c;
s:=s+c;
end;
Button2.SetFocus;
end;


• Саставити програм који израчунава збир квадрата бројева између m и n, где су m и n
цели позитивни бројеви.
• Саставити програм који израчунава збир кубова бројева између m и n, где су m и n цели
позитивни бројеви.
• Саставити програм који исписује све троцифрене бројеве који су дељиви са 6 и нису
дељиви ни са 4 ни са 9.
• Саставити програм који исписује све троцифрене бројеве који су дељиви производом,
а нису дељиви збиром својих цифара.
• Саставити програм који исписује све просте бројеве мање од n са свим различитим
цифрама.
• Саставити програм који одређује нзс и нзд за три уписана броја.
• Саставити програм који одређује збир простих бројева од a до b.
• Саставити програм који на случајан начин формира n целих бројева од -500 до 500, а
затим одређује број негативних, број позитивних, број парних, број непарних.
• Саставити програм који на случајан начин одређује n троцифрених бројева, а затим
одређује број непарних и њихов збир и аритметичку средину парних.
• Уписују се бројеви све док се не упише 0. Саставити програм који одређује број са
највећим и најмањим збиром цифара, њихове редне бројеве и укупан број цифара свих
уписаних бројева. У случају да више елемената има исти (највећи или најмањи) збир
цифара исписује се најмањи од њих.
• Уписују се бројеви све док се не упише 0. Саставити програм који одређује најмањи
парни, највећи непарни уписани број и њихове редне бројеве.
• Саставити програм који одређује да ли је уписана реч палиндромна.
• Саставити програм који исписује слова која се у речи појављују тачно једном.
• Саставити програм који исписује слова која се у речи појављују више пута.
• Саставити програм који одређује број самогласника у уписаној речи и исписује их.
• Саставити програм који одређује број сугласника у уписаној речи и исписује их.
• Саставити програм који одређује број самогласника који се у уписаној речи појављују
више пута.
• Саставити програм који одређује број сугласника који се у уписаној речи појављују
тачно два пута.
• Саставити програм који од унете речи формира словну пирамиду одузимајући по
једно слово са леве и десне стране наизменично.
• Саставити програм који од унете речи формира словни пешчани сат одузимајући по
једно слово са леве и десне стране наизменично, а затим враћајући слова истим редом.
• Саставити програм који од унете речи формира словно вретено одузимајући по једно
слово са леве и десне стране наизменично од средине према врховима вретрена.
• Саставити програм који симулира бацање коцкице за јамб n пута, а затим исписује
број појављивања сваке стране.
• Саставити програм који одређује разлику два цела броја са двадесет и више цифара.
• Саставити програм који арапски број мањи од 4000 претвара у римски.
• Саставити програм који римски број претвара у арапски.
• Саставити програм који број у систему са основом m претвара у број у систему са
основом n.
• Саставити програм који одређује производ два цела броја са двадесет и више цифара.
• Саставити програм који одређује збир бројева од m до n чија је последња цифра 7, а
прва није 3.
• Саставити програм који одређује са колико јединица се декадни број n пише у
бинарном бројном систему.
• Саставити програм који исписује све двоцифрене бројеве који се могу написати као
збир квадрата два броја.
• Саставити програм који исписује све троцифрене бројеве чија је средња цифра
једнака суми прве и последње.

• Саставити програм који исписује све троцифрене бројеве који су једнаки збиру
факторијела својих цифара.
• Саставити програм који за текст написан у MemoBox-у одређује:
- Прву реч која почиње великим словом К
- Број речи које почињу и завршавају истим словом
- Број великих слова у тексту
- Број појављивања речи Delphi и број појављивања речи Pascal
• Саставити програм који за текст написан у MemoBox-у у други MemoBox исписује:
- Све речи које завршавају малим словом е
- Све речи из текста у обрнутом поретку слова
- Све речи из текста са великим почетним словом
- Све речи које почињу и завршавају истим словом
- Исти текст, али из кога су избрисани сви симболи *
- Исти текст, али у коме су слова с замењена симболом *
• Саставити програм који одређује вредност суме:
1 1 1
a 1   
1 1 1
1 2 1 2  3 1  2  13   
1 1
n
• Саставити програм који одређује вредност израза:

1
a 1 
1
2
1
3
1

n
1
1 2 1
• Саставити програм који исписује цифарску пирамиду: 1 2 3 2 1
1 2 3 4 3 2 1

• Саставити програм који одређује редни број првог елемента низа задатог формулом:
xn
an  , x  R, n  N који је мањи од произвољног, унапред задатог броја .
n!

Опис методе класе
Стање сваког објекта класе дефинишу поља класе. Поља која одражавају стање које је
јединствено називају се променљиве примерка. Када је декларисано, поље се може
иницијализовати додељивањем вредности одговарајућег типа. Иницијализатор не мора бити
константа, већ може бити друго поље, позив методе или неки израз који садржи ова два
елемента, док год одговарају по типовима. Различите класе могу имати различит број и врсте
поља. Вредности поља могу се дефинисати у фази израде апликације, али и касније, у фази
извршавања, ако је алгоритамски предвиђено, односно, ако се та промена не би могла лоше
одразити на ток извршења алгоритма. На пример, било би прилично непрофесионално
дозволити кориснику да у току извршавања програма обрише едит за унос података или
дугме за излазак из програма.
Класа, осим објеката, садржи и методе, односно, операције које су дефинисане са
објектима те класе. Операције морају да се декларишу и дефинишу. Декларација мора
садржати тип операције, назив и параметре са којима ради. Као метода може се дефинисати
функција или процедура. Једним именом функције и процедуре зовемо потпрограмима зато
што имају структуру било којег програма, али не могу да стоје самостално, јер су везане за
објекат класе и извршавају се као реакција на неки догађај објекта. Потпрограми могу бити
дефинисани и изван класе и не морају бити ни у каквој вези са објектима класе. Зато ћемо овде
обрадити и функције и процедуре које нису методе класе. Структура је потпуно иста, разлика је
само у власнику и параметрима функције или процедуре и у начину позивања. Методе класе
позивају се као реакција на неки догађај, а позиви других функција или процедура пишу се у
оквиру неке наредбе или су независне наредбе програма.
Врло често програм који пишемо постаје јако компликован, при чему се неки делови
програма понављају са истим или сличним вредностима. Да би се поједноставило писање,
читање и разумевање програма делови програма се издвајају у посебне релативно независне
целине које се називају потпрограмима. Потпрограмима се придружује симболичко име
помоћу којег ће се позивати из програма кад год је потребно извршити те издвојене радње.
Потпрограми имају исту структуру као и сам програм, тј. имају заглавље и тело са наредбама.
Потпрограми морају да се деклариши и дефинишу. Декларација се пише у заглављу програма,
у делу за декларације, а дефиниције се пишу у делу за дефиниције (после службене речи
implementation). Разликујемо две врсте потпрограма: функције и процедуре.
Функције су једноставније. Декларишу се службеном речи function, својим именом,
аргументима са типом и типом функције, на пример:
function Stepen(b,e:real):real;
Декларација функције може да се напише у делу означеном са private или public.
Приватне декларације видљиве су само из класе којој припадају, а јавне декларације су
видљиве из читавог програма. Видљиве, значи да се могу позивати.
Функција може имати произвољан број аргумената који могу, а не морају бити истог
типа. Они се називају још и улазним параметрима или улазним променљивама зато што
вредност добијају у главном програму и ту своју вредност преносе у функцију. Осим улазних
постоје и излазни параметри који своју вредност преносе из функције у главни програм.
Функција може имати само један излазни параметар и то је само име функције (зато функција
мора имати декларисан тип јер се помоћу њеног имена нека вредност преноси у програм). Да би
се нека вредност из функције пренела у главни програм, имену функције се бар једном мора
доделити вредност. У телу са наредбама име функције не сме да се нађе са десне стране знака
додељивања нити у оквиру неке друге наредбе или израза, јер би то било позивање функције
из саме функције, па би то била рекурзивна функција. Рекурзивне функције су специфичне
функције које саме себе позивају. Коришћењем рекурзивних функција формално се избегава
коришћење наредби циклуса, али како оне саме представљају једну нову врсту циклуса, то
значи да њиховом употребом не избегавамо стварно коришћење циклуса, већ само користимо
једну другачију врсту циклуса. При креирању рекурзивних функција мора се водити рачуна да
постоји најмање један коректан услов који ће одређивати колико пута ће она саму себе позивати.
Ако се напише некоректан или погрешан услов програм неће давати исправне резултате или
ће се ублокирати.
Функција мора да се дефинише да би могла да се користи у програму. Дефиниција функције
је навођење радњи које се врше над неким подацима ради добијања неког резултата.
Дефиниција функције се састоји из заглавља које мора бити идентично заглављу у декларацији
функције и тела функције са наредбама, на пример:
function TForm1.Stepen(b,e:real):real;
var s:real;
begin s:=1;
While e>0 do begin s:=s*b; e:=e-1;
end;
stepen:=s;
end;
Једина разлика је TForm1. ознака која нам говори коме припада дефинисана функција.
Улазне променљиве у заглављу дефиниције морају бити истог имена и типа и написане
истим редоследом као и у декларацији. Тип функције, такође мора бити идентичан типу функције
у декларацији.
Осим улазних параметара, у функцији се могу користити и локалне и глобалне променљиве.
Дефиниција функције се не сме преклапати са неком другом процедуром или функцијом, а име
функције не сме бити исто као име неке друге функције, процедуре или променљиве. Име
функције може се слободно изабрати при чему треба водити рачуна да се не користе
резервисане речи и стандардни идентификатори. Обавезно је да име почне словом енглеске
абецеде и не сме да садржи специјалне и знаке интерпункције.
Променљиве b и e у примеру декларације и дефиниције функције Stepen су формални
параметри, тј. њихова функција је задовољење форме и немају никакву вредност. Када се
функција позива из главног програма позива се са стварним, конкретним вредностима и зато
се променљиве у позиву процедуре зову стварни параметри.
Функција се позива из главног програма навођењем имена и стварних параметара УВЕК
из неке друге наредбе. Стварни параметри могу бити променљиве којима су додељене вредности
у претходним наредбама програма, позиви неке друге дефинисане функције или конкретне
вредности. Једини услов за стварне параметре је да се морају слагати по типу са формалним
параметрима. Позив функције није независна наредба програма, а не може се у програму наћи
ни са леве стране знака додељивања. Примери позива функције:
a:=Stepen(b,n); <- одређује н-ти степен броја б
a:=Stepen(b,3); <- одређује трећи степен броја б
a:=Stepen(2,4); <- одређује четврти степен броја 2
Процедура је издвојени низ радњи који представља логичку целину посебно именовану
ради позивања и извршавања по позиву у било којем делу програма. Процедуре се декларишу
службеном речи procedure, именом процедуре и улазним и излазним параметрима, на пример:
procedure Stepen(b,e:real;VAR s:real);
Процедура може имати произвољан број улазних и излазних параметара. Излазни се од
улазних параметара одвајају службеном речи Var. Улазни параметри вредност добијају у главном
програму и ту вредност преносе у процедуру, вредност могу мењати у процедури, али се њихова
нова вредност не преноси у главни програм. Излазни параметри процедуре своју вредност
могу добијати у главном програму и уносити је у процедуру, могу добијати и мењати вредност
унутар процедуре, а своју вредност преносе из процедуре у главни програм. Редослед параметара
није предефинисан, тј. не морају сви улазни параметри бити на почетку, а излазни на крају
листе. Могу се и наизменично писати један улазни, па један излазни, ако нам се тако свиђа, али
је при томе, обавезно, да испред сваке листе излазних променљивих које су истог типа
напишемо службену реч Var. Број улазних и излазних параметара није ограничен већ зависи
од тога шта се обрађује и шта је резултат обраде у процедури. У телу са наредбама процедуре
не сме се наћи име процедуре јер би то било позивање процедуре из саме процедуре, па би то
онда била рекурзивна процедура. Рекурзивне процедуре су специфичне процедуре које саме
себе позивају. Коришћењем рекурзивних процедура формално се избегава коришћење наредби
циклуса, али како саме те процедуре представљају једну нову врсту циклуса, то значи да њиховом
употребом не избегавамо стварно коришћење циклуса, већ само користимо једну другачију врсту
циклуса. При креирању рекурзивних процедура мора се водити рачуна да постоји најмање
један коректан услов који ће одређивати колико пута ће саму себе позивати. Ако се напише
некоректан или погрешан услов програм неће давати исправне резултате или ће се ублокирати.

Процедура мора да се декларише и дефинише да би могла да се користи у програму.

Декларација процедуре може да се напише у делу означеном са private или public. Приватне
декларације видљиве су само из класе којој припадају, а јавне декларације су видљиве из
читавог програма. Видљиве, значи да се могу позивати. Дефиниција процедуре је навођење
радњи које се врше над неким подацима ради добијања неког резултата. Састоји се из
заглавља које мора бити идентично декларацији процедуре и тела процедуре са наредбама.
Улазне и излазне променљиве у заглављу дефиниције морају бити истог имена и типа и
написане истим редоследом као и у декларацији. Пример дефиниције:
procedure TForm1.Stepen(b,e:real; VAR s:real);
begin s:=1;
While e>0 do
begin s:=s*b; e:=e-1;
end;
end;
Једина разлика је TForm1. ознака која нам говори коме припада дефинисана функција.
Променљиве b и e су улазне, а и променљива s је излазни параметар процедуре. Осим
улазних и излазних параметара, у процедури се могу користити и локалне и глобалне
променљиве. Дефиниција процедуре се не сме преклапати са неком другом процедуром или
функцијом, а име процедуре не сме бити исто као име неке друге функције, процедуре или
променљиве. Име процедуре може се слободно изабрати при чему треба водити рачуна да се
не користе резервисане речи и стандардни идентификатори. Обавезно је да име почне словом
енглеске абецеде и не сме да садржи специјалне и знаке интерпункције.
Променљиве b, e и s у заглављу декларације и дефиниције процедуре Stepen су формални
параметри, тј. њихова функција је задовољење форме и немају никакву вредност. Када се
процедура позива из главног програма позива се са стварним, конкретним вредностима и зато
се променљиве у позиву процедуре зову стварни параметри.
Процедура се позива из главног програма навођењем имена и стварних параметара
УВЕК као независна наредба програма. Стварни параметри могу бити променљиве којима су
додељене вредности у претходним наредбама програма, претходно дефинисане функције или
конкретне вредности. Једини услов за стварне параметре је да се морају слагати по типу са
формалним параметрима. Позив процедуре је независна наредба програма и не може се наћи у
оквиру неке друге наредбе или израза у програму. Улазни параметри у позиву процедуре могу
бити променљиве којима су додељене вредности у претходним наредбама програма, позиви
претходно дефинисаних функција или конкретне вредности, а излазни параметри увек морају
бити променљиве. Примери позива процедуре:
Stepen(b,n,s); <- одређује н-ти степен броја б
Stepen(b,3,s); <- одређује трећи степен броја б
Stepen(2,4,s); <- одређује четврти степен броја 2
У функцијама и/или процедурама могу се позивати друге функције и процедуре и
користити њихове вредности да би се добили неки други резултати. Сваки задатак који може
да се реши помоћу једне функције може да се реши и помоћу једне процедуре. Ако је задатак
решен помоћу процедуре онда се он може решити и са онолико функција колико има излазних
резултата у процедури (али то понекад није једноставно јер излазни параметри могу бити
зависни једни од других). Зато се каже да су функције специјална врста процедуре које описују
рачунање са једним излазним резултатом, а које се могу користити непосредно у формулама
за израчунавање других вредности.
Тело функције или процедуре почиње службеном речи begin, а завршава службеном речи
end; између којих се налази потребан број наредби. Сва правила везана за тело програма важе
и у овом случају, само што се, на крају програма ставља симбол тачка, а на крају функције или
процедуре симбол тачка-зарез.
Променљиве које се користе у оквиру неке функције или процедуре могу бити глобалне, ако
су декларисане у главном програму или локалне ако су декларисане у заглављу функције или
процедуре. Глобалне променљиве своју вредност могу добијати и мењати било где у програму и
преносе је из функције или процедуре у било који део програма. Ово, понекад, није практично
јер се може десити да нам вредност променљиве добијена негде у програму треба и након
повратка из функције или процедуре. Зато се чешће користе локалне променљиве. Оне своју
вредност добијају у функцији или процедури у којој су декларисане и могу се користити само
ту. Ако имамо више функција или процедура и у свима су декларисане променљиве истог имена
њихове вредности су независне, не мешају се. Изван функције или процедуре немају никакву
вредност и не могу се користити. Ако је у некој функцији или процедури декларисана локална

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

• Факторијел унетог броја
Улазни параметар функције је број - граница за који се рачуна факторијел. Због ограничења скупа
целих бројева не можемо израчунати факторијел за сваки цео број. То ограничење треба уградити у
главни програм, а функција треба да рачуна факторијел само за бројеве за које не прелази преко
границе за целе бројеве (за бројеве веће од 20 функција не даје тачан резултат, да бисмо решили
проблем са ограничењем целих бројева, можемо резултат прогласити реалним, али ни ово нам не
помаже да добијемо тачан резултат код већих бројева јер факторијел неограничено расте, а меморија
рачунара је ограничена).
function TForm1.Fakt(n:Integer):Int64; // или :Real;
var i:Integer;f:Int64; // или f:Real;
begin f:=1;
For i:=1 to n do
f:=f*i;
fakt:=f;
end;
• Степеновање унетог броја другим унетим бројем

Улазни параметри функције су број који се степенује (основа) и број којим се степенује
(експонент). Због ограничења меморије не може се израчунати степен за сваки број на било
који експонент. Разликујемо два случаја, када је експонент цео број и када је експонент реалан
број. Прво решење је очигледније, друго решење подразумева коришћење логаритама и
експоненцијалне функције јер се у програмирању не може израчунати корен било којег реда.
Друго решење је општије, али користи експоненцијалну функцију и логаритме који се одређују
са извесном грешком, може се десити да се добије резултат који је приближно тачан.
function TForm1.Step(a:Real; n:Integer):Real; // или Step(a,b:Real):Real;
var i:Integer;s:Real;
begin s:=1;
For i:=1 to n do
s:=s*a; // или, уместо комплетног циклуса само: step:=exp(b*ln(a));
step:=s;
end;
• Утврђивање да ли је уписани број прост

Улазни параметар је број који тестирамо, а резултат је логичка вредност true ако је број прост или false
ако број није прост:
function TForm1.Prost(n:Integer):boolean;
var d:integer;
begin If n<4
then prost:=true // сви мањи од 4 су прости бројеви
else If not Odd(n)
then prost:=false // парни бројеви већи од 2 нису прости
else begin d:=3; // тражимо делиоце броја n
{ Пошто су бројеви непарни не могу бити дељиви парним бројем, зато је d:=3 најмањи потенцијални делилац.
У циклусу проверавамо да ли је d делилац броја и да ли је мањи или једнак корену броја (јер је корен броја највећи
делилац који не треба множити већим од њега да би се добио број). Број је прост ако нисмо нашли неки његов
делилац док није d>Sqrt(n) }
While (n mod d<>0)and(d<=Sqrt(n)) do
d:=d+2;
prost:=d>Sqrt(n);
end;
end;
Примери једноставнијих процедура

Улазни параметар процедуре је број - граница за који се рачуна факторијел. Због ограничења скупа
целих бројева не можемо израчунати факторијел за сваки цео број. То ограничење треба уградити у
главни програм, а процедура треба да рачуна факторијел само за бројеве за које не прелази преко
границе за целе бројеве (за бројеве веће од 20 функција не даје тачан резултат, да бисмо решили
проблем са ограничењем целих бројева, можемо резултат прогласити реалним, али ни ово нам не
помаже да добијемо тачан резултат код већих бројева јер факторијел неограничено расте, а меморија
рачунара је ограничена).
procedure TForm1.Fakt(n:Integer; Var f:Int64); // или Var f:Real;

var i:Integer;
begin f:=1;
For i:=1 to n do
f:=f*i;
end;

Улазни параметри процедуре су број који се степенује (основа) и број којим се степенује (експонент), а
излазни параметар је степен. Због ограничења меморије не може се израчунати степен за сваки број на
било који експонент. Разликујемо два случаја, када је експонент цео број и када је експонент реалан број.
Прво решење је очигледније, друго решење подразумева коришћење логаритама и експоненцијалне
функције јер се у програмирању не може израчунати корен било којег реда. Друго решење је општије,
али користи експоненцијалну функцију и логаритме који се одређују са извесном грешком, може се
десити да се добије резултат који је приближно тачан.
procedure TForm1.Step(a:Real; n:Integer; var s:Real); // или Step(a,n:Real; var s:Real);
var i:Integer;
begin s:=1;
For i:=1 to n do
s:=s*a; // или, уместо комплетног циклуса само: step:=exp(b*ln(a));
end;

Улазни параметар је број који тестирамо, а резултат је логичка вредност true ако је број прост или false
ако број није прост:
procedure TForm1.Prost(n:Integer; Var p:boolean);
var d:integer;
begin If n<4
then p:=true
else If not Odd(n)
then p:=false
else begin d:=3;
While (n mod d<>0)and(d<=Sqrt(n)) do
d:=d+2;
p:=d>Sqrt(n);
end;
end;
Примери рекурзивних функција и процедура

Карактеристично за рекурзивну функцију или процедуру је постојање услова који одређује докле ће ће
се рекузија понављати.
function TForm1.Fakt(n:Integer):Int64; // или :Real;
begin If n=0
then fakt:=1
else fakt:=fakt(n-1)*n;
end;
procedure TForm1.Fakt(n:Integer; Var f:Int64); //или Var f:Real);
begin If n=0
then f:=1
else begin fakt(n-1,f);f:=f*n;
end;
end;

function TForm1.Step(o,e:Integer):Integer;
begin If e=0
then step:=1
else step:=step(o,e-1)*o;
end;
procedure TForm1.Step(o,e:Integer; Var s:Integer);
begin If e=0
then s:=1
else begin step(o,e-1,s);s:=s*o;
end;
end;


Почетна вредност променљиве d, која представља потенцијалне делиоце броја који се тестира, у позиву
функције или процедуре мора бити 2.
// рекурзивна функција позива саму себе док не нађе делиоца броја или док је d<=Sqrt(b)
function TForm1.Prost(b,d:Integer):Boolean;
begin prost:=true;
If (b mod d<>0)and(d<=Sqrt(b))
then prost:=Prost(b,d+1)
else If b mod d=0
then prost:=false;
end;
// рекурзивна процедура позива саму себе док не нађе делиоца броја или док је d<=Sqrt(b)
procedure TForm1.Prost(b,d:Integer; Var p:Boolean);
begin p:=true;
then Prost(b,d+1,p)
else If b mod d=0
then p:=false;
end;

• Шта су методе класе?
• Декларација и дефиниција методе.
• Шта су функције?
• Врсте функција.
• Декларација функције.
• Дефиниција функције.
• Шта су процедуре?
• Врсте процедура.
• Декларација процедуре.
• Дефиниција процедуре.
• Разлика између функција и процедура.
• Разлика између private и public декларације.
• Параметри код функција.
• Параметри код процедура.
• Разлика између улазних и излазних параметара.
• Позивање функције.
• Позивање процедуре.
• Формални параметри.
• Стварни параметри.
• Локалне променљиве.
• Глобалне променљиве.

Задаци са функцијама и процедурама
Задаци који следе биће урађени на два начина: први ће бити сирово решавање задатка уз минимално
коришћење уметничког надахнућа, а други начин ће бити покушај да неке од читалаца ових редова
убеди да свет програмирања може бити цветни аранжман који креирамо срцем и свом својом душом.
Задаци са функцијама и процедурама се решавају као и сви други, разлика је само што неке, погодне
делове програма замењујемо позивима функција или процедура и на тај начин олакшавамо писање,
читање и разумевање програма.
Први задатак ћемо објаснити детаљно да би се схватила суштина и предност коришћења кориснички
дефинисаних функција и процедура, док ћемо наредне задатке решавати у тишини, односно, са много
мање коментарисања, препуштајући читаоцима да сами дођу до неких, корисних закључака.
• Саставити програм који одређује n-ти степен уписног броја.
// двокликом на први едит декларише се процедура
// брише резултат ако се промени експонент
// ова процедура није неопходна јер се контрола уноса и
// исписа остварује помоћу ReadOnly контрола едита
procedure TForm1.Edit1Change(Sender: TObject);
begin Edit3.Clear;
end;
// у Object Inspector-у на листићу Events дефинишемо
// реакцију на догађај OnKeyPress
begin If not (key in ['-','0'..'9',#8,#13,#128])
then key:=#27
else If key=#13
end;
// у Object Inspector-у на листићу Events дефинишемо реакцију на догађај OnChange тако што
// из падајућег менија изаберемо већ дефинисану процедуру Edit1KeyPress на тај начин смо
// дефинисали да се резултат брише и ако се основа промени
// у Object Inspector-у на листићу Events дефинишемо реакцију на догађај OnKeyPress
then key:=#27
else If key=#13
then Button1.Click;
end;
// двокликом на тастер Крај рада декларише се процедура
end;
// двокликом на тастер Обриши декларише се процедура
Edit3.Clear;
Edit1.SetFocus;
end;
// двокликом на тастер Одреди декларише се процедура
var n,b:integer;
s:real;
s:=Stepen(b,Abs(n));
If n<0
then Edit3.Text:=Format('%1.5f',[1/s])
else Edit3.Text:=Format('%1.0f',[s]);
Button2.SetFocus;
end;
Функцију Stepen(b,n) ћемо прво декларисати у делу за декларације (испод службене речи private). Ово
морамо да урадимо сами јер функција није реакција на неки догађај, па преводилац не може да је
препозна и декларише сам.
private
function Stepen(o,e:integer):integer;
Оваква декларација значи: функција има формалне целобројне параметре о - основа и е - експонент и
целобројна је. Сада функцију треба дефинисати. То можемо урадити било где у телу програма, а
најједноставније је пре самог краја програма (пре краја са тачком, испред end. додаћемо ред и уписати
дефиницију функције). Комплетну дефиницију, и заглавље и тело функције са наредбама, такође,
пишемо сами.
// функција за одређивање степена природног броја

function TForm1.Stepen(o,e:integer):integer;
var s:integer;
begin s:=1;
While e>0 do
begin s:=s*o;e:=e-1;
end;
stepen:=s;
end;
// рекурзивна функција за одређивање степена природног броја
begin If e=0
then stepen:=1
else stepen:=stepen(o,e-1)*o;
end;
Приметили смо колико је рекурзивна функција једноставније записана, то је њена главна предност.
Услов e=0 је јако важан и одлучује да ли ће се функцији доделити вредност или ће се поново позвати.
Понекад су рекурзивне функције много једноставније (за писање, не увек и за разумевање) и тада се
оправдано користе, други пут су компликованије и нема оправдања за њихово коришћење. На
програмеру је да се определи да ли ће и када користити рекурзивну функцију у решавању неког задатка.
Решићемо сада задатак са процедуром за степеновање.
Разлика је у декларацији и дефиницији процедуре за степеновање као и у позиву из главног програма,
остатак програма је истоветан, па га нећемо поново исписивати.
// декларација процедуре Stepen
private
procedure Stepen(o,e:integer;var s:integer);
// дефиниција процедуре Stepen
procedure TForm1.Stepen(o,e:integer;var s:integer);
begin s:=1;
While e>0 do
end;
end;
// дефиниција рекурзивне процедуре Stepen
procedure TForm1.Stepen(o,e:integer;var s:integer);
begin If e=0
then s:=1;
else begin stepen(o,e-1,s);s:=s*o;
end;
end;
// позивање процедуре Stepen
var n,b:integer;
s:real;
Stepen(b,Abs(n),s);
If n<0
then Edit3.Text:=Format('%1.5f',[1/s])
else Edit3.Text:=Format('%1.0f',[s]);
Button2.SetFocus;
end;
Приметили смо да рекурзивна процедура није много једноставније записана, али то не мора бити увек
тако. Понекад су рекурзивне процедуре много једноставније и тада се оправдано користе, други пут су
компликованије и нема оправдања за њихово коришћење. На програмеру је да се определи да ли ће и
када користити рекурзивну процедуру у решавању неког задатка.
• Саставити програм који одређује факторијел уписаног броја.
then key:=#27
else If key=#13
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
end;


Edit2.Clear;
Edit1.SetFocus;
end;
var n,b:integer;
s:real;
If n<0
then n:=0;
f:=Fakt(n);
Button2.SetFocus;
end;
Функцију Fakt(n) ћемо прво декларисати у делу за декларације.
private
function Fakt(n:integer):integer;
Сада ћемо ову функцију дефинисати.
// функција за одређивање факторијела природног броја
function TForm1.Fakt(n:integer):integer;
var f:integer;
begin f:=1;
While n>0 do
begin f:=f*n;n:=n-1;
end;
fakt:=f;
end;
// рекурзивна функција за одређивање факторијела природног броја
function TForm1.Fakt(n:integer):integer;
begin If n=0
then fakt:=1
end;
Исто, са процедуром.
// декларација процедуре Fakt
private
procedure Fakt(n:integer;var f:integer);
// дефиниција процедуре Fakt
procedure TForm1.Fakt(n:integer;var f:integer);
begin f:=1;
While n>0 do
begin f:=f*n;n:=n-1;
end;
end;
// дефиниција рекурзивне процедуре Fakt
procedure TForm1.Fakt(n:integer;var f:integer);
begin If n=0
then f:=1
else begin fakt(n-1);f:=f*n;
end;
end;
// позивање процедуре Fakt
var n,f:integer;
If n<0
then n:=0;
Fakt(n,f);
Button2.SetFocus;
end;
• Саставити програм који одређује све Армстронгове бројеве до n.

Армстронгови бројеви су они код којих је збир цифара степенованих бројем цифара једнак почетном
броју. Јасно је да за једноцифрене нема смисла проверавати услов јер је n1=n, па можемо рећи да сви
једноцифрени бројеви испуњавају услов да буду Армстронгови. Да бисмо проверили услов за остале,
вишецифрене бројеве декларисаћемо и дефинисати функцију за степеновање и функцију која рачуна
збир степенованих цифара. У главном програму ћемо само позивати одговарајућу функцију и проверавати
испуњеност услова. Армстронгове бројеве ћемо уписивати у мемо поље.
Најпре ћемо креирати форму као на слици, а затим написати комплетан програм:


then key:=#27
else If key=#13
end;
end;
Memo1.Clear;
Edit1.SetFocus;
end;
var n,b:integer;
For b:=1 to n do
If (b<10)or(b=Cifre(b,Length(Edit1.Text)))
Button2.SetFocus;
end;
var s:integer;
begin s:=1;
While e>0 do
end;
stepen:=s;
end;
function TForm1.Cifre(n,m:integer):integer;
var c,z:integer;
begin z:=0;
While n>0 do
begin c:=n mod 10;
n:=n div 10;
z:=z+Stepen(c,m);
end;
cifre:=z;
end;
// Рекурзивна функција за одређивање збирова степена цифара
function TForm1.Cifre(n,m:integer):integer;
var c:integer;
begin If n=0
then cifre:=0
else begin c:=n mod 10;
cifre:=Cifre(n div 10)+Stepen(c,m);
end;
end;
Исто, са процедуром:
var n,b,z:integer;
For b:=1 to n do
begin If b>9
then Cifre(b,Length(Edit1.Text),z)
else z:=b;
If b=z
end;
Button2.SetFocus;
end;
procedure TForm1.Cifre(n,m:integer;var z:integer);
var c:integer;
begin z:=0;
While n>0 do
begin c:=n mod 10;
n:=n div 10;
z:=z+Stepen(c,m);
end;
end;
// Рекурзивна процедура за одређивање збира степена цифара
procedure TForm1.Cifre(n,m:integer;var z:integer);
var c:integer;
begin If n=0
then z:=0
else begin c:=n mod 10;

Cifre(n div 10,z);

z:=z+Stepen(c,m);
end;
end;
Функцију Stepen смо већ описали као рекурзивну, а видели смо и како се степен може одредити помоћу
процедуре и рекурзивне процедуре, па овде нису приказане.
• Саставити програм који исписује све просте бројеве мање од n са две исте цифре.
Направићемо логичку функцију која одређује да ли је неки број
прост и логичку функцију која проверава да ли број има две исте
цифре. Јасно је да једноцифрени прости бројеви не могу имати
две исте цифре, али и да, осим броја 11, нема двоцифрених
простих са две исте цифре. Зато ћемо проверу почети од 101,
наравно, ако је уписани број већи од 100.
Најпре ћемо креирати форму као на слици, а затим написати
then key:=#27
else If key=#13
end;
end;
Memo1.Clear;
Edit1.SetFocus;
end;
var n,b:integer;
If n>11
then Memo1.Lines.Add('11');
b:=101;
While b<=n do
begin If (Prost(b)) and (Isto(b))
b:=b+1;
end;
Button2.SetFocus;
end;
// функција која проверава да ли је број прост
function TForm1.Prost(a:integer):boolean;
var d:integer;
begin d:=3;
While (a mod d<>0)and(d<=Sqrt(a)) do
d:=d+2;
prost:=d>Sqrt(a);
end;
// функција која проверава да ли број има све различите цифре
function TForm1.Isto(a:integer):boolean;
var c:integer;
sc:set of 0..9;
begin sc:=[a mod 10];
a:=a div 10;
isto:=false;
Repeat c:=a mod 10;
a:=a div 10;
If c in sc
then isto:=true
else sc:=sc+[c];
Until a=0;
end;
// рекурзивна функција која проверава да ли је број прост
function TForm1.Prost(b,d:integer):boolean;
begin prost:=true;
else If b mod d=0
then prost:=false;
end;
Ако решавамо задатак рекурзивном функцијом која одређује да ли је број прост позив функције треба
изменити са Prost(b, 3), како бисмо задали почетну вредност за потенцијалне делиоце, односно:
If (Prost(b,3)) and (Isto(b))

Исто, са процедурама:
var n,b:integer;
p:boolean;
If n>11
b:=101;
While b<=n do
begin Prost(b,p);
If p
then begin Isto(b,p);
If p
end;
b:=b+2;
end;
Button2.SetFocus;
end;
// процедура која проверава да ли је број прост
procedure TForm1.Prost(a:integer;var p:boolean);
var d:integer;
begin d:=3;
d:=d+2;
p:=d>Sqrt(a);
end;
// рекурзивна процедура која проверава да ли је број прост
procedure TForm1.Prost(a,d:integer;var p:boolean);
begin If(a mod d<>0)and(d<=Sqrt(a))
then Prost(a,d+2,p)
else p:=d>Sqrt(a);
end;
// процедура која проверава да ли број има све различите цифре
procedure TForm1.Isto(a:integer;var p:boolean);
var c:integer;
sc:set of 0..9;
a:=a div 10;
p:=true;
Repeat c:=a mod 10;
a:=a div 10;
If c in sc
then p:=false
else sc:=sc+[c];
Until a=0;
end;
Процедуру и функцију Isto, такође, можемо написати као рекурзивне, али оне не постају ништа
једноставније, па на томе овог пута нећемо инсистирати.
• Саставити програм који исписује све просте бројеве мање од n са свим различитим
цифрама.
прост и логичку функцију која проверава да ли број има истих
цифара. Јасно је да једноцифрени прости бројеви не могу имати
истих цифар, али и да, осим броја 11, сви двоцифрени прости
имају две различите цифре. Зато ћемо проверу почети од 101,
наравно, ако је уписани број већи од 100.
then key:=#27
else If key=#13
end;
end;
Memo1.Clear;
Edit1.SetFocus;
end;


var n,b:integer;
If n>11
b:=101;
While b<=n do
begin If (Prost(b)) and (Isto(b))
b:=b+2;
end;
Button2.SetFocus;
end;
// функција која проверава да ли је број прост
function TForm1.Prost(a:integer):boolean;
var d:integer;
begin d:=3;
d:=d+2;
prost:=d>Sqrt(a);
end;
// функција која проверава да ли број има све различите цифре
function TForm1.Isto(a:integer):boolean;
var c:integer;
sc:set of 0..9;
a:=a div 10;
isto:=true;
Repeat c:=a mod 10;
a:=a div 10;
If c in sc
then isto:=false
else sc:=sc+[c];
Until a=0;
end;
// рекурзивна функција која проверава да ли је број прост
function TForm1.Prost(b,d:integer):boolean;
begin prost:=true;
else If b mod d=0
then prost:=false;
end;
Ако решавамо задатак рекурзивном функцијом која одређује да ли је број прост позив функције треба
изменити са Prost(b, 3), како бисмо задали почетну вредност за потенцијалне делиоце, односно:
If (Prost(b,3)) and (Isto(b))
var n,b:integer;
p:boolean;
If n>11
b:=101;
While b<=n do
begin Prost(b,p);
If p
then begin Isto(b,p);
If p
end;
b:=b+2;
end;
Button2.SetFocus;
end;
// процедура која проверава да ли је број прост
procedure TForm1.Prost(a:integer;var p:boolean);
var d:integer;
begin d:=3;
d:=d+2;
p:=d>Sqrt(a);
end;
// рекурзивна процедура која проверава да ли је број прост
procedure TForm1.Prost(a,d:integer;var p:boolean);
begin If(a mod d<>0)and(d<=Sqrt(a))
then Prost(a,d+2,p)

else p:=d>Sqrt(a);
end;
// процедура која проверава да ли број има све различите цифре
procedure TForm1.Isto(a:integer;var p:boolean);
var c:integer;
sc:set of 0..9;
a:=a div 10;
p:=true;
Repeat c:=a mod 10;
a:=a div 10;
If c in sc
then p:=false
else sc:=sc+[c];
Until a=0;
end;
Процедуру и функцију Isto, такође, можемо написати као рекурзивне, али оне не постају ништа
једноставније, па на томе ни овог пута нећемо инсистирати.
• Саставити програм који одређује збир цифара савршених бројева до n.
савршен и целобројну функцију која одређује збир цифара броја.
then key:=#27
else If key=#13
then Button1.Click;
end;
end;
Edit2.Clear;
Memo1.Clear;
Edit1.SetFocus;
end;
var n,i,z:integer;
z:=0;
For i:=1 to n do
If Savrsen(i)
then begin Memo1.Lines.Add(IntToStr(i));
z:=z+ZCifara(i);
end;
Edit2.Text:=IntToStr(z);
Button2.SetFocus;
end;
// функција која проверава да ли је број савршен
function TForm1.Savrsen(b:integer):boolean;
var s,d:integer;
begin s:=1;
If b mod d=0
then s:=s+d;
savrsen:=s=b;
end;
// функција која одређује збир цифара броја
function TForm1.ZCifara(b:integer):integer;
var s:integer;
begin s:=0;
Repeat s:=s+b mod 10;
b:=b div 10;
until b=0;
zcifara:=s;
end;
// рекурзивна функција која одређује збир цифара броја
function TForm1.ZCifara(b:integer):integer;
begin If b=0
then zcifara:=0
else zcifara:=b mod 10+zcifara(b div 10);
end;

var n,i,z,s:integer;
p:boolean;
z:=0;
For i:=1 to n do
begin Savrsen(i,p);
If p
then begin Memo1.Lines.Add(IntToStr(i));
ZCifara(i,s);
z:=z+s;
end;
end;
Edit2.Text:=IntToStr(z);
Button2.SetFocus;
Button2.SetFocus;
end;
// процедура која проверава да ли је број савршен
procedure TForm1.Savrsen(b:integer; var p:boolean);
var d,s:integer;
begin s:=1;
If b mod d=0
then s:=s+d;
p:=s=b;
end;
// процедура која одређује збир цифара броја
procedure TForm1.ZCifara(b:integer; var s:integer);
begin s:=0;
While b>0 do
begin s:=s+b mod 10;
b:=b div 10;
end;
end;
• Саставити програм који одређује парове пријатељских бројева до n.

Направићемо целобројну функцију која одређује збир делилаца
броја и позиваћемо је за тестирани број и збир његових делилаца.
then key:=#27
else If key=#13
then Button1.Click;
end;
end;
Memo1.Clear;
Edit1.SetFocus;
end;
var n,a,s,b:integer;
For a:=1 to n do
begin b:=ZDelilaca(a);
s:=ZDelilaca(b);
If (s=a)and(a<b) then
Memo1.Lines.Add(Format('%5d%5d',[a,b]));
end;
end;
// функција која одређује збир делилаца броја
function TForm1.ZDelilaca(b:integer):integer;
var s,d:integer;
begin s:=1;
If b mod d=0
then s:=s+d;
zdelilaca:=s;
end;
Исто са процедуром:
var n,a,s,b:integer;

For a:=1 to n do
begin ZDelilaca(a,b);
ZDelilaca(b,s);
If (s=a)and(a<b)
then Memo1.Lines.Add(Format('%5d%5d',[a,b]));
end;
end;
// процедура која одређује збир делилаца броја
procedure TForm1.ZDelilaca(b:integer;var s:integer);
var d:integer;
begin s:=1;
end;
// рекурзивна процедура која одређује збир делилаца броја
procedure TForm1.ZDelilaca(b,d:integer;var s:integer);
begin If d<2 then s:=1
else begin ZDelilaca(b,d-1,s);
end;
end;
Ако се користи рекурзивна процедура онда треба променити њене позиве у:
ZDelilaca(a,a div 2,b);
ZDelilaca(b,b div 2,s);
• Саставити програм који одређује НЗС и НЗД за два уписана броја.

Направићемо неколико верзија целобројних функцију која ће
одређивати НЗС и НЗД да бисмо што више прихватили начин
решавања проблема функцијама. Наравно, довољно је имати само
једну од приказаних функција.
then key:=#27
else If key=#13
end;
then key:=#27
else If key=#13
then Button1.Click;
end;
end;
Edit1.SetFocus;
end;
var a,b,s:integer;
s:=NZS(a,b);Edit3.Text:=IntToStr(s);
s:=NZD(a,b);Edit4.Text:=IntToStr(s);
Button2.SetFocus;
end;
// функција за одређивање НЗС са циклусом For
function TForm1.NZS(a,b:integer):integer;
var i:integer;
begin For i:=a*b downto a do
If (i mod a=0)and(i mod b=0)
then nzs:=i;
end;
// функција за одређивање НЗС са циклусом While
var s:integer;
begin s:=a;
While s mod b<>0 do s:=s+a;
nzs:=s;
end;

// функција за одређивање НЗС са циклусом Repeat

var s:integer;
begin s:=a*b+a;
Repeat s:=s-a;
until s-a mod b<>0;
nzs:=s;
end;
// функција за одређивање НЗД са циклусом For
function TForm1.NZD(a,b:integer):integer;
var i:integer;
begin For i:=1 to a do
If (a mod i=0)and(b mod i=0) then nzd:=i;
end;
// функција за одређивање НЗД са циклусом While
function TForm1.NZS(a,b:integer):integer; // Euklidov algoritam
var s:integer;
begin While (a mod b<>0)and(b mod a<>0) do
begin If a>b
then a:=a-b
else b:=b-a;
end;
If a<b
then nzs:=a
else nzs:=b;
end;
// рекурзивна функција за одређивање НЗД са циклусом Repeat
function TForm1.NZD(a,b:integer):integer; // Euklidov algoritam
var s:integer;
begin s:=Abs(a-b);
If a<b
then nzd:=NZD(a,s)
else If a>b
then nzd:=NZD(s,b)
else nzd:=a;
end;
Уместо две функције могли смо задатак решити и помоћу једне функције и особине НЗС и НЗД овако:
var a,b,d:integer;
d:=NZD(a,b);Edit4.Text:=IntToStr(d);
Edit3.Text:=IntToStr(a*b div d);
Button2.SetFocus;
end;
// или овако
var a,b,d:integer;
d:=NZS(a,b);Edit3.Text:=IntToStr(d);
Edit4.Text:=IntToStr(a*b div d);
Button2.SetFocus;
end;
Исти, са процедуром:
var a,b,c,d:integer;
NZSiD(a,b,c,d);
Edit3.Text:=IntToStr(c);Edit4.Text:=IntToStr(d);
Button2.SetFocus;
end;
// један од начина записа процедуре за НЗС и НЗД
procedure TForm1.NZS(a,b:integer; VAR c,d:integer); // Euklidov algoritam
begin c:=a*b;
While (a mod b<>0)and(b mod a<>0) do
begin If a>b
then a:=a-b
else b:=b-a;
end;
If a<b
then d:=a
else d:=b;
c:=c div d;
end;

• Саставити програм који декадни број претвара у бинарни или обрнуто.

then key:=#27
else If key=#13
then Button1.Click;
end;
then key:=#27
else If key=#13
then Button2.Click;
end;
end;
Клик мишем у првом или другом едиту брише садржај оба едита:
end;
// превођење бинарног у декадни број - стрелица на доле
var a:string;
Edit2.Text:=IntToStr(Dekadni(a));
end;
function TForm1.Dekadni(a:string):integer;
var s,i,d:integer;
begin s:=1;d:=0;
begin d:=d+StrToInt(a[i])*s;
s:=s*2;
end;
dekadni:=d;
end;
// превођење декадног у бинарни број - стрелица на горе
var d:integer;
begin d:=StrToIntDef(Edit2.Text,0);
Edit1.Text:=Binarni(d);
end;
function TForm1.Binarni(d:integer):string;
var b:string;
begin b:='';
While d>0 do
begin b:=IntToStr(d mod 2)+b;
d:=d div 2;
end;
binarni:=b;
end;
// превођење бинарног у декадни број рекурзивном процедуром:
var a:string;
d:integer;
d:=0;
dekadni(a,1,d);
end;
procedure TForm1.Dekadni(a:string;s:integer;var d:integer);
begin if length(a)=1
then d:=d+StrToInt(a)*s
else begin d:=d+StrToInt(a[Length(a)])*s;
dekadni(Copy(a,1,Length(a)-1),s*2,d);
end;
end;
// превођење декадног у бинарни број рекурзивном процедуром
var a:string;
b:integer;
begin b:=StrToIntDef(Edit2.Text,0);
Binarni(b,a);
Edit1.Text:=a;
end;

procedure TForm1.Binarni(b:integer;var a:string);

begin If b=0
then a:=''
else begin binarni(b div 2,a);
a:=a+IntToStr(b mod 2);
end;
end;
• Саставити програм који римски број претвара у арапски или обрнуто.

begin If not (key in ['I','V','X','L','C','D','M',#8,#13,#128])
then key:=#27
else If key=#13
then Button1.Click;
end;
then key:=#27
else If key=#13
then Button2.Click;
end;
end;
Клик мишем у првом или другом едиту брише садржај оба едита:
end;
// превођење римског у арапски број функцијом - стрелица на доле
var a:string;
If length(a)>0
then begin a:=Arapski(a);
If a=' '
then ShowMessage('Greska u unosu broja')
else Edit2.Text:=a;
end;
end;
function TForm1.Arapski(a:string):string;
var i,b:integer;
g:boolean;
begin g:=false;
b:=0;i:=0;
Repeat i:=i+1;
case a[i] of
'M':If b mod 1000=0
then If b<3000
then b:=b+1000
else g:=true
else If b mod 1000=100
then b:=b+800
else g:=true;
'C':If b mod 100=0
then If(b mod 1000<300)or(b mod 1000>400)and(b mod 1000<800)
then b:=b+100
else g:=true
then b:=b+80
else g:=true;
'X':If b mod 10=0
then If(b mod 100<30)or(b mod 100>40)and(b mod 100<80)
then b:=b+10
else g:=true
else If b mod 10=1
then b:=b+8
else g:=true;
'D':If b mod 1000=0
then b:=b+500
then b:=b+300
else g:=true;
'L':If b mod 100=0
then b:=b+50
then b:=b+30
else g:=true;

'V':If b mod 10=0

then b:=b+5
else If b mod 10=1
then b:=b+3
else g:=true;
'I':If(b mod 10<3)or(b mod 10>4)and(b mod 10<8)
then b:=b+1
else g:=true;
else g:=true;
end;
Until i=length(a);
if g
then arapski:=' '
else arapski:=IntToStr(b);
end;
// превођење арапског у римски број рекурзивном процедуром - стрелица на горе
var a:string;
b:integer;
begin b:=StrToIntDef(Edit2.Text,1);
If (b>3999)or(b<1) then b:=3999;
Rimski(b,0,a);
Edit1.Text:=a;
end;
procedure TForm1.Rimski(a,c:integer;var r:string);
var c1,c2,c3:string;
begin If a>0 then
begin c:=c+1;
case c of
1 : begin c1:='I';c2:='V';c3:='X';
end;
2 : begin c1:='X';c2:='L';c3:='C';
end;
3 : begin c1:='C';c2:='D';c3:='M';
end;
4 : begin c1:='M';c2:=' ';c3:=' ';
end;
end;
case a mod 10 of
1 : r:=c1+r;
2 : r:=c1+c1+r;
3 : r:=c1+c1+c1+r;
4 : r:=c1+c2+r;
5 : r:=c2+r;
6 : r:=c2+c1+r;
7 : r:=c2+c1+c1+r;
8 : r:=c2+c1+c1+c1+r;
9 : r:=c1+c3+r;
end;
Rimski(a div 10,c,r);
end;
end;
• Саставити програм који исписује Паскалов троугао до реда n.

Функцијом BK(n,k) одредићемо к-ти биномни коефицијент у н-том
реду, а н-ти ред ћемо формирати стринг функцијом Red(n) која
ће н пута позивати претходну функцију. Редове ћемо уписивати
у мемо поље. Најпре ћемо креирати форму као на слици, а затим
написати комплетан програм:
then key:=#27
else If key=#13
then Button2.Click;
end;
end;
Memo1.Clear;
Edit1.SetFocus;
end;
var n,p:integer;
begin p:=StrToIntDef(Edit1.Text,10); // овако креирана форма може да прихвати само 10 редова
If p>10 then p:=10; // ограничење се може укинути ако се повећа ширина форме
For n:=0 to p do
Memo1.Lines.Add(Red(n));
Button2.SetFocus;
end;
function TForm1.Red(n:integer):string;
var k:integer;
a:string;
begin a:='1';
For k:=1 to n do
a:=a+Format('%4d',[BK(n,k)]);
red:=a;
end;
function TForm1.BK(n,k:integer):integer;
var i:integer;
b:real;
begin b:=1;
For i:=1 to k do
b:=b*(n-i+1)/i;
bk:=Trunc(b);
end;
Функцију за одређивање биномног коефицијента можемо написати и као рекурзивну:
function TForm1.BK(n,k:integer):real;
begin If k=0
then BK:=1
else BK:=BK(n,k-1)*(n-k+1)/k;
end;
Задатак се може решити и са три функције, овако:
function TForm1.Red(n:integer):string;
var k:integer;
a:string;
begin a:='';
For k:=0 to n do
a:=a+Format('%1.0f',[BK(n,k)])+' ';
red:=a;
end;
function TForm1.BK(n,k:integer):real;
begin bk:=Fakt(n)/(Fakt(k)*Fakt(n-k));
end;
function TForm1.Fakt(n:integer):real;
var f:real;
i:integer;
begin f:=1;
For i:=1 to n do
f:=f*i;
fakt:=f;
end;
Функција за одређивање факторијела може бити и рекурзивна:
function TForm1.Fakt(n:integer):real;
begin If n=0
then fakt:=1
end;
• Саставити програм који са тастатуре прихвата n бројева, а затим одређује број са

највећим и број са најмањим збиром цифара и њихове редне бројеве, као и аритметичку
средину уписаних бројева.
Променљиве k, s, n, max и min декларисаћемо као глобалне јер се
користе у различитим процедурама, а треба да преносе чувају
своју вредност у читавом програму. Прва променљива ће бити
бројач унетих бројева. Друга променљива је збир унетих. Трећа
је граница за унос бројева и уноси се у први едит и не сме бити
нула. Почетна вредност четврте променљиве је -1 јер је то мање
од најмањег могућег збира цифара неког броја, па када се било
који број упише он ће бити са већим збиром цифара и задатак ће
увек имати коректно решење (замислимо да смо за почетну
вредност узели 20, а може се десити да приликом уноса бројева не
унесемо ниједан број са више од две цифре, тј. највећи могући збир
цифара унетих бројева је 18, па се никада неће десити да унети
број има већи збир цифара од 20 и ниједан број се неће исписати
као решење задатка што није коректно). Пета променљива има
почетну вредност maxint (највећи цео број) јер било који
уписани број има мањи збир цифара и задатак ће увек имати

коректно решење. Креираћемо форму као на слици, а затим написати комплетан програм. Неким
глобалним променљивама ћемо дати предефинисану вредност у заглављу програма:
var
k:integer = 0; s:integer = 0;
n:integer;
max:integer = -1; min:integer = maxint;
Form1: TForm1;
then key:=#27
else If key=#13
then Button1.Click;
end;
then key:=#27
else If key=#13
then Button2.Click;
end;
Ове две процедуре можемо заменити једном, нешто мало компликованијом:
begin If key=#13
then If sender=edit1
then Button1.Click
else Button2.Click
else If not (key in ['0'..'9',#8,#128])
then key:=#27
end;
Пошто немамо тастер за брисање, његову фукцију ће преузети процедура - реакција на измену садржаја
првог едита:
Memo1.Clear;
k:=0;s:=0;
max:=-1;min:=maxint;
end;
end;
If n=0 then n:=1;
Edit1Change(sender);
Edit1.Enabled:=false;Button1.Enabled:=false;
Edit2.Enabled:=true; Button2.Enabled:=true;
Edit2.SetFocus;
end;
var b,z:integer;
Memo1.Lines.Add(Edit2.Text);
k:=k+1;s:=s+b;
z:=ZbirCifara(b);
If max<z // одређивање броја са највећим збиром цифара
then begin max:=z;
end;
If min>z // одређивање броја са најмањим збиром цифара
then begin min:=z;
end;
If n=k // крај уноса бројева јер су сви унешени
then begin Edit1.Enabled:=true; Button1.Enabled:=true;
Edit2.Enabled:=false;Button2.Enabled:=false;
Edit7.Text:=FloatToStr(s/n);
Edit1.SetFocus;
end
else begin Edit2.Clear;Edit2.SetFocus;
end;
end;
function TForm1.ZbirCifara(a:integer):integer;
var z:integer;
begin z:=0;
Repeat z:=z+a mod 10;

a:=a div 10;

until a=0;
zbircifara:=z;
end;
Ова функција може се написати и као рекурзивна:
begin If a=0
then zbircifara:=0
else zbircifara:=ZbirCifara(a div 10)+a mod 10;
end;
Ако два уписана броја имају исти збир и то је најмањи или највећи збир цифара као резултат ће се
исписати онај који је први унет. Заменом релације < релацијом <= и релације > релацијом >= исписаће се
последњи унети број што је једнако оправдано. Коректније би било да се испишу сви бројеви који имају
исти, највећи или најмањи збир цифара, али то би било јако компликовано извести са овим нивоом
знања програмирања.
• Уписују се бројеви све док се не упише 0. Саставити програм који одређује број са
највећим и број са најмањим збиром цифара и њихове редне бројеве, као и аритметичку
средину позитивних уписаних бројева.
Задатак врло сличан претходном. Основна и највећа разлика је
што је овде граница за упис бројева непозната. Може се уписати
један, а може се уписати и хиљаду бројева, то се унапред не зна.
Променљиве s, n, k, max и min декларисаћемо као глобалне јер се
користе у различитим процедурама, а треба да преносе чувају
своју вредност у читавом програму. Прва променљива је збир
унетих бројева и на почетку мора бити 0. Друга је бројач унетих
бројева и на почетку је, такође, 0. Трећа променљива броји
позитивне уписане бројеве и почетна вредност јој је, такође, 0.
Почетна вредност четврте променљиве је -1, а пете maxint тако
ће задатак увек имати коректно решење. Креираћемо форму као
на слици, а затим написати комплетан програм. Свим глобалним
променљивама доделићемо предефинисану вредност у заглављу
програма:
var
n:integer = 0; k:integer = 0; max:integer = -1;
s:integer = 0; min:integer = maxint;
Form1: TForm1;
begin If not (key in ['-','0'..'9',#8,#13,#128])
then key:=#27
else If key=#13
then Button1.Click;
end;
end;
Button1.Enabled:=true;
Button2.Enabled:=false;
Memo1.Clear;
n:=0; max:=-maxint;
s:=0; min:=maxint;
Edit1.SetFocus;
end;
var b,z:integer;
If b=0
then begin Edit1.ReadOnly:=true;
Button2.SetFocus;
end
else begin Memo1.Lines.Add(Edit1.Text);
n:=n+1;z:=ZbirCifara(b);
If max<z // одређивање броја са највећим збиром цифара
then begin max:=z;
end;

If min>z // одређивање броја са најмањим збиром цифара

then begin min:=z;
end;
If b>0
then begin s:=s+b;k:=k+1;
Edit6.Text:=Format('%1.5f',[s/n]);
end;
end;
end;
var z:integer;
begin z:=0;
a:=a div 10;
until a=0;
zbircifara:=z;
end;
Ова функција може се написати и као рекурзивна:
begin If a=0
then zbircifara:=0
end;
Ако два уписана броја имају исти збир и то је најмањи или највећи збир цифара као резултат ће се
исписати онај који је први унет. Заменом релације < релацијом <= и релације > релацијом >= исписаће се
последњи унети број што је једнако оправдано. Коректније би било да се испишу сви бројеви који имају
исти, највећи или најмањи збир цифара, али то би било јако компликовано извести са овим нивоом знања
програмирања.
Уместо иницијалног додељивања вредности глобалним променљивама могли смо дефинисати процедуру
у којој се ради то исто, а која се покреће исцртавањем форме на екрану:
begin n:=0; k:=0; max:=-1;
s:=0; min:=maxint;
end;
• Саставити програм који за унети број одређује најближи прости број.

Ако је уписани број прост он је самом себи најближи. Ако број
није прост проверићемо за један манји и за један већи број. Ако је
један од нјих прост он је најближи. Ако су оба проста оба су
најближа и треба их исписати оба. Ако ниједан није прост онда
ћемо манји сманјити за један, а већи повећати за један и радити
нову проверу за ова два броја. Поступак понављамо све док не
нађемо бар један прост број који је онда најближи уписаном броју.
Проверу, да ли је број прост обрадићемо логичком функцијом.
Креираћемо форму као на слици, а затим написати комплетан
програм.
then key:=#27
else If key=#13
then Button1.Click;
end;
end;
Label3.Caption:='';
Edit1.SetFocus;
end;
var i,b:integer;
p,q:boolean;
p:=false;q:=p;
i:=1;
If Prost(b)
then Label3.Caption:='Уписани број је најближи прост.'
else While (not p) and (not q) do
begin p:=Prost(b-i);
q:=Prost(b+i);

If p
then If q
then Label3.Caption:='Најближи прости су '+Format('%1d %1d',[b-i,b+i])
else Label3.Caption:='Најближи прост je '+IntToStr(b-i)
else If q
then Label3.Caption:='Најближи прост je '+IntToStr(b+i)
else i:=i+1;
end;
Button2.SetFocus;
end;
Логичка функција Prost тестира да ли је број прост:
function TForm1.Prost(n:integer):boolean;
var d:integer;
begin If n<4
then prost:=true
else If Odd(n)
then begin d:=3;
While (n mod d<>0)and(d<=Sqrt(n)) do d:=d+2;
prost:=d>Sqrt(n);
end
else prost:=false;
end;
Задатак се може решити и са процедуром уместо функције, али се не добија ништа једноставније. Такође,
задатак би се могао незнатно убрзати ако бисмо водили рачуна да ли је број паран или непаран, па да се
променљива мења за 2 уместо за 1. Но, све то не би битно поправило програм, али би га укомпликовало.
• Саставити програм који исписује n-ти елемент низа чија су прва два елемента дати
бројеви, а сваки следећи елемент се одређује као збир претходна два (Фибоначијев низ).
Ако би почетне вредности два броја биле 0 и 1 онда би то био
Фибоначијев низ у оригиналном опису. Овако само много личи.
Испис елемената низа у мемо поље није неопходан, али је згодно
видети шта програм ради. Елементе низа одредићемо уз помоћ
процедуре. Креираћемо форму као на слици, а затим написати
комплетан програм.
begin If key=#13
then Edit2.SetFocus
else If sender=edit2
then Edit3.SetFocus
else Button1.SetFocus
else If not (key in ['0'..'9',#8,#128])
then key:=#27
end;
var n:integer;
begin n:=StrToInt(Edit1.Text);
If n=0
end;
end;
Edit1.SetFocus;
end;
var a,b,n:integer;
a:=StrToIntDef(Edit2.Text,0);Edit2.Text:=IntToStr(a);
Memo1.Lines.Add(IntToStr(a));
Memo1.Lines.Add(IntToStr(b));
Label8.Caption:=IntToStr(n);
Odredi(n,a,b);
Button2.SetFocus;
end;

procedure TForm1.Odredi(n,a:integer; VAR b:integer);

var i,p:integer;
begin For i:=2 to n do
begin p:=a+b;a:=b;b:=p;
Memo1.Lines.Add(IntToStr(p));
end;
end;
procedure TForm1.Odredi(n,a:integer; VAR b:integer); // рекурзивна процедура
var p:integer;
begin p:=a;
If n>1
then begin b:=a+b;
Memo1.Lines.Add(IntToStr(b));
Odredi(n-1,b-p,b);
end;
end;
// уместо процедуре, може се искористити и ова, прилично једноставна рекурзивна функција
function TForm1.Odredi(n,a,b:integer):integer;
begin If n>1
then begin Memo1.Lines.Add(IntToStr(a+b));
odredi:=Odredi(n-1,b,a+b);
end
else odredi:=b;
end;
• Саставити програм који исписује просте бројеве од m до n код којих је цифра прва са
леве стране већа од 6, а прва са десне стране мања од 4, а затим исписати бројеве са
највећим и најмањим збиром цифара.
Задатак ћемо решити коришћењем две функције: логичке
функције Prost која одређује да ли је неки број прост и целобројне
функције ZbirC која одређује збир цифара броја. Измена садржаја
било ког од прва два едита брише садржаје друга два едита и
мемо поља. Креираћемо форму као на слици, а затим написати
begin If key=#13
then Edit2.SetFocus
else Button1.Click
else If not (key in ['0'..'9',#8,#128])
then key:=#27
end;
Memo1.Clear;
end;
end;
Memo1.Clear;Edit1.SetFocus;
end;
var i,m,n,p,mzc,bmzc,nzc,bnzc:integer;
begin m:=StrToIntDef(Edit1.Text,1);
n:=StrToIntDef(Edit2.Text,11);
If m>n
then begin p:=m; m:=n; n:=p;
end;
mzc:=0;
nzc:=maxint;
For i:=m to n do
If (IntToStr(i)[1]>'6')and(i mod 10<4)and(Prost(i))
then begin p:=ZbirC(i);
Memo1.Lines.Add(IntToStr(i));
If p>mzc
then begin mzc:=p; bmzc:=i;
end;
If p<nzc
then begin nzc:=p; bnzc:=i;
end;
end;

Edit3.Text:=IntToStr(bmzc);
Edit4.Text:=IntToStr(bnzc);
Button2.SetFocus;
end;
function TForm1.Prost(b:integer):boolean;
var d:integer;
begin prost:=false;
If b<4
then prost:=true
else If Odd(b)
then begin d:=3;
While (b mod d<>0)and(d<=Sqrt(b)) do d:=d+2;
If d>Sqrt(b)
then prost:=true;
end;
end;
function TForm1.ZbirC(b:integer):integer;
var z:integer;
begin z:=0;
While b>0 do
begin z:=z+b mod 10;
b:=b div 10;
end;
zbirc:=z;
end;
• Саставити програм који одређује редни број првог елемента низа задатог формулом
xn
an  , n  N , x  R који је мањи од произвољно малог унетог броја .
n!
Задатак ћемо решити коришћењем две већ познате функције
Fakt која одређује факторијел броја и Step која одређује степен
броја (факторијел ће бити реалан број да бисмо могли да радимо
са јако великим бројевима). Креираћемо форму као на слици, а
затим написати комплетан програм. У процедури Edit1KeyPress
ће можда бити потребно заменити #44, тј. ',' са #46, тј. '.' (у
зависности од постављених параметара оперативног система,
конкретно, ознаке за децимални зарез).
begin If key=#13
then Edit2.SetFocus
else Button1.Click
else If not (key in ['0'..'9',#8,#128])
then key:=#27
end;
end;
Edit1.SetFocus;
end;
var e,x,a:real;n:integer;
begin x:=StrToFloatDef(Edit1.Text,1); Edit1.Text:=FloatToStr(x);
e:=StrToFloatDef(Edit2.Text,11);Edit2.Text:=Format('%1.10f',[e]);
Repeat n:=n+1;
a:=Step(x,n)/Fakt(n);
Memo1.Lines.Add(Format('%20.15f',[a]));
until a>e;
Button2.SetFocus;
end;
function TForm1.Fakt(b:integer):real;
var f:real;
begin f:=b;
While b>1 do
begin b:=b-1;
f:=f*b;
end;
fakt:=f;
end;

function TForm1.Step(a:real; n:integer):real;

var s:real;
begin s:=a;
While n>1 do
begin n:=n-1;
s:=s*a;
end;
step:=s;
end;
Уместо ове две функције, згодније је користити једну овакву, која ће смањити проблем великих бројева
код факторијела (чиниоци су све мањи бројеви јер n стално расте, а х је увек исто, па нема проблема са
факторијелом када n пређе преко 20):
function TForm1.Clan(a:real; n:integer):real;
var s:real;
begin s:=a;
While n>1 do
begin n:=n-1;
s:=s*a/n;
end;
clan:=s;
end;
У том случају у процедури Button1Click потребно је наредбу додељивања:
a:=Step(x,n)/Fakt(n);
заменити једноставнијом наредбом:
a:=Clan(x,n);
• Саставити програм који за унети први члан и количник геометријског низа одређује
редни број последњег елемента који је већи од произвољно малог унетог броја .
Да би постојало решење потребно је да а0 буде веће од  или да q
буде веће од 1 (ако је први члан низа мањи од границе и количник
је мањи од 1 сви елементи низа биће мањи од границе, па задатак
нема решења). Претпоставићемо да ће услови задатка бити
испуњени. Задатак ћемо решити коришћењем познате функције
Step која одређује степен броја. Креираћемо форму као на слици,
а затим написати комплетан програм. У процедури Edit1KeyPress
ће можда бити потребно заменити #44, тј. ',' са #46, тј. '.' (у
зависности од постављених параметара оперативног система,
конкретно, ознаке за децимални зарез). Исписивање елемената
низа у мемо поље није обавезно, али је згодно видети понашање
низа када се мења почетна вредност броја х.
begin If key=#13
then Edit2.SetFocus
else If sender=edit2
then Edit3.SetFocus
else Button1.SetFocus
else If not (key in ['0'..'9',#8,#44,#128])
then key:=#27
end;
end;
Edit1.SetFocus;
end;
var e,q,a,c:real;n:integer;
begin a:=StrToFloatDef(Edit1.Text,1) ;Edit1.Text:=FloatToStr(a);
q:=StrToFloatDef(Edit2.Text,1) ;Edit2.Text:=FloatToStr(q);
n:=0;Memo1.Lines.Add('%3d.%18.15f',[n,a]));
Repeat n:=n+1;c:=a*Step(q,n);
Memo1.Lines.Add('%3d.%18.15f',[n,c]));
until c<e;
Edit4.Text:=IntToStr(n-1);
Button2.SetFocus;
end;

function TForm1.Step(a:real; n:integer):real;

var s:real;
begin s:=a;
While n>1 do
begin n:=n-1;
s:=s*a;
end;
step:=s;
end;
Треба рећи да у овом задатку функција није најбоље решење. Ефикасније и ефектније решење било би
са оваквом процедуром:
procedure TForm1.Clan(a,q,e:real; VAR n:integer);
begin n:=0;
While a<=e do
begin Memo1.Lines.Add(Format('%20.15f',[a]));
n:=n+1;a:=a*q;
end;
end;
У том случају процедуру која повезује функције са остатком решења је још једноставнија:
var e,q,a:real;n:integer;
q:=StrToFloatDef(Edit2.Text,1); Edit2.Text:=FloatToStr(q);
Clan(a,q,e,n);
Button2.SetFocus;
end;
• Саставити програм који исписује цифарску пирамиду.

Врло једноставан задатак у коме треба формирати палиндромне
речи састављене од онолико различитих цифара колики је
редни број слоја пирамиде који се гради. Јасно је да пирамида
може имати максимално 10 редова. Да се не би приказао
правоугли троугао треба испис центрирати. Коришћењем мемо
поља и његове карактеристике Alignment може се подесити да се
испис центрира. Овде ћемо, међутим, приказати решење где се
испис центрира програмски. За испис слоја користићемо
функцију Red која ће формирати реч од цифара до одговарајућег
реда. На врху пирамиде поставићемо цифру 1. Креираћемо
форму као на слици, а затим написати комплетан програм.
end;
begin ComboBox1.ItemIndex:=9;
ComboBox1.Enabled:=true;
Memo1.Clear;
ComboBox1.SetFocus;
end;
var n,p:integer;
begin p:=ComboBox1.ItemIndex;
Memo1.Clear;
For n:=0 to p do
Memo1.Lines.Add(Red(n,p));
Button2.SetFocus;
end;
function TForm1.Red(n,p:integer):string;
var k:integer;
a:string;
begin If n=9
then a:='0'
else a:=IntToStr(n+1);
For k:=n downto 1 do
a:=IntToStr(k)+' '+a+' '+IntToStr(k);
For k:=1 to p-n do
a:=' '+a;
red:=a;
end;
Ако желимо да центрирамо садржај мемо поља карактеристиком Alignment мемо поља, из функције
треба избрисати други циклус који додаје потребан број размака на почетак речи да би била центрирана.
• Саставити програм који од унете речи формира пешчани сат тако што у горњем
делу одузима, а у доњем делу додаје по једно слово са обе стране речи.
Једноставан задатак у коме треба формирати све речи које се од
почетне добијају одузимањем по једног слова са десне стране и
распоређивањем речи у облику два једнакокрака троугла са
заједничким врхом. Јасно је да испис мора имати 2*н-1 редова,
где је н број слова у унетој речи, зато је форма подешена да реч
има максимално 13 слова. Ако желимо да користимо дуже речи
морамо проширити мемо поље и повећати висину форме да би се
комплетна слика видела. Да се не би приказала два правоугла
троугла треба испис центрирати. Коришћењем карактеристике
мемо поља Alignment, може се подесити да се испис центрира.
Овде ћемо, међутим, приказати решење где се испис центрира
програмски. За испис слоја користићемо функцију Red која ће
формирати реч од почетне одузимањем потребног броја слова.
програм.
begin If key=#13
then Button1.SetFocus;
end;
end;
begin Edit1.Clear;Edit1.Enabled:=true;
Memo1.Clear;
Edit1.SetFocus;
end;
var n,p:integer;
a:string;
p:=Length(a);
Memo1.Clear;
For n:=1 to (p+1) div 2 do // горњи део пешчаног сата
Memo1.Lines.Add(Red(a,n));
If p mod 2=0 // да се код речи парне дужине средња два слова не би исписивала дупло
then p:=p-1;
For n:=p div 2 downto 1 do // доњи део пешчаног сата је један ред краћи
Memo1.Lines.Add(Red(a,n));
Edit1.Enabled:=false;
Button2.SetFocus;
end;
function TForm1.Red(a:string;n:integer):string;
var k:integer;
b:string;
begin b:=Copy(a,n,Length(a)-2*n+2);
For k:=1 to n do
b:=' '+b;
red:=b;
end;
• Саставити програм који одређује које две од четири тачаке задате координатама у
равни су најближе.
Да бисмо решили овај задатак морамо знати како да одредимо
растојање између две тачке у кординатној равни. Ако нацртамо
у координатној равни две тачке са дужима које представљају
њихове апсисе и ординате, приметићемо правоугли троугао чија
су два темена на хипотенузи дате тачке. Према томе, растојање
између тачака је хипотенуза тог троугла. Катете троугла су
разлике апсциса и ордината тачака, па је формула за тражено
растојање:
d  ( x 1  x2 )2  ( y1  y2 )2 .
Четири тачке одређују шест дужи. Јасно је да треба одредити
међусобна растојања сваке две тачке и, затим најкраће. За унос
координата тачака користићемо два едита, зато ће координате
бити глобалне променљиве. Упоређиваћемо увек само две дужи,
па нећемо имати потребе за превеликим бројем локални променљивих. Да бисмо приказали све тачке,
искористићемо мемо поље. Ако има више парова које су на истом, најкраћем растојању приказаћемо
све парове. Креираћемо форму као на слици, а затим написати комплетан програм.
var
Form1: TForm1;
x1,x2,x3,x4,y1,y2,y3,y4:real;
n:integer=0;
begin If not (key in ['-','0'..'9',#8,#13,#44,#128]) // уместо #44 -> , можда треба #46 -> .
then key:=#27
else If key=#13
then Edit2.SetFocus
else Button1.Click;
end;
end;
begin Edit1.Clear;Edit1.Enabled:=true;
Edit2.Clear;Edit2.Enabled:=true;
Edit3.Clear;
Memo1.Clear;Memo1.Lines.Add('Тачке су:');
Edit1.SetFocus;
end;
var n,p,q:integer;
d,dmin:real;
a,b,c:string;
begin a:=Memo1.Lines.Strings[1];
n:=Length(a);p:=Pos(' ',a);q:=Pos(';',a);
y1:=StrToFloat(Copy(a,q+2,n-q));
x1:=StrToFloat(Copy(a,p+1,q-p-1));
a:=Memo1.Lines.Strings[2];
a:='A12'; // претпостављамо да су најближе прве две тачке, па тражимо ближе од њих
dmin:=DD(x1,y1,x2,y2);Memo1.Lines.Add('A12: '+FloatToSTr(dmin));
d:=DD(x1,y1,x3,y3);Memo1.Lines.Add('A13: '+FloatToSTr(d));
If d<dmin
then begin dmin:=d;a:='A13';
end;
If d<dmin
end;
If d<dmin
end;
If d<dmin
end;
If d<dmin
end;
b:=FloatToSTr(dmin); // проверавамо да ли има више парова тачака на истом растојању
c:=Memo1.Lines.Strings[8]; // проверу почињемо од другог пара тачака
If (b=Copy(c,6,Length(c)-5))and(Copy(c,1,3)<>Copy(a,1,3))
then a:=a+', '+Copy(c,1,3);
c:=Memo1.Lines.Strings[9];

Edit3.Text:=a;
Button3.SetFocus;
end;
var x,y:real;
a:string;
begin x:=StrToFloatDef(Edit1.Text,1);
y:=StrToFloatDef(Edit2.Text,1);
n:=n+1;
a:='A'+IntToStr(n)+': '+FloatToStr(x)+'; '+FloatToStr(y);
Memo1.Lines.Add(a); // унос координата у мемо поље
If n=4 // провера да ли су унете координате све четири тачке
then begin Edit1.Enabled:=false;
Memo1.Lines.Add('');
Memo1.Lines.Add('Растојања су:');
Button2.SetFocus;
end
else begin Edit1.Clear;Edit2.Clear;
Edit1.SetFocus;
end;
end;
function TForm1.DD(x1,y1,x2,y2:real):real;
begin dd:=Sqrt(Sqr(x1-x2)+Sqr(y1-y2));
end;
Задатак је мало компликованији, али смо научили да читамо унете податке из мемо поља и да их
конвертујемо у одговарајући тип и различите употребе стринг променљивих, па је веома корисно
добро га разумети због, евентуалне, касније примене.
• Саставити програм који за унети стринг одређује најдужу и најкраћу реч и одређује
која од њих се прва појављује.
Још један задатак где ће стрингови бити у жижи интересовања.
Јасно је да је тражење најдуже или најкраће речи исти посао,
треба само код услова за дужину речи ставити ознаку > или <.
Зато ћемо написати функцију која ће налазити и једну и другу
реч. Проблем код тражења речи је што се реч може ограничити
размаком или неким од интерпункцијских знакова и да ли ћемо
бројеве писане цифрама рачунати као речи или не (на пример:
да ли је 2000. година број и реч или две речи и ако се договоримо
да су то две речи да ли је 2000 реч или 2000. јер тачка мења
смисао броја). Ове проблеме треба да разреши онај ко прави
захтев за програмским решењима и ми немамо ништа са тим. Ми
само морамо да договорено преточимо у програмски код. У овом
случају, претпоставићемо да је унети стринг састављен само од
слова и интерпункцијских знакова без цртица за поделу и
пренос слогова речи у нови ред. За унос стринга и испис резултата
предвидећемо по једно мемо поље. Могуће је уносити текст и ћирилицом и латиницом. Креираћемо
// скуп дозвољених карактера обухвата ћирилична и латинична слова и знаке интерпункције
procedure TForm1.Memo1KeyPress(Sender: TObject; var Key: Char);
begin If not (key in ['a'..'z','A'..'Z','ђ'..'ш','Ђ'..'Ш','.',',','!','?',' ',#8,#13,#128])
then key:=#27
else If key=#13
then Button1.Click;
end;
end;
Memo2.Clear;Memo1.SetFocus;
end;
var c,d:integer;
a,b:string;
begin a:=Memo1.Text+'.';
If Length(a)>1
then begin Naj(a,1,b,c);
Memo2.Text:='Најдужа реч је '+b;
Naj(a,0,b,d);
Memo2.Lines.Add('Најкраћа реч је '+b);

If c<d
then Memo2.Lines.Add('Најдужа је испред најкраће.')
else Memo2.Lines.Add('Најкраћа је испред најдуже.');
Memo1.ReadOnly:=true;
Button2.SetFocus;
end;
end;
// параметар с вредностима 1 и 0 одређује да ли се тражи најдужа или најкраћа реч
procedure TForm1.Naj(a:string;s:integer; Var b:string; Var n:integer);
var c:string;
g:integer;
begin a:=Obrisi(a); // брише водеће размаке и знакове интерпункције
g:=Duzina(a); // броји слова у првој речи унутар текста
n:=g-1; // прва реч се проглашава најдужом или најкраћом
b:=Copy(a,1,n); // памти се вредност прве речи
Delete(a,1,g); // брише се прва реч из унетог текста
a:=Obrisi(a); // брише водеће размаке и знакове интерпункције у новом тексту
While Length(a)>0 do // тражи се дужа или краћа реч све док има слова у тексту
begin g:=Duzina(a); // броји слова у првој речи унутар текста
c:=Copy(a,1,g-1); // памти се вредност нове речи
Delete(a,1,g); // брише се реч из текста
If (Length(c)>n)and(s=1) // проверава да ли је нова реч најдужа
or(Length(c)<n)and(s=0) // проверава да ли је нова реч најкраћа
then begin n:=g-1; // памти се нова најдужа или најкраћа дужина
b:=c; // памти се вредност речи
end;
a:=Obrisi(a); // брише водеће размаке и знакове интерпункције
end;
end;
//функција одређује број слова у следећој речи у унетом тексту
function TForm1.Duzina(a:string):integer;
var g:integer;
begin g:=Pos(' ',a);
If g=0 then g:=Length(a);
If (Pos(',',a)<g)and(Pos(',',a)>0)
then g:=Pos(',',a);
If (Pos('.',a)<g)and(Pos('.',a)>0)
then g:=Pos('.',a);
If (Pos('!',a)<g)and(Pos('!',a)>0)
then g:=Pos('!',a);
If (Pos('?',a)<g)and(Pos('?',a)>0)
then g:=Pos('?',a);
duzina:=g;
end;
// функција брише дупле размаке и удвојене знаке интерпункције
function TForm1.Obrisi(a:string):string;
begin While (Length(a)>0) and
(not (a[1] in ['a'..'z','A'..'Z','ђ'..'ш','Ђ'..'Ш'])) do
Delete(a,1,1);
obrisi:=a;
end;
Задаци за самостални рад

• Саставити програм који израчунава обим и површину троугла задатог помоћу
координата његових темена.
• Саставити програм који израчунава вредност функције задате формулом:
 min( x , 5), x  0

f ( x )  15  x  5, 0  x  1
 max( x ,10), x  1

• Саставити програм који израчунава вредност функције задате формулом:
1 1 1
f (x )  1    , x N
1  12 1  12  13 1  12  13  1x
• Саставити програм који исписује све бројеве од m до n који су дељиви сваком својом
цифром.
• Саставити програм који симулира бацање коцкице све док се три пута за редом не
добије исти број, а затим исписати статистику појављивања сваког броја.
• Саставити програм који исписује назив дана за било који датум за године од 1900. до
2100.
• Саставити програм који исписује календар за било који месец за године од 1900. до 2100.
• Саставити програм који одређује разлику у данима између два датума за године од
1900. до 2100.
• Саставити програм који за унети датум одређује датум који је био пре и који ће бити
после унетог броја дана.
• Саставити програм који одређује колико има бројева од m до n који нису прости и чија
је последња цифра мања од 6, а прва већа од 4, исписати их одредити збир њихових
цифара.
• Дати су бројеви: a, b, c, d. Формирају се два низа на следећи начин:
први низ: a, a+b, a+b+a, a+b+a+b, a+b+a+b+a, ...
други низ: c, c+d, c+d+c, c+d+c+d, c+d+c+d+c, ...
Саставити програм који одређује првих n елемената низова који су једнаки и
исписати њихове редне бројеве.
• Саставити програм који одредује збир непарних цифара бројева од м до н.
• Саставити програм који исписује двоцифрене бројеве код којих је цифра десетица
дељива цифром јединица.
• Саставити програм који одредује колико пута се цифра ц појаљује у бројевима од м до н.
• Саставити програм који одредује број од м до н који има највише делилаца.
• Саставити програм који исписује све двоцифрене бројеве чија се сума цифара не мења
при множењу бројевима од 2 до 9.
• Саставити програм који исписује све троцифрене бројеве код којих је сума цифара
једнака датом целом броју.
• Саставити програм који одређује које две од четири тачаке задате координатама у
простору су најближе.
• Саставити програм који за два уписана стринга одређује најдужи заједнички подниз
• Написати програм којим се одређују сви троцифрени бројеви који су једнаки суми
факторијела својих цифара.
• Кинески цар Циу Ши је развијао своје царство и свако село је било у обавези да му у
току године пошаље лопту од ћилибарда одређеног полупречника. Он је лопте слагао
на под у једној од својих одаја, тако да чине троугао једнаких страница.Када би освајао
села или оснивао нова увек је водио рачуна о броју и о томе да када те године добије по
лопту од свих села може да их дода на сваку страницу по један ред и да опет добије
троугао једнаких страница. Написати програм у коме се задаје тренутан број лопти
Н на једној страници троугла, а који израчунава колико села укупно цар мора да има
те године да би допунио свој троугао до новог троугла.

Тип низ
Код рада са већом количином података врло често се јавља потреба за великим бројем
променљивих које би чувале потребне вредности. У већини таквих случајева број неопходних
променљивих је или јако велики или се и не зна колико променљивих ће бити употребљено у
програму. Да би се олакшало решавање оваквог типа проблема уводи се појам низа. Низ је
уређени скуп података једног типа са заједничким именом које се назива именом низа. Тип
низ има следеће особине:
• Садржи коначан, унапред одређен број чланова (низ може имати произвољно много
чланова, што засвиси од потреба проблема који се решава и од расположиве меморије)
• Сви чланови једног низа морају бити истог типа
• Сваки члан се означава именом низа и својим индексом (редним бројем)
• Индекси чланова једног низа морају бити истог типа.
Да би се низ могао користити у програму мора бити претходно дефинисан (имплицитно или
експлицитно). Експлицитна дефиниција подразумева да се дефинише нови тип података који
има своје име. Имплицитна дефиниција се користи када не желимо да измишљамо име новом
типу података, него га само описујемо кроз декларацију променљивих које му припадају.
Декларација променљиве типа низ се састоји у давању имена низа и одређивању типа индекса
и типа чланова низа. Тип индекса мора бити интервални подтип уређених простих типова
(boolean, char, integer, набројани). Тип чланова низа може бити било који дефинисани тип.
Декларацијом низа резервише се количина меморије потребна за чување свих његових
елемената без обзира да ли ће се сви они користити у програму или не.
ARRAY[1..100] of REAL
низ може имати највише сто чланова који су реални бројеви, резервише се меморија за
чување сто реалних бројева, а у програму можемо користити, рецимо, само првих 15
елемената низа
ARRAY['a'..'z'] of INTEGER
низ може имати највише 26 чланова који су целобројних и чији индекси су мала слова
енглеске абецеде, резервише се меморија за чување 26 целих бројева
Службена реч array је обавезна код декларације низовног типа.
Ако се некој речи придружи декларација низовног типа онда она постаје нови,
дефинисани (изведени) тип и може се употребљавати као да је стандардни тип (експлицитна
дефиниција иза).
TYPE NIZ=ARRAY[1..50] of INTEGER;
{ дефинишемо нови тип података који се зове NIZ и представља низ који може имати
највише педесет целобројних елемената }
ZNAK=(pik,karo,herc,tref);
{ дефинишемо набројани тип са именом ZNAK са четири елемента који су наведени у
загради }
BROJ=1..14;
{ дефинишемо интервални тип са именом BROJ са четрнаест елемента који су дати у
облику интервала }
SPIL=ARRAY[znak] of broj;
{ дефинишемо нови тип података низ SPIL и који може имати највише четири елемента
који могу бити цели бројеви од 1 до 14 }
Када смо дефинисали нове типове података, помоћу њих можемо да дефинишемо
променљиве које ћемо користити у програму на уобичајен начин:
VAR a:INTEGER;
b:NIZ;
karta:SPIL;

Све операције које су дозвољене у раду са променљивама типа којег су чланови низа
дозвољене су и у раду са члановима тог низа.
Два низа се могу упоређивати ако су им једнаки типови. У том случају кажемо да су два
низа једнака ако имају једнак број елемената и одговарајући чланови су им једнаки (први са
првим, други са другим, итд).
Једнодимензионални низови.
Линеарно уређени низ једноиндексних променљивих чини једнодимензионални низ.
При декларацији сваког низа преводилац резервише потребну количина меморије за
чување вредности свих елемената низа, без обзира да ли се они користе или не у програму,
зато максималан број чланова једнодимензионалног низа (исто тако и сваког другог низа)
зависи од расположиве количине радне меморије рачунара. У случају да нема довољно
меморије за чување декларисаног низа добићемо једну од следећих порука:
"Error 22: Structure too large" или
"Error 96: Too many variables"
Грешке се отклањају смањењем дужине низова или променом типа елемената низова
или се другачијим алгоритмом број низова смањи и ослободи довољна количина меморије.
У делфију програм може користити целокупну слободну RAM меморију, па се овакве
грешке неће јављати, али и овде важе нека ограничења, међутим у задацима са којима ћемо се
сретати у животу обичних смртника нећемо имати проблема са недостатком меморије за
чување вредности чланова низа.
Примери декларација једнодимензионалних низова
Декларација променљиве типа низ (тип низ је имплицитно дефинисан, нема своје име и
не може се користити као тип података улазних и излазних параметара функција и
процедура):
VAR x:ARRAY[1..20] of REAL;
једнодимензионални низ од највише двадесет реалних бројева.
VAR slovo:ARRAY[1..55] of CHAR;
једнодимензионални низ типа карактер са највише 55 елемената.
Експлицитно дефинисани тип низ и декларација променљивих типа низ помоћу њега
(овако дефинисан тип низ може се користити за декларацију улазних и излазних параметара
функција и процедура):
TYPE rniz=ARRAY[1..20] of REAL;
cniz=ARRAY[1..55] of CHAR
VAR y:rniz;
једнодимензионални низ од највише двадесет реалних бројева.
VAR slovo:cniz;
једнодимензионални низ типа карактер са највише 55 елемената.
Променљиве x и y из претходних примера формално нису истог типа и не могу се
упоређивати или замењивати у позивима функција и процедура.
Основне операције са низовима

• израчунавање просечне вредности
Ако треба одредити просечну вредност елемената низа то значи да треба сабрати све
елементе низа и поделити тај збир са бројем елемената низа. Као и увек, код рачунања
збирова у циклусу, морамо за почетну вредност узети неки број који неће утицати на решење
проблема, у овом случају то ће бити 0. Затим ћемо у циклусу for сабирати све елементе низа. На
крају ћемо исписати тражени резултат.
zbir:=0; // почетна вредност за збир елемената низа
For i:=1 to n do // n je број елемената низа
begin // овде треба учитати или генерисати нови елемент низа ако низ није претходно формиран
zbir:=zbir+a[i]; // нови елемент низа се сабира са свим претходним
end;
arsred:=zbir/n // одређује се просечна вредност елемената низа, наравно,
// треба водити рачуна o декларисаним типовима променљивих

Нешто је већи проблем ако се низ уноси све до испуњења неког услова, односно, низ има
највише 100 елемената (на пример, не мора бити 100, може бити било који унапред задати
број), а елементи се уносе све док се не унесе 0 (када се унесе 0 то није елемент низа, већ то
значи да су унети сви елементи низа). Тада би овај задатак морао да се решава помоћу циклуса
са условом, најбоље са while.
zbir:=0; // почетна вредност за збир елемената низа
n:=0; // број елемената низа је 0 јер још није унет ни један
broj:=... // овде треба унети вредност помоћне променљиве broj
While (n<=100)and(broj<>0) do // ако није унета 0 формира се неки елемент низа
begin n:=n+1; // редни број елемента низа увећава се за један
a[n]:=broj; // додаје се нови елемент низа
zbir:=zbir+a[n]; // нови елемент низа се сабира са свим претходним
broj:=... // овде треба унети нову вредност помоћне променљиве broj
end;
arsred:=zbir/n // одређује се просечна вредност елемената низа, наравно,
// треба водити рачуна o декларисаним типовима променљивих
• израчунавање минималне / максималне вредности низа

Код одређивања максималне и минималне вредности низа користићемо две помоћне
променљиве које ће на почетку имати вредност првог елемента низа, а затим ћемо их
упоређивати са осталим елементима низа и кад год пронађемо елемент који је већи од прве
променљиве доделићемо јој ту вредност, односно, када нађемо елемент низа који је мањи од
друге променљиве доделићемо јој ту вредност.
min:=a[1];
max:=a[1];
For i:=2 to n do // циклус креће од 2 јер нема потребе тестирати први елемент
If a[i]>max
then max:=a[i] // ако је елемент низа већи од највећег, онда је он највећи
else If a[i]<min
then min:=a[i]; // ако је елемент низа мањи од најмањег, онда је он најмањи
За почетну вредност променљивих min и max не мора се узети први елемент низа, сасвим
би исправно радио програм и ако бисмо узели било који елемент низа, али је овако
једноставније и јасније. Оваква метода налажења екстремних вредности позната је као метода
лажне претпоставке.
• претраживање у низу
Претраживање у низу који није уређен своди се на претходни пример, разлика је само
што не тражимо највећи или најмањи елемент низа већ елемент који задовољава неки услов,
већи је или је мањи од неког задатог броја или је једнак неком броју. Програм би нам могао
дати одговор да ли такав елемент постоји и колико је таквих елемената у низу.
Ако треба одредити редни број елемента у уређеном низу који испуњава неки услов онда
можемо применити различите методе претраживања, али је најједноставније користити
методу половљења. Проверавамо да ли је елемент на средини низа тражени, па ако није
одређујемо у којој половини низа се он налази, делимо низ на пола и узимамо половину низа у
којој се налази тражени елемент. Сада ту половину низа посматрамо као неки низ и
понављамо претходни поступак. Овако организован програм би могао дати одговор да ли
постоји одговарајући елемент и који је његов редни број, али и колико таквих елемената има.
• сортирање низа
Код сортирања низа потребно је упоређивати узастопне елементе и наместити да свака
два узастона елемента буду у одговарајућем поретку. Низ може бити уређен у растућем или
опадајућем поретку. Но, ова два поретка, строго математички гледано, подразумевају да у
низу нема истих елемената. Пошто ми унапред не знамо да ли ће у низу бити истих елемената
или не, уместо појма растући користимо појам неопадајући, а уместо појма опадајући
користимо појам нерастући.
Размотримо случај неопадајућег поретка (јер читањем неопадајућег низа од краја према
почетку добијамо нерастуће поређане елементе низа). Да бисмо били сигурни да је низ уређен
у неопадајући поредак није довољно једном проћи кроз низ и наместити да сваки други од два
узастопна елемента буде већи или једнак првом јер не знамо какав је однос претходних
елемената низа са мањим од ова два. Показаћемо то на простом примеру:

Нека је дат низ 2, 3, 1. Упоређиваћемо први са другим и други са трећим. Пошто је први
мањи од другог ништа се не мења, а пошто је други већи од трећег заменићемо им места.
Добили смо низ 2, 1, 3 који, очигледно, није неопадајући јер је први елемент низа већи од
другог.
Зато, код уређивања низа морамо сваки елемент низа упоређивати са свима иза њега. То
ћемо остварити двоструким циклусом. Први циклус ће почети од првог елемента низа и
извршаваће се све док не стигнемо до претпоследњег, тј. узимаће први елемент у пару
елемената низа. Други циклус почиње са првим следећим елементом и извршаваће се док не
стигнемо до последњег, тј. редни број другог елемента у пару биће увек већи од редног броја
првог елемента. Затим ћемо упоређивати ова два елемента, једног из првог циклуса и једног
из другог, и кад год нам њихов редослед не одговара заменићемо им места. Практично ћемо то
записати овако:
// нека је n укупан број елемената у низу
For i:=1 to n-1 do // i је редни број првог у пару елемената низа који се упоређују
For j:=i+1 to n do // ј је редни број другог у пару елемената низа
If a[i]>a[j] then // проверавамо да ли је нарушен поредак елемената низа
begin // ако јесте елементима мењамо места
p:=a[i]; // вредност првог елемента чувамо у помоћној променљивој р
a[i]:=a[j]; // први елемент узима вредност другог елемента низа
a[j]:=p; // други елеменат узима вредност првог сачувану у помоћној
end;
Уређивање у нерастући поредак остварило би се на исти начин, једино би се уместо
релације веће од користила релација мање од:
// нека је n укупан број елемената у низу
For i:=1 to n-1 do // i је редни број првог у пару елемената низа који се упоређују
For j:=i+1 to n do // ј је редни број другог у пару елемената низа
If a[i]<a[j] then // проверавамо да ли је нарушен поредак елемената низа
begin // ако јесте елементима мењамо места
p:=a[i]; // вредност првог елемента чувамо у помоћној променљивој р
a[i]:=a[j]; // први елемент узима вредност другог елемента низа
a[j]:=p; // други елеменат узима вредност првог сачувану у помоћној
end;
Постоје и другачији алгоритми за сортирање низа. Овај је најефикаснији када низ има
мањи број елемената. У случају сортирања низа са јако великим бројем елемената треба
изабрати неки други алгоритам јер је овај прилично спор.
Дводимензионални низови
Дводимензионалним низом зовемо низ двоиндексних променљивих. Ова врста низова
обично се назива матрица или таблица, хоризонтални елементи чине редове, а вертикални
колоне матрице. Индекси низа имају своје границе, али оне не морају бити једнаке. Ако су
границе једнаке матрицу зовемо квадратном. Елементи од горњег левог до доњег десног у
квадратној матрици чине главну, а елементи од горњег десног до доњег левог споредну
дијагоналу. Типови индекса не морају да буду једнаки, тј. један индекс може бити цео број, а
други, на пример, типа карактер. Укупан број декларисаних променљивих, за које се
резервише меморија, код дводимензионалног низа добија се када се највећи редни бројеви
оба индекса помноже.
TYPE MATRICA=ARRAY [1..10,1..20] of INTEGER;
дефинише се тип дводимензионални низ са 10 * 20 = 200 целобројних чланова.
TYPE FIGURA=(prazno,pesak,top,konj,lovac,kralj,dama);
SAHTABLA=ARRAY['a'..'h',1..8] of FIGURA;
VAR mesto:SAHTABLA;
дефинишу се типови фигура и шахтабла и декларише се дводимензионални низ са 8 * 8 =
64 елемената типа фигура.
Аналогно би се могао дефинисати низ са више индекса, на пример троиндексни низ је
низ троиндексних променљивих, итд. Начин рада са таквим, вишедимензионалним низовима,
би био аналоган раду са једнодимензионалним или дводимензионалним низовима. Низ се
најпре декларише, члановима се доделе неке вредности и обави се задатак због којег је низ
формиран. Но, мора се признати да се врло ретко јавља потреба за низовима са више од три
димензије (индекса), али добро је знати да је и то могуће. Наравно са повећањем броја
димензија низа повећава се потреба за меморијом, па се смањује максимална, реално могућа,
дужина таквих низова.

Алгоритми за израчунавања и трансформације на табели и њеним деловима.

• Збир два дводимензионална низа
Најједноставнија математичка операција са два дводимензионална низа је одређивање
њиховог збира. Збир је, такође, дводимнезионални низ чији се елементи добијају сабирањем
одговарајућих елемената оба низа. Да би се
два низа могла сабирати морају имати исте
димензије, односно, број редова и колона
једног мора бити једнак броју редова и
колона другог низа (не морају бити квадратни као на слици).
Алгоритам за сабирање низова ћемо записати на следећи начин:
For i:=1 to n do
For j:=1 to m do
c[i,j]:=a[i,j]+b[i,j];
• Производ два дводимензионална низа

Да би се два дводимензионална низа могла помножити обавезно мора број колона првог
бити једнак броју редова другог низа (број редова првог и број колона другог
дводимензионалног низа не морају бити једнаки). Производ два дводимензионална низа
димензија NxK и KxM је дводимензионални
низ димензије NxM чији се елементи
добијају као збир производа свих елемената
одговарајуће колоне првог низа и елемената
одговарајућег реда другог низа.
Алгоритам за множење низова ћемо записати на следећи начин (n - број редова првог, m -
број колона другог низа):
For i:=1 to n do
For j:=1 to m do
begin c[i,j]:=0;
For k:=1 to p do
c[i,j]:=c[i,j]+a[i,k]*b[k,j];
end;
• Додавање колоне или реда

Нека треба додати један ред дводимензионалном низу димензија N x M, после његовог
к-тог реда. То значи да ћемо имати нови низ са димензијама (N+1) x M. Додавање реда ћемо
остварити тако што ћемо редове од k+1 до n преписати у редове k+2 do n+1, a на место k+1 ћемо
уметнути нови ред низа. Ради једноставнијег записа алгоритма, посматраћемо ред који треба
уметнути као једнодимензионални низ.
Алгоритам за додавање реда ћемо записати на следећи начин:
For j:=1 to m do
begin For i:=n+1 downto k+2 do
a[i,j]:=a[i-1,j];
a[k+1,j]:=b[j];
end;
n:=n+1;
Алгоритам за додавање колоне ћемо записати на следећи начин:
For i:=1 to n do
begin For j:=m+1 downto k+2 do
a[i,j]:=a[i,j-1];
a[i,k+1]:=b[i];
end;
n:=n+1;
• Брисање колоне или реда

Нека треба обрисати један ред дводимензионалном низу димензија N x M, на пример к-ти
ред. То значи да ћемо имати нови низ са димензијама (N-1) x M. Брисање реда ћемо остварити
тако што ћемо редове од k+1 до n преписати у редове k do n-1, а затим прву променљиву (N)
смањити за један. Брисање колоне ћемо остварити тако што ћемо колоне од k+1 до m
преписати у колоне k do m-1, а затим другу променљиву (M) смањити за један.
Алгоритам за брисање реда ћемо записати на следећи начин:
For j:=1 to m do
For i:=k to n-1 do
a[i,j]:=a[i+1,j];
n:=n-1;

Алгоритам за брисање колоне ћемо записати на следећи начин:

For i:=1 to n do
For j:=k to m-1 do
a[i,j]:=a[i,j+1];
m:=m-1;
Визуелна компонента за табеларни приказ текста.

За приказивање елемената дводимензионалног низа може се
користити мемо поље, при чему морамо форматизовати сваки
елемент и сваки ред низа како бисмо добили табелу или можемо
користити компоненту StringGrid. Црвено обојена поља на слици су
фиксна, тј. у фази извршавања програма кориснику није дозвољен
приступ овим пољима. Карактеристике које би требало подесити
су:
Align - положај грида у односу на рубове форме
ColCount - број колона
DefaultColWidth - предефинисана ширина колона
DefaultRowHeight - предефинисана висина редова
Enabled - доступност активностима корисника
FixedColor - боја фиксних поља
FixedCols - број фиксних колона
FixedRows - број фиксних редова
Font - врста фонта којим се попуњава грид
GridLineWidth - дебљина линија које ограничавају поља грида
Height - висина грида
Left - растојање од левог руба форме
Name - име грида
RowCount - број редова грида
ScrollBars - да ли се приказују хоризонтални и вертикални клизач ако сва поља
грида нису видљива
Top - растојање од врха форме
Visible - да ли је видљив грид
Width - ширина грида
Ако желимо да дводимензионални низ буде исписан у гриду, онда морамо знати да је
први аргумент грида редни број колоне, а други реда (супротно од дводимензионалног низа).
Попуњавање остварујемо са:
For i:=1 to 6 do
For j:=1 to 7 do
StringGrid1.Cells[j,i]:=IntToStr(a[i,j]);
Компонента StringGrid се може користити за табеларно приказивање текста. У том

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

Задаци са низовима
Претходни задаци решени су без коришћења типа низ и предности које он доноси. Следе задаци који ће
бити решавани са променљивама типа низ. Формирање низа може се остварити на три начина:
директним уписом преко тастатуре, генерисањем бројева помоћу функције Random или преузимањем
података из датотеке (мада се и та датотека мора некако попунити). У зависности од изабраног начина
формирања низа форма може бити дизајнирана на два начина: са делом за унос елемената низа или без
тог дела. Урадићемо први задатак са уносом елемената помоћу тастатуре, а све остале ћемо решавати
генерисањем елемената низа.
• Саставити програм који формира низ са највише 100 троцифрених бројева, а затим
одређује број и збир непарних и аритметичку средину парних елемената низа
За унос елемената помоћу тастатуре морамо предвидети: едит за
унос дужине низа и едит за унос елемената низа и тастере за
потврду оба уноса. Задатак ће бити решен онако како би
кориснику апликације било најједноставније. Креираћемо
Најпре ћемо дефинисати нови тип података - низ у делу за
дефиниције типова (на самом почетку јунита - глобални тип):
type
niz=array[1..100] of integer;
...
Затим ћемо декларисати глобалне променљиве n - број
елемената низа и k - бројач елемената низа, које су цели бројеви
и a - променљива типа низ у делу за декларације:
var
Form1: TForm1;
n,k:integer;
a:niz;
Да бисмо имали потпуну контролу над програмом, поставићемо следеће карактеристике објеката на
форми: Edit2.Enabled - false, Button2.Enabled - false, Edit3.ReadOnly - true, Edit4.ReadOnly - true,
Edit5.ReadOnly - true, Memo1.ReadOnly - true. Да не бисмо имали четири тастера на форми, уместо
тастера за брисање написаћемо процедуру која ће брисати претходни унос низа када се курсор постави
у први едит.
begin Memo1.Clear;Edit1.Clear;
end;
Забранићемо кориснику да уноси слова и знакове у прва два едита.
begin If key=#13
then Button1.Click
else Button2.Click
else If not (key in ['0'..'9',#8,#128])
then key:=#27;
end;
Када се унесе дужина низа глобалне променљиве n и k добиће одговарајуће вредности.
If n>100 // забрањујемо унос више од 100 елемената низа због дефинције низа
then n:=100;
Edit1.Enabled:=false; // забрањује се приступ едиту 1
Edit2.Enabled:=true; // дозвољава се приступ едиту 2
Button1.Enabled:=false; // забрањује се употреба тастера 1
Button2.Enabled:=true; // дозвољава се употреба тастера 2
k:=0; // бројач елемената низа постављамо на 0
Edit2.SetFocus; // курсор постављамо у други едит
end;
Сада се уносе елеменати низа помоћу тастатуре, уносе се у мемо поље, одређују се тражени резултати и
исписују у предвиђене едите.
var par,zp,zn:integer;
begin k:=k+1;
a[k]:=StrToIntDef(Edit2.Text,100);
If a[k]<100 // забрањујемо унос једноцифрених и двоцифрених бројева
then a[k]:=100;

Edit2.Text:=IntToStr(a[k]);
Memo1.Lines.Add(IntToStr(k)+'. '+Edit2.Text); // исписујемо елемент низа у мемо поље
If k<n // припремамо унос следећег елемента
end
else begin Edit2.Enabled:=false; // забрањује се приступ едиту 2
Button2.Enabled:=false; // забрањује се употреба тастера 2
par:=0;zp:=0;zn:=0; // почетне вредности бројача и збирова
For k:=1 to n do
If Odd(a[k])
then zn:=zn+a[k] // сабирамо непарне елементе низа
else begin par:=par+1; // бројимо парне елементе
zp:=zp+a[k]; // сабирамо парне елементе
end;
Edit3.Text:=IntToStr(zn);
Edit4.Text:=IntToStr(n-par); // број непарних елемената
If par>0 // аритметичку средину тражимо ако има парних
then Edit4.Text:=Format('%1.5f',[zp/par])
else Edit4.Text:='0';
Button1.Enabled:=true; // дозвољава се употреба тастера 1
Edit1.Enabled:=true; // дозвољава се приступ едиту 1
Button3.SetFocus; // жижу постављамо на тастер крај рада
end;
end;
Још само недостаје процедура за крај рада.
end;
• Саставити програм који генерише низ са највише 100 троцифрених бројева, а затим
одређује збир и број парних и аритметичку средину непарних елемената низа
Задатак је готово идентичан претходном, само што ћемо овде
генерисати троцифрене бројеве помоћу Random функције.
програм. Најпре ћемо дефинисати нови тип података - низ у делу
за дефиниције типова (на самом почетку јунита - глобални тип):
type
...
Затим ћемо декларисати глобалне променљиве n - број
елемената низа и a - променљива типа низ у делу за декларације:
var
Form1: TForm1;
n:integer = 0;
a:niz;
Уносимо само број елемената низа, па су сви, осим тог едита
заштићени од уноса. Можемо додати тастер за брисање или задржати процедуру за брисање из
претходног задатка.
begin Memo1.Clear;Edit1.Clear;
end;
begin If key=#13
then Button1.Click
else If not (key in ['0'..'9',#8,#128])
then key:=#27;
end;
var k:integer;
If n>100
then n:=100;
Randomize;
For k:=1 to n do
begin a[k]:=Random(900)+100;
Memo1.Lines.Add(IntToStr(k)+'. '+IntToStr(a[k]));
end;
Button2.SetFocus;
end;
procedure TForm1.Button2.Click(Sender: TObject);

var nep,zp,zn,k:integer;
begin par:=0;
zp:=0;zn:=0;
For k:=1 to n do
If Odd(a[k])
then zp:=zp+a[k]
else begin nep:=nep+1;
zn:=zn+a[i]
end;
Edit2.Text:=IntToStr(zp);
Edit3.Text:=IntToStr(n-nep);
If par>0
then Edit4.Text:=Format('%1.5f',[zn/nep])
else Edit4.Text:='0';
Edit1.Enabled:=true;
Button3.SetFocus;
end;
end;
• Саставити програм који формира низ од 100 природних бројева, а затим одређује
редни број елемента који има највећи (најмањи) збир цифара, у случају да више
елемената има исти збир цифара исписује се најмањи (највећи).
програм. Најпре ћемо дефинисати нови тип података - низ у делу
за дефиниције типова, затим ћемо декларисати глобалне
променљиве n - број елемената низа и a - променљива типа низ у
делу за декларације.
type
...
var
Form1: TForm1;
n:integer = 0;
a:niz;
end;
begin Memo1.Clear;
end;
begin If key=#13
then Button1.Click
else If not (key in ['0'..'9',#8,#128])
then key:=#27;
end;
If n>100 then n:=100;
FormirajNiz;
Button2.SetFocus;
end;
procedure TForm1.FormirajNiz;
begin k:=0;Randomize;
While k<n do
begin k:=k+1;a[k]:=Random(900)+100;
Memo1.Lines.Add(Format('%2d.%4d',[k,a[k]]));
end;
end;
begin Button2.Enabled:=false;
Odredi(k);
Edit1.SetFocus;
end;

procedure TForm1.Odredi(VAR j:integer);

var i,nz,zc:integer;
begin j:=1;
nz:=ZbirCifara(a[j]);
For i:=2 to n do
begin zc:=ZbirCifara(a[i]);
If (nz<zc)or(nz=zc)and(a[j]>a[i]) // највећи збир цифара
// (nz>zc)or(nz=zc)and(a[j]<a[i]) ако желимо да одредимо најмањи збир цифара
then begin nz:=zc;
j:=i;
end;
end;
end;
function TForm1.ZbirCifara(a:integer):integer; // рекурзивна процедура за збир цифара
begin If a=0
then zbircifara:=0
end;
function TForm1.ZbirCifara(a:integer):integer; // процедура за збир цифара која није рекурзивна
var z:integer;
begin z:=0;
a:=a div 10;
until a=0;
zbircifara:=z;
end;
• Саставити програм који формира низ од 100 природних бројева, а затим одређује
редни број највећег и најмањег елемента, у случају да има више једнаких елемената
исписује се елемент са најмањим редним бројем.
Тражење екстремних вредности је једна од важнијих процедура
са низовима. Креираћемо форму као на слици, а затим написати
type
...
var
Form1: TForm1;
n:integer = 0;
a:niz;
begin Memo1.Clear;
end;
end;
begin If key=#13
then Button1.Click
else If not (key in ['0'..'9',#8,#128])
then key:=#27;
end;
var k:integer;
begin Randomize;
k:=0;
While k<n do
begin k:=k+1;
a[k]:=Random(1000); // уместо 1000 могао је бити било који други број
end;
end;
If n>100
then n:=100;
FormirajNiz;
Button2.SetFocus;
end;


var k:integer;
Odredi(k,true);
Odredi(k,false);
Edit1.SetFocus;
end;
procedure TForm1.Odredi(VAR j:integer; m:boolean);
var i:integer;
begin j:=1
For i:=2 to n do
If m and (a[i]>a[j]) or
not m and (a[i]<a[j])
then j:=i;
end;
Параметар м, логичка променљива, одређује да ли процедура Одреди тражи највећи (m:=true) или
најмањи (m:=false) елемент низа. Променљива не мора бити логичка, могла је бити и целобројна, где би
1 било тражење највећег, а било шта друго најмањег, а могла је бити и било ког другог типа. Овако
троши најмање меморије и то је био једини разлог да буде логичког типа.
• Саставити програм који формира низ од највише 100 троцифрених бројева, а затим
одређује аритметичку средину низа и редни број елемента низа који јој је најближи, у
случају да има више елемената исписује се већи елемент са највећим редним бројем.
програм.
type
...
var
Form1: TForm1;
n:integer = 0;
a:niz;

begin Memo1.Clear;
end;
end;
begin If key=#13
then Button1.Click
else If not (key in ['0'..'9',#8,#128])
then key:=#27;
end;
var k:integer;
begin Randomize;
k:=0;
While k<n do
begin k:=k+1;
a[k]:=Random(900)+100;
end;
end;
If n>100
then n:=100;
FormirajNiz;
Button2.SetFocus;
end;


var ars:real;
Odredi(ars,k);
Edit2.Text:=Format('%1.3f',[ars]);
Edit1.SetFocus;
end;
procedure TForm1.Odredi(VAR ars:real; VAR k:integer);
var i,k:integer;
begin ars:=0;
For i:=1 to n do
ars:=ars+a[i]/n;
k:=1;
For i:=2 to n do
If (Abs(a[i]-ars)<Abs(a[k]-ars)) or
(Abs(a[i]-ars)=Abs(a[k]-ars)) and (a[i]>a[k])
then k:=i;
end;
Израчунавање аритметичке средине низа могла је бити и посебна функција;
function TForm1.ASred:real; // нема аргумената јер су n и a глобалне променљиве
var i:integer;
s:integer;
begin s:=0;
For i:=1 to n do
s:=s+a[i];
asred:=s/n;
end;
• Саставити програм који формира низ од највише 100 целих бројева, а затим одређује
број парних и позитивних који имају непаран редни број.
програм.
type
...
var
Form1: TForm1;
n:integer = 0;
a:niz;
begin Memo1.Clear;
end;
end;
begin If key=#13
then Button1.Click
else If not (key in ['0'..'9',#8,#128])
then key:=#27;
end;
var k:integer;
begin k:=0;Randomize;
While k<n do
begin k:=k+1;
a[k]:=Random(2001)-1000; // формира бројеве од -1000 до 1000
end;
end;
If n>100
then n:=100;
FormirajNiz;
Button2.SetFocus;
end;


var ars:real;
k:integer;
Odredi(ars,k);
Edit2.Text:=Format('%1.3f',[ars]);
Edit1.SetFocus;
end;
procedure TForm1.Odredi(VAR p,pp,ppn:integer);
var i:integer;
begin p:=0; // број позитивних
pp:=0; // број парних позитивних
ppn:=0; // број парних позитивних на непарним местима
For i:=1 to n do
If a[i]>0
then begin p:=p+1;
If not Odd(a[i])
then begin pp:=pp+1;
If Odd(i)
then ppn:=ppn+1;
end;
end;
end;
га уређује у неопадајући или нерастући поредак.
програм.
type
...
var
Form1: TForm1;
n:integer = 10;
k:integer = 0;
a:niz;
end;
begin Memo1.Clear;Memo2.Clear;
Edit1.Clear;Edit1.Enabled:=true;
Edit1.SetFocus;
end;
begin If key=#13
then Button1.Click
else If not (key in ['0'..'9',#8,#128])
then key:=#27;
end;
If n>100
then n:=100;
FormirajNiz;
k:=0;
Button2.SetFocus;
end;
begin Randomize;
k:=0;
While k<n do
begin k:=k+1;
a[k]:=Random(900)+100;
end;
end;


begin k:=1-k;
UrediNiz(k);
IspisiNiz;
end;
procedure TForm1.UrediNiz(k:integer);
var i,j,p:integer;
begin For i:=1 to n-1 do
For j:=i+1 to n do
If (a[i]>a[j])and(k=1) or // за уређење у неопадајући поредак
(a[i]<a[j])and(k=0) // за уређење у нерастући поредак
then begin p:=a[i];a[i]:=a[j];a[j]:=p;
end;
end;
procedure TForm1.IspisiNiz;
var i:integer;
begin Memo2.Clear;
For i:=1 to n do
Memo2.Lines.Add(Format('%2d.%4d',[i,a[i]]));
end;
Уређење се мења сваки пут када се кликне тастер Уреди. Можда је једноставније решење са два тастера
за уређење, један за растући, један за опадајући поредак, а клик на било који од њих би позивао исту
процедуру Button2Click. У том случају требало би ред:
k:=1-k;UrediNiz(k);
заменити једном оваквом IF наредбом:
If sender=Button2
then UrediNiz(1)
else UrediNiz(0)
• Саставити програм који формира низ од највише 100 двоцифрених бројева, а затим
од тог низа формира нови низ чији су сви елементи различити.
програм.
type
...
var
Form1: TForm1;
n,k:integer;
a,b:niz;
end;
Edit1.Clear;
Edit1.SetFocus;
end;
begin If key=#13
then Button1.Click
else If not (key in ['0'..'9',#8,#128])
then key:=#27;
end;
If n>100
then n:=100;
FormirajNiz;
Button2.SetFocus;
end;
begin Randomize;
k:=0;
While k<n do
end;
end;


begin Razliciti;
IspisiNiz;
Button3.SetFocus;
end;
procedure TForm1.Razliciti;
var i,j:integer;
dodaj:boolean;
begin k:=1;b[k]:=a[k];
i:=2;
While i<=n do
begin j:=0;
Repeat j:=j+1;dodaj:=a[i]=a[j];
until (dodaj)or(j=i-1);
If not dodaj
then begin k:=k+1;b[k]:=a[i];
end;
i:=i+1;
end;
end;
procedure TForm1.IspisiNiz;
var i:integer;
begin Memo2.Clear;
For i:=1 to k do
Memo2.Lines.Add(Format('%2d.%4d',[i,b[i]]));
end;
• Саставити програм који формира низ од највише 100 природних бројева, а затим
неуређујући низ исписује к највећих.
Овде ћемо приказати једну другачију процедуру за испис
елемената низа која као параметре има низ који се исписује, број
елемената који се исписују и редни број мемо поља у које ће се
исписати низ. Креираћемо форму као на слици, а затим написати
type
...
var
Form1: TForm1;
n,k:integer;
a,b:niz;
end;
Edit1.Clear;
Edit1.SetFocus;
end;
begin If key=#13
then Button1.Click
else Button2.Click
else If not (key in ['0'..'9',#8,#128])
then key:=#27;
end;
If n>100
then n:=100;
FormirajNiz;
Edit2.SetFocus;
end;
begin Randomize;
k:=0;
While k<n do

begin k:=k+1;
a[k]:=Random(900)+100;
end;
IspisiNiz(a,n,1);
end;
procedure TForm1.IspisiNiz(a:niz;n,k:integer);
var i:integer;
begin TMemo(FindComponent('Memo'+IntToStr(k))).Clear; // празни мемо поље број k
For i:=1 to n do
TMemo(FindComponent('Memo'+IntToStr(k))).Lines.Add(Format('%2d.%4d',[i,a[i]]));
end;
begin k:=StrToIntDef(Edit2.Text,10);
If k>n
then k:=n;
Najveci(k);
IspisiNiz(b,k,2);
Button3.SetFocus;
end;
procedure TForm1.Najveci(k:integer);
var i,j,p:integer;
dodaj:boolean;
begin For i:=1 to k do
b[i]:=a[i]; // првих k елемената низа a формира низ b
For i:=k+1 to n do // проверавамо да ли има већих у остатку низа а
begin dodaj:=false;
j:=1;p:=1;
While j<=k do
begin If a[i]>b[j] // ако је већи елемент у остатку низа a
then begin dodaj:=true; // памтимо да треба додати елемент
If b[j]<b[p]
then p:=j; // тражи се најмањи у b
end;
j:=j+1;
end;
If dodaj
then begin For j:=p to k-1 do
b[j]:=b[j+1]; // брише најмањи у b
b[k]:=a[i]; // додаје се нови елемент на крај низа b
end;
end;
end;
Додавањем елемената на крај низа b учинили смо да се редослед k највећих елемената низа а не мења,
тј. поредак елемената у низу b је исти као у низу а.
из низа издваја најдужи растући подниз.
програм.
type
...
var
Form1: TForm1;
n,k:integer;
a,b:niz;

end;
Edit1.Clear;
Edit1.SetFocus;
end;
begin If key=#13
then Button1.Click
else If not (key in ['0'..'9',#8,#128])
then key:=#27;
end;


If n>100
then n:=100;
FormirajNiz;
Button2.SetFocus;
end;
begin Randomize;
k:=0;
While k<n do
end;
IspisiNiz(a,n,1);
end;
var i:integer;
For i:=1 to n do
end;
OdrediPodniz(b,k);
IspisiNiz(b,k,2);
Edit1.Enabled:=true;Edit1.SetFocus;
end;
procedure TForm1.OdrediPodniz(VAR b:niz;VAR k:integer);
var i,p,q,pp:integer;
begin k:=0; pp:=1; // број елемената и редни број првог у најдужем поднизу
p:=1; q:=1; // број елемената и редни број првог у помоћном поднизу
For i:=2 to n do
If a[i-1]<a[i] // проверава да ли следећи елемент припада растућем поднизу
then p:=p+1 // повећава се дужина растућег подниза
else begin If np<p // ако следећи елемент није у текућем поднизу
then begin k:=p;pp:=q; // памти се тренутно најдужи подниз
end;
p:=1;q:=i; // тражи се следећи растући подниз
end;
For i:=1 to k do // формира се низ елемената из најдужег подниза
b[i]:=a[pp+i-1];
end;
Није обавезно формирати нови низ, могли смо га исписати директно из низа а, али би у том случају
процедура за исписивање морала да се промени да би се додао редни број почетног елемента за испис.
• Саставити програм који формира два низа са по n (n<=100) троцифрених бројева, а
затим од њих формира трећи низ узимајући парне елементе из првог и непарне
елементе из другог низа.
Дефинисаћемо тип низ са највише 200 елемената јер се може
десити да су у првом низу свих 100 елемената парни, а у другом
сви непарни, па трећи низ може да има 200 елемената. Креираћемо
type
...
var
Form1: TForm1;
n,k:integer;
a,b,c:niz;
end;
begin Memo1.Clear;
Memo2.Clear;
Memo3.Clear;
end;
begin If key=#13
then Button1.Click

else If not (key in ['0'..'9',#8,#128])

then key:=#27;
end;
procedure TForm1.FormirajNiz(VAR a:niz); // параметар је обавезан јер процедура формира оба низа
begin Randomize;
k:=0;
While k<n do
end;
end;
var i:integer;
For i:=1 to n do
end;
procedure TForm1.Button1Click(Sender: TObject); // формира први низ
If n>100
then n:=100;
FormirajNiz(a);IspisiNiz(a,n,1);
Button2.SetFocus;
end;
procedure TForm1.Button2Click(Sender: TObject); // формира други низ
FormirajNiz(b);IspisiNiz(b,n,2);
Button3.SetFocus;
end;
procedure TForm1.Button3Click(Sender: TObject); // формира трећи низ
var i:integer;
begin k:=0;
For i:=1 to n do
begin If not Odd(a[i])
then begin k:=k+1;c[k]:=a[i];
end;
If Odd(b[i])
then begin k:=k+1;c[k]:=b[i];
end;
end;
IspisiNiz(c,k,3);
Edit1.SetFocus;
end;
У задатку није конкретно дефинисан начин додавања елемената у низ c, па је овде праћен паралелни
редослед елемената у оба низа при чему се прво тестирају елементи низа а. Могао се применити и неки
други принцип, на пример, прво се додају сви из првог, па онда сви из другог низа или другачије.
неуређујући га исписује редне бројеве елемента од најмањег до највећег .
Један од начина да се реши овај задатак је тражити најмањи
елемент низа и његов редни број сместити у нови низ, а на
његово место ставити maxint, поступак понављамо све до сви
елементи првог низа не постану исти. Ово ћемо урадити у
процедури, при чему ће почетни низ бити улазни параметар
процедуре да се не би изгубиле вредности елемената низа, па
касније не бисмо могли да испишемо низ у новоодређеном
поретку. Креираћемо форму као на слици, а затим написати
type
...
var
Form1: TForm1;
n,k:integer;
a,b:niz;


end;
begin Memo1.Clear;
Memo2.Clear;
end;
begin If key=#13
then Button1.Click
else If not (key in ['0'..'9',#8,#128])
then key:=#27;
end;
begin Randomize;
k:=0;
While k<n do
Memo1.Lines.Add(Format('%3d.%4d',[k,a[k]]);
end;
end;
If n>100
then n:=100;
FormirajNiz;
Button2.SetFocus;
end;
Odredi(a);
Edit1.SetFocus;
end;
procedure TForm1.Odredi(a:niz);
var i,p:integer;
begin k:=0; // број елемената низа b је на почетку 0
While k<n do // циклус се завршава када се формира n елемената низа b
begin p:=1;
For i:=2 to n do
If a[i]<a[p] // тражи се најмањи елемент низа а
then p:=i;
k:=k+1;b[k]:=p; // памти се редни број најмањег елемента низа а
Memo2.Lines.Add(Format('%3d.4d',[b[k],a[b[k]]])); // исписује низ b
a[p]:=maxint; // најмањем елементу низа а се увећава вредност
end;
end;
Задатак се врло лепо може решити и уз помоћ скупова. Тражи се најмањи елемент чији редни број се не
налази у скупу индекса и када се нађе његов редни број се смести у нови низ и дода у скуп индекса. У
овом случају почетни низ не мења вредности, па не мора бити улазни параметар процедуре (наравно,
није забрањено ако нам се то свиђа). Ево и овако организоване процедуре:
procedure TForm1.Odredi;
var i,p:integer;
si:set of 1..100;
begin k:=0;si:=[]; // број елемената низа b је 0 и скуп редних бројева је празан
While k<n do // циклус се завршава када се формира n елемената низа b
begin p:=0;
Repeat p:=p+1;
until not(p in si); // тражи се први редни број који недостаје скупу
For i:=1 to n do // тражи се најмањи елемент низа а
If not(i in si)and(a[i]<a[p]) // чији редни број није у скупу
then p:=i;
k:=k+1;b[k]:=p; // памти се редни број најмањег елемента низа а
Memo2.Lines.Add(Format('%3d.4d',[b[k],a[b[k]]])); // исписује низ b
si:=si+[p]; // редни број најмањег елемента се смешта у скуп
end;
end;
Ево још једног решење за које се може рећи да задовољава слободније тумачење услова задатака.
Формира се низ чије су вредности индекси првог низа, а затим новоформирани низ уредити у
неопадајући помоћу одговарајућих вредности првог низа. И овде се не мењају вредности почетног низа,
па га не морамо уводити као улазни параметар (наравно, није забрањено ако нам се то свиђа).

procedure TForm1.Odredi;
var i,ј,p:integer;
begin For i:=1 to n do b[i]:=i;
For i:=1 to n-1 do
For j:=i+1 to n do
If a[b[i]]>a[b[j]]
then begin p:=b[i];b[i]:=b[j];b[j]:=p;
end;
For i:=1 to n do
Memo2.Lines.Add(Format('%3d.4d',[b[k],a[b[k]]]));
end;
Има још различитих и лепих решења овог (као и сваког другог) задатка. Читаоцима се оставља на вољу
да истражују и пронађу бар још једно решење које им се чини лепим.
• Саставити програм који формира низ са највише 100 троцифрених бројева, а затим
елементе циклично помера за m места (mN).
програм.
type
...
var
Form1: TForm1;
n,k:integer;
a,b:niz;
end;
begin Memo1.Clear;
Memo2.Clear;
end;
begin Memo2.Clear;
end;
begin If key=#13
then Button1.Click
else If not (key in ['0'..'9',#8,#128])
then key:=#27;
end;
begin If key=#13
then Button2.Click
else If not (key in ['-','0'..'9',#8,#128])
then key:=#27;
end;
var i:integer;
For i:=1 to n do
end;
begin Randomize;
k:=0;
While k<n do
end;
end;
If n>100
then n:=100;
FormirajNiz;IspisiNiz(a,n,1);
Edit2.SetFocus;
end;
begin k:=StrToIntDef(Edit2.Text,10);Edit2.Text:=IntToStr(k);
If k<0
then PomeriLevo(-k)

else PomeriDesno(k);
IspisiNiz(a,n,2);
Edit1.SetFocus;
end;
procedure TForm1.PomeriLevo(k:integer);
var i,j,p:integer;
begin p:=a[1];
For j:=2 to n do
a[j-1]:=a[j];
a[n]:=p;
end;
end;
procedure TForm1.PomeriDesno(k:integer);
var i,j,p:integer;
begin p:=a[n];
For j:=n downto 2 do
a[j]:=a[j-1];
a[1]:=p;
end;
end;
Процедуре за померање лево и десно могу се написати као једна ако се уведе помоћна променљива s са
вредностима s=0 за померање у лево, s=1 за померање у десно. Процедура је мало компликованија, али
много ефикаснија:
procedure TForm1.PomeriLevo(s,k:integer);
var i,j,p:integer;
begin p:=a[1+(n-1)*s];
For j:=1 to n-1 do
a[Abs((n+1)*s-j)]:=a[Abs((n+1)*s-j-1)];
a[n-(n-1)*s]:=p;
end;
end;
• Саставити програм који на случајан начин формира низ са највише 100 троцифрених
бројева, а затим од њега формира нови низ тако што цифре сваког елемента уређује
у растући поредак (на пример: 453 постаје 345), а затим исписује број елемената
другог низа који су једнаки неком елементу почетног низа.
програм.
type
...
var
Form1: TForm1;
n,k:integer;
a,b:niz;
end;
begin Memo1.Clear;
Memo2.Clear;
Edit2.Clear;
end;
begin If key=#13
then Button1.Click
else If not (key in ['0'..'9',#8,#128])
then key:=#27;
end;
var i:integer;
For i:=1 to n do
end;
begin Randomize;
k:=0;

While k<n do
end;
end;
If n>100
then n:=100;
Button2.SetFocus;
end;
var i,j,br:integer;
begin For i:=1 to n do
b[i]:=Rastuce(a[i]);
IspisiNiz(b,n,2);
br:=0;
For i:=1 to n do
For j:=1 to n do
If a[i]=b[j]
then br:=br+1;
Edit2.Text:=IntToStr(br);
Edit1.SetFocus;
end;
function TForm1.Rastuce(p:integer):integer;
begin c1:=p mod 10;
c2:=p div 10 mod 10;
c3:=p div 100;
If c1<c2
then begin p:=c1;c1:=c2;c2:=p;
end;
If c1<c3
end;
If c2<c3
end;
rastuce:=c1+c2*10+c3*100;
end;
• Саставити програм који формира низ од 80 троцифрених бројева који имају бар две
исте цифре, а затим га уређује у опадајући поредак.
Овде, наравно, треба променити до сада стандардну процедуру за
генерисање елемената низа. Други део задатка је већ решаван.
програм.
type
...
var
Form1: TForm1;
n,k:integer;
a:niz;
end;
begin Memo1.Clear;
Memo2.Clear;
end;
begin If key=#13
then Button1.Click
else If not (key in ['0'..'9',#8,#128])
then key:=#27;
end;
begin Randomize;

k:=1;
While k<=n do
begin a[k]:=Random(900)+100;
If Iste(a[k]) then k:=k+1;;
end;
end;
function TForm1.Iste(p:integer):boolean;
begin c1:=p mod 10;
c2:=p div 10 mod 10;
c3:=p div 100;
iste:=(c1=c2)or(c2=c3)or(c3=c1);
end;
var i:integer;
For i:=1 to n do
end;
If n>100
then n:=100;
Button2.SetFocus;
end;
var i,j,p:integer;
begin For i:=1 to n-1 do
For j:=i+1 to n do
If a[i]<a[j]
then begin p:=a[i];a[i]:=a[j];a[j]:=p
end;
IspisiNiz(a,n,2);
Edit1.SetFocus;
end;
Има још пуно лепих и карактеристичних задатака са једнодимензионалним низовима, али не могу се
баш сви урадити и сервирати читаоцима, зато сада прелазимо на нешто сасвим ново, на групу од
четири задатка са дводимензионалним низовима да се упознамо са начином рада са њима и неким
лепим начинима размишљања у две димензије. Користићемо низове двоцифрених бројева и димензије
10х10 због лакшег исписа, а решења су универзална и могу се применити на било који низ елемената.
• Саставити програм који формира дводимензионални низ 10 x 10 двоцифрених бројева,
а затим одређује аритметичку средину и број елемената већих од ње.
За исписивање елемената дводимензионалног низа могу се користити компоненте Memo или ListBox.
У том случају редови дводимензионалног низа формирају стринг који се затим исписује у одговарајући
ред изабраног објекта. Ми ћемо за испис користити објекат StringGrid. Овај објекат подсећа на excel
табелу у којој колоне и редови нису означени (водимо рачуна код исписа низа да је у гриду прва
координата колона, а друга ред, супротно од уобичајеног). Најпре ћемо поставити неколико
стандардних карактеристика како би приказивање елемената низа било једноставније: Align = alRight
(подаци ће бити десно поравнати); BorderStyle = bsNone (нема оквира); ColCount = 11 (десет колона за
елементе низа и једна за редне бројеве); Color = clTeal (боја позадине); DefaultColWidth = 35
(предефинисана ширина колона); DefaultRowHeight = 27
(предефинисана висина редова); Enabled = False (корисник нема
права да мења садржај било којег поља); Font = Courier New,
Regular, 16; GridLineWidth = 0 (нема линија између редова и
колона); Height = 300; RowCount = 11 (десет редова за елементе
низа и један за редне бројеве); ScrollBars = ssNone (нема клизача
јер се сви елементи виде); Width = 385. У процедури FormCreate
ћемо попунити нулти ред и колону редним бројевима (додајемо
ознаке редова и колона да бисмо се лакше сналазили у низу, није
обавезно и овај ред и колона се могу искључити, ако тако желимо).
програм.

type
niz=array[1..10,1..10] of integer;
...
var
Form1: TForm1;
a:niz;

var i:integer;
begin For i:=1 to 10 do
begin StringGrid1.Cells[0,i]:=Format('%2d',[i]);
StringGrid1.Cells[i,0]:=Format('%2d',[i]);
end;
end;
end;
var i,j:integer;
begin Randomize;
For i:=1 to 10 do
For j:=1 to 10 do
begin a[i,j]:=Random(90)+10;
StringGrid1.Cells[j,i]:=Format('%2d',[a[i,j]]);
end;
Button2.SetFocus;
end;
var asr:real;
i,j,n:integer;
begin asr:=0;n:=0;
For i:=1 to 10 do
For j:=1 to 10 do
asr:=asr+a[i,j]/100;
For i:=1 to 10 do
For j:=1 to 10 do
If asr<a[i,j]
then n:=n+1;
Edit1.Text:=FloatToStr(asr);
Button1.SetFocus;
end;

а затим одређује збирове елемената по колонама, по редовима и по дијагоналама.
Основни низ ћемо допунити још једним редом и колоном у
којима ће се исписати одговарајући збирови елемената. Збир
споредне дијагонале ћемо исписати у посебном едиту. Грид ће
имати дванаест редова и колона да бисмо све суме уписали у
одговарајућа поља. Последње поље у првом реду и првој колони
ћемо попунити симболом  (велико слово S). Да би се симбол
видео у делфи програму за грид ћемо подесити фонт Symbol.
програм.
type
...
var
Form1: TForm1;
a:niz;
var i:integer;
end;
StringGrid1.Cells[0,11]:='';
StringGrid1.Cells[11,0]:='';
end;


end;
var i,j:integer;
begin Randomize;
For i:=1 to 10 do
For j:=1 to 10 do
end;
Edit1.Clear;
For i:=1 to 11 do
begin StringGrid1.Cells[11,i]:='';
StringGrid1.Cells[i,11]:='';
end;
Button2.SetFocus;
end;
var i,j,sd:integer;
begin a[11,11]:=0;sd:=0;
For i:=1 to 10 do
begin a[11,11]:=a[11,11]+a[i,i];
sd:=sd+a[i,11-i];
a[11,i]:=0;
a[i,11]:=0;
end;
For i:=1 to 10 do
For j:=1 to 10 do
begin a[11,j]:=a[11,j]+a[j,i];
a[j,11]:=a[j,11]+a[i,j];
end;
For i:=1 to 11 do
begin StringGrid1.Cells[11,i]:=Format('%3d',[a[11,i]]);
StringGrid1.Cells[i,11]:=Format('%3d',[a[i,11]]);
end;
Edit1.Text:=Format('%3d',[sd]);
Button1.SetFocus;
end;

а затим одређује збир елемената испод главне и збир елемената изнад споредне
дијагонале.
Креираћемо форму као на слици а затим написати комплетан
програм.
type
...
var
Form1: TForm1;
a:niz;
var i:integer;
end;
end;
end;
var i,j:integer;
begin Randomize;
For i:=1 to 10 do
For j:=1 to 10 do
end;
Button2.SetFocus;
end;

var i,j,g,s:integer;
begin g:=0;s:=0;
For i:=2 to 10 do // елементи испод главне дијагонале
For j:=1 to i-1 do
g:=g+a[i,j];
For i:=1 to 9 do // елементи изнад споредне дијагонале
For j:=1 to 10-i do
s:=s+a[i,j];
Button1.SetFocus;
end;

а затим одређује број елемената испод главне и споредне дијагонале који су већи од
највећег елемента изнад главне и споредне дијагонале.
програм.
type
...
var
Form1: TForm1;
a:niz;
var i:integer;
end;
end;
end;
var i,j:integer;
begin Randomize;
For i:=1 to 10 do
For j:=1 to 10 do
end;
Button2.SetFocus;
end;
var i,j,g,s:integer;
begin g:=0;s:=0;
For i:=1 to 4 do // елементи изнад главне и споредне дијагонале
For j:=i+1 to 10-i do
If a[i,j]>g
then g:=a[i,j];
For i:=7 to 10 do // елементи испод главне и споредне дијагонале
For j:=12-i to i-1 do
If a[i,j]>g
then s:=s+1;
Button1.SetFocus;
end;

а затим га проширује за један ред и колону највећим елементима у одговарајућем
реду, колони или главној дијагонали.
Креираћемо форму као на слици на следећој страни, а затим написати комплетан програм.
type
...

var
Form1: TForm1;
a:niz;
var i:integer;
end;
end;
end;
var i,j:integer;
begin Randomize;
For i:=1 to 10 do
For j:=1 to 10 do
end;
Button2.SetFocus;
end;
var i:integer;
begin a[i,11]:=Najveci(a,i,1);
StringGrid1.Cells[11,i]:=Format('%2d',[a[i,11]]);
a[11,i]:=Najveci(a,i,2);
StringGrid1.Cells[i,11]:=Format('%2d',[a[11,i]]);
end;
a[11,11]:=Najveci(a,1,3);
StringGrid1.Cells[11,11]:=Format('%2d',[a[11,11]]);
Button1.SetFocus;
end;
function TForm1.Najveci(a:niz; i,j:integer):integer;
var k,n:integer;
begin Case j of
1 : n:=a[i,1];
2 : n:=a[1,i];
else n:=a[1,1];
end;
For k:=2 to 10 do
begin If (j=1)and(a[i,k]>n) // тражимо највећи у реду i
then n:=a[i,k];
If (j=2)and(a[k,i]>n) // тражимо највећи у колони i
then n:=a[k,i];
If (j=3)and(a[k,k]>n) // трађимо највећи на главој дијагонали
then n:=a[k,k];
end;
najveci:=n;
end;
• Саставити програм који симулира игру ИксОкс.

Следе два примера коришћења низова у једноставнијим логичким играма. У овим примерима нећемо
направити нешто револуционарно, јер у овом тренутку нити можемо нити хоћемо да тако нешто
постигнемо. Циљ је да се само демонстрира моћ коју у рукама програмера могу имати низови. Први
пример је игра ИксОкс. Ово је једна од савршених игара. Термин савршена игра се користи за игре у
којима, ако играчи играју увек најбољи потез онда на крају игре нема победника. Постоје три могућа
нивоа игре у зависности од функције коју има рачунар: рачунар игра и као први и као други играч,
рачунар игра као један од играча док је други играч човек, корисник програма и игру играју два играча,
а рачунар има улогу посматрача и судије. Према сложености поља за игру, такође, можемо да
направимо нивое, постоје варијанте у две и три димензије са различитим бројем позиција на којима
може да се игра. Овде ће бити приказана најједноставнија варијанта 3х3 игре, демо ниво, тј. рачунар
игра сам против себе и без икаквог коефицијента интелигенције, тј. сви потези се бирају на случајан
начин. Да би се добила права игра мора се додати и мало мозгања (постоје потези које никако не смемо
одиграти ако не желимо да изгубимо). Као симболи играча коришћени су карактери из фонта Webdings
 и . У коду програма користи се само основни фонт, па ће се уместо симбола из фонта Webdings
приказивати карактери = и r. Креираћемо форму као на слици на следећој страни, а затим написати
комплетан програм без неког претераног објашњавања.

type
...
var
Form1: TForm1;
a:niz;
slob:integer;
ch:char;
end;
var i,j:integer;
For j:=0 to 3 do
begin a[i,j]:=0;
// почетно стање низа, сви елементи су на нули
If (i<3)and(j<3)
then StringGrid1.Cells[i,j]:='';
// празне се сва поља стринг грида
end;
slob:=9; // свих девет поља је слободно
ch:='r'; // на потезу је први играч
Timer1.Enabled:=true; // укључује се тајмер који контролише одигравање потеза
Button2.SetFocus;
end;
function TForm1.Kraj:char; // функција која одређује завршетак игре
var i,j,p:integer;
begin kraj:=' '; // нема победника
p:=0; // контрола споредне дијагонале
a[3,3]:=0; // контрола главне дијагонале
For i:=0 to 2 do
begin a[3,i]:=0; // контрола колона
a[i,3]:=0; // контрола редова
p:=p+a[i,3-i]; // збир елемената на споредној дијагонали
a[3,3]:=a[3,3]+a[i,i]; // збир елемената на главној дијагонали
For j:=0 to 2 do
begin a[3,i]:=a[3,i]+a[j,i]; // збирови елемената по колонама
a[i,3]:=a[i,3]+a[i,j]; // збирови елемената по редовима
end;
end;
For i:=0 to 3 do // проверава да ли је неко од играча победио
If (Abs(a[3,i])=3) // први играч је победио ако је збир неке колоне, реда или
or(Abs(a[i,3])=3) // дијагонале 3, а други ако је -3, зато користимо функцију Abs
or(Abs(p)=3)
then kraj:=ch; // ако јесте, проглашава победника
end;
var i,j:integer;
pl:string;
begin Randomize; // потези се бирају на случајан начин
slob:=slob-1; // број слободних поља се смањује након сваког потеза
Repeat i:=Random(3);
j:=Random(3);
Until a[i,j]=0; // одређује се потез
StringGrid1.Cells[j,i]:=ch; // исписује се потез играча
If ch='=' // одређује ко је на потезу и вредност потеза 1 или -1
then begin a[i,j]:=-1;ch:='r';
// вредност потеза једног играча је -1
end
else begin a[i,j]:=1;ch:='=';
// вредност потеза другог играча је 1
end;
If Kraj=ch // тестира да ли је игра завршена
then begin If ch='=' // ако јесте проглашава победника
then pl:='први'
else pl:='други';
Timer1.Enabled:=false;
ShowMessage('Победио је '+pl+' играч');
end
else If slob=0 // ако нико није победио тестира да ли је завршено нерешено
then begin Timer1.Enabled:=false;
ShowMessage('Нерешено!');
end;
// ако игра није завршена одиграва се следећи потез
end;

• Саставити програм који симулира игру Меморије.

Игра меморије састоји се из различитог броја парова сличица (број парова зависи од нивоа). Задатак
играча је да открије све парове у што краћем времену и са што је могуће мање отварања парова. У игри
разликујемо два потеза:
• прво отварање - отвара се изабрано поље, ако су претходно отворена два различита поља затварају
се оба поља и
• друго отварање - отвара се изабрано поље и упоређује
се са претходно отвореним, ако су иста обрачунавају се
поени и забрањује се каснија употреба ових поља.
Да бисмо ово постигли дефинисаћемо дводимензионални низ
и доделити му вредности редних бројева парова и неколико
помоћних променљивих које ће водити рачуна о редном броју
отварања, претходно отвореном пољу и броју поља која још
нису отворена. У примеру који се овде приказује, да бисмо
олакшали примену програма на рачунару читаоца, уместо
сличица користићемо цифре декадног бројног система (значи
играће се на пољу димензија 4 х 5). Логика програма је иста
као и да се ради са сличицама само код писања програма не
морамо проналазити и погодне сличице. Наравно, са мало
више знања, игра би се могла допунити листом најбољих
резултата, музиком у позадини, звуцима када се погоди или
промаши пар и слично. Границе не постоје. Креираћемо форму
као на слици, а затим написати комплетан програм без неког
претераног објашњавања.
type
...
var
Form1: TForm1;
h,m,s,ss,po,pa,b1,b2,aI,aP,aD,mk,pp:integer;
polje:niz;
var i:integer;
begin aD:=Min(Screen.Width*2 div 3,Screen.Height*2 div 3);
Form1.Left:=aD div 4;Form1.Width:=aD;
Form1.Top :=aD div 4;Form1.Height:=aD;
aP:=aD*3 div 4;aI:=aD*3 div 20;
Panel1.Left:=aD div 9;Panel1.Width:=aP+15;
Panel1.Top :=aD div 9;Panel1.Height:=aP*4 div 5+15;
For i:=1 to 20 do
begin TButton.Create(Self).Name := 'BTN' + IntToStr(i);
with TButton(FindComponent('BTN' + IntToStr(i))) do
begin Left:=aI*((i-1) div 4)+5;Width :=aI;
Top :=aI*((i-1) mod 4)+5;Height:=aI;
Parent := Panel1;
Caption:=IntToStr(i mod 10);
Font.Name:='Comic Sans MS';
Font.Size:=aI div 2;
OnClick:=MouseClick;
Enabled:=false;
end;
end;
end;
begin ss:=ss+1;
If ss=100
then begin s:=s+1;ss:=0;
end;
If s=60
then begin s:=0;m:=m+1;
end;
If m=60
then begin m:=0;h:=h+1;
end;
StatusBar1.Panels[2].Text:='Дужина игре: '+RightStr('00'+IntToStr(h),2)+':'
+RightStr('00'+IntToStr(m),2)+':'
+RightStr('00'+IntToStr(s),2);
If pa=10
then begin Timer1.Enabled:=false;
ShowMessage('Игра је завршена!');
end;
end;

procedure TForm1.Exit1Click(Sender: TObject);

end;
procedure TForm1.New1Click(Sender: TObject);
var i:integer;
begin h:=0;m:=0;s:=0;ss:=0;
po:=0;pa:=0;
pp:=0;mk:=1;
StatusBar1.Panels[1].Text:='Број парова: '+RightStr('00'+IntToStr(pa),2);
StatusBar1.Panels[0].Text:='Број потеза: '+RightStr('00'+IntToStr(po),2);
Rasporedi;
For i:=1 to 20 do
TButton(FindComponent('BTN'+IntToStr(i))).Enabled:=true;
Timer1.Enabled:=true;
end;
procedure TForm1.Rasporedi;
var x,y,z:integer;
i:char;
ch:array[0..9] of char;
begin Randomize;
For x:=1 to 4 do
For y:=1 to 5 do polje[x,y]:=-1;
For z:=0 to 9 do ch[z]:='.';
For z:=1 to 20 do TButton(FindComponent('BTN'+IntToStr(z))).Caption:='';
For i:='0' to '9' do
begin Repeat z:=Random(10);
until ch[z]='.';
ch[z]:=i;
Repeat x:=Random(4);
y:=Random(5);
until polje[x,y]=-1;
polje[x,y]:=StrToInt(i);
end;
z:=0;
For x:=1 to 4 do
For y:=1 to 5 do
If (polje[x,y]=-1)and(z<10)
then begin polje[x,y]:=StrToInt(ch[z]);z:=z+1;
end;
end;
procedure TForm1.MouseClick(Sender: TObject);
var i,x,y,b:integer;
begin x:=0; y:=0; b:=0;
If sender.ClassName='TButton' then
If sender=TButton(FindComponent('BTN'+IntToStr(i))) then
begin x:=(i-1) mod 4+1;
y:=(i-1) div 4+1;
TButton(FindComponent('BTN'+IntToStr(i))).Caption:=IntToStr(polje[x,y]);
b:=i;
end;
If mk=1 then
begin If b1>0 then
begin TButton(FindComponent('BTN'+IntToStr(b1))).Caption:=' ';
TButton(FindComponent('BTN'+IntToStr(b2))).Caption:=' ';
b1:=0;b2:=0;
end;
pp:=polje[x,y];
mk:=2;b1:=b;
end
else If b1<>b then
begin mk:=1;b2:=b;
If pp=polje[x,y] then
begin TButton(FindComponent('BTN'+IntToStr(b1))).Enabled:=false;
TButton(FindComponent('BTN'+IntToStr(b2))).Enabled:=false;
b1:=0;b2:=0;
pa:=pa+1;
StatusBar1.Panels[1].Text:='Број парова: '+
RightStr('00'+IntToStr(pa),2);
end;
po:=po+1;
StatusBar1.Panels[0].Text:='Број потеза: '+
RightStr('00'+IntToStr(po),2);
end;
end;
end;
У програму је коришћен панел на коме се у фази извршења креирају тастери, мени компонента, тајмер
и статусна линија. Форма је направљена да се у програму препозна резолуција монитора и подесе
димензије тако да се форма види комплетна. Панел и тастери, такође, мењају димензије у зависности
од резолуције монитора. Могла су се додати и још нека подешавања, пре свега панели у статусној

линији који су овде фиксни, па се на нижим резолуцијама може десити да се не види број потеза или
парова. Али, ово је само демонстрација дела могућности програмског окружења.

• Саставити програм који уписани петоцифрени број раздваја на цифре, а затим од
тих цифара формира све различите бројеве и одређује који од њих су прости.
• Саставити програм који на случајан начин формира низ од највише 100 бројева од
-500 до 500, а затим одређује најмањи и највећи по апсолутној вредности двоцифрени
број, број позитивних и број негативних троцифрених бројева.
• Саставити програм који на случајан начин формира низ са највише 100 бројева
мањих од 1000, а затим од њега формира нови низ тако што сваку цифру елемената
првог низа мења допуном до 9 (на пример: 473 постаје 526), а затим исписује највећи и
најмањи елемент који се налази у оба низа, ако такви постоје.
• Саставити програм који на случајан начин формира низ са највише 100 троцифрених
бројева, а затим од њега формира нови низ чији су елементи збирови цифара
одговарајућих елемената првог низа (на пример: 453 постаје 12), а затим одређује
елемент другог низа који се појављује највише пута.
• Саставити програм који на случајан начин формира низ од највише 100 троцифрених
бројева, а затим формира низ чији и-ти елемент представља број елемената првог
низа који су већи од и-тог елемента првог низа и низ чији и-ти елемент представља
број елемената првог низа који су мањи од и-тог елемента првог низа.
• Саставити програм који формира низ од 80 природних бројева (мањих од 1000), а
затим одређује низ чији први и последњи елемент су једнаки одговарајућим
елементима првог низа, а остали се добијају по формули: bi = (ai-1 + ai+1) / 2.
• Саставити програм који на случајан начин формира низ од највише 100
четвороцифрених бројева, а затим одређује број елемената који почињу и завршавају
истом цифром и њихову аритметичку средину.
• Саставити програм који на случајан начин формира два низа са по н<=100 чланова, а
затим одређује укупан број парова елемената са истим индексом у оба низа који су
једнаки (ai =bi).
• Саставити програм који на случајан начин формира низ са највише 100
четвороцифрених бројева, а затим од њега формира нови низ чији се елементи
добијају од елемената првог низа заменом прве две са последњим двема цифрама (на
пример: 1453 постаје 5314), а затим исписује елементе који се појављују у оба низа.
• Саставити програм који формира низ од највише 100 природних бројева (мањих од
1000), а затим одређује низ чији je први елемент једнак првом елементу првог низа, а
остали се добијају по формули: bi = (a1 + a2 + a3 + ... + ai-1) / i.
1000), а затим одређује низ чији елементи се добијају по формули:
bi = (a1 + a2 + a3 + ... + ai-1 + ai+1 + ai+2 + ai+3 + ... + an) / (n-1).
• Саставити програм који са тастатуре прихвата три природна броја n, p, q, а затим
формира два низа по формулама: a1 = p, ai = (ai-1 + bi-1) / 2, 1 < i <= n; b1 = q, ai = Sqrt(ai-1 +
bi-1), 1 < i <= n.
• Саставити програм који формира низ од највише 100 двоцифрених бројева, а затим
одређује низ чији елементи се добијају по формули: b2i = (a2 + a4 + a6 + ... + a2i) / (2i)
b2i-1 = (a1 + a3 + a5 + ... + a2i-1) / (2i-1).
1000), а затим одређује низ чији елемент на месту i представља број елемената
првог низа који су мањи од елемента ai.
• Саставити програм који формира два низа са по од највише 100 природних бројева
(мањих од 1000), а затим одређује низ чији елементи се добијају по формули:
1, ai bi
c i   0, ai  bi .
 1, ai bi
• Саставити програм који на случајан начин формира низ целих двоцифрених бројева,
формира низ бинарних записа чланова тог низа и исписује оба низа.

• Саставити програм који на случајан начин формира низа са највише 100 целих бројева
од -1000 до 1000, а затим формирати нови низ тако сто се члановима низа са парним
индексима промени знак , а чланови са непарним индексима се умање за свој индекс.
• Саставити програм који у несортираном низу одређује највећи и најмањи члан и
затим исписује низ без та два елемента.
одређује колико пута у низу следећи елемент почиње цифром којом претходни
завршава.
• Саставити програм којим се уносе елементи низа од н елемената, а затим се од тога
низа формира матрица n x n која има елементе првог низа на главној дијагонали, а
сви остали су јединице.
• Саставити програм који у матрица са n врста и m колона налази и исписује највећи и
најмањи елемент матрице, као и врсту и колону где се они налазе.
• Саставити програм којим се уносе елементи низа са n2 елемената, затим се од тога
низа формира матрица која има n врста и n колона.
• Саставити програм који формира матрицу n x n, а затим израчунава која колона
има највећи збир и исписује колону и збир.
• Саставити програм којим се проверава да ли је збир две матрице n x n јединична
матрица.
• Саставити програм којим се проверава да ли је производ две матрице n x n јединична
матрица.
• Саставити програм који симулира игру Ханојске куле (три штапа и дискови који се
премештају).
• Саставити програм који симулира игру Otello (познатија као реверси).
• Саставити програм који симулира игру GoMoKo (као хох на табли 40х30 или више
поља).
• Саставити програм који симулира игру Потапање бродова.
• Саставити програм који симулира игру MasterMind ("Скочко", са бојама или
цифрама).
• Саставити програм који симулира игру Дама (на шаховској табли по 8 белих и црних
жетона).
• Саставити програм који симулира игру Мица (традиционална игра са зрнима пасуља и
кукуруза).
• Саставити програм који симулира игру Не љути се човече.
• Саставити програм који симулира игру Монопол.
• Саставити програм који симулира игру Јамб.
• Саставити програм који симулира игру Connect 4.
• Саставити програм који симулира игру Шах.

Тип слог и датотеке
Тип слог
Решавање задатака помоћу низова је ефикасно и задовољавајуће, међутим, има и

недостатака. Главни проблем код оваквог начина решавања задатака је што се код сваке
провере морају уносити сви елементи низа. То се може избећи коришћењем слогова и
датотека. Такође, врло често се подаци са којима радимо састоје из делова који могу, али не
морају бити истог типа. Готово свакодневно гледамо телефонски именик, распоред ТВ
програма, свој распоред часова... Све су то подаци који се састоје из неколико делова. Онако
како их ми гледамо, они су уређени, али не морају увек да буду. Обратимо пажњу на
организацију података у адресару. Податак се састоји из имена и презимена неке особе, адресе
и броја телефона, при чему су адреса и број телефона такође сложени подаци, јер се адреса
састоји из улице, броја и места (код неких и држава), а број телефона се састоји из позивног
броја и броја. Ово мноштво података можемо да организујемо помоћу неколико низова, али је
тада руковање подацима гломазно, оптерећено бројним називима и индексима низова. Све су
то разлози који су довели до увођења слоговног типа. Слоговни тип (слог, запис или record) се
састоји из унапред дефинисаног броја делова који се називају поља (field). Уколико се програм
састоји из само једне процедуре или се вредност променљивих типа слог користи само у једној
процедури или функцији експлицитна дефиниција типа се може изоставити, довољно је
имплицитно дефинисати тип слог кроз декларацију променљивих, међутим, ако желимо да
вредности променљивих типа слог преносимо из једне процедуре или функције у другу онда је
експлицитна дефиниција обавезна:
TYPE adrese=RECORD ulica,broj,mesto,drzava:string;
END;
brojtlf=RECORD pozivni:string;
broj:string;
END;
adresar=RECORD prezime,ime:string;
adresa:adrese;
telefon:brojtlf;
END;
Слог adresar састоји се из четири податка, два су типа стринг (prezime, ime), а два су такође
слогови (adresa, telefon) који се састоје из четири (ulica, broj, mesto, drzava), односно, два податка
(pozivni, broj).
Променљива типа слог може се декларисати претходно експлицитно дефинисаним
слоговним типом или директно у декларацији променљивих (без претходне декларације
слоговног типа):
VAR ucenik1,ucenik2:RECORD ime,prezime,skola:string;
razred:(I,II,III,IV);
odelјenje:1..8;
END;
podatak1,podatak2:adresar;
telefon:brojtlf;
Променљиве ucenik1 и ucenik2 имплицитно дефинишу слог са пет податка. Ако су поља у
слогу истог типа могу се декларисати збирно, али то није обавезно, тј. дозвољена је и равноправна
и оваква декларација:
VAR ucenik1,ucenik2:RECORD ime:string;
prezime:string;
skola:string;
razred:(I,II,III,IV);
odelјenje:1..8;
END;
Поља у слогу могу бити било ког стандардног или дефинисаног типа. Припадност неког
поља слогу означава се навођењем имена слога и имена поља раздвојених тачком:
podatak1.prezime // поље prezime припада слогу podatak1

podatak1.adresa.ulica // поље ulica припада слогу adresa који је део слога podatak1.
Директно упоређивање слогова није дозвољено. Упоређују се само вредности појединих
поља у оквиру слогова. На пример, овако је дозвољено упоређивати слогове, односно, поједина
поља у оквиру слога:
ucenik1.prezime<ucenik2.prezime
podatak1.adresa.ulica<=podatak2.adresa.ulica
Али овакве релације нису дозвољене:
ucenik1<ucenik2
podatak1.adresa<=podatak2.adresa
Замена вредности између две променљиве истог слоговног типа се остварује једноставно:
VAR a,b,pom:slog;
...
pom:=a; a:=b; b:=pom;
Променљиве које мењају вредности и помоћна променљива морају бити декларисане и
истог типа. Замена вредности слоговних променљивих a и b врши се као и замена вредности
две променљиве било којег другог типа. Наредба додељивања pom:=a означава да се сваком
пољу слоговне променљиве pom додељује вредност одговарајућег поља слоговне променљиве
а (и исто тако у остале две наредбе додељивања).
Приликом рада са слоговима име слога се врло често понавља код уноса, код исписа, код
упоређивања или других обрада и то може да представља непотребно губљење времена,
нарочито ако је име слога предугачко. Да би се проблем решио уведена је наредба With којом
се ова незграпна понављања имена слога елиминишу. Тако се група наредби:
podatak1.prezime:=’Илић’;
podatak1.ime:=’Мирослав’;
podatak1.adresa:=’Улица и број’;
podatak1.telefon:=’011/123-45-67’;
може се заменити једном једноставнијом за писање наредбом:
with podatak1 do
begin prezime:=’Илић’;
ime:=’Мирослав’;
adresa:=’Улица и број’;
telefon:=’011/123-45-67’;
end;
Наравно, имена поља се не могу изоставити нити скратити. Код упоређивања два слога
ова наредба не помаже много, јер се не може применити на оба слога истовремено.
Датотеке
Главни недостаци рада са подацима у примеру из претходног одељка је ограниченост

броја података и њихово чување. Организација података у низу омогућава да се подаци чувају
само док је програм у меморији, тј. док се са тим подацима ради. Нема могућности да после
неког времена, поново погледамо уписане податке, ако смо у међувремену обављали неке
друге послове са рачунаром или смо једноставно искључили рачунар. А јасно је, сврха
прикупљања података није њихова једнократна употреба после које податке бацамо у кош.
Неки подаци су важни и треба их сачувати за будућу употребу.
Појам датотека је уско везан са чувањем података. Датотека може бити скуп адреса,
подаци из неколиких експеримената, рецепти, на пример, италијанске кухиње, програм или
скуп програма корисника, скуп (библиотека) функција над неким подацима итд. Овде ћемо
под појмом датотека подразумевати скуп података одређеног типа који се чува на спољашним
носиоцима меморије.
У основи, разликујемо две врсте датотека: текстуалне датотеке и датотеке са другим
типовима. Оне се разликују и структурно и функционално (по начину рада са њима, али и по
подацима у њима). Основни послови који се јављају у раду са датотекама су:
• отварање (креирање или формирање) датотеке,
• упис и допуна података датотеке,
• уређивање (сортирање) података датотеке,
• читање и претраживање датотеке,
• брисање неких података или читаве датотеке,
• промена имена датотеке итд.
Да би се радило са датотекама морају се схватити сви ови послови. Поменућемо најпре

неке функције и процедуре са којима се најчешће сусрећемо у раду са датотекама:
Append отвара постојећу текстуалну датотеку за додавање нових података.
AssignFile име датотеке на спољашњем носиоцу меморије додељује променљивој
датотеке у програму.
CloseFile затвара отворену датотеку.
Eof логичка функција која одређује да ли се показиваи података у датотеци налази
иза последњег податка или не.
Eoln логичка функција која одређује да ли се показивач података у текстуалној
датотеци налази на крају реда или не.
Erase брише датотеку на спољашњем носиоцу меморије.
FilePos целобројна функција која одређује редни број податка на којем је показивач
података у датотеци.
FileSize целобројна функција која одређује број података у датотеци, не може се
примењивати на текстуалне датотеке.
IOResult целобројна функција која одређује статус претходно извршене улазно -
излазне операције са датотеком, има вредност 0 ако није било грешке.
Read стандардна процедура за читање једног или више података из датотеке.
Readln стандардна процедура за читање једног или више података из датотеке и код
текстуалних датотека постављање показивача података иза краја реда.
Rename стандардна процедура за промену имена датотеке, датотека мора бити
затворена пре примене процедуре.
Reset стандардна процедура која отвара постојећу датотеку.
ReWrite стандардна процедура која креира и отвара нову датотеку, ако се примени на
већ постојећу датотеку брише све податке из ње.
Seek стандардна процедура која поставља показивач података у датотеци на
податак са одређеним редним бројем, не може се примењивати на текстуалне
датотеке.
SeekEof стандардна процедура која поставља показивач података у датотеци на крај
текстуалне датотеке.
SeekEoln стандардна процедура која поставља показивач података у текстуалној
датотеци на крај реда.
Truncate стандардна процедура која брише све податке од тренутне позиције
показивача података у датотеци.
Write стандардна процедура за упис једног или више података у датотеку.
Writeln стандардна процедура за упис једног или више података у датотеку и
дефинише крај реда у текстуалној датотеци.
А сада ћемо покушати да објаснимо начин рада са датотекама уз посебне примере за
текстуалну и датотеку са слогом.
Формирање датотеке
Пре употребе, датотека се мора декларисати или дефинисати. Датотека се експлицитно
дефинише у делу за дефиниције типова:
TYPE imena=FILE OF string;
adresa=RECORD ulica:string;
broj:integer
END;
adrese=FILE OF adresa;
Тип текстуалне датотеке не мора бити посебно дефинисан јер постоји стандардни тип
TextFile који се може користити свуда у програму.
Да би се радило са датотеком, мора да се декларише променљива која ће бити повезана са
стварном датотеком смештеном на спољашњем носиоцу меморије. Променљива датотечког
типа се декларише у делу за декларације променљивих на уобичајени начин помоћу претходно
експлицитно декларисаног датотечког типа или директно као имплицитна дефиниција тог типа:
VAR imenik:imena;
adresar:adresa;
ceobroj:FILE OF integer;
slova:FILE OF char;
opis:TextFile;

Декларацијом датотеке не завршава се посао формирања датотеке. Сада је потребно

такву датотеку креирати на одговарајућем носиоцу спољне меморије. Нека је потребно
креирати декларисану датотеку на активној диск јединици. Најпре треба променљивој
датотечког типа доделити стварно име датотеке, односно, повезати променљиву датотечког
типа са датотеком која ће бити креирана на спољашњем носиоцу меморије:
AssignFile(imenik,’imena.dat’); // претходно декларисаној променљивој imenik придружује се
// датотека на диску са именом imena.dat
AssignFile(opis,’pismo.txt’); // променљивој opis придружује се текстуална датотека pismo.txt
Уместо конкретног текста измеру апострофа може се употребити и нека друга променљива
која има одговарајућу текстуалну вредност (на пример, текст из неког едита).
Сада треба креирати датотеку помоћу стандардне процедуре ReWrite:
ReWrite(imenik); // на активном диску формира нова датотеку са именом imena.dat
ReWrite(opis); // на активном диску формира текстуалну датотеку са именом pismo.txt
Карактеристика ове процедуре је да не проверава да ли на диску већ постоји датотека са
наведеним именом. То значи, ако датотека већ постоји, биће уништени сви подаци који су у
њој били чувани. Зато, ако знамо да је датотека већ формирана (некад раније), а хоћемо да је
користимо (тј. желимо да сачувамо претходне податке), нећемо употребити ову већ, стандардну
процедуру Reset:
Reset(imenik); // отвара датотеку са именом imena.dat на активном диску
Reset(opis); // отвара текстуалну датотеку са именом pismo.txt која постоји на активном диску
Основни проблем који се може јавити код употребе ове процедуре је да датотека не
постоји (тј. у тренутку извршења програма нисмо сигурни да ли датотека постоји или не). Ако
датотека не постоји на активном диску (могуће је да смо формирали датотеку, али је она
касније намерно или грешком избрисана) употреба процедуре Reset прекида извршавање
програма и пријављује се I/O (input/output) грешка. Проблем се решава стандардном
функцијом IOResult која тестира претходну улазно-излазну радњу (било које обраћање
датотеци) и која може имати вредност 0 ако у претходној улазно-излазној радњи није дошло
до грешке, односно, било који други цео, позитиван број (до 256) у зависности од врсте грешке.
Зато, у случају да не знамо да ли датотека постоји или не, а ако не желимо да изгубимо
податке који су, евентуално, у датотеци, правилно би било креирати датотеку на почетку
програма на следећи начин:
{$I-} Reset(imenik); {$I+}
If IOResult<>0
then ReWrite(imenik);
Објаснимо шта значи то што је у претходном примеру написано:
{$I-} - директива која саопштава преводиоцу да у случају I/O (Input/Output, тј. улазно/излазне)
грешке не прекида програм, тј. одузима преводиоцу контролу над I/O грешкама,
Reset(imenik) - команда покушава да отвори датотеку за рад као да она постоји,
{$I+} - директива враћа преводиоцу контролу над I/O грешкама,
If IOResult<>0 - тестира претходну улазно-излазну радњу и ако је датотека већ постојала на
диску функција IOResult је добила вредност 0, па ће се прећи на следећу наредбу иза If наредбе,
а ако датотека није постојала, дошло је до I/O грешке и функција IOResult је добила неку
вредност различиту од 0, па ће се извршити наредба у then грани, односно, ReWrite(imenik), тј.
формираће се нова (и празна) датотека на диску.
Код текстуалних датотека поступићемо овако:
{$I-} Append(opis); {$I+}
If IOResult<>0
then ReWrite(opis);
На овај начин смо решили проблем прекида програма у случају непостојања датотеке
или губљења података у случају постојања датотеке са којом желимо да радимо.
Наравно, није ово једина примена функције IOResult. Она се може употребљавати и у
другим случајевима улазно-излазних радњи, али треба запамтити да се њена вредност може
употребити само једном за једну радњу, тј. код сваког позива њена вредност се мења:
i:=IOResult;
If IOResult<>0
променљива i ће чувати вредност функције IOResult у покушају да се отвори датотека, па
ако датотека не постоји i ће добити вредност различиту од 0. У If наредби се, поново, позива
функција IOResult, али пошто није било улазно/излазних радњи њена вредност ће бити 0 иако
датотека стварно не постоји, па неће бити креирана ни наредбом ReWrite што ће, као
последицу, имати појаву грешке код прве следеће улазно/излазне радње са датотеком (јер
датотека и даље не постоји). Зато, ако из неког разлога желимо да вредност функције IOResult
доделимо променљивој i онда би исправно било написати овај део кода на следећи начин:
i:=IOResult;
If i<>0
Упис података, читање и претраживање датотеке

Када је датотека формирана, потребно је у њу сместити неке податке. За овај посао
користе се стандардне процедуре Write i WriteLn:
Write(imenik,ime); // у датотеку imena.dat уписује се вредност променљиве ime.
WriteLn(opis,’текст између апострофа или променљива типа стринг’);
Append(opis); // у текстуалну датотеку pismo.txt уписује се текст или вредност
// текстуалне променљиве са ознаком краја реда.
Упис података у датотеку остварује се, обично, у неком циклусу са критеријумом краја
уписа који задовољава услове задатка (најчешћи су услови задат број података или специјално
означени крај података). Додељивање вредности променљивој чија се вредност уписује у
датотеку може се извршити стандардном наредбом Read, наредбом додељивања, уписом у
неку текст компоненту (на пример, унос у неки едит) или на неки други начин (на пример,
читањем из неке друге датотеке):
Read(ime);
ime:=a;
ime:=’Viktorija’;
ime:=a+b;
Када је посао уписа података завршен треба затворити датотеку, тј. означити крај
датотеке. Ако се то не уради подаци се неће моћи пронаћи и сав посао уписа био је узалудан. У
делфију, када се програм изврши, аутоматски се затварају све отворене датотеке, али се може
десити да се неки подаци том приликом изгубе, зато би требало писати коректно програме, тј.
програмски затварати датотеке, а не ослањати се на срећу и очекивања. Затварање датотеке
се остварује стандардном процедуром CloseFile:
CloseFile(imenik);
Код текстуалних датотека не мора се вршити затварање датотеке уколико се после
сваког уписа употреби наредба Append. У паскалу, дозвољено је само једно затварање
датотеке. Насупрот томе, дозвољено је произвољан број пута употребити наредбу Reset.
Читање података из датотеке остварује се помоћу стандардних процедура Реад и ReadLn:
Read(imenik,ime) // из датотеке imena.dat читамо један податак и додељујемо га променљивој ime
Read(opis,ime) // из текстуалне датотеке pismo.txt читамо један ред и додељујемо га променљивој
За читање свих података из датотеке треба користити неки циклус са условом. За критеријум краја
читања најчешће се узима функција EOF:
While not EOF(imenik) do
Read(imenik,ime);
While not EOF(opis) do
ReadLn(opis,ime);
Могуће је читање свих података остварити и у For циклусу уз помоћ функције FileSize (не
важи за текстуалне датотеке):
For i:=1 to FileSize(imenik) do
Read(imenik,ime);
То што је неки податак прочитан из датотеке не значи да смо га и видели. Да би се
прочитани податак могао видети морају се употребити наредбе Write или WriteLn или се
прочитана вредност смешта у неку лабелу, едит или други објекат за приказивање података
којима се прочитани податак исписује на екрану:
Write(ime);
WriteLn(ime);
Label1.Caption:=ime;
Важно је, пре покушаја читања свих података из датотеке, употребити наредбу Reset да
би се показивач података ставио на први податак (ако се то не уради, може се десити да
читање почне од неког средњег податка или, у горој варијанти, показивач може бити на крају
датотеке, па неће бити прочитан ниједан податак).
Међутим, врло ретко су нам потребни баш сви подаци. Најчешће треба пронаћи један или
више одређених података. Читањем читаве датотеке и њеним исписивањем тек би започео
посао тражења жељеног података. Тај податак треба пронаћи једноставније, програмски.
Посао претраживања датотеке организује се:
• ако знамо редни број податка (или података) који тражимо
• ако знамо део податка који тражимо
У првом случају користи се стандардна процедура Seek:
Seek(imenik,redbrpod); // поставља показивач на податак са редним бројем redbrpod
Read(imenik,ime); // чита изабрани податак
У другом случају читају се подаци из датотеке све док се не нађе одговарајући податак
или док се не дође до краја датотеке:
While not EOF(imenik)or(Pos(sifra,ime)0) do // sifra је део податка који је познат
Read(imenik,ime);
Наравно, ово је пример претраживања у случају када су подаци типа стринг, у другим
случајевима услов се другачије формулише. Код текстуалних датотека претраживање се може
вршити само на други начин, тј. читањем редом свих података у датотеци док се не дође до
жељеног.
Уређивање података датотеке

Подаци у текстуалној датотеци се не могу уређивати, већ се уређују пре уписа у датотеку.
Подаци у датотеци са слогом се могу уређивати по абецедном реду (ако су типа стринг или
карактер) или по неком другом редоследу. Овај посао није увек једноставан, нарочито ако се
ради о датотеци слогова са више поља, где услов уређења не мора бити једноставан. Ако
претпоставимо да је датотека добро дефинисана и да су подаци уписани, сам принцип уређења
види се у следећем примеру:
Reset(imenik); // постави показивач на почетак датотеке
For i:=0 to FileSize(imenik)-2 do // редни број првог податка се мења од првог места у датотеци
For j:=i+1 to FileSize(imenik)-1 do // до претпоследњег, а другог од првог следећег места до
Begin // последњег у датотеци
Seek(imenik,i); // постави показивач на податак на месту i
Read(imenik,ime1); // прочитај податак
Seek(imenik,j); // постави показивач на податак на месту j
Read(imenik,ime2); // прочитај податак
If ime1>ime2 // упореди прочитане податке и ако треба замени им места у датотеци
then Begin Seek(imenik,j); // постави показивач на други податак, тј. на место j
Write(imenik,ime1); // упиши први податак
Seek(imenik,i); // постави показивач на први податак, тј. на место i
Write(imenik,ime2); // упиши други податак
End
End;
Јасно је да се овде ради о абецедном сортирању стрингова, али би се аналогно решили и
сложенији случајеви, само што би услов промене места слогова био другачије формулисан.
Брисање података или датотеке

Ако нам датотека више није потребна, онда је треба уклонити са диска да непотребно не
заузима меморијски простор. То се врло једноставно ради директно из програма стандардном
процедуром Erase:
Erase(imenik) // физички брише са диска датотеку придружену променљивој imenik
Датотека мора бити затворена да би се могла обрисати.
Нешто је тежи случај када нам само неки подаци не требају, па само њих треба избрисати.
Ово се може постићи на два начина:
• преписивањем свих потребних података у помоћну датотеку, брисањем главне датотеке
и променом имена помоћне датотеке у главну
• померањем свих података иза оног који треба избрисати за једно место у лево и
одсецањем краја датотеке.
У првом случају проблем би се решио овако (наравно, подразумева се да су обе датотеке
добро декларисане, да је датотека imena.dat после првог пуњења затворена и да је вредност
променљиве sifra податак који треба избрисати из датотеке):
Reset(imenik);
ReWrite(pom);
Begin Read(imenik,ime);
If ime<>sifra then Write(pom,ime)
End;

Close(pom);
Erase(imenik);
Rename(pom,’imena.dat’);
У другом случају проблем би се решио овако:
Reset(imenik);
Begin Read(imenik,ime);
If ime<>sifra then
Begin Seek(imenik,i-1);
Write(imenik,ime)
End
End;
Seek(imenik,FileSize(imenik)-1);
Truncate(imenik);
У овом случају се преко податка који се брише уписује следећи податак, преко овога
следећи итд. На крају се последњи податак исписује на претпоследњу позицију и сада имамо
два једнака податка. Стандардна процедура Truncate брише податке од неког места до краја
датотеке, у овом примеру, брише се само последњи податак и тако смо елиминисали
непожељни податак из датотеке.
У неким верзијама програмског језика процедура Truncate не ради, па је корисно
упамтити и први начин као начин брисања непотребних података из датотеке, мада је други
начин нешто бржи. Други начин се никако не може применити на текстуалне датотеке (јер се у
раду са текстуалним датотекама не може користити процедура Seek).
У овом делу је употребљена и стандардна процедура Rename за промену имена датотеке.
Ради се о команди која ради са диском, тј. датотеци на диску се мења име.
Овим смо заокруглили рад са датотекама. Сада је потребно огледати се на конкретном
примеру и увежбати рад са датотекама. Наравно, теже је радити са датотекама чији су
елементи слогови са већим бројем поља, али принцип рада је исти. Сваки од проблема који смо
решавали треба уоквирити у одговарајућу процедуру и тако решити овај сложени посао. Следе
задаци који ће бити решавани са променљивама типа слог како бисмо научили њихову
употребу и припремили се за програмирање и употребу датотека, а касније и база података.
Сваки задатак може се решити и са низом слогова и са датотеком одговарајућег типа.
Задаци са слоговима и датотекама
• Саставити програм који прихвата податке о датумима рођења ученика једног одељења
и уређује их по датуму.
Слогове ћемо формирати у оквиру процедуре
Button1Click, а затим ћемо, у посебној процедури Uredi,
уређивати унете слогове по датуму и исписивати их у
листбокс, зато ћемо дефинисати тип rodjendan и глобалне
променљиве a - низ слоговa и n - редни број слогa. Након
уноса сваког слога сортирају се сви до тада унети слогови.
Предвидели смо да у одељењу има највише 32 ученика.
Креираћемо форму као на слици, а затим написати
type rodjendan=record d,m,g:integer;
ime:string;
end;
podatak=array[1..32] of rodjendan;
...
procedure Uredi;
procedure FormCreate(Sender: TObject);
...
var
Form1: TForm1;
a:podatak;
n:integer;
begin n:=0;
end;
begin if n<32 then
begin n:=n+1;

a[n].ime:=Edit1.Text;
a[n].d:=StrToIntDef(Edit2.Text,1);
a[n].m:=StrToIntDef(Edit3.Text,1);
a[n].g:=StrToIntDef(Edit4.Text,1950);
Uredi;
end;
If n=32 then
begin Edit1.Enabled:=false;
end;
end;
procedure TForm1.Uredi;
var i,j:integer;
pom:rodjendan;
begin for i:=1 to n-1 do
for j:=i+1 to n do
if(a[i].g>a[j].g)or(a[i].g=a[j].g)and(a[i].m>a[j].m)or
(a[i].g=a[j].g)and(a[i].m=a[j].m)and(a[i].d>a[j].d)
then begin pom:=a[i];a[i]:=a[j];a[j]:=pom;
end;
ListBox1.Clear;
ListBox1.Items.Add('П Р Е З И М Е И И М Е ДАТУМ РОЂЕЊА');
for i:=1 to n do
begin j:=30-Length(a[i].ime);
ListBox1.Items.Add(a[i].ime+Format('%*s%*d.%*d.%*d.',
[j,' ', 2,a[i].d,2,a[i].m,4,a[i].g]))
end;
end;
Код исписа смо искористили функцију Format за групно форматирање исписа у листбоксу,
а за испис презимена и имена смо резервисали 30 места. Између апострофа је низ формата са
звездицама уместо конкретних бројева места која се резервишу за испис података,а између [ ]
је низ бројева места и вредности које се на тим местима исписују. Променљива ј одређује
колико од резервисаних 30 није искоришћено за испис презимена и имена. У решењу задатка
није коришћена никаква контрола уписа, тј. корисник може уписати било шта као датум рођења
(на пример 45.52.1000). Коректне контроле уписа датума урађене су код једноставнијих
задатака са простим типовима података, овде би само искомпликовале програм, па би се теже
видео принцип рада са слоговима. Наравно, да би све било коректно одрађено ове контроле
треба додати.
Коришћењем наредбе With последње две процедуре се мењају у:
begin if n<32 then
begin n:=n+1;
With a[n] do
begin ime:=LabeledEdit1.Text;
d:=StrToIntDef(LabeledEdit2.Text,1);
m:=StrToIntDef(Edit1.Text,1);
g:=StrToIntDef(Edit2.Text,1950);
end;
Uredi;
end;
If n=32 then
begin LabeledEdit1.Enabled:=false;Edit1.Enabled:=false;
LabeledEdit2.Enabled:=false;Edit2.Enabled:=false;
end;
end;
procedure TForm1.Uredi;
var i,j:integer;
pom:rodjendan;
begin for i:=1 to n-1 do
for j:=i+1 to n do
with a[i] do if(g>a[j].g)or(g=a[j].g)and(m>a[j].m)or
(g=a[j].g)and(m=a[j].m)and(d>a[j].d)
then begin pom:=a[i];a[i]:=a[j];a[j]:=pom;
end;
ListBox1.Clear;
for i:=1 to n do
with a[i] do
begin j:=30-Length(ime);
ListBox1.Items.Add(ime+format('%*s%*d.%*d.%*d.',
[j,' ', 2,a[i].d,2,a[i].m,4,a[i].g]))
end;
end;

Следи решење са коришћењем датотеке уместо низа слогова.

Тастер Упиши унети податак уписује у датотеку иза последњег
уписаног и приказује га као последњи у ListBox-у не водећи
рачуна о сортирању. Тастер Уреди сортира податке у датотеци
према датуму и исписује сортиране податке у ListBox. Пошто
овде нисмо имали потребу за бројањем података број уписа није
ограничен, а ако желимо да започнемо нови унос кликом на
тастер Обриши празнимо податке из датотеке и ListBox-а:
var n:integer;
begin a.ime:=Edit1.Text;
a.d:=StrToIntDef(Edit2.Text,1);
a.m:=StrToIntDef(Edit3.Text,1);
a.g:=StrToIntDef(Edit4.Text,1950);
ListBox1.Color:=clTeal;
n:=30-Length(a.ime);
ListBox1.Items.Add(a.ime+format('%*s%*d.%*d.%*d.',
[n,' ', 2,a.d,2,a.m,4,a.g]));
Reset(dat);
Seek(dat,FileSize(dat));
Write(dat,a);
end;
var i,j:integer;
b:rodjendan;
begin ListBox1.Color:=clMoneyGreen;
Reset(dat);
For i:=0 to FileSize(dat)-2 do
For j:=i+1 to FileSize(dat)-1 do
begin Seek(dat,i);Read(dat,a);
Seek(dat,j);Read(dat,b);
if(a.g>b.g)or(a.g=b.g)and(a.m>b.m)or(a.g=b.g)and(a.m=b.m)and(a.d>b.d)
then begin Seek(dat,j);Write(dat,a);
Seek(dat,i);Write(dat,b);
end;
end;
ListBox1.Clear;
Reset(dat);
While not Eof(dat) do
begin Read(dat,a);
i:=30-Length(a.ime);
ListBox1.Items.Add(a.ime+format('%*s%*d.%*d.%*d.',[i,' ', 2,a.d,2,a.m,4,a.g]));
end;
end;
begin ListBox1.Clear;
ReWrite(dat);
end;
begin ListBox1.Clear;
AssignFile(dat,'podaci.dat');
{$I-} Reset(dat); {$I+}
If IOResult<>0
then ReWrite(dat);
CloseFile(dat);
end;
• Саставити програм који прихвата податке о адресама и телефонима, а затим

омогућити додавање новог податка, измену постојећег податка, брисање непотребног
податка и уређивање података по презимену и имену.
Ово је пример комплетно урађеног задатка са датотекама у делфију. Све процедуре су коректно решене.
Објашњења унутар кода су скраћена на најнужнија. Биће приоказани сви важнији екрани у програму.
Претходна подешавања карактеристика објеката нису наведена јер су прилично предвидљива.
type
podatak=RECORD redbr,d,m,g:integer;
prezime, ime, ulica, broj, mesto,pbroj, ftel, mtel, email:string[50];
END;
...
var
dat:FILE OF podatak;
a:podatak;
Form1: TForm1;

// ********************************************
// *** Отвара датотеку са адресама ************
// ********************************************
begin Label1.Caption:='МОЈ'+#13+'АДРЕСАР';
AssignFile(dat,'Adresar.dat');
{$I-} Reset(dat); {$I+}
If IOResult<>0
then ReWrite(dat);
CloseFile(dat);
end;
// ********************************************
// *** Крај рада са програмом *****************
// ********************************************
procedure TForm1.IzlazClick(Sender: TObject);
end;
// ********************************************
// *** Унос података у датотеку ***************
// ********************************************
procedure TForm1.UnosClick(Sender: TObject);
begin PUnos.Visible:=true; // отвара панел за унос адреса
UnosP.Click;
end;
procedure TForm1.UnosKClick(Sender: TObject);
begin PUnos.Visible:=false; // затвара панел за унос адреса
end;
procedure TForm1.UnosPClick(Sender: TObject);
var i:integer;
begin For i:=0 to 11 do // празни све едите за нови унос
TEdit(FindComponent('U'+IntToStr(i))).Clear;
U0.SetFocus;
end;
procedure TForm1.U0KeyPress(Sender: TObject; var Key: Char);
var i:integer;
begin If key=#13 // дефинише прелазак на следећи објекат када
then begin For i:=0 to 10 do // се притисне Ентер
If sender=TEdit(FindComponent('U'+IntToStr(i)))
then TEdit(FindComponent('U'+IntToStr(i+1))).SetFocus;
If sender=U11
then UnosZ.SetFocus;
end;
end;
procedure TForm1.UnosZClick(Sender: TObject);
var n:integer;
begin Reset(dat); // смешта уписани податак у адресар
n:=FileSize(dat);
With a do
begin prezime:=U0.Text;ime:=U1.Text;
ulica:=U5.Text; broj:=U6.Text;
mesto:=U7.Text;pbroj:=U8.Text;
ftel:=U9.Text; mtel:=U10.Text;
email:=U11.Text; redbr:=n;
d:=StrToIntDef(U2.Text,1);
m:=StrToIntDef(U3.Text,1);
g:=StrToIntDef(U4.Text,2000);
end;
Seek(dat,n);Write(dat,a);
end;
// ********************************************
// *** Преглед података у датотеци ************
// ********************************************
procedure TForm1.PregledClick(Sender: TObject);
begin PPregled.Visible:=true; // отвара панел за преглед адреса
Reset(dat);Memo1.Clear;
While not Eof(dat) do // чита све податке из датотеке и преноси их у мемо
begin Read(dat,a);
With a do
begin Memo1.Lines.Add(Format('%3d. %1s %1s',[redbr,prezime,ime]));
Memo1.Lines.Add(' '+ulica+' '+broj);
Memo1.Lines.Add(' '+pbroj+' '+mesto);
Memo1.Lines.Add(Format('%7d.%2d.%4d.%13s%13s',[d,m,g,ftel,mtel]));
Memo1.Lines.Add(' '+email);
end;
end;
end;
procedure TForm1.PregledKClick(Sender: TObject);
begin PPregled.Visible:=false; // затвара панел за преглед адреса
end;

// ********************************************
// *** Брисање података из датотеке ***********
// ********************************************
procedure TForm1.BrisanjeClick(Sender: TObject);
begin PBrisi.Visible:=true; // отвара панел за брисање адреса
Reset(dat);Memo2.Clear; // чита све податке из датотеке
While not Eof(dat) do // и преноси их у мемо поље
begin Read(dat,a);
With a do
begin Memo2.Lines.Add(Format('%3d. %1s %1s',
[redbr,prezime,ime]));
Memo2.Lines.Add(' '+mesto+' '+ulica+
' '+broj);
end;
end;
end;
procedure TForm1.OBrisiClick(Sender: TObject);
var i,k:integer;
begin If MessageBox(0,'ДА ЛИ СТЕ СИГУРНИ?','ПАЖЊА',MB_OKCANCEL+MB_ICONQUESTION)=IDOK
then begin k:=StrToInt(Edit1.Text);
Reset(dat);
For i:=k+1 to FileSize(dat)-1 do
Begin Seek(dat,i);Read(dat,a);
a.redbr:=a.redbr-1;
Seek(dat,i-1);Write(dat,a)
End;
Seek(dat,FileSize(dat)-1);
Truncate(dat);
Brisanje.Click;
end;
end;
procedure TForm1.B1KeyPress(Sender: TObject; var Key: Char);
begin If key=#13
then BrisiK.Click
else If not (key in ['0'..'9',#8,#128])
then key:=#27;
end;
procedure TForm1.BrisiKClick(Sender: TObject);
begin PBrisi.Visible:=false; // затвара панел за брисање адреса
end;
// ********************************************
// *** Брисање свих података из датотеке ******
// ********************************************
procedure TForm1.IsprazniClick(Sender: TObject);
begin If MessageBox(0,'!!!БРИСАЊЕ СВИХ ПОДАТАКА!!!'+#13+
'ДА ЛИ СТЕ САСВИМ СИГУРНИ???','ПАЖЊА',
MB_OKCANCEL+MB_ICONQUESTION)=IDOK
then begin ReWrite(dat);
CloseFile(dat);
MessageBox(0,'СВИ ПОДАЦИ СУ ОБРИСАНИ.','Адресар',
MB_OK+MB_ICONASTERISK);
end;
end;
// ********************************************
// *** Сортирање података у датотеци **********
// ********************************************
procedure TForm1.SortClick(Sender: TObject);
var b:podatak;
i,j,p:integer;
begin MessageBox(0,'ПРИТИСНИТЕ ОК ЗА ПОЧЕТАК.','Адресар',
Reset(dat);
For i:=0 to FileSize(dat)-2 do
For j:=i+1 to FileSize(dat)-1 do
begin Seek(dat,i);Read(dat,a);
Seek(dat,j);Read(dat,b);
If a.prezime+a.ime>b.prezime+b.ime
then begin p:=a.redbr;
a.redbr:=b.redbr;
b.redbr:=p;
Seek(dat,j);Write(dat,a);
Seek(dat,i);Write(dat,b);
end
end;
MessageBox(0,'ПОДАЦИ СУ СОРТИРАНИ!','Адресар',
end;

// ********************************************
// *** Претраживање података из датотеке ******
// ********************************************
procedure TForm1.PronadjiClick(Sender: TObject);
begin PNadji.Visible:=true; // отвара панел за претраживање
Memo3.Clear;
Memo3.Lines.Add(' УПИШИТЕ ПОДАТАК ИЛИ
ПОДАТКЕ КОЈЕ ЗНАТЕ!');
P1.SetFocus;
end;
procedure TForm1.NadjiKClick(Sender: TObject);
begin PNadji.Visible:=false; // затвара панел за претраживање
end;
procedure TForm1.PromeniClick(Sender: TObject);
begin p1.Clear;p2.Clear;
p3.Clear;p1.SetFocus;
end;
procedure TForm1.PronadjiPClick(Sender: TObject);
var br:integer;
begin Memo3.Clear;
If Length(P1.Text+P2.Text+P3.Text)=0
then MessageBox(0,'Морате уписати бар један податак за претраживање.','ПАЖЊА',
MB_OK+MB_ICONQUESTION)
else begin br:=0;
Reset(dat);
While not Eof(dat) do
begin Read(dat,a);
If Length(P1.Text)>0
then If a.prezime=P1.Text
then If Length(P2.Text)>0
then If a.ime=P2.Text
then If a.mesto=P3.Text // p1+p2+p3
then begin br:=br+1;Unesi;
end
else
else begin br:=br+1;Unesi; // p1+p2
end
else
else If Length(P3.Text)>0
then If a.mesto=P3.Text // p1+p3
end
else
else begin br:=br+1;Unesi; // p1
end
else
then If a.ime=P2.Text
end
else
else begin br:=br+1;Unesi; // p2
end
else
end
else
else;
end;
MessageDlg('Број пронађених података: '+IntToStr(br),mtInformation,[mbOk],0);
end;
Promeni.SetFocus;
end;
procedure TForm1.P1KeyPress(Sender: TObject; var Key: Char);
begin If key=#13 // дефинише прелазак на следећи објекат када се притисне Ентер
then If sender=P1
then P2.SetFocus
else If sender=P2
then P3.SetFocus
else If sender=P3
then PronadjiP.SetFocus;
end;
procedure TForm1.Unesi;
begin With a do


end;
end;
// ********************************************
// *** Исправка података из датотеке **********
// ********************************************
procedure TForm1.IzmenaClick(Sender: TObject);
begin PIzmena.Visible:=true; // отвара панел за измену података
IBrisi.Click;
Reset(dat);
I0.Clear;I0.SetFocus;
end;
procedure TForm1.IzmenaKClick(Sender: TObject);
begin PIzmena.Visible:=false; // затвара панел за измену података
end;
procedure TForm1.Ispisi;
begin With a do
begin I1.Text:=prezime;I2.Text:=ime;
I6.Text:=Ulica; I7.Text:=broj;
I8.Text:=mesto; I9.Text:=pbroj;
I10.Text:=ftel; I11.Text:=mtel;
I12.Text:=email;
I3.Text:=IntToStr(d);
I4.Text:=IntToStr(m);
I5.Text:=IntToStr(g);
end;
end;
procedure TForm1.I0KeyPress(Sender: TObject; var Key: Char);
begin If key=#13
then begin Seek(dat,StrToIntDef(I0.Text,FileSize(dat)-1));
Read(dat,a);Ispisi;
I1.SetFocus;
end
else If not (key in ['0'..'9',#8,#128])
then key:=#27;
end;
procedure TForm1.IPamtiClick(Sender: TObject);
begin With a do
begin prezime:=I1.Text;ime:=I2.Text;
Ulica:=I6.Text; broj:=I7.Text;
mesto:=I8.Text;pbroj:=I9.Text;
ftel:=I10.Text; mtel:=I11.Text;
email:=I12.Text;
d:=StrToIntDef(I3.Text,1);
m:=StrToIntDef(I4.Text,1);
g:=StrToIntDef(I5.Text,2000);
end;
Seek(dat,StrToIntDef(I0.Text,FileSize(dat)));Write(dat,a);
IBrisi.Click;
I0.Clear;I0.SetFocus;
end;
procedure TForm1.IBrisiClick(Sender: TObject);
var i:integer;
begin For i:=1 to 12 do // празни све едите за нови унос
TEdit(FindComponent('I'+IntToStr(i))).Clear;
I1.SetFocus;
end;
procedure TForm1.IPregledClick(Sender: TObject);
begin Memo4.Visible:=true;
Reset(dat);Memo4.Clear;
While not Eof(dat) do // чита све податке из датотеке и преноси их у мемо
begin Read(dat,a);
With a do
end;
end;
Memo4.SetFocus;
end;
procedure TForm1.Memo4KeyPress(Sender: TObject; var Key: Char);
begin If key=#13
then begin Memo4.Visible:=false;
I0.SetFocus;
end;
end;
procedure TForm1.I1KeyPress(Sender: TObject; var Key: Char);
var i:integer;
begin If key=#13 // дефинише прелазак на следећи објекат када се притисне Ентер
then begin For i:=1 to 11 do
If sender=TEdit(FindComponent('I'+IntToStr(i)))
then TEdit(FindComponent('I'+IntToStr(i+1))).SetFocus;
If sender=I12
then IPamti.SetFocus;
end;
end;

• Саставити програм који прихвата координате тачака у простору све док се не упишу
кординате (0, 0, 0), а затим одређује тачку најближу координатном почетку и тачку
која је најудаљенија од те тачке.
• Саставити програм који прихвата углове у облик степен, минут секунд све док се не
упише угао 0, 0, 0, а затим одређује колико има оштрих, правих и тупих углова и
колико има неконвексних углова.
• Саставити програм који прихвата податке са такмичења у облику: презиме и име
ученика, одељење, школа и број освојених поена, а затим одредити која школа има
највие освојених поена и исписује имена три најбоље пласирана ученика.
• Саставити програм који прихвата податке о изостанцима ученика у облику:
презиме и име ученика, одељење и број оправданих и неоправданих изостанака, а
затим исписати име ученика који има највише изостанака и одељење које има
најмањи број неоправданих изостанака. Формирати листу одељења по просечном
броју укупних изостанака.
• Саставити програм који прихвата податке о висинама и тежинама ученика једног
одељења, а затим исписује имена највишег, најнижег, најлакшег и најтежег ученика,
као и просечну висину и тежину ученика и ученика који је најближи просеку.
• Саставити програм који прихвата податке о успеху ученика на крају школске године,
а затим исписује ученике уређене по средњој оцени и имена ученика који имају највише
петица или четворки.

Литература

Informatika I Racunarstvo PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Informatika I Racunarstvo PDF

Uploaded by

Copyright:

Available Formats

М и р о с л а в И л и ћ

ПРОГ РА МСКИ ЈЕЗИК

Мирослав Илић Девета гимназија "Михаило Петровић Алас" Нови Београд

Решавање проблема помоћу рачунара . . . . . . . . . . . . . . . . . . . . . . 5

Мирослав Илић Девета гимназија "Михаило Петровић Алас" Нови Београд

Решавање проблема помоћу рачунара

Појам програмирања подразумева дуг процес размишљања о задатку. У том процесу

Мирослав Илић Девета гимназија "Михаило Петровић Алас" Нови Београд

Алгоритам је коначан низ једноставних корака којим се описује поступак решавања

Постоји много начина да се алгоритам прецизније дефинише, али за нас је довољна и

Мирослав Илић Девета гимназија "Михаило Петровић Алас" Нови Београд

Трансформација проблема на облик погодан за решавање на рачунару

Да бисмо решили неки проблем коришћењем рачунара, неопходно је креирати програм у

не значи да је програм исправан. Програм се тестира тако што се извршава за одабране

Програмски језици и њихова синтакса и семантика.

Језик је средство комуницирања у процесу размене и обраде информација и података.

Класификација програмских језика

Процедурални језици подразумевају најпре алгоритамско решавање проблема, а затим

Мирослав Илић Девета гимназија "Михаило Петровић Алас" Нови Београд

• ada - универзални, вишенаменски програмски језик високог нивоа који је заснован на

Програмски језик паскал

проширења. Нека од тих проширења обезбеђују боље искоришћавање

Мирослав Илић Девета гимназија "Михаило Петровић Алас" Нови Београд

Питања на која треба обратити пажњу

• Разлика између решавања проблема у животу и на рачунару

• Граматика програмског језика

Мирослав Илић Девета гимназија "Михаило Петровић Алас" Нови Београд

Мирослав Илић Девета гимназија "Михаило Петровић Алас" Нови Београд

Програми засновани на прозорима

Апликације су програмски системи пројектовани за решавање одређеног проблема. Поступак

Основне карактеристике програма заснованих на прозорима

Слика приказује главни прозор апликације WordPad, једне од стандардних апликација

Мирослав Илић Девета гимназија "Михаило Петровић Алас" Нови Београд

Прозори апликације могу да имају следеће делове:

Мирослав Илић Девета гимназија "Михаило Петровић Алас" Нови Београд

Тренутно одабране ставке у менију приказују се истицањем другом бојом подлоге и

Мирослав Илић Девета гимназија "Михаило Петровић Алас" Нови Београд

Елементи графичког корисничког интерфејса (Graphical User Interface)

Графичко корисничко окружење (Graphical User Interface, GUI) је тип корисничког

Мирослав Илић Девета гимназија "Михаило Петровић Алас" Нови Београд

Програми руковођени догађајима

У објектно оријентисаним програмским језицима у центру пажње су догађаји на које

Питања на која треба обратити пажњу

• Одлике апликација заснованих на прозорима

Мирослав Илић Девета гимназија "Михаило Петровић Алас" Нови Београд

Мирослав Илић Девета гимназија "Михаило Петровић Алас" Нови Београд

Увод у развојно окружење програмског језика

На персоналним рачунарима данас врло је популаран рад под оперативним системом

Мирослав Илић Девета гимназија "Михаило Петровић Алас" Нови Београд

Убрзо, затим, појавила се верзија Делфи 8 и то је последњи пројекат

Привредна комора Београда, Удружење информатичке делатности у сарадњи са

наслеђивању - Механизам наслеђивања (inheritance) састоји се у томе да једна класа може

Почетак рада и управљање развојним окружењем.

Покретањем апликације отвара се неколико прозора које ћемо укратко описати.

Стандардна трака прозора садржи назив програмског модула (Delphi 7 - Project1) са

Мирослав Илић Девета гимназија "Михаило Петровић Алас" Нови Београд

Save - омогућава чување тренутно активне датотеке са датим именом (команду

Мирослав Илић Девета гимназија "Михаило Петровић Алас" Нови Београд

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

Мирослав Илић Девета гимназија "Михаило Петровић Алас" Нови Београд

један начин. Листа догађаја објекта може бити променљиве дужине у

Мирослав Илић Девета гимназија "Михаило Петровић Алас" Нови Београд

Отварањем делфи апликације отворили смо празан пројекат. И овакав пројекат је