Подпрограммы в Pascal. 1-й курс

На последней лекции по программированию были даны на самостоятельное решение задачи, решить которые нужно с использованием подпрограмм:

1. Найти все простые числа на отрезке [m, n], где m и n задаются пользователем.

2. Дана квадратная целочисленная матрица. Найти сумму элементов матрицы, которые

а) отрицательны

b) имеют сумму делителей, не превосходящую заданное число k

Я решила пока что только с использованием функций. Есть ли у кого-нибудь предложения по оптимизации? Можно ли что-то улучшить в моих решениях? Присылайте свои версии программ, буду рада. )))

Первая:

 

  1. program mn;
  2.  
  3. var
  4.   m, n, i: Integer;
  5. function IsSimple(a: Integer): Boolean;
  6. var
  7.   i: Byte;
  8.   f: Boolean;
  9. begin
  10.   f := true;
  11.   if (a = 1) then
  12.     f := false
  13.   else
  14.     for i := 2 to (a - 1) do
  15.       if (a mod i = 0) then begin
  16.         f := false;
  17.         break
  18.       end;
  19.   IsSimple := f;
  20. end;
  21.  
  22. begin
  23.   Read(m, n);
  24.   Writeln;
  25.   for i := m to n do
  26.     if IsSimple(i) then
  27.       Write(i, ' ');
  28. end.

 

Вторая а)

 

  1. program SumOtrits;
  2.  
  3. const
  4.   m = 100;
  5. type
  6.   TMtrx = array[1..m, 1..m] of Integer;
  7. var a: Tmtrx;
  8.     i, j, n: Integer;
  9. function SumNegative(a: Tmtrx; n: Integer): Integer;
  10. var i, j, S: Integer;
  11. begin
  12.   S := 0;
  13.   for i := 1 to n do
  14.     for j := 1 to n do
  15.       if (a[i, j]0) then
  16.         S := S + a[i, j];
  17.   SumNegative := S;    
  18. end;
  19.  
  20. begin
  21.   Write('Введите порядок матрицы ');
  22.   Readln(n);
  23.   Writeln('Введите элементы матрицы ');
  24.   for i := 1 to n do
  25.     for j := 1 to n do
  26.       Read(a[i, j]);
  27.   Writeln('Сумма отрицательных элементов ', SumNegative(a, n));
  28. end.

 

Вторая b)

 

  1. program SumEl;
  2.  
  3. const
  4.   m = 100;
  5. type
  6.   TMTRX = array[1..m, 1..m] of Integer;
  7. var
  8.   i, j, n, k, Sum: Integer;
  9.   a: TMTRX;
  10. function Del(a, k: Integer): Boolean;
  11. var
  12.   i, c: Integer;
  13.   f: Boolean;
  14. begin
  15.   c := 0; f := true;
  16.   for i := 1 to a do begin
  17.     if (a mod i = 0) then
  18.       с := c + i;
  19.     if (c › k) then begin
  20.       f := false;
  21.       break
  22.     end;
  23.   end;
  24.   Del := f;
  25. end;
  26.  
  27. begin
  28.   Write('Введите порядок матрицы ');
  29.   Readln(n);
  30.   Writeln('Введите элементы матрицы ');
  31.   for i := 1 to n do
  32.     for j := 1 to n do
  33.       Read(a[i, j]);
  34.   Write('Введите k ');
  35.   Readln(k);
  36.   for i := 1 to n do
  37.     for j := 1 to n do
  38.       if Del(a[i, j], k) then
  39.         Sum := Sum + a[i, j];
  40.   Writeln('Сумма элементов ', Sum);
  41. end.

Вот я к сожалению, не

Вот я к сожалению, не разобрался с подпрограммами, и туго понимаю как они работают, люди помогите плиз разобраться с выше приведенным пр. !

Что конкретно тебе не

Что конкретно тебе не понятно, спрашивай, помогу

Ну как я понял, программа и

Ну как я понял, программа и подпрограмма пишутся отдельно, выходит это не так?

так-же ,непонятно как она на

