Реферат на тему:

Цикл "поки" та його використання

1. Поки...

Приклад 1. Розглянемо дещо штучну задачу: написати цілочислову функцію з ім'ям pow для обчислення степеня aⁿ за довільним натуральним a і n 0. Задача має елементарне розв'язання: aⁿ=e^nlna, і в тілі функції достатньо написати pow:=round(exp(n*ln(a))). Проте невід'ємні степені цілих чисел є цілими, тому спробуємо обійтися без нецілих виразів із функціями exp і ln.

За означенням, aⁿ є a a ... a, тобто a⁰=1, aⁱ=a^i-1 a для i=1, 2, ... , n. Це підштовхує до спроби обчислення aⁿ шляхом багаторазового множення на a. Спочатку шуканий степінь p=1, і треба n разів умножити його на a. Після першого множення p=a, і треба n-1 разів умножити його на a тощо. Перед останнім множенням p=a^n-1. Таким чином,

спочатку p=1 і треба виконати n множень на a, і поки залишаються "невикористані" множники a, ми множимо p на a, одержуємо новий степінь p і запам'ятовуємо, що "невикористаних" множників стало менше на 1.

Остання фраза, власне, і є алгоритмом обчислення aⁿ. Перекладемо його на мову Паскаль.

Нам потрібні змінні p і a для збереження степеня і його основи, а також змінні n і k для збереження показника степеня й кількості "невикористаних" множників. Змінні a і n – параметри нашої функції, тому їх початкові значення тут не важливі. Тепер алгоритм можна уточнити:

p:=1; k:=n;

поки k>0 виконувати {залишилися "невикористані" співмножники}

begin p:=p*a; k:=k-1 end

Якщо перекласти на англійську мову слова поки і виконувати як while і do, то утвориться:

p:=1; k:=n;

while k>0 do{залишилися "невикористані" співмножники}

begin p:=p*a; k:=k-1 end

Але це вже Паскаль! Справа в тім, що вираз вигляду

while умова do оператор

називається while-оператором, або оператором циклу з перед-умовою. Вираз "while умова do" називається заголовком циклу, "оператор" – тілом. Ми б назвали while-оператор циклом з умовою продовження, але цей термін дотепер у літературі не з'являвся.

Опишемо семантику оператора циклу та прокоментуємо всі ці назви. Виконання оператора циклу починається з того, що обчислюється умова, записана в заголовку. Якщо вона істинна, то виконується тіло циклу і знову обчислюється умова. Якщо вона істинна, усе повторюється. Якщо ж при черговому обчисленні умова стає хибною, то тіло циклу не виконується і взагалі виконання оператора циклу на цьому закінчується. Зокрема, якщо при першому обчисленні умова хибна, то тіло циклу не виконується жодного разу.

Отже, обчислення умови й виконання тіла повторюється, тобто має циклічний характер. Можна сказати, що обчислення умови й виконання тіла утворюють цикл, як день і ніч, змінюючи одне одного, утворюють добу. Істинність умови веде до продовження виконання оператора циклу, хибність – до його завершення, тому умова називається умовою продовження. Вона також називається перед-умовою, оскільки з її обчислення починається черговий цикл. Останній цикл неповний – у ньому тільки обчислюється умова (і виявляється хибною).

Оператору з перед-умовою відповідає блок-схема, зображена на рис.4.1.

Повернемося до задачі. Послідовність операторів для обчислення aⁿ при a=2, n=3 задає процес

p:=1; k:=3;

обчислення умови k>0: true ;

p:=1*2; k:=3-1; {p=2; k=2}

обчислення умови k>0: true;

p:=2*2; k:=2-1; {p=4; k=1}

обчислення умови k>0: true;

p:=4*2; k:=1-1; {p=8; k=0}

обчислення умови k>0: false,

а при a=5, n=0 – процес

p:=1; k:=0;

обчислення умови k>0: false.

У вигляді коментарів тут указано стани пам'яті наприкінці циклів.

Запишемо, нарешті, функцію pow:

function pow(a, n:integer):integer;

var p, k: integer;

begin

p:=1; k:=n;

while k>0 do

begin p:=p*a; k:=k-1 end;

pow:=p

end;



Приклад 2. Розглянемо задачу: за цілим A>0 обчислити мінімальне n таке, що n!  A.

