hodza/BlackBox.Shkola.2014 huggingface dataset:
i21диал/Mod/Флажки2.odc

(* Флажки [Check box], связанные с SET. 
Данный диалог может быть частью диалога ввода данных для базы данных школьников. *)

MODULE  i21диалФлажки2;
	IMPORT  StdLog, Dialog;

	CONST  прог = 0;  матем = 1;  англ = 2;  худож = 3;  муз = 4;

	VAR  доп_занятия*: SET;
	
	PROCEDURE Напечатать*;
		VAR  i: INTEGER;
	BEGIN
		IF  доп_занятия # {}  THEN
			StdLog.String('дополнительные занятия:');  StdLog.Ln;
			FOR  i := 0  TO  4  DO
				IF  i IN доп_занятия  THEN
					CASE  i  OF
					прог:
						StdLog.Tab;  StdLog.String('программирование');  StdLog.Ln
					|матем:
						StdLog.Tab;  StdLog.String('математика');  StdLog.Ln
					|англ:
						StdLog.Tab;  StdLog.String('английский язык');  StdLog.Ln
					|худож:
						StdLog.Tab;  StdLog.String('художественная школа');  StdLog.Ln
					|муз:
						StdLog.Tab;  StdLog.String('музыкальная школа');  StdLog.Ln
					END
				END
			END
		ELSE
			StdLog.String('дополнительных занятий не посещает');  StdLog.Ln;
		END
	END Напечатать;
	
BEGIN
END  i21диалФлажки2.

Создание диалога:
Диалоги, Новая форма... , в текстовом поле напечатать i21диалФлажки2, OK.
Сдвигая кнопку вправо вниз и выполняя Разметка, Пересчитать размер, увеличить размер поля до нужного.
Для каждого вида доп. занятий сделать:
	Диалоги, Вставить флажок, 
	оттащить в нужное место,
	если нужно, воспользоваться командой Разметка, Пересчитать размер.
	Правый клик, Свойства (или левый клик, затем нажать Alt+Enter)
	заполнить поля:
		Связан с: i21диалФлажки2._,
		Ярлык: соотв. текст,
		Уровень: указать соотв. целое значение.
	OK.
	Растянуть, чтобы был виден текст. 
После того, как это проделано для каждого вида занятий, сохранить форму в файл и закрыть.

"StdCmds.OpenAuxDialog('i21диал/Rsrc/Флажки2','SET')"

Открыть форму для модификации:
"StdCmds.OpenDoc('i21диал/Rsrc/Флажки2')"
i21егэ/Mod/Demo2010C4en.odc

MODULE i21егэDemo2010C4en;  
(* не проверено по УСЛОВИЮ; русский вариант; см. инструкции в конце документа *)
	IMPORT  Log := StdLog,  In := i21sysIn,  Math;
	
	VAR  
		минЦена, сколько: ARRAY 3 OF INTEGER;
		осталось, i, марка, цена: INTEGER;  
		x: ARRAY 21 OF CHAR;
		
BEGIN
	FOR i := 0 TO 2 DO
		минЦена[ i ] := 3001;  сколько[ i ] := 0
	END;

	In.Open;
	In.Int( осталось );
	WHILE осталось > 0 DO
		In.String( x );  In.String( x ); (* пропускаем пару цепочек в данных *)

		In.Int( марка );
		IF  марка = 92  THEN  марка := 0
		ELSIF  марка = 95  THEN  марка := 1
		ELSE  марка := 2
		END;

		In.Int( цена );  ASSERT( (цена >= 1000) & (цена <= 3000) );

		IF цена < минЦена[ марка ] THEN
			минЦена[ марка ] := цена;
			сколько[ марка ] := 1
		ELSIF цена = минЦена[ марка ] THEN
			сколько[ марка ] := сколько[ марка ] + 1
		END;
		осталось := осталось - 1;
	END;

	Log.Int( сколько[0] );
	Log.Int( сколько[1] );
	Log.Int( сколько[2] );
	Log.Ln;
END i21егэDemo2010C4en.


Выделить мышкой входные данные и нажать Ctrrl+F9

 2
aaa bbb 92 2000
ccc dddd 95 2001