так-же ,непонятно как она на практике будет работать

Описания функций и процедур

Описания функций и процедур обычно размещаются после описания переменных, т.е. после var ... В описании процедур и функций мы реализуем некоторый алгоритм, т.е. то, что должна делать эта процедура или функция. И уже в теле главной программы между begin и end. мы можем вызывать эту функцию и процедуру. Смотри первую программу. После описания переменных я описываю функцию IsSimple. Внутри нее также может быть раздел описаний и обязательно тело begin ... end; Эта функция по моей задумке должна определять простое число или нет. Соответственно в теле функции я реализую алгоритм проверки. Функция всегда возвращает какое-либо значение. В моем случае она возвращает true или false. При вызове функции - IsSimple(i) ей подается значение переменной i. Оно присваивается локальной переменной a и далее идет проверка: а - простое или нет. Если да, то функция возвращает true, иначе false. Про процедуры ты можешь подробно прочитать в новой статье Валерия Шахомболетовича.

Спасибо Наташа

теперь что-то проясняется в моей голове

Косарин! Давайте уже назовём

Косарин! Давайте уже назовём Вас как-то ...

В первой программе

В первой программе проверяются делители от 2 до a-1, но можно проверять до корня квадратного из a.
Теорема:
Если нет делителей до корня(включая корень), то число простое.

Т.о. сложность проверки каждого числа будет O(sqrt(n)), а не O(n)...

А еще можно проверять нечетные числа, только нужно не забыть про двойку....

Число делителей N

"сложность проверки каждого числа будет O(sqrt(n)), а не O(n)..." Математически - да, фактически (по крайней мере, для не очень больших N)- скорее всего нет. Нельзя забывать, что вычисление sqrt(n) - реализационно, свой итерационный процесс, вовлекающий, к тому же, медленную арифметику плавающей точки. Так что, вместо корня лучше уж использовать n div 2. А вообще, с этим интересно бы поэкспериментировать.
Как устроить такую экспериментальную программу?
А насчёт нечётных - безусловно, да.

Как уже заметил В.Ш., я

Как уже заметил В.Ш., я сильно увлеклась парой for и break. В 1-й программе вместо строк 10-18 можно было бы написать:

  1.   f := false;
  2.   i := 2;
  3.   if (a <> 1) then begin
  4.     while (a mod i <> 0) do
  5.       Inc(i);
  6.     if (a = i) then
  7.       f := true
  8.   end;

