# Lesson #12. Enumeration type. Arrays

Дата изменения: 21 ноября 2020

## Theory: Enumeration type

Lection in pdf format

• An enumeration type, or enum, is a structure that enables you to create a variable with a fixed set of possible values. The most common example is to use an enum to define the day of the week. There are only seven possible values for days of the week, and you can be reasonably certain that these values will never change.
• ### Creating and Using Enums

• To create an enum, you declare it in your code before the main program with the following syntax, which demonstrates creating an enum called DayOfWeek, that contains short names of the days of the week:
• type DayOfWeek = (Mon,Tue,Wed,Thu,Fri,Sat,Sun); begin //... end.
• We can use for loop and case statement with an Enumeration type:
• for var d:= Mon to Fri do case d of Mon: Print('Monday'); Tue: Print('Tuesday'); Wed: Print('Wednesday'); Thu: Print('Thursday'); Fri: Print('Friday'); end;
• It’s more correct to use the variable of the created Enumeration type:
• type Season = (Spring, Summer, Autumn, Winter);   begin var d: Season; // the variable of enum type d := Season.Spring; // Set an enum variable using the typeName.value notation print(d); // Spring d:=Autumn; // Set an enum variable by name if d = Season.Summer then // false print(d) end.
• An enumerated constant can be accessed directly by name, or you can use the typeName.value notation.
• Enumerated values can be compared (<) :
• DayOfWeek.Wed < DayOfWeek.Sat
• For values of an enumerated type you can use the functions Ord, Pred and Succ, and the procedures Inc and Dec. The function Ord returns the ordinal value in the list of constants corresponding enumerated type, the numbering starts at the zero.
• An instance function ToString is defined for an enumerated type, which returns a string representation of an enumerated variable.
• type Season = (Winter,Spring,Summer,Autumn); var s: Season; begin s := Summer; writeln(s.ToString); // Summer writeln(s); // Summer end.

## Theory: Arrays

• Array is a set of elements of the same type sequentially located in memory. Each element has its own index.
• We will use so called dynamic arrays. This means that they allocate memory dynamically - during program execution
• Creating and using single-dimensional arrays
begin var a: array of integer; a := new integer; a := 5; a := 2; a := 3; end.

or inside the same line of code:

begin var a: array of integer; a := new integer(5,2,3); print(a) end.
• The memory allocation and the size of such an array are set already during the program:
• 1.

var a: array of integer; var n:=readInteger; a:=new integer[n];

2.

var a: array of integer; a:=new integer[readInteger];

3.

var a: array of integer; var n:=readInteger; SetLength(a,n); // set the size
• To return memory allocated by array we can assign a special nil value to an array variable:
• var a := nil;
• To iterate through the array elements by their indexes we can use for loop:
• for var i:=0 to a.Length-1 do a[i] += 1;
• For read-only access (without changing the values) we can use foreach loop:
• foreach var x in a do Print(x)

### Enumerations

{0.5 points} Task 1:

To do: Request user to input a number - a mark ('1', '2', '3', '4', '5'). Check the inputted number to print out the explanation of the mark (very_bad - '1', bad — '2', satisfactory - '3', good - '4', excellent - '5'). Provide also an answer for incorrect input. You should use an enumeration type.

Note 1: entered mark must be stored at the variable of char type. Also, you should use a variable of enum type to output the explanation.

Note 2: it is better to use case statement to check the entered value.

The resulting example:

enter your mark, please (1..5)
>>>2
The explanation for 2 is bad
---
>>>6
The explanation for 6 is noSuchMark


[Program name: 12task-01.pas]

Lab 1, Generic functions:

To do: Create a generic IsitDigit (D) function that returns true if entered integer D is a digit (a one-digit number, that is, D is in the range [0-9]). In the main program, output the value of this function for N (N ≥ 0) given numbers.

Resulting example:

enter how many numbers 2
enter number  > 0 45
False enter number  > 0 8
True


✍ Algorithm:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 function IsitDigit<T>(d: T): boolean; begin var ch := [0..9]; if d in ch then result := true else result := false; end;   begin var k := readInteger('enter how many numbers'); assert(k > 0, 'entered number must be > 0'); loop k do begin var n := readInteger('enter number > 0'); assert(n > 0, 'entered number must be > 0'); print(IsitDigit(n)); end; end.

### Arrays

{0.3 points} Task 2:

To do: Create two dynamic arrays. One is with integer elements, the other is for working with real numbers. Initialize each array with three values. Create procedure to display array elements. Call this procedure for both arrays.

Note 1: To make the procedure generic, <T> is required (<T> means any type).

procedure printArray<T>(a: array of T);

The resulting example:

first array: 5  2  3
second array: 5.1  1.2  3


[Program name: 12task-02.pas]

Lab 2, Array search:

To do: search for a specified value in an array (display the index of an element).

✍ Algorithm:

1. Without using generic function:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 function IndexOf(a:array of integer;x:integer):integer; begin result:=-1; for var i:=0 to High(a) do if a[i]=x then begin result:=i; break end end; begin var a:=Arr(1,2,3,4,5); print(IndexOf(a,5)) end.

2. Using generic function:

1 2 3 4 5 6 7 8 function IndexOf<T>(a:array of T;x:T):integer; begin // the same as in the previous example end; begin var a:=Arr(1,2,3,4,5); print(IndexOf(a,5)) end.

When calling a generic function, compilation will be in two stages:

1. Auto deduction of type T, comparison with real numbers, etc. numbers are integers, then T is defined as an integer.
2. The body of the function is taken and replaced by T with integer (instantiation of a function with a specific type).

{0.3 points} Task 3:

To do: Create an array of 10 randomly generated integer elements. Create a procedure to output the elements of the array with even indexes.