---------
Справкапоучебномувводу-выводу
i21егэ/Mod/Demo2010C4ru.odc

МОДУЛЬ i21егэDemo2010C4ru;
(* не проверено по УСЛОВИЮ; англ. вариант; см. инструкции в конце документа *)
(* см. также Использованиенеанглийскихключевыхслов *)
	ПОДКЛЮЧИТЬ  Вывод := i21eduВывод,  Ввод := i21eduВвод;
	
	ПЕРЕМЕННЫЕ  осталось, i, марка, цена: ЦЕЛЫЕ;
		минЦена, сколько: МАССИВ 3 ИЗ ЦЕЛЫХ;  x: МАССИВ 21 ИЗ ЛИТЕР;
		
НАЧАЛО
	ДЛЯ  i := 0  ДО  2  ДЕЛАТЬ
		минЦена[ i ] := 3001;  сколько[ i ] := 0
	КОНЕЦ;

	Ввод.Открыть;
	Ввод.Цел( осталось );
	ПОКА осталось > 0 ДЕЛАТЬ
		Ввод.Цепочка( x );  Ввод.Цепочка( x ); (* пропускаем пару цепочек в данных *)

		Ввод.Цел( марка );
		ЕСЛИ  марка = 92  ТО  марка := 0
		АЕСЛИ  марка = 95  ТО  марка := 1
		ИНАЧЕ  марка := 2
		КОНЕЦ;

		Ввод.Цел( цена );  УБЕДИТЬСЯ( (цена >= 1000) & (цена <= 3000) );

		ЕСЛИ цена < минЦена[ марка ] ТО
			минЦена[ марка ] := цена;
			сколько[ марка ] := 1
		АЕСЛИ цена = минЦена[ марка ] ТО
			сколько[ марка ] := сколько[ марка ] + 1
		КОНЕЦ;
		осталось := осталось - 1
	КОНЕЦ;

	Вывод.Цел( сколько[0] );
	Вывод.Цел( сколько[1] );
	Вывод.Цел( сколько[2] );
	Вывод.НовСтрока;
	
КОНЕЦ i21егэDemo2010C4ru.


Выделить мышкой данные и нажать Ctrrl+F9:


 2
aaa bbb 92 2000
ccc dddd 95 2001

---------------
Справкапоучебномувводу-выводу
i21егэ/Mod/Demo2010C4плохо.odc

(* то же, что и i21егэDemo2010C4, но без отступов и без пустых строк *)
MODULE i21егэDemo2010C4плохо;  
IMPORT  Log := StdLog,  In := i21sysIn,  Math;
VAR минЦена, сколько: ARRAY 3 OF INTEGER;
n, i, марка, цена: INTEGER;  
x: ARRAY 21 OF CHAR;
BEGIN
FOR i := 0 TO 2 DO  минЦена[ i ] := 3001;  сколько[ i ] := 0  END;
In.Open;
In.Int( n );
FOR  i := 1  TO  n  DO  In.String( x );  In.String( x );
In.Int( марка );
IF  марка = 92  THEN  марка := 0
ELSIF  марка = 95  THEN  марка := 1
ELSE  марка := 2
END;
In.Int( цена );  ASSERT( (цена >= 1000) & (цена <= 3000) );
IF цена < минЦена[ марка ] THEN
минЦена[ марка ] := цена;
сколько[ марка ] := 1
ELSIF цена = минЦена[ марка ] THEN
сколько[ марка ] := сколько[ марка ] + 1
END
END;
Log.Int( сколько[0] );
Log.Int( сколько[1] );
Log.Int( сколько[2] );
Log.Ln;
END i21егэDemo2010C4плохо.


Выделить мышкой входные данные и нажать Ctrrl+F9


 2
aaa bbb 92 2000
ccc dddd 95 2001
i21прим/Docu/ru/Тетрис.odc

i21примерыТетрис

DEFINITION i21примерыТетрис;

	IMPORT Views, Stores, Models, Ports;

	PROCEDURE НоваяИгра;

END i21примерыТетрис.


Управление игрой:

	Esc  начать/остановить игру.
	Стрелка влево/вправо (или цифры 4/6)  сдвинуть фигурку влево/вправо.
	Стрелка вниз/пробел  сбросить фигурку.
	Стрелка вверх/5  повернуть фигурку.