За означенням, n!=1 2 … n, тобто 1!=1, 2!=1! 2, 3!=2! 3 тощо, n!=(n-1)! n. Обчислимо 1! та порівняємо з A; якщо 1!<A, то обчислимо 2!=2 1! і знову порівняємо тощо. Зрештою після чергового збільшення n виявиться, що n! A, і отримане значення n – шукане. Наприклад, при A=5 треба дійти до n=3, при A=120 – до n=5. Нам потрібна змінна n для запам'ятовування чисел 1, 2, 3 тощо, та змінна f – для значень 1!, 2!, 3! тощо. Отже,

спочатку n:=1, f:=1, і

поки f<A, треба збільшувати n на 1 і f домножати на n.

Перекладемо цей алгоритм на Паскаль. Скористаємося while-оператором із умовою продовження f<A і тілом, у якому задано зміни n і f:

n:=1; f:=1;

while f<A do {значення n менше шуканого}

begin n:=n+1; f:=f*n end;

{f>=A, f=n! , тому значення n – шукане}

Коментар після циклу містить умову f>=A – по суті, заперечення умови продовження f<A.

Коментар із запереченням умови продовження після оператора циклу може істотно допомогти в розробці циклічних операторів, тому радимо записувати його.

Оформлення алгоритму у вигляді функції з параметром A залишається як вправа.

Досвідчені програмісти в деяких випадках користуються "нескінченним циклом" вигляду while true do оператор. Засоби, якими задається вихід із тіла циклу незалежно від значення умови продовження, ми розглянемо в підрозділах 5.3, 5.4.

2. Рекурентні послідовності та співвідношення

2.1. Деталі конструктора

У прикладі 4.1 змінна p у процесі виконання операторів приймала значення 1, a, a², a³, … , aⁿ. У цій послідовності перший член 1, а кожний наступний дорівнює попередньому, помноженому на a. Позначивши члени послідовності через p₀, p₁, p₂, ... p_n, маємо рівність: p_i=p_i-1*a при i=1,2,…,n. Така рівність, що виражає член послідовності через попередні (один або кілька), називається рекурентним співвідношенням.

"Рекурентний" означає "зворотний". Справді, елемент послідовності тут визначається через попередні, і для його обчислення треба повернутися до них. Усім добре відомі рекурентні співвідношення вигляду a_n=a_n-1+d або b_n=b_n-1 q – їм задовольняють члени відповідно арифметичних або геометричних прогресій. Конкретна ж прогресія, тобто послідовність чисел, задається першим членом a₁ і різницею d (або знаменником q). Власне, послідовність степенів у прикладі 4.1 p₀, p₁, p₂, … – геометрична прогресія: вона визначається першим членом p₀=1 і рекурентним співвідношенням p_i=p_i-1*a при будь-якому i>0.

У прикладі 4.2 змінна n послідовно приймала значення, що утворюють арифметичну прогресію з першим членом 1 і різницею 1. Послідовність же значень змінної f не була прогресією, але визначалася першим членом f₁=1 і співвідношенням f_n=f_n-1 n при n>1.

Послідовність, члени якої задовольняють деяке рекурентне співвідношення, також називається рекурентною.

Приклад 3. Розглянемо послідовність {f} чисел 1, 1, 2, 3, 5, 8, 13, … , у якій f₁=f₂=1, а наступні члени задаються рекурентним співвідношенням

f_n=f_n-2+f_n-1, n>2.

Вона називається послідовністю чисел Фібоначчі – за прізвиськом Леонардо Пізанського, який першим її описав. За першими двома її членами можна обчислити третій. Для обчислення четвертого перший член уже не потрібний, тому що f₄=f₂+f₃. Для обчислення п'ятого достатньо пам'ятати лише третій і четвертий тощо. Обчислюючи члени послідовності один за одним, ми дістанемося будь-якого, почавши з перших двох. При цьому щоразу ми використовуємо лише два останніх значення і, обчисливши наступне, "забуваємо" перше з двох використаних.

Нехай дано номер n, n>2, і треба обчислити f_n. Опишемо ці обчислення. З попередніх міркувань випливає, що потрібні дві змінні для двох сусідніх членів і третя для наступного (назвемо їх fa, fb і fc), а також змінна m для зберігання номера останнього з обчислених членів.

Спочатку fa=1, fb=1, m=2, (*)