function IsSimple(a:

  1. function IsSimple(a: Integer): Boolean;
  2. var
  3.   i: Byte;
  4.   f: Boolean;
  5. begin
  6.   f := true;
  7.   if (a > 1) then begin
  8.     for i := 2 to (a div 2) do
  9.       if (a mod i = 0) then
  10.         f := false;
  11.   end else
  12.     f := false;
  13.   IsSimple := f;
  14. end;

А если еще и для нечетных

А если еще и для нечетных учесть, то вот что у меня получилось:

  1. function IsSimple(a: Integer): Boolean;
  2. var
  3.   i, k: Integer;
  4.   f: Boolean;
  5. begin
  6.   f := true;
  7.   i := 3;
  8.   k := a div 2;
  9.   if (a > 1) then begin
  10.     if (a <> 2) then
  11.       if (a mod 2 <> 0) then begin
  12.         while (i <= k) do begin
  13.           if (a mod i = 0) then
  14.             f := false;
  15.           Inc(i, 2);
  16.         end;
  17.       end else
  18.         f := false
  19.   end else
  20.     f := false;
  21.   IsSimple := f;
  22. end;

Можно использовать не sqrt, а

Можно использовать не sqrt, а sqr:

  1. function IsSimple(a: Integer): Boolean;
  2. var
  3.   i: Integer;
  4.   f: Boolean;
  5. begin
  6.   f := true;
  7.   i := 3;
  8.   if (a > 1) then begin
  9.     if (a <> 2) then
  10.       if (a mod 2 <> 0) then
  11.         while (sqr(i) <= a) do begin
  12.           if (a mod i = 0) then begin
  13.             f := false;
  14.             break
  15.           end;
  16.           Inc(i, 2);
  17.         end
  18.       else
  19.         f := false
  20.   end else
  21.     f := false;
  22.   IsSimple := f;
  23. end;

Наташа, вот "корявый" момент,

Наташа,
Вот "корявый" момент, который я не раз замечал в Вашем (и не только в Вашем) коде ...

  1.       f := false;
  2.       ...
  3.       if (a = i) then
  4.                   f := true
  5.  

Это всегда можно заменить на более короткое и эффективное ...
  1.      // Убрали  f := false;
  2.       ...
  3.           f:= (a = i)      
  4.  

А что касается ф -ции IsSimple в её sqr- реализации, то принимая идею как позитивную, всё же замечу, что представленный код довольно небрежен и может быть улучшен.

Да, Вы правы. Я все время

Да, Вы правы. Я все время забываю, что результат "f := (a = i)" булевский.

Как можно улучшить

Как можно улучшить sqr-реализацию у меня пока нет идей, но сделать код более понятным можно:

  1. function IsSimple(a: Integer): Boolean;
  2. var
  3.   i: Integer;
  4.   f: Boolean;
  5. begin
  6. //i - первое нечетное число. Единицу не берем в расчет,
  7. //т.к. на нее делятся все целые числа
  8.   i := 3;
  9.   if (a < 2) then //Отрицательные числа, 0 и 1 не являются простыми
  10.     f := false
  11.   else begin
  12.     if (a = 2) then //2 является простым числом
  13.       f := true
  14.     else
  15.       if (a mod 2 = 0) then //Если а делится на 2, то оно не простое
  16.         f := false
  17.       else
  18.         while (sqr(i) <= a) do begin //Очередной делитель
  19.           if (a mod i = 0) then begin //Если i - делитель, то число не простое
  20.             f := false;
  21.             break;
  22.           end;
  23.           Inc(i, 2); //Следующее нечетное число
  24.         end
  25.   end;
  26.   IsSimple := f;
  27. end;

Наташа,

Три важных принципа, нарушаемых без нужды в Вашем коде:
1. Чем меньше глубина вложенностей, тем легче читать программу (у Вас -5, у меня - 2);
2. Чем меньше if-then-else, тем понятней. Порой лучше пара последовательных if-then, чем один if-then-else (у меня их - ни одного);
3. НЕ ЗЛОУПОТРЕБЛЯЙТЕ оператором break (оставьте лучше его для for-циклов).

И вообще, будьте намного тщательней в кодировании. Вырабатывайте профессиональный стиль. Я замечаю, что положительных сдвигов здесь пока маловато. А жаль. Количество не должно доминировать над качеством.

  1. function IsSimple(a: Integer): Boolean;
  2. var
  3.    i: Word;
  4.    f: Boolean;
  5. Begin
  6.    f := (a=2) or (a=3);
  7.    If (not f) and (a>1) and odd(a) Then Begin
  8.        i:=3;
  9.        While (sqr(i)<=a)
  10.                  and ((a mod i ) <>0)
  11.         do begin
  12.             Inc(i,2)
  13.         End;
  14.         f:= ((a mod i) <>0)
  15.     End;  
  16.     IsSimple:=f
  17. End;

А если быстродействие

А если быстродействие совсем уж критично, ПРЕДЛАГАЮ ...
в последней реализации IsSimple обойтись без ф-ции sqr(i), заменив

  1.        i:=3;
  2.        While (sqr(i)<=a)
  3.                  and ((a mod i ) <>0)
  4.         do begin
  5.             Inc(i,2)
  6.         End;

на ...
  1. //   используем тот факт, что sqr(i+2) =  sqr(i) +4i +4=sqr(i) +4(i+1)  
  2.  
  3.        i:=3;
  4.        isqr:=9; // sqr(3)
  5.        While (isqr <= a)
  6.                  and ((a mod i ) <>0)
  7.         do begin
  8.              Inc(i);
  9.              Inc(isqr, (i shl 2) );
  10.              Inc(i);
  11.          End;

Как думает общество, это будет работать?

Оо если честно, очень неожиданный способ

но самое классное, что работает, правда я проверяла только в ручную, и не доходила до очень больших чисел, но по моим проверкам, програмка работет как часы)) надо будет запомнить способ))