i21примерыТетрис.НоваяИгра  кликнуть по коммандеру, чтобы начать игру.
i21прим/Docu.Пошаговая разработка/0. Пошаговая разработка.odc

0. Пошаговая разработка программ: Обзор


Упоминаемые ниже документы можно использовать в качестве введения в программирование на Компонентном Паскале в системе Блэкбокс для тех, кто уже умеет программировать на старом Паскале и знаком с общими принципами работы в системе MS Windows  например, для учителей информатики.

Ниже даются ссылки на несколько подробных примеров разработки простых программ методом пошагового уточнения (еще говорят о пошаговой детализации, по английски step-wise refinement; термин введен Н.Виртом в классической статье Program development by step-wise refinement в 1971 г.).

Предполагается, что идеи алгоритмов в общем известны. Речь идет лишь об их реализации на языке Компонентный Паскаль в системе Блэкбокс. В частности, в первом примере подробно объясняются технические детали работы в Блэкбоксе.

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

Рекомендуется изучать примеры, начиная с первого, т.к. он самый подробный. Лучше всего изучать примеры, повторяя описанные там действия в новом документе (Ctrl+N; см. пояснения в первом примере).

1.Сортировкавставками
2.Пузырьковаясортировка
3.Простыечисла
4.Уплотнениесимвольногомассива

Полезная информация о программировании в системе Блэкбокс содержится в документе Полезныесведения.


Общие замечания

По необходимости последовательные варианты модуля помещаются прямо в тексте описания, хотя в реальной разработке модифицируется один и тот же документ.

Не оговаривается необходимость периодического сохранения файла (достаточно нажимать Strl+S; хотя сам Блэкбокс в высшей степени надежен, сбой операционной системы может быть вызван другими программами).
Полезно сохранять промежуточные варианты программы с другими именами (например, добавляя последовательные номера в конце имени файла). Для этого имеется удобная команда меню Файлы --> Сохранить копию как ... (Files --> Save Copy As ...).

В каждой очередной версии модуля вновь добавленные или измененные куски текста показаны зеленым цветом.
i21прим/Mod/Files.odc

(** Пример использования модуля i21eduFiles **)

MODULE  i21примFiles;
	IMPORT  StdLog,  Files := i21eduFiles;

	PROCEDURE Создаем* ( a: ARRAY OF CHAR; n: INTEGER );
	BEGIN
		Files.New( a$ );
		Files.WriteString( a$ );
		Files.WriteString( 'Информатика-21' );
		Files.WriteInt( n );
		Files.WriteReal( 3.141592 );
		Files.WriteChar( 's' );
		Files.Close (* это нельзя забывать! а то модуль i21eduFiles будет ругаться *)
	END Создаем;

	PROCEDURE Читаем* ( a: ARRAY OF CHAR );
		VAR  i: INTEGER;  x: REAL;  c: CHAR;  s: ARRAY 1000 OF CHAR;
	BEGIN
		StdLog.Ln;
		Files.Open( a$ );
		(* читаем точно в том же порядке *)
		Files.ReadString( s );   	StdLog.String( s );	StdLog.Ln;
		Files.ReadString( s );   	StdLog.String( s ); 	StdLog.Ln;
		Files.ReadInt( i );  	StdLog.Int( i );  	StdLog.Ln;
		Files.ReadReal( x );   	StdLog.Real( x );  	StdLog.Ln;
		Files.ReadChar( c );   	StdLog.Char( c );  	StdLog.Ln;
		Files.Close; (* это нельзя забывать! а то модуль i21eduFiles будет ругаться *)
		StdLog.Ln
	END Читаем;

	PROCEDURE Стираем* ( a: ARRAY OF CHAR );
		VAR  i: INTEGER;  x: REAL;  c: CHAR;  s: ARRAY 1000 OF CHAR;
	BEGIN
		(* прежде чем создать новый файл с тем же именем, нужно старый стереть явной командой *)
		Files.Delete( a )
	END Стираем;

END  i21примFiles.

Для выполнения процедур кликать по черным коммандерам:

"i21примFiles.Стираем('test5.DAT')"
"i21примFiles.Создаем('test5.DAT',106)"
"i21примFiles.Читаем('test5.dat')"


Выгрузка двух модулей в правильном порядке:
DevDebug.UnloadThis  i21примFiles i21eduFiles

Компиляция двух модулей в правильном порядке:
DevCompiler.CompileThis  i21eduFiles i21примFiles
i21прим/Mod/In with global done.odc

MODULE  i21примIn;
(* Примеры передачи входных параметров в процедуру с помощью средств модуля i21sysIn. *)

	IMPORT  StdLog, In := i21sysIn; (* конструкция In := ... вводит сокращенное имя In для использования в данном модуле; длинные имена модулей встречаются нередко, для них удобно вводить короткие псевдонимы *)
	
	PROCEDURE ПростоПечать ( x: REAL; i: INTEGER; a: ARRAY OF CHAR ); (* эту процедуру нельзя вызвать с помощью коммандера *)
	BEGIN
		StdLog.Real( x );  StdLog.Ln;
		StdLog.Int( i );  StdLog.Ln;
		StdLog.String( a );  StdLog.Ln;
	END ПростоПечать;

	PROCEDURE Пример1*; (* вспомогательная интерфейсная процедура для ввода данных для Процедура *)
		VAR   x: REAL;  i: INTEGER;  a: ARRAY 1000 OF CHAR;
	BEGIN
		In.Open;  (* открываем входной поток *)
		ASSERT( In.Done ); (* проверяем, что все нормально *)
		In.Real( x );  ASSERT( In.Done ); (* читаем значение для x; проверяем *)
		In.Int( i );  ASSERT( In.Done );
		In.String( a );  ASSERT( In.Done );

		ПростоПечать( x, i, a )  (* вызываем тестируемую процедуру с нужными параметрами *)
	END Пример1;

END  i21примIn.

При клике по черному коммандеру будут считаны данные, отмеченные синим:
i21примIn.Пример1 3.14 2002 "цепочка литер"

Черный треугольник закрывает поток ввода, он вставляется посредством Ctrl+Shift+Q

Результаты (копия считанных данных) можно видеть в рабочем журнале.
Можно данные менять и снова кликать по левому коммандеру.

Если цепочка литер не содержит пробелов и других специальных символов, то можно опустить кавычки., например: 2.718 2008 информатика -- выделить синий текст мышкой, кликнуть по коммандеру выше -- и посмотреть в Рабочем журнале, что вышло.
i21прим/Mod/In.odc

MODULE  i21примIn;
(* Примеры передачи входных параметров в процедуру с помощью средств модуля i21sysIn. *)

	IMPORT  StdLog, In := i21eduIn; (* конструкция In := ... вводит сокращенное имя In для использования в данном модуле; длинные имена модулей встречаются нередко, для них удобно вводить короткие псевдонимы *)
	
	PROCEDURE ПростоПечать ( x: REAL; i: INTEGER; a: ARRAY OF CHAR ); (* эту процедуру нельзя вызвать с помощью коммандера *)
	BEGIN
		StdLog.Real( x );  StdLog.Ln;
		StdLog.Int( i );  StdLog.Ln;
		StdLog.String( a );  StdLog.Ln;
	END ПростоПечать;

	PROCEDURE Пример1*; (* вспомогательная интерфейсная процедура для ввода данных для Процедура *)
		VAR   done: BOOLEAN;  x: REAL;  i: INTEGER;  a: ARRAY 1000 OF CHAR;
	BEGIN
		In.Open( done );  (* открываем входной поток *)
		ASSERT( done ); (* проверяем, что все нормально *)
		In.Real( x, done );  ASSERT( done ); (* читаем значение для x; проверяем *)
		In.Int( i, done );  ASSERT( done );
		In.String( a, done );  ASSERT( done );

		ПростоПечать( x, i, a )  (* вызываем тестируемую процедуру с нужными параметрами *)
	END Пример1;

END  i21примIn.

При клике по черному коммандеру будут считаны данные, отмеченные синим:
i21примIn.Пример1 3.14 2014 "цепочка литер"