потім обчислимо fc:=fa+fb і збільшимо m на 1. Якщо значення fb і fc зробити відповідно значеннями fa і fb (fa:=fb, fb:=fc), то обчислення четвертого члена можна задати таким самим оператором fc:=fa+fb. Отже,

поки m<n, виконуємо:

fc:=fa+fb, m:=m+1, fa:=fb, fb:=fc. (**)

Очевидно, що з кожним виконанням fc:=fa+fb, m:=m+1 ми переходимо до наступного члена послідовності і в m запам'ятовуємо його номер. Оскільки значення m щоразу зростає, зрештою виявиться, що m=n, умова m<n стане хибною, і змінних fb і fc матимуть потрібне нам значення f_n. Залишилося перекласти на Паскаль рядки, відзначені (*) і (**):

fa=1; fb=1; m=2;

while m<n do

begin

fc:=fa+fb; m:=m+1;

fa:=fb; fb:=fc

end;

{m=n, значення змінних fc і fb – шукане}

Відзначимо, що присвоювання fa:=fb та fb:=fc ні в якому разі не можна переставляти – можете проімітувати початок виконання цього алгоритму з переставленими присвоюваннями й переконатися, що значеннями змінної fc будуть аж ніяк не числа Фібоначчі. 

У загальному випадку рекурентне співвідношення задає залежність члена рекурентної послідовності s_n від k попередніх у вигляді деякого виразу s_n=F(s_n-k, … , s_n-1). Число k називається порядком рекурентного співвідношення. Якщо відомі s_n-k, ... , s_n-1, то вираз F фактично задає обчислення s_n. Назвемо це обчислення застосуванням рекурентного співвідношення.

Припустимо, нам відомо рекурентне співвідношення s_n=F(s_n-k, ... , s_n-1) і перші k членів рекурентної послідовності. Треба за номером p обчислити s_p. Знаючи перші k членів, можна застосувати до них співвідношення й обчислити s_k+1; аналогічно за s₂, ... , s_k+1 обчислюється s_k+2 тощо. Щоразу для обчислення чергового члена потрібні тільки k останніх із попередніх.

Отже, для опису цих обчислень потрібні:

• k змінних для k останніх членів (нехай їх імена A, B, … , X),