Note: The signature of a procedure must be as follows:

procedure printEven(a:array of integer);

The resulting example:

Array: 2 6 4 1 8 6 5 3 7 8
Elements with even indexes: 2 4 8 5 7


[Program name: 12task-03.pas]

{0.4 points} Task 4:

To do: Create a procedure to generate n elements of array, the values should be generated in the interval[minBound,maxBound]. The array must be output parameter. You should call the procedure in the main program twice with different arrays, after each calling print the array.

Note 1: The signature of a procedure must be as follows:

procedure generateArray(n: integer;var a:array of integer;minBound,maxBound:integer);

Note 2: Don't forget to make input validation (n>0), use assert() function.

The resulting example:

Array 1: [-2,3,5,-3,-1,-1,0,1,-3,2]
Array 2: [8,4,9,8,9]


[Program name: 12task-04.pas]

{0.3 points} Task 5:

To do: Create a procedure to find minimum and maximum of 10 real numbers of an array (10 element of the array should be generated and printed inside the main protgram). To search the minimum and maximum foreach loop must be used.

Note 1: The signature of a procedure must be as follows:

procedure printMinMax (a: array of real);

Note 2: To display the reals it is better to use writelnFormat function, with specified number of digits after floating point, e.g.:

writeFormat('{0:f2}', a); // f2 means 2 digits after floating point

The resulting example:

array:
3.05 3.47 -0.53 3.84 -0.51 2.67 4.07 4.48 2.21 3.64
min = -0.53, max = 4.48


[Program name: 12task-05.pas]

{0.3 points} Task 6:

To do: Create a ArraySum function that returns the sum of the elements of a dynamic array. Pay attention to checking the input array: if the memory for the array is not allocated, the parameter value is nil, you cannot work with this value.

Note 1: Create the TestArraySum procedure to test the correctness of the ArraySum fuction. Add some tests there. Make sure all tests from TestArraySum works well.

function ArraySum(a: array of integer): integer; begin // TODO calculate the sum end; procedure TestArraySum; begin // array of one element: var a := new integer(0); Assert(ArraySum(a) = 0, 'arr-sum:  must be 0'); a := new integer(-5); Assert(ArraySum(a) = -5, 'arr-sum: [-5] must be -5'); // array of some elements: // TODO: type your tests here end; // --- main program --- begin TestArraySum; // all the rest code end.

Note 2: Demonstrate the use of ArraySum function in the main program: create an array, print its length and the sum of its elements.

The resulting example:

array:
-94 -4 -30 -79 15 42 -83 -44 -74 0
sum = -351


[Program name: 12task-06.pas]

### Multi-file layout

{0.5 points} Task 7:

To do: Create a multi-file layout for the task #2 of current lesson.

[Program name: 12task-07.pas]

✍ Algorithm:

1. Create a file with a name DynArr.pas. Add the code to give a name of the unit (unit DynArrs;) and add two sections - the interface section and implementation.

unit DynArrs;
// ======================================== interface section
interface

// ======================================== implementation section
implementation
end.


2. Find your solution of the task #2. Copy the header of the printArray procedure and paste it inside the interface section of your unit-file. Add the summary before the pasted code.

...

interface

/// <summary>
/// prints array of any type
/// </summary>
procedure printArray<T>(a: array of T);

...


3. Copy the body of the printArray procedure and paste it inside the implementation section of your unit-file. Add the comments before the pasted code.

...

implementation

// prints array of any type
procedure printArray<T>(a: array of T);
begin
for var i := 0 to a.Length - 1 do
begin
print(a[i]);
end;
println
end;

...


4.Create a new main file with a name 12task-07.pas. Add the code to include the unit. In the main program create an array and call the printArray procedure.

uses DynArrs;

begin
var a := new integer(1, 2, 3);
printArray(a);
end.

{0.5 points} Task 8:

To do: Create a multi-file layout for the following task: create a PrintArrDelim procedure to display the array elements, separating them with some simbol (delim parameter of string type). To do the task, open the DynArrs.pas unit-file (of task #7) and add there all needed code. In the main file call the procedure several times with different separators.

Note 1. ThePrintArrDelim procedure must accept an array and a separator string. Use the default value for delim which is '; '.

procedure PrintArrDelim(a: array of integer; delim: string := '; ');

Note 2. When you add the implementation code, you don't need to have a default value for the delim:

procedure PrintArrDelim(a: array of integer; delim: string);

The resulting example:

1,  2,  3,
1~  2~  3~


[Program name: 12task-08.pas]

{0.5 points} Task 9:

To do: Create a multi-file layout for the Task #4 of the current lesson. To do the task, open the DynArrs.pas unit-file and add there all needed code (the code of generateArray procedure).

The resulting example:

Array 1: [-2,3,5,-3,-1,-1,0,1,-3,2]
Array 2: [8,4,9,8,9]


[Program name: 12task-09.pas]

{1.0 point} Task 10:

To do: Create a multi-file layout for the following task: Print the number of positive numbers of the given array. You need to write two different solutions to this problem:
1) positiveArr function with the array as a parameter, returning a number of positives.
2) printPositiveArr procedure with two parameters: the input parameter that is an array of integers and output counter of the positives.
To do the task, open the DynArrs.pas unit-file and add there all needed code. In the main file create an array and call the procedure and function.

Note. Create test procedures for positiveArr function. Add the code to the unit-file.
The resulting example:

array:
1  -5  2  -9  8
result with function: 3
result with procedure: 3


[Program name: 12task-10.pas]

Вставить формулу как
Дополнительные настройки
Цвет формулы
Используйте LaTeX для набора формулы
Предпросмотр
$${}$$
Формула не набрана
Вставить 