А у меня не работает! В обоих

А у меня не работает! В обоих предложенных Вами вариантах нет проверки делится ли число а на 2. Например, пусть а = 4. Смотрим выполнение функции:

  1. f := (a=2); // f = false
  2. If (not f) and (a>1)  Then Begin // а = 4 проходит это условие
  3.        i:=3;
  4.        While (sqr(i)<=a) // 9<=4 - не верно, while не выполняется
  5.                  and ((a mod i ) <>0)
  6.         do begin
  7.             Inc(i,2)
  8.         End;
  9.         f:= ((a mod i) <>0) // 4 mod 3 <> 0 - верно
  10.     End;  
  11.     IsSimple:=f // IsSimple := true

Получается, что 4 - простое число

А еще если а = 3, то скажет,

А еще если а = 3, то скажет, что 3 не простое число. Потому что while не выполняется и f := 3 mod 3 <> 0 - false! А значит и IsSimple - false!

odd(a), (a=3)

1. Я действительно упустил odd(a), так что пафос Вашего подробно комментированного "разноса" и восклицательные знаки по этому поводу принимаю.
2. Случай, когда a=3, советую Вам внимательней рассмотреть (именно, рассмотреть, а не протестировать!) в Вашем собственном решении, которое я, не перепроверив, в иной форме и воспроизвёл.
Обе эти помарки мною исправлены.
Принимая Ваши замечания, я всё же удивлён, что то главное, концептуальное, на что были направлены мои комментарии у Вас не вызвало ни мыслей, ни вопросов, ни интереса - полный игнор.

Даже не знаю, что Вам

Даже не знаю, что Вам сказать, я очень удивлена. Я не собиралась устраивать Вам какой-либо разнос. Действительно, в последней предоставленной мной функции 3 выпадает из поля зрения. В предыдущей учитывается. А полный игнор лишь потому что у меня банально хватало времени только на то, чтобы обновить страницу и быстро пробежать глазами новые сообщения, не вникая. Вчера у меня появилось время. Ваши идеи вне сомнения хороши и они вызвали у меня и мысли, и интерес. И мои "пафосные" комментарии как раз свидетельствуют о том, что я не осталась равнодушной.

Повторюсь, этот сайт для вас.

Друзья мои, повторюсь, этот сайт не для меня, для вас.
Он об основах, а для тех, кто их более менее постиг, о тонкостях нашей профессии.
Любая задача, любая программа, появляющаяся здесь - это прежде всего тема для размышлений, повод что-то открыть для себя, может быть что-то где-то почитать, поэкспериментировать у компьютера, поискать варианты, оценить и выбрать из них наилучший. И во всём этом - я вам добровольный, круглосуточный помощник. И смею рассчитывать - вы мне тоже. Но пока не складывается.
Вот, только в последней задаче, два никем не подхваченных момента, которые по своей значимости достойны, на мой взгляд, не менее подробного освещения, чем вызвавшая неподдельно живой отклик "сенсация" в форме тривиального бага в коде "самого учителя".
1. Вопрос в моём комментарии к варианту решения данной задачи от 25.01.10 : " ... с этим интересно бы поэкспериментировать. Как устроить такую экспериментальную программу? " так и повис в воздухе. Показался не интересным, не был понят? Не знаю.
2. Поcледнее моё предложение о возможном способе исключения ф-ции sqr(i) так же не получило какого либо конструктивного обсуждения. Повышает данный приём быстродействие или нет, если да, то на сколько, в каких случаях, в каких единицах и как это подсчитать? Для пытливого ума - вопросов тьма!
И примеров незаинтересованности аудитории в подобных вопросах, выводящих далеко за рамки конкретной задачи и, собственно и составляющих суть профессии, скопилось на этом сайте уже немало. Здесь есть над чем подумать и вам и мне.