Черный треугольник закрывает поток ввода, он вставляется посредством Ctrl+Shift+Q

Результаты (копия считанных данных) можно видеть в рабочем журнале.
Можно данные менять и снова кликать по левому коммандеру.

Если цепочка литер не содержит пробелов и других специальных символов, то можно опустить кавычки., например: 2.718 2022 информатика -- выделить синий текст мышкой, кликнуть по коммандеру выше -- и посмотреть в Рабочем журнале, что вышло.
i21прим/Mod/Random.odc

MODULE  i21примRandom;
	IMPORT  Log := StdLog,  Ran := i21eduRandom;
	
	PROCEDURE Do*;
		VAR  i, N: INTEGER;  s, x: REAL;
	BEGIN
		(* печатаем несколько случайных целых чисел из диапазона 0..9 *)
		FOR  i := 1  TO  10  DO
			Log.Int( Ran.Int( 10 ) );  Log.Ln
		END;
		Log.Ln;

		(* печатаем несколько случайных вещественных чисел из сегмента 0..1 *)
		FOR  i := 1  TO  10  DO
			Log.Real( Ran.Real() );  Log.Ln
		END;
		Log.Ln;

		(* вычисляем интеграл функции 3*x*x от 0 до 1 методом Монте Карло *)
		N := 1000000;
		s := 0;
		FOR  i := 1  TO  N  DO
			x := Ran.Real();
			s := s + 3*x*x
		END;
		s := s / N;
		(* должно получиться примерно 1: *)
		Log.Real( s );  Log.Ln;
		Log.Ln;

		(* чтобы последовательность чисел можно было воспроизвести, нужно вначале сделать специальный вызов *)
		Ran.InitSeed( 99 );  (* аргумент  любое целое значение, от его выбора зависит конкретная получающаяся последовательность *)
		FOR  i := 1  TO  10  DO
			Log.Int( Ran.Int( 10 ) );  Log.Ln
		END;
		Log.Ln;

	END Do;
	
END  i21примRandom.

Для выполнения примера кликнуть по черному коммандеру:
i21примRandom.Do
i21прим/Mod/StdLog.odc

MODULE  i21примStdLog;
	IMPORT  Math,
		Log := StdLog; (* Можно вводить сокращенный псеводним для любого импортируемого модуля (у них нередко длинные имена). Тогда вместо полного имени нужно указывать псевдоним во всех обращениях к нему в данном модуле.
		Чтобы открыть описание модуля StdLog, нужно дважды кликнуть по имени и вызвать команду меню Инфо, Документация *)
	
	PROCEDURE Делать*; (* звездочка после имени нужна, чтобы сделать процедуру видимой извне данного модуля -- иначе ее не выполнить с помощью коммандера или меню *)
		VAR  i: INTEGER;  x: REAL;  
			a, b, c: ARRAY 10 OF CHAR;
			s: SET;
	BEGIN
		Log.Ln; (* переход на новую строчку *)
		Log.Char("'"); (* печать одной литеры -- одиночной кавычки *)
		Log.Real( Math.Pi() ); (* печать вещественного числа *)
		Log.Char("'");  
		Log.Ln;
		
		Log.String("Блэкбокс'"); (* печать цепочки литер *)
		Log.Ln;
		
		Log.Tab; (* символ табуляции *)
		Log.Char( 201CX );  Log.Char( 201DX ); (* пара кавычек -- литеры можно задавать в 16-ричном виде *)
		Log.Ln
	END Делать;
	
END  i21примStdLog.

Для выполнения примера кликнуть по черному коммандеру:
i21примStdLog.Делать
i21прим/Mod/Вставки.odc