• змінна для нового члена (нехай її ім'я Y),

• змінна M для номера останнього з обчислених членів.

Треба створити "деталі конструктора", тобто запрограмувати:

• ініціалізацію змінних A, B, … , X першими k значеннями послідовності;

• застосування рекурентного співвідношення, тобто обчислення нового члена й запам'ятовування його в змінній Y;

• присвоювання значень змінних B, … , X, Y відповідно змінним A, B, … , X (назвемо це переприсвоюванням).

Тоді розв'язання задачі має вигляд:

ініціалізація змінних A, B, … , X;

M:=k;

while умова продовження do

begin

присвоїти Y результат застосування рекурентного співвідношення до значень змінних A, B, … , X;

M:=M+1;

A:=B; ... ; X:=Y {переприсвоювання}

end

У нашому випадку умова продовження – це просто вираз M<p.

Розв'язанням такого вигляду є алгоритм обчислення числа Фібоначчі за його номером (приклад 4.3). Там k=2 і використано імена fa, fb, fc замість A, ... , X, Y.

Далі ми наведемо приклади розв'язання задач з іншими умовами продовження й іншим розташуванням "деталей конструктора", хоча в основі алгоритму все рівно буде цикл while.

Зауважимо, що якщо порядок рекурентного співвідношення k=1, то для обчислення нового члена може виявитися достатнім однієї змінної. Так було в перших задачах, де, наприклад, при виконанні p:=p*a спочатку за старим значенням змінної p обчислювалося нове й потім їй же присвоювалося. Проте далі ми наведемо приклади, де послідовність задається співвідношенням порядку 1, але в умові продовження обчислень використовуються два останніх члени. Тому там будуть потрібні дві змінні.

Приклад 4. Античні греки вміли приблизно обчислювати за допомогою послідовності чисел, що сходиться до нього. За алгоритмом Герона така послідовність утворюється застосуванням рекурентного співвідношення , починаючи з будь-якого додатного x₁, наприклад, із x₁=(a+1)/2. Однією з властивостей послідовності є те, що < при n>1.

Умови продовження обчислень можуть бути різними, наприклад, >d або >d для деякого d>0. Розглянемо друге з них. Оскільки в ньому вказано два сусідніх члени, потрібні дві змінні для їх збереження, причому обидві повинні мати різні значення вже перед першою перевіркою умови продовження. Після того, як вона виявляється істинною, для обчислення нового члена передостанній член уже не потрібний, тому що рекурентне співвідношення має порядок 1. Тому в тілі циклу треба спочатку вказати переприсвоювання, а потім обчислення нового члена. Номера членів послідовності нас не цікавили, тому алгоритм має вигляд:

X:=(a+1)/2; Y:=0.5*(X+a/X);

while abs(X-Y)>d do

begin

X:=Y; Y:=0.5*(X+a/X);

end;

{ abs(X-Y)<=d, значення Y вважається шуканим, адже |Y-a|<d}



Використання рекурентних співвідношень дозволяє легко програмувати розв'язання задач, де шукані величини можуть бути виражені як члени рекурентних послідовностей. Треба:

• зрозуміти, що розв'язання задачі можна побудувати на використанні рекурентної послідовності;

• записати відповідне рекурентне співвідношення;

• визначити перші члени послідовності, що обчислюються без застосування співвідношення;

• сформулювати умову, за якої треба продовжувати застосування рекурентного співвідношення.

Після цього згадані вище "деталі конструктора" та порядок їх розташування в алгоритмі стають очевидними.

Програма – це абсолютно точний опис дій, які треба виконати. Її неможливо написати, не сформулювавши чітко й точно, що ж саме повинно бути виконано. Рекурентні співвідношення якраз і дають точне вираження необхідних дій та служать надійною основою для написання програми. Насмілимося запевнити читача, що витрати часу на попереднє формулювання рекурентних співвідношень окупаються при написанні програми і дозволяють уникнути багатьох помилок.

2.2. Системи рекурентних співвідношень

Є чимало задач, у розв'язанні яких використовуються не одна, а кілька рекурентних послідовностей. Члени послідовності можуть залежати від попередніх членів як "своєї", так і інших послідовностей. Ці залежності записуються у вигляді систем рекурентних співвідношень. Насправді, ми вже бачили зв'язані послідовності: члени послідовності 1!, 2!, 3!, … залежать від їх номерів і попередніх членів. Але послідовність номерів сама рекурентна, оскільки кожний номер на 1 більше попереднього.

Приклад 5. Значення функції sinx виражається у вигляді нескінченної суми: sinx= . При |x| 1 кожний доданок a_n, n 1, цієї суми за модулем менше попереднього. Крім того, |a_n| > ||. Тому, якщо додати всі члени від першого до останнього з таких a_n, що |a_n|>d за деякого d>0, то одержана сума відрізняється від sinx не більш, ніж на d.

Отже, треба обчислити s_n=, де n невідомо, а відомо лише, що |a_n|>d, |a_n+1| d. Очевидно, s_n=s_n-1+a_n за будь-якого n>1, а s₁=a₁=x. Ці рівності виражають залежність значення суми від попередньої суми і відповідного доданка, тобто послідовність значень сум рекурентна. Помітимо, що при d<|x| доданок a₁ не треба додавати до суми, і результатом повинна бути "сума без доданків". Тому до послідовності сум додамо s₀=0; тепер s_n=s_n-1+a_n для n>0.

Знайдемо рекурентне співвідношення для послідовності доданків , виразивши a_n через a_n-1. Для цього у виразі для a_n побудуємо вираз, яким задається a_n-1:

=

= .

Отже, при n>1, a₁=x. Запишемо одержані рекурентні співвідношення в систему:

Побудуємо за нею алгоритм обчислення. Оскільки порядок обох співвідношень 1, достатньо двох змінних, S і A, для збереження членів послідовностей. Спочатку A:=x; S:=0. Далі перед кожним обчисленням S:=S+A треба спочатку перевірити, що A>d. Після додавання A до S обчислюється новий доданок (значення A), і все повторюється. Таким чином, цикл складений діями в такому порядку:

перевірка умови A>d,

додавання S:=S+A,

обчислення нового значення A.

Нехай змінна I зберігає номер останнього обчисленого доданка; спочатку I=1. Оскільки при обчисленні нового доданка використовується його номер, то цей номер треба попередньо збільшити. Тепер алгоритм очевидний:

S:=0; A:=x; I:=1;

while A>d do

begin

S:=S+A; I:=I+1;

A:=A*(-x*x)/((2*I-2)*(2*I-1));

end

{A<=d, і воно не додано до S; значення S – шукане}

Оформлення цього алгоритму у вигляді функції з параметром x і розумно підібраним значенням d залишається вправою.

3. Числа прості й не тільки

Приклад 6. Напишемо функцію визначення, чи є натуральне значення її параметра, більше 1, простим числом.

Як відомо, число n є простим, якщо його додатними дільниками є лише 1 і n. Число 2 просте, а n>2 просте, якщо не ділиться без остачі на жодне з чисел 2, 3, … , n-1. Якщо ж воно ділиться хоча б на одне з них, то є не простим, а складеним. Отже, n – просте тоді й тільки тоді, коли (n=2) або (n>2 і n не ділиться на жодне з чисел 2, 3, … , n-1). Очевидно також, що n – складене, якщо n>2 і ділиться хоча б на одне з чисел 2, 3, … , n-1.

Таким чином, при n>2 треба перевірити подільність n на кожне з чисел k=2, 3, … , n-1.

Результат перевірок можна запам'ятати у вигляді кількості d дільників серед цих чисел. До початку перевірок d=0, тобто жодний дільник ще не знайдений, і з кожним знайденим дільником d збільшується на 1. Тоді умова d=0 є ознакою того, що число просте. Оформимо сказане у вигляді алгоритму:

if n>2 then

begin

d:=0;

для всіх k=2, 3, … , n-1 перевірити, чи ділиться n на k:

якщо ділиться, то d:=d+1

if d>0 then n – складене

else n – просте

end

else n – просте

Уточнимо цей алгоритм. Нехай issimple, тобто "є_простим" – ім'я функції, яку ми пишемо. Природно означити тип значень, що повертаються з неї, як булів. Тоді "n – просте" і "n – складене" уточнюються як issimple:=true і issimple:=false. На початку обчислень вважаємо, що число просте, тому присвоюємо issimple:=true. Тоді достатньо оператора розгалуження з умовою n>2 без else-гілки. Так само достатньо і скороченого оператора розгалуження з умовою d>0.

Фраза "для всіх k=2, 3, … , n-1 перевірити, чи ділиться n на k" задає повторення тих самих дій: перевірка подільності n на k та підготування до наступної перевірки, тобто збільшення k на 1. Спочатку k=2. Умовою продовження перевірок, очевидно, є умова k<n.

issimple:=true;

if n>2 then

begin

d:=0; k:=2;

while k<n do

begin

if n mod k = 0 then d:=d+1;

k:=k+1

end;

if d>0 then issimple:=false

end

Цей алгоритм можна істотно поліпшити. Почнемо з дрібниць. За оператором "if d>0 then …" змінній issimple фактично присвоюється значення виразу not (d>0). Простіше написати: issimple:=not(d>0). Насправді змінна d взагалі не потрібна. Дійсно, значенням issimple буде false, якщо хоча б один раз виконується оператор d:=d+1. Замість нього напишемо issimple:=false. Крім того, якщо n=2, то умова продовження k<n хибна при початковому значенні k, тому перевірку умови n>2 можна взагалі вилучити:

issimple:= true; k:= 2;

while k<n do {при n=2 тіло циклу не виконується жодного разу й значенням issimple залишається true}

begin

if n mod k=0 then issimple:=false;

k:=k+1

end

Внесемо істотніші поліпшення. Перше. Якщо n=k₁k₂, де k₁ і k₂ обидва більше 1 і менше n, то одне з цих чисел обов'язково не більше, ніж. Тому для того, щоб дізнатися, чи є простим число n, достатньо перевірити його подільність на числа від 1 до [], де [x] позначає цілу частину x. Тоді умова продовження перевірок виражається як k<trunc(sqrt(n))+1. Така зміна веде до зменшення кількості виконуваних дій приблизно в разів, що не так мало при достатньо великих значеннях n. Наприклад, .

Щоб не обчислювати trunc(sqrt(n))+1 при кожному виконанні циклу, означимо допоміжну змінну tsn і присвоїмо їй trunc(sqrt(n))+1.

Друге. Після того, як у циклі змінна issimple одержала значення false, подальші перевірки не потрібні, тому що вже ясно, що n не просте. Тому до умови продовження слід додати, що issimple має значення "істина". А перевірка цієї умови задається таким виразом: issimple.

Було б природно записати вираз (k<tsn) and issimple як умову продовження. Проте використання імені функції у виразі означає її виклик. Виклик функції тут зовсім ні до чого, тому цей вираз помилковий. Замість issimple скористаємося допоміжною змінною з ім'ям, наприклад, simp, додавши наприкінці issimple:=simp:

simp:= true; tsn:= trunc(sqrt(n))+1; k:= 2;

while (k<tsn) and simp do

begin

if n mod k=0 then simp:=false;

k:=k+1

end;

issimple:=simp

Оформлення функції з заголовком

function issimple(n:integer):boolean

лишаємо для вправи. Відзначимо ще раз, що тіло функції треба записувати так, що при виконанні її виклику виконувався хоча б один оператор присвоювання з її ім'ям у лівій частині.

З цього прикладу напрошується простий висновок: після того, як алгоритм розв'язання задачі написаний, майже ніколи не пізно і не завадить подумати про те, як його поліпшити.

Поліпшення алгоритму й програми можуть стосуватися таких цілком різних властивостей, як зрозумілість, обсяг пам'яті комп'ютера, що використовується, та кількість дій, заданих програмою. А ця кількість визначає тривалість виконання програми, яка іноді буває дуже істотною.

Приклад 7. Прості числа 2, 3, 5, 7, 11, 13, … розташовані в натуральному ряду дуже загадковим чином. Нехай треба обчислити просте число за його номером у цій послідовності. Є формула, що задає просте число за його номером k, але обчислення за нею не простіші, ніж "лобові":

Йти натуральним рядом і рахувати, скільки простих чисел зустрілося.

Коли цей рахунок доходить до k, ми одержуємо те, що нам треба.

Це і є алгоритм пошуку k-го простого числа. Уточнимо його.

Нехай k>0. Означимо для зберігання натуральних чисел, що перебираються, змінну m. З алгоритму випливає, що нам потрібна ще змінна для збереження кількості простих чисел, які вже зустрілися. Нехай cs – ім'я цього "лічильника простих чисел". Спочатку cs=1, m=2 (у значенні лічильника враховано перше просте число 2). Далі починається цикл:

якщо умова продовження cs<k істинна, то треба перейти до ще неперевіреного значення m, перевірити, чи є воно простим, і якщо так, то збільшити значення лічильника cs. Коли значення cs досягає значення k, останнє перевірене число і є шуканим.

Ось переклад останніх фраз на Паскаль у вигляді програми з функцією issimple із попереднього прикладу:

program simpi(input, output);

var k, m, cs: integer;

function issimple(n:integer):boolean;

...

end; {issimple}

begin

writeln('задайте номер(>0):');

readln(k);

cs:=1; m:=2;

while cs<k do

begin

m:=m+1;

if issimple(m) then cs:=cs+1

end;

{cs=k, значення m – шукане}

writeln( k, '-е просте : ', m)

end.



Приклад 8. Як відомо, кожне натуральне число, більше 1, однозначно розкладається в добуток простих співмножників, наприклад, 13=13, 105=3 5 7, 72=2 2 2 3 3 тощо. Щоб побудувати розклад довільного числа, або його факторизацію, знайдемо його найменший дільник (очевидно, що він простій), запишемо його і поділимо на нього число. Подальші співмножники розкладу утворюються так само доти, поки в результаті ділень не утвориться 1. Наприклад, 36=2 18 (виписали 2), 18=2 9 (2), 9=3 3 (3), 3=3 1 (3).

Очевидно, що найменший дільник частки від ділення не може бути менше, ніж найменший дільник діленого. Тому після чергового ділення пошуки такого найменшого дільника можна починати не з 2, а з останнього дільника.

Алгоритм друкування розкладу n оформимо у вигляді процедури simpdivisors із параметром n ("divisor" означає "дільник"). Можливі дільники будуть значеннями змінної k.

Спочатку k=2. Потім, поки n>1, перевіряється подільність n на k. Якщо ділиться, то виписується значення k і виконується ділення, інакше k збільшується, тому що менших дільників уже бути не може.

Наведене описання обчислень уточнюється в такому вигляді:

procedure simpdivisors(n:integer);

var k:integer;

begin

k:=2;

while n>1 do

begin

if n mod k = 0 then

begin writeln(k); n:=n div k end

else k:=k+1

end

end