Вопрос про экспериментальную

Вопрос про экспериментальную программу мною не был понят. В чем конкретно состоит эксперимент? В использовании а div 2? Такая функция расположена выше. И она работала за то же время, что и sqr-реализация без проверки только нечетных.
P.S. Еще раз повторюсь в надежде Вас все-таки убедить, что я не устраивала никакой сенсации, не испытываю ни малейшей радости и удовлетворения от нахождения "тривиального бага в коде "самого учителя"". Восклицательные знаки и подробное комментирование присутствовали, потому что выше было сказано, что программа работает как часы.

В том моём вопросе про

В том моём вопросе про эксперимент противопоставлялись два метода - с использованием sqrt (и как я там отметил, с внутренним циклом по вычислению корня) и с использованием div 2. Эксперимент мог бы состоять в программе, где запускаются оба метода на очень большом количестве случайно (или последовательно) генерируемых в автоматическом режиме данных и сравниваются, например усреднённые результаты собранной временнОй статистики по обоим методам. Идеально было бы оформить результаты в виде графика (например, зависимости времени от x). Польза такой работы не ограничена конкретно этой задачей, а состоит в отработке общей методики подобных экспериментов.

Для того, чтобы понять как

Для того, чтобы понять как производить временнЫе замеры, можно посмотреть, например, это

Статья ооочень интересная, да

Статья ооочень интересная, да и сайт в целом тоже. :) Но писал ее явно не русский человек. "цыкл", "компютер", "обявить" ))))
А где график делать? В Exel? И куда его потом разместить, чтобы дать на него ссылку?

Если грубо, то при a,b,c -

Если грубо, то при a,b,c - LongInt и при дополнительном модуле Windows :

a := gettickcount;
замеряемый по времени код
b := gettickcount;
c := b-a; // время в миллисекундах

)

)

наташе

Я написала, что программа работает ка часы, имея ввиду конкретно указанные два кусочка, а точнее, что чем можно заменить, мне показалось необычным, и я выразила своё мнение конкретно по этому участку, видимо то, что я не уточнила, привело к этому казусу, извини. В следующий раз буду проверять и вышеизложенные, а не конкретно то, что заинтересовало))

В статье "Линейная

В статье "Линейная сортировка" Акатовым Алексеем было показано как замерять время с помощью gettickcount.

Кате

Это ты меня прости. И тебя втянула... Давайте уже закроем эту тему...