MODULE  i21примВставки;
	IMPORT  StdLog, In := i21sysIn;
	
	PROCEDURE Вставить ( VAR a: ARRAY OF INTEGER;  i: INTEGER );
		VAR  t: INTEGER;
	BEGIN
		IF  a[i] < a[i-1]  THEN
			t := a[i];  a[i] := a[i-1];  a[i-1] := t;
			IF  i - 1 # 0  THEN
				Вставить( a, i - 1 )
			END;
		END;
	END Вставить;

	PROCEDURE Сорт* ( VAR a: ARRAY OF INTEGER );
		VAR  i: INTEGER;
	BEGIN
		FOR  i := 1  TO  LEN(a) - 1  DO
			Вставить( a, i )
		END;
	END Сорт;
	
	PROCEDURE Демо*;
		VAR  x, n: INTEGER;  a: POINTER TO ARRAY OF INTEGER;
	BEGIN  In.Open;  n := 0;  In.Int( x );
		WHILE  In.Done  DO
			INC( n );  In.Int( x )
		END;
		NEW( a, n );
		In.Open;  n := 0;  In.Int( x );
		WHILE  In.Done  DO
			a[n] := x;  INC( n );  In.Int( x )
		END;
		Сорт( a );
		FOR  n := 0  TO  LEN(a) - 1  DO
			StdLog.Int( a[n] )
		END;
	END Демо;
	
END  i21примВставки.


Для выполнения процедуры кликнуть по черному круглому коммандеру:
i21примВставки.Демо  2 0 90 11 -4 8
i21прим/Mod/Простые.odc

MODULE  i21примПростые;
	IMPORT Math;
	
	PROCEDURE Простое* ( n: INTEGER ): BOOLEAN;
		VAR  кандидат: INTEGER;  корень: REAL;
	BEGIN
		кандидат := 2;
		корень := Math.Sqrt( n );
		WHILE  (кандидат <= корень) & ~( (n MOD кандидат) = 0 )  DO
			кандидат := кандидат + 1
		END;		
		RETURN  ~(кандидат <= корень)
	END Простое;
	
END  i21примПростые.
i21прим/Mod/ПростыеЧисла(Ру).odc

МОДУЛЬ  i21примПростыеЧисла;
	ПОДКЛЮЧИТЬ  Вывод := i21eduВывод,  Math;
	
	ПРОЦЕДУРА НеДелит ( i, n: ЦЕЛАЯ ): ЛОГИЧЕСКОЕ;
	НАЧАЛО
		ВЕРНУТЬ  ( n MOD i ) # 0
	КОНЕЦ НеДелит;

	ПРОЦЕДУРА Простое* ( n: ЦЕЛАЯ ): ЛОГИЧЕСКОЕ;
		ПЕРЕМЕННЫЕ  i, мин, макс: ЦЕЛАЯ;
	НАЧАЛО
		(* проверка разрешенного значения параметра на входе *)
		УБЕДИТЬСЯ( n > 1, 20 );

		(* диапазон потенциальных делителей *)
		мин := 2;
		макс := SHORT( ENTIER( Math.Sqrt( n ) ) );

		(* цикл поиска наименьшего делителя *)
		i := мин;
		ПОКА  ( i <= макс ) & НеДелит( i, n )  DO
			INC( i )
		КОНЕЦ;

		ВЕРНУТЬ  i > макс  (* прошли все возможности -- делителя не нашли *)
	КОНЕЦ Простое;
	
	ПРОЦЕДУРА КоличПростыхДо* ( n: ЦЕЛАЯ ): ЦЕЛАЯ;
		ПЕРЕМЕННЫЕ  i, k: ЦЕЛЫЕ;
	НАЧАЛО
		k := 0;
		ДЛЯ  i := 2  TO  n - 1  DO
			ЕСЛИ  Простое( i )  ТО
				INC( k )
			КОНЕЦ
		КОНЕЦ;
		ВЕРНУТЬ  k
	КОНЕЦ КоличПростыхДо;

	ПРОЦЕДУРА Показать* ( n: ЦЕЛАЯ );
	НАЧАЛО
		Вывод.НовСтрока;  Вывод.Цепочка("Число ");  Вывод.Цел( n ); 
		ЕСЛИ  ~Простое( n )  ТО
			Вывод.Цепочка(" не")
		КОНЕЦ;
		Вывод.Цепочка(" является простым.");  Вывод.НовСтрока;
		Вывод.Цел( КоличПростыхДо( n ) );  
		Вывод.Цепочка(" простых, меньших ");  
		Вывод.Цел( n );  
		Вывод.НовСтрока
	КОНЕЦ Показать;

КОНЕЦ  i21примПростыеЧисла.