program Simple2;   {$APPTYPE

  1. program Simple2;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.   SysUtils, Windows;
  7. var
  8.   m, n, i: LongInt;
  9.   Start, Time1, Time2: Cardinal;
  10.  
  11. function IsSimple1(a: LongInt): Boolean;
  12. var
  13.   i: Word;
  14.   f: Boolean;
  15. Begin
  16.   f := (a = 2) or (a = 3);
  17.   If (not f) and (a > 1) and odd(a) Then Begin
  18.     i := 3;
  19.     While ( i < (a div 2) ) and ((a mod i ) <> 0) do begin
  20.       Inc(i, 2);
  21.     End;
  22.     f := ((a mod i) <> 0)
  23.   End;
  24.   IsSimple1 := f
  25. End;
  26.  
  27. function IsSimple2(a: LongInt): Boolean;
  28. var
  29.   i, isqr: Word;
  30.   f: Boolean;
  31. Begin
  32.   f := (a = 2) or (a = 3);
  33.   If (not f) and (a > 1) and odd(a) Then Begin
  34.     i := 3;
  35.     isqr := 9;
  36.     While (isqr<a) and ((a mod i ) <> 0) do begin
  37.       Inc(i);
  38.       Inc(isqr, (i shl 2));
  39.       Inc(i);
  40.     End;
  41.     f := ((a mod i) <> 0)
  42.   End;
  43.   IsSimple2 := f
  44. End;
  45.  
  46. begin
  47.   Readln(m, n);
  48.   Start := GetTickCount;
  49.   for i := m to n do
  50.     if IsSimple1(i) then
  51.       Write(i, ' ');
  52.   Writeln;
  53.   Time1 := GetTickCount - Start;
  54.   Start := GetTickCount;
  55.   for i := m to n do
  56.     if IsSimple2(i) then
  57.       Write(i, ' ');
  58.   Writeln;
  59.   Time2 := GetTickCount - Start;
  60.   Writeln(Time1);
  61.   Writeln(Time2);
  62.   Writeln(abs(Time1 - Time2));
  63.   Readln;
  64. end.

Результаты впечатляют. Полная победа sqr-реализации над div-реализацией. Только вот я не пойму почему при одних и тех же исходных данных, например, диапазон от -50000 до 50000, выдаются разные ответы:
Time1 = 813
Time2 = 172
Разница: 641
Time1 = 828
Time2 = 172
Разница: 656
Time1 = 812
Time2 = 156
Разница: 656
и т.д.

Да, неплохо. Правда, Вы

Да, неплохо. Правда, Вы упустили то, что наиболее интересно - sqrT (именно там внутренний цикл ), а заодно - sqr. Можно было бы сделать вывод в виде таблицы, где показаны все рассмотренные здесь варианты ограничения перебора.

Что-то я не пойму о чем Вы

Что-то я не пойму о чем Вы говорите. Замерять время внутри функции без цикла for и самого вызова функции?

И снова возвращаю Вас к

И снова возвращаю Вас к замечанию Каспарьяна М. по поводу Вашего кода и моему комменту на это замечание от Пнд, 25/01/2010 - 09:21.
Там речь идёт об ограничении цикла For
не таким (Вы предложили):

  1.  
  2. For i:=2 to a-1 do ...

а математически более быстрым вот таким (Каспарьян предложил) способом:
  1.  
  2. For i:=2 to trunc(sqrt(a))+1 do ...

Так вот, там я выдвинул гипотезу о том, что второй ("быстрый") метод на практике может оказаться медленней чем первый.
Действительно, внутренний процесс вычисления стандартной ф-ции sqrt(a) (в который мы конечно же не вмешиваемся!) по-видимому содержит свой итерационный цикл (например, реализованный как вычисления по формулам Ньютона, - их мы рассматривали в нашем курсе "Программирование"), а так же арифметику плавающей точки. Поэтому, при этом методе, в конечном счёте, получаем цикл в цикле (в решаемой задаче a ведь тоже меняется), да ещё с медленной арифметикой.
И в своём том комменте я всего лишь просил экспериментально подтвердить или опровергнуть эту гипотезу.
Вы же не стали этого делать, проверив только самое последнее моё предложение (не использующее ни функции sqrt(x), ни функции sqr(x) ).
Если всё ещё не понятно, то давайте оставим это.

Пусть ... type   TElem =

Пусть

  1. ...
  2. type
  3.   TElem = LongInt;
  4. ...
  5. function IsSimple3(a: TElem): Boolean;
  6. var
  7.   i: TElem;
  8.   f: Boolean;
  9. Begin
  10.   f := (a >= 2);
  11.   if (a > 2) then
  12.     for i := 2 to trunc(sqrt(a)) + 1 do
  13.       if (a mod i = 0) then begin
  14.         f := false;
  15.         break;
  16.       end;
  17.   IsSimple3 := f
  18. End;
  19.  
  20. function IsSimple4(a: TElem): Boolean;
  21. var
  22.   i: TElem;
  23.   f: Boolean;
  24. Begin
  25.   f := (a = 2) or (a = 3);
  26.   If (not f) and (a > 1) and odd(a) Then Begin
  27.     i := 3;
  28.     While (sqr(i)<a) and ((a mod i ) <> 0) do begin
  29.       Inc(i,2)
  30.     End;
  31.     f := ((a mod i) <> 0)
  32.   End;
  33.   IsSimple4 := f
  34. End;
  35.  
  36. function IsSimple5(a: TElem): Boolean;
  37. var
  38.   i: TElem;
  39.   f: Boolean;
  40. Begin
  41.   f := false;
  42.   i := 2;
  43.   if (a > 1) then begin
  44.     while (a mod i <> 0) do
  45.       Inc(i);
  46.     f := (a = i)
  47.   end;
  48.   IsSimple5 := f
  49. End;

Тогда результат в промежутке от 1 до 300 000:
IsSimple1: 18703 мс
IsSimple2: 1063 мс
IsSimple3: 1187 мс
IsSimple4: 1032 мс
IsSimple5: 67906 мс!!!
Каждое значение варьируется на этом промежутке в пределах 40-ка миллисекунд.
Причем, время выполнения IsSimple2 и IsSimple4 можно считать равным, иногда они совпадают, а иногда несколько различаются.
От 1 до 1 000 000:
IsSimple1: 177360
IsSimple2: 3734
IsSimple3: 4484
IsSimple4: 3719
IsSimple5: 661406

Ну, вот это уже действительно

Ну, вот это уже действительно интересно ...

Получается, что на время

Получается, что на время выполнения могут повлиять другие процессы? Например, я запустила в Delphi выполнение этой программы и во время выполнения включаю AIMP (проигрыватель). Время выполнения увеличивается?
Еще во время тестирования у меня случалась непонятная ситуация. Простые числа выводятся на экран и когда дело доходит до 64 тысячи с лишним, на несколько секунд вывод останавливается, потом дальше идет. В итоге получалась "незаконная", неправдоподобно огромная разница между IsSimple2 и IsSimple3. Потом я еще неоднократно изменяла программу и такого больше не повторялось.

Говоря что это интересно, я

Говоря что это интересно, я имею ввиду наличие здесь не до конца понятых (по-крайней мере, мною) моментов, которые заслуживают дальнейшего изучения. Но это - уже за пределами формата данного сайта.
Поведение на границе 64000 я объяснить не могу, а насчёт влияния параллельных процессов, думаю, вряд ли. Но опять же, нетрудно спланировать и провести соответствующие эксперименты.
Аккуратная доводка этих вопросов вполне могла бы быть предметом доклада "О временной сложности Delphi-реализаций алгоритмов распознавания простых чисел" на нашей традиционной апрельской студ. научной конференции.

Нет, все-таки параллельные

Нет, все-таки параллельные процессы влияют, по крайней мере, на моем ПК. Он довольно старенький уже. Более 5-ти лет без апгрейда. Я добилась очень интересных результатов.
От 1 до 100000 без активного использования других программ, некоторое количество все же включено (Касперский, Free Download Manager, Mozilla Firefox, Mozilla Thunderbird, ну и какие-то системные):
IsSimple1: 2671
IsSimple2: 375
IsSimple3: 438
IsSimple4: 359
IsSimple5: 9016
Опять запускаю выполнение на том же промежутке и резко включаю Total Commander, Opera, AIMP, RadioSure, OpenOffice.org Writer, Google Chrome. Получаю результаты:
IsSimple1: 5703
IsSimple2: 19141 (видимо, на нее пришелся пик моих включений :) )
IsSimple3: 1047
IsSimple4: 265 (этот результат тоже очень интересен)
IsSimple5: 18954

И мне также интересно какие

И мне также интересно какие моменты не были Вами поняты. Я могу по этому поводу на сайте ничего не размещать, если это выходит за его рамки, но сама поразбираться.

Это хорошие

Это хорошие эксперименты.
Слишком длинное обсуждение. Потерпите до начала занятий.

Здравствуйте Валерий

Здравствуйте Валерий Шахамболетович, нам вот на ОСМ предложили написать программу для нахождения булевой функции многочлена А состоящего из 100 элементов. Ломаю голову вот уже несколько часов и так толком не чего не придумал не могли бы вы навести на мысль.

Здравствуйте, Александр!

Постановка задачи не корректна. Совершенно не понятно, что такое многочлен булевой функции, да к тому же
соостоящий из 100 элементов(!!!??).
А вообще, давайте не будем спешить ...