Для выполнения процедуры кликнуть по черному коммандеру:
"i21примПростыеЧисла.Показать(1791)"
i21прим/Mod/ПростыеЧисла.odc

MODULE  i21примПростыеЧисла;
	IMPORT  Log := StdLog,  Math;
	
	PROCEDURE НеДелит ( i, n: INTEGER ): BOOLEAN;
	BEGIN
		RETURN  ( n MOD i ) # 0
	END НеДелит;

	PROCEDURE Простое* ( n: INTEGER ): BOOLEAN;
		VAR  i, мин, макс: INTEGER;
	BEGIN
		(* проверка разрешенного значения параметра на входе *)
		ASSERT( n > 1, 20 );

		(* диапазон потенциальных делителей *)
		мин := 2;
		макс := SHORT( ENTIER( Math.Sqrt( n ) ) );

		(* цикл поиска наименьшего делителя *)
		i := мин;
		WHILE  ( i <= макс ) & НеДелит( i, n )  DO
			INC( i )
		END;

		RETURN  i > макс  (* прошли все возможности -- делителя не нашли *)
	END Простое;
	
	PROCEDURE КоличПростыхДо* ( n: INTEGER ): INTEGER;
		VAR  i, k: INTEGER;
	BEGIN
		k := 0;
		FOR  i := 2  TO  n - 1  DO
			IF  Простое( i )  THEN
				INC( k )
			END
		END;
		RETURN  k
	END КоличПростыхДо;

	PROCEDURE Показать* ( n: INTEGER );
	BEGIN
		Log.Ln;  Log.String("Число ");  Log.Int( n ); 
		IF  ~Простое( n )  THEN
			Log.String(" не")
		END;
		Log.String(" является простым.");  Log.Ln;
		Log.Int( КоличПростыхДо( n ) );  Log.String(" простых, меньших ");  Log.Int( n );  Log.Ln
	END Показать;

END  i21примПростыеЧисла.

Для выполнения процедуры кликнуть по чёрному коммандеру:
"i21примПростыеЧисла.Показать(1791)"
i21прим/Mod/СортДемо1.odc

MODULE  i21примСортДемо1;
	IMPORT  StdLog,  Модуль := i21примВставки,  Тест := i21примСортТест;
	
	PROCEDURE Выполнить*;
		CONST  L = 5;
		VAR  n: INTEGER;  a: ARRAY L OF INTEGER;
	BEGIN
		(* инициализация массива *)
		a[0] := 9;
		a[1] := -2;
		a[2] := 19;
		a[3] := -6;
		a[4] := 1;

		(* печать массива до сортировки *)
		StdLog.Ln;  StdLog.String("до сортировки:  ");
		FOR  n := 0  TO  L - 1  DO  StdLog.Int( a[n] )  END;
		StdLog.Ln;

		Модуль.Сорт( a );  (* это сортировка *)
		ASSERT( Тест.Отсортирован( a ) );  (* автоматическая проверка результата *)

		(* печать массива после сортировки *)
		StdLog.Ln;  StdLog.String("после сортировки:  ");
		FOR  n := 0  TO  L - 1  DO  StdLog.Int( a[n] )  END;
		StdLog.Ln;

	END Выполнить;
	
END  i21примСортДемо1.

Чтобы выполнить тест, нужно кликнуть по коммандеру (черный кружок):
i21примСортДемо1.Выполнить

Если хочется поменять числа, то нужно их поменять прямо в тексте, 
а потом кликнуть по коммандеру здесь:
"DevCompiler.Compile;DevDebug.Unload;i21примСортДемо1.Выполнить"

Точно так же можно поменять модуль, содержащий проверяемую программу сортировки: достаточно изменить i21примВставки в операторе IMPORT на i21примПузырь.

Внимание! Так как процедуры сортировки и проверяющие программы реализованы в разных модулях, могут возникнуть проблемы (вызывается старая версия сортировки, когда уже написана и успешно скомпилирована новая). О том, что делать в таких случаях, см. здесь.
i21прим/Mod/СортДемо1original.odc

MODULE  i21примСортДемо1;
	IMPORT  StdLog,  Модуль := i21примВставки,  Тест := i21примСортТест;
	
	PROCEDURE Выполнить*;
		CONST  L = 5;
		VAR  n: INTEGER;  a: ARRAY L OF INTEGER;
	BEGIN
		(* инициализация массива *)
		a[0] := 9;
		a[1] := -2;
		a[2] := 19;
		a[3] := -6;
		a[4] := 1;

		(* печать массива до сортировки *)
		StdLog.Ln;  StdLog.String("до сортировки:  ");
		FOR  n := 0  TO  L - 1  DO  StdLog.Int( a[n] )  END;
		StdLog.Ln;

		Модуль.Сорт( a );  (* это сортировка *)
		ASSERT( Тест.Отсортирован( a ) );  (* автоматическая проверка результата *)

		(* печать массива после сортировки *)
		StdLog.Ln;  StdLog.String("после сортировки:  ");
		FOR  n := 0  TO  L - 1  DO  StdLog.Int( a[n] )  END;
		StdLog.Ln;

	END Выполнить;
	
END  i21примСортДемо1.

Чтобы выполнить тест, нужно кликнуть по коммандеру (черный кружок):
i21примСортДемо1.Выполнить

Если хочется поменять числа, то нужно их поменять прямо в тексте, 
а потом кликнуть по коммандеру здесь:
"DevCompiler.Compile;DevDebug.Unload;i21примСортДемо1.Выполнить"

Точно так же можно поменять модуль, содержащий проверяемую программу сортировки: достаточно изменить i21примВставки в операторе IMPORT на i21примПузырь.

Внимание! Так как процедуры сортировки и проверяющие программы реализованы в разных модулях, могут возникнуть проблемы (вызывается старая версия сортировки, когда уже написана и успешно скомпилирована новая). О том, что делать в таких случаях, см. здесь.
i21прим/Mod/СортДемо2.odc

MODULE  i21примСортДемо2;
	IMPORT  StdLog,  In := i21sysIn,  Модуль := i21примВставки,  Тест := i21примСортТест;
	
	PROCEDURE Выполнить*;
		VAR  x, n: INTEGER;  a: POINTER TO ARRAY OF INTEGER;
	BEGIN
		(* подсчет количества сортируемых чисел *)
		In.Open;  n := 0;  In.Int( x );
		WHILE  In.Done  DO  INC( n );  In.Int( x ) END;
		IF  n > 0  THEN
			(* инициализация массива *)
			NEW( a, n );
			In.Open;  n := 0;  In.Int( x );
			WHILE  In.Done  DO  a[n] := x;  INC( n );  In.Int( x ) END;

			(* печать до сортировки *)
			StdLog.Ln;  StdLog.String('до сортировки: ');
			FOR  n := 0  TO  LEN(a) - 1  DO  StdLog.Int( a[n] )  END;
			StdLog.Ln;
			
			Модуль.Сорт( a );  (* это сортировка *)
			ASSERT( Тест.Отсортирован( a ) );  (* автоматическая проверка результата *)

			(* печать после сортировки *)
			StdLog.Ln;  StdLog.String('после сортировки: ');
			FOR  n := 0  TO  LEN(a) - 1  DO  StdLog.Int( a[n] )  END;
			StdLog.Ln;
		END
	END Выполнить;
	
END  i21примСортДемо2.

Чтобы выполнить тест, нужно кликнуть по коммандеру (черному кружку с восклицат. знаком).
Программа прочтет все числа после Выполнить и до второго коммандера отсортирует их и распечатает в рабочем журнале.

i21примСортДемо2.Выполнить  2 0 90 -111 151 -4 8

Можно призвольно менять последовательность чисел  стирать, добавлять новые (в любом количестве) и т.п.

Можно поменять модуль, содержащий проверяемую программу сортировки: достаточно изменить i21примВставки в операторе IMPORT на i21примПузырь. После этого нужно клюкнуть по следующему коммандеру:
"DevCompiler.Compile;DevDebug.Unload;i21примСортДемо1.Выполнить"

Внимание! Так как процедура сортировки и проверяющие программы реализованы в разных модулях, могут возникнуть проблемы (вызывается старая версия сортировки, когда уже написана и успешно скомпилирована новая). О том, что делать в таких случаях, см. здесь.