746 lines
21 KiB
ObjectPascal
746 lines
21 KiB
ObjectPascal
unit TasksArr;
|
||
|
||
uses LightPT;
|
||
|
||
var AllTaskNames := Arr('Arr1','Arr2','Arr3','Arr4','Arr5','Arr6',
|
||
'Arr_Sum0','Arr_Sum1','Arr_Sum2','Arr_Sum3','Arr_Sum4','Arr_CountA1','Arr_CountA2',
|
||
'Arr_Replace1','Arr_Replace2','Arr_Find1','Arr_Find2','Arr_Find3','Arr_Find4',
|
||
'Arr_Index1','Arr_Index2','Arr_Index2a','Arr_Index3','Arr_Index4',
|
||
'Arr_MinMax1','Arr_MinMax2','Arr_MinMax3','Arr_MinMax4','Arr_Neighbors1','Arr_MinMaxInd1','Arr_MinMaxInd2',
|
||
'Arr_Fill1','Arr_Fill2','Заполнение1','ЗаполнениеЛямбда1','Заполнение2','ЗаполнениеЛямбда2',
|
||
'ЗаполнениеПоПред1','ЗаполнениеПоПред2','ЗаполнениеГеом1','ЗаполнениеГеом2','ЗаполнениеСумма1','ЗаполнениеСумма2',
|
||
'Arr_Transf1','Arr_Transf1a','Arr_Transf2','Arr_Transf3','Arr_Transf4','Arr_Transf5','Arr_Transf7',
|
||
'Arr_Transf8','Arr_Transf9','Arr_Transf6',
|
||
'Arr_Reverse1','Arr_Reverse2','Arr_Reverse3','Arr_Reverse3a',
|
||
'Arr_Count1','Arr_Count2','Arr_Count3','Arr_Count4',
|
||
'Arr_FindIndex1','Arr_FindIndex2',
|
||
'Arr_Filter1','Arr_GenFilter1','Arr_GenFilter2',
|
||
'Arr_Op1',
|
||
'Arr_Slice1','Arr_Slice2','Arr_Slice3','Arr_Slice7','Arr_Slice10','Arr_Slice11','Arr_Slice12',
|
||
'Arr_InsDel1','Arr_InsDel2','Arr_InsDel3',
|
||
'Arr_Shift1','Arr_Shift2',
|
||
'List1','List2','List3','List4','List5','List6','List6a','List6b','List7','List8','List9','List9a','List9b',
|
||
'Sort1','Sort2','Sort3',
|
||
'BubbleSort','BubbleSort2');
|
||
|
||
procedure CheckTaskT(name: string);
|
||
begin
|
||
FlattenOutput; // Во всех задачах на массивы
|
||
ClearOutputListFromSpaces; // Это чтобы a.Print работал. По идее, надо писать всегда. Яне знаю задач, где пробелы в ответе
|
||
|
||
case name of
|
||
'Arr1','Arr2': begin
|
||
FilterOnlyNumbersAndBools;
|
||
CheckData(InitialOutput := |cInt|*5);
|
||
CheckOutputSeq(|cInt|*10);
|
||
// Надо проверить, что Output[9] - целое ненулевое
|
||
if OutputList.Count<10 then // чтобы не получить исключение
|
||
exit;
|
||
if OutIsInt(9) then
|
||
if OutInt(9) = 0 then
|
||
begin
|
||
ColoredMessage('Массив надо заполнить ненулевыми значениями');
|
||
TaskResult := BadSolution;
|
||
end;
|
||
end;
|
||
'Arr3','Arr4': begin
|
||
FilterOnlyNumbersAndBools;
|
||
TaskResult := PartialSolution; // То есть, уже начали проверять, уже под контролем
|
||
CheckData(|cInt|*5, |cInt|*5, |cInt|*10);
|
||
if TaskResult <> PartialSolution then
|
||
exit;
|
||
|
||
CheckOutputSeq(InputList);
|
||
end;
|
||
'Arr5','Arr6': begin
|
||
// Проверка того что введено и выведено 10 значений, что ввод совпадает с выводом и что вывод в диапазоне от 2 до 5
|
||
// Что плохо - все Check неявно меняют TaskResult, а здесь надо еще и явно
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
|
||
TaskResult := PartialSolution; // потому что если просто запустить - будет InitialSolution
|
||
|
||
CheckOutputSeq(InputList);
|
||
// Дополнительная проверка
|
||
if TaskResult = Solved then
|
||
begin
|
||
// проверим на диапазон от 2 до 5
|
||
var a := IntArr(n);
|
||
if a.Any(x->x not in 2..5) then
|
||
begin
|
||
TaskResult := BadSolution;
|
||
ColoredMessage('Результирующие данные должны быть от 2 до 5',MsgColorGray);
|
||
exit;
|
||
end;
|
||
end;
|
||
end;
|
||
'Arr_Sum0': begin
|
||
// Это паттерн: вводится n, а потом вводится n элементов массива
|
||
FilterOnlyNumbersAndBools;
|
||
var n := Int;
|
||
CheckInput(|cInt| + n*|cInt|);
|
||
var a := IntArr(n);
|
||
CheckOutput(a.Sum)
|
||
end;
|
||
'Arr_Sum1','Arr_Sum2': begin
|
||
FilterOnlyNumbersAndBools;
|
||
// Это всё надо. Начальный ввод - 10 целых, весь ввод - тоже
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*(n+1), |cInt|*n);
|
||
|
||
var a := IntArr(n);
|
||
var p := integer(a.Product);
|
||
CheckOutputAfterInitial(p)
|
||
end;
|
||
'Arr_Sum3': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*(n+1), |cInt|*n);
|
||
|
||
var a := IntArr(n);
|
||
CheckOutputAfterInitial(a.Product)
|
||
end;
|
||
'Arr_Sum4': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n, |cInt|*n);
|
||
|
||
var a := IntArr(n);
|
||
var ave := a.Average;
|
||
CheckOutputAfterInitialSeq(|ave|*2)
|
||
end;
|
||
'Arr_CountA1': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n, |cInt|*n);
|
||
GenerateTests(10,tInt * n);
|
||
var a := IntArr(n);
|
||
CheckOutputAfterInitial(a.CountOf(3));
|
||
end;
|
||
'Arr_CountA2': begin
|
||
ClearOutputListFromSpaces; // Кроме чисел тут строки
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n, |cInt|*n);
|
||
GenerateTests(10,tInt * n);
|
||
|
||
var lst := ObjectList.New;
|
||
var a := IntArr(n);
|
||
var cnt4 := a.CountOf(4);
|
||
var cnt5 := a.CountOf(5);
|
||
|
||
case cnt4.CompareTo(cnt5) of
|
||
1: lst.Add('четвёрок больше');
|
||
0: lst.Add('одинаково');
|
||
-1: lst.Add('пятёрок больше');
|
||
end;
|
||
CheckOutputAfterInitialSeq(lst);
|
||
end;
|
||
'Arr_Replace1': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n, |cInt|*n);
|
||
GenerateTests(10,tInt * n);
|
||
|
||
var arr := IntArr(n);
|
||
arr.Replace(2,3);
|
||
CheckOutputAfterInitialSeq(arr);
|
||
end;
|
||
'Arr_Replace2': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n, |cInt|*n);
|
||
GenerateTests(10,tInt * n);
|
||
|
||
var arr := IntArr(n);
|
||
arr.Replace(2,22);
|
||
arr.Replace(5,55);
|
||
arr.Replace(22,5);
|
||
arr.Replace(55,2);
|
||
CheckOutputAfterInitialSeq(arr);
|
||
end;
|
||
'Arr_Find1': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 5;
|
||
CheckData(|cInt|*n, |cInt|*n, |cInt|*n);
|
||
GenerateTests(10,tInt * n);
|
||
|
||
var a := IntArr(n);
|
||
var has2 := 2 in a;
|
||
CheckOutputAfterInitial(has2);
|
||
end;
|
||
'Arr_Find2': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 5;
|
||
CheckData(|cInt|*n, |cInt|*n, |cInt|*n);
|
||
TestCount := 10;
|
||
GenerateTestData := tnum -> begin
|
||
var a := ArrRandomInteger(n,2,5);
|
||
if tnum = 2 then
|
||
a := ArrFill(n,1);
|
||
InputList.AddTestData(a);
|
||
end;
|
||
|
||
var a := IntArr(n);
|
||
var haseven := a.FindIndex(x -> x.IsEven) <> -1;
|
||
CheckOutputAfterInitial(haseven);
|
||
end;
|
||
'Arr_Find3': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 5;
|
||
CheckData(|cInt|*n, |cInt|*n, |cInt|*n);
|
||
TestCount := 10;
|
||
GenerateTestData := tnum -> begin
|
||
var a := ArrRandomInteger(n,1,99);
|
||
if tnum = 2 then
|
||
a := ArrRandomInteger(n,1,30)
|
||
else if tnum = 3 then
|
||
a := ArrRandomInteger(n,51,99);
|
||
InputList.AddTestData(a);
|
||
end;
|
||
|
||
var a := IntArr(n);
|
||
var haseven := a.ToArray.FindIndex(x -> x in 40..50) <> -1;
|
||
CheckOutputAfterInitial(haseven);
|
||
end;
|
||
|
||
'Arr_Find4': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 3;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
TestCount := 10;
|
||
GenerateTestData := tnum -> begin
|
||
var a := ArrRandomInteger(n,2,5);
|
||
if tnum = 2 then
|
||
a := ArrFill(n,11);
|
||
InputList.AddTestData(a);
|
||
end;
|
||
|
||
var a := IntArr(n);
|
||
var allodd := a.All(x -> x.IsOdd);
|
||
CheckOutputAfterInitial(allodd);
|
||
end;
|
||
'Arr_Index1': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
TestCount := 10;
|
||
GenerateTestData := tnum -> begin
|
||
var a := ArrRandomInteger(n,2,5);
|
||
if tnum = 2 then
|
||
a := ArrFill(n,5);
|
||
InputList.AddTestData(a);
|
||
end;
|
||
|
||
var a := IntArr(n);
|
||
var ind := a.FindIndex(x -> x = 2);
|
||
CheckOutputAfterInitial(ind);
|
||
end;
|
||
'Arr_Index2': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
TestCount := 10;
|
||
GenerateTestData := tnum -> begin
|
||
var a := ArrRandomInteger(n,2,5);
|
||
if tnum = 2 then
|
||
a := ArrFill(n,4);
|
||
InputList.AddTestData(a);
|
||
end;
|
||
|
||
var a := IntArr(n);
|
||
var ind := a.FindLastIndex(x -> x = 5);
|
||
CheckOutputAfterInitial(ind);
|
||
end;
|
||
'Arr_Index2a': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateTests(10,tInt * n);
|
||
var a := IntArr(n);
|
||
var ind2 := a.IndexOf(2);
|
||
var ind5 := a.IndexOf(5);
|
||
CheckOutputAfterInitialSeq(|ind2,ind5|);
|
||
end;
|
||
'Arr_Index3': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 20;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateTests(10,tInt * n);
|
||
|
||
var arr := IntArr(n);
|
||
var ind2 := arr.IndexOf(2);
|
||
var ind5 := arr.IndexOf(5);
|
||
Swap(arr[ind2],arr[ind5]);
|
||
CheckOutputAfterInitialSeq(arr);
|
||
end;
|
||
'Arr_Index4': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 30;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateTests(10,tInt * n);
|
||
var arr := IntArr(n);
|
||
var ind := arr.IndexOf(2);
|
||
ind := arr.IndexOf(2,ind + 1);
|
||
CheckOutputAfterInitial(ind);
|
||
end;
|
||
|
||
'Arr_MinMax1': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(InitialOutput := |cInt|*n);
|
||
|
||
var a := OutSliceIntArr(0,n-1);
|
||
var min := a.Min;
|
||
CheckOutputAfterInitial(min);
|
||
end;
|
||
'Arr_MinMax2': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateTests(10,tInt * n);
|
||
|
||
var a := IntArr(n);
|
||
var max := a.Max;
|
||
CheckOutputAfterInitial(max);
|
||
end;
|
||
'Arr_MinMax3': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateTests(10,tInt * n);
|
||
|
||
var a := IntArr(n);
|
||
CheckOutputAfterInitial(a.Min);
|
||
end;
|
||
'Arr_MinMax4': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateTests(10,tInt * n);
|
||
|
||
var a := IntArr(n);
|
||
CheckOutputAfterInitialSeq(|a.Min,a.Max|);
|
||
end;
|
||
|
||
'Arr_Neighbors1': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 20;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateTests(10, tInt*n);
|
||
|
||
var a := IntArr(n);
|
||
var cnt := 0;
|
||
for var i := 0 to n-2 do
|
||
if (a[i] = 2) and (a[i+1] = 5) then
|
||
cnt += 1;
|
||
CheckOutputAfterInitial(cnt);
|
||
end;
|
||
'Arr_MinMaxInd1': begin
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateAutoTests(10);
|
||
|
||
var a := IntArr(n);
|
||
CheckOutputAfterInitial(a.IndexMax,a.IndexMax);
|
||
end;
|
||
'Arr_MinMaxInd2': begin
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateAutoTests(10);
|
||
|
||
var a := IntArr(n);
|
||
var indmax := a.IndexMax;
|
||
var indmin := a.IndexMin;
|
||
Swap(a[indmax],a[indmin]);
|
||
CheckOutputSeq(a);
|
||
end;
|
||
|
||
'Arr_Fill1': begin
|
||
FilterOnlyNumbersAndBools;
|
||
CheckData(Input := nil);
|
||
|
||
CheckOutputSeq(ArrFill(10,1));
|
||
end;
|
||
'Arr_Fill2': begin
|
||
FilterOnlyNumbersAndBools;
|
||
CheckData(Input := nil);
|
||
|
||
CheckOutputSeq(ArrFill(10,1));
|
||
end;
|
||
'Заполнение1','ЗаполнениеЛямбда1': begin
|
||
FilterOnlyNumbersAndBools;
|
||
CheckData(Input := Empty);
|
||
CheckOutputSeq(ArrGen(10,i->i*i));
|
||
end;
|
||
'Заполнение2','ЗаполнениеЛямбда2': begin
|
||
FilterOnlyNumbersAndBools;
|
||
CheckData(Input := Empty);
|
||
CheckOutputSeq(ArrGen(10,1,i->i+2));
|
||
end;
|
||
'ЗаполнениеПоПред1','ЗаполнениеПоПред2': begin
|
||
FilterOnlyNumbersAndBools;
|
||
CheckData(Input := Empty);
|
||
CheckOutputSeq(ArrGen(10,5,i->i+5));
|
||
end;
|
||
'ЗаполнениеГеом1','ЗаполнениеГеом2': begin
|
||
FilterOnlyNumbersAndBools;
|
||
CheckData(Input := Empty);
|
||
CheckOutputSeq(ArrGen(10,1,i->i*2));
|
||
end;
|
||
'ЗаполнениеСумма1': begin
|
||
FilterOnlyNumbersAndBools;
|
||
CheckData(Input := Empty);
|
||
CheckOutput(ArrGen(10,5,i->i+5).Sum);
|
||
end;
|
||
'ЗаполнениеСумма2': begin
|
||
FilterOnlyNumbersAndBools;
|
||
CheckData(Input := Empty);
|
||
CheckOutput(ArrGen(10,1,i->i*2).Sum);
|
||
end;
|
||
|
||
// 'Arr_Transf1' 'Arr_Transf1a' 'Arr_Transf2' 'Arr_Transf3' 'Arr_Transf4' 'Arr_Transf5' 'Arr_Transf7' 'Arr_Transf8' 'Arr_Transf9'- задачник
|
||
'Arr_Transf6': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateTests(10, tInt * n);
|
||
|
||
var a := IntArr(n);
|
||
foreach var i in a.Indices do
|
||
if i.IsOdd then
|
||
a[i] := 0;
|
||
CheckOutputAfterInitialSeq(a);
|
||
end;
|
||
|
||
'Arr_Reverse1','Arr_Reverse2': begin
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateTests(10, tInt * n);
|
||
|
||
var a := IntArr(n);
|
||
CheckOutputAfterInitialSeq(a.Reverse);
|
||
end;
|
||
'Arr_Reverse3': begin
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateTests(10, tInt * n);
|
||
|
||
var a := IntArr(n);
|
||
for var i:= 0 to n div 2 - 1 do
|
||
Swap(a[i],a[i + n div 2]);
|
||
CheckOutputAfterInitialSeq(a);
|
||
end;
|
||
|
||
'Arr_Reverse3a': begin
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
|
||
var out := IntArr(n);
|
||
var out0 := Copy(out);
|
||
Reverse(out, 0, 5);
|
||
Reverse(out, 5, 5);
|
||
CheckOutputSeq(out0 + out);
|
||
end;
|
||
|
||
'Arr_Count1','Arr_Count2': begin
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateTests(10, tInt * n);
|
||
|
||
var a := IntArr(n);
|
||
CheckOutputAfterInitial(a.Count(x -> x.IsEven));
|
||
end;
|
||
'Arr_Count3': begin
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateTests(10, tInt * n);
|
||
|
||
var a := IntArr(n);
|
||
CheckOutputAfterInitial(a.CountOf(3),a.CountOf(4),a.CountOf(5));
|
||
end;
|
||
'Arr_Count4': begin
|
||
var n := 30;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateTests(10, tInt * n);
|
||
|
||
var a := IntArr(n);
|
||
CheckOutputAfterInitialSeq(|a.CountOf(a.Min),a.CountOf(a.Max)|);
|
||
end;
|
||
|
||
'Arr_FindIndex1': begin
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateTests(10, tInt * n);
|
||
|
||
var a := IntArr(n);
|
||
CheckOutputAfterInitialSeq(|a.FindIndex(x-> x.IsOdd),a.FindLastIndex(x-> x.IsOdd)|);
|
||
end;
|
||
'Arr_FindIndex2': begin
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateTests(10, tInt * n);
|
||
|
||
var a := IntArr(n);
|
||
var i1 := a.FindIndex(x -> x.IsEven);
|
||
var i2 := a.FindLastIndex(x -> x.IsOdd);
|
||
Swap(a[i1],a[i2]);
|
||
CheckOutputAfterInitialSeq(a);
|
||
end;
|
||
|
||
'Arr_Filter1': begin
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateTests(10, tInt(1,100) * n);
|
||
|
||
var a := IntArr(n);
|
||
CheckOutputAfterInitialSeq(a.Where(x->x<50));
|
||
end;
|
||
'Arr_GenFilter1': begin
|
||
CheckData(Input := Empty);
|
||
var a := ArrGen(50,1,x->x+2);
|
||
CheckOutputSeq(a.Where(x->x mod 7 = 0));
|
||
end;
|
||
'Arr_GenFilter2': begin
|
||
var n := 40;
|
||
CheckData(InitialOutput := |cInt|*n);
|
||
var a := ArrGen(40,1,1,(x,y)->x+y);
|
||
CheckOutputAfterInitialSeq(a.Where(x->x mod 5 = 0));
|
||
end;
|
||
|
||
'Arr_Op1': begin
|
||
CheckData(Empty);
|
||
var a := |1,2,3|*5;
|
||
var b := |0| * 6 + |1| * 6;
|
||
var c := |1,2,3|*3 + |4,5,6|*3;
|
||
var d := |1| * 5 + |2| * 5 + |1| * 5 + |2| * 5;
|
||
CheckOutputSeq(a+b+c+d);
|
||
end;
|
||
|
||
'Arr_Slice1': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(InitialOutput := |cInt| * n);
|
||
var a := Arr(0..9);
|
||
CheckOutputSeq(a + a[2:6] + a[:4] + a[2:]);
|
||
end;
|
||
'Arr_Slice2': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(InitialOutput := |cInt| * n);
|
||
var a := Arr(0..9);
|
||
CheckOutputSeq(a + a[:2] + a[5:] + a[1:^1]);
|
||
end;
|
||
'Arr_Slice3': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(InitialOutput := |cInt| * n + |cInt| * 2);
|
||
var a := Arr(0..9);
|
||
CheckOutputSeq(a + |9| + |8| + |7| + a[^2:] + a[1:^1])
|
||
end;
|
||
'Arr_Slice7': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(InitialOutput := |cInt| * n);
|
||
var a := Arr(0..9);
|
||
CheckOutputSeq(a + a[5::-1] + a[9::-2])
|
||
end;
|
||
'Arr_Slice10': begin
|
||
FilterOnlyNumbersAndBools;
|
||
CheckData(Input := Empty);
|
||
var a := |6,2,4,3,6,1,7,8,2,4|;
|
||
CheckOutput(a[:5].Sum);
|
||
end;
|
||
'Arr_Slice11': begin
|
||
FilterOnlyNumbersAndBools;
|
||
CheckData(Input := Empty);
|
||
var a := |6,2,4,3,6,1,7,8,2,4|;
|
||
CheckOutput(a[5:].Min);
|
||
end;
|
||
'Arr_Slice12': begin
|
||
FilterOnlyNumbersAndBools;
|
||
CheckData(Input := Empty);
|
||
var a := |6,2,4,3,6,1,7,8,2,4|;
|
||
CheckOutput(a[::2].Average);
|
||
end;
|
||
|
||
'Arr_InsDel1': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
var a := Arr(0..9);
|
||
CheckData(InitialOutput := |cInt| * n);
|
||
CheckOutputSeq(a + a[:5] + a[6:]);
|
||
end;
|
||
'Arr_InsDel2': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
var a := Arr(0..9);
|
||
CheckData(InitialOutput := |cInt| * n);
|
||
CheckOutputSeq(a + a[:5] + |333| + a[5:]);
|
||
end;
|
||
'Arr_InsDel3': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
var a := Arr(0..9);
|
||
CheckData(InitialOutput := |cInt| * n);
|
||
CheckOutputSeq(a + a[:1] + |555| + a[1:^1] + |555| + a[^1:]);
|
||
end;
|
||
|
||
'Arr_Shift1': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
var a := Arr(0..9);
|
||
CheckData(InitialOutput := |cInt| * n);
|
||
CheckOutputSeq(a + a[1:] + |0|);
|
||
end;
|
||
'Arr_Shift2': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
var a := Arr(0..9);
|
||
CheckData(InitialOutput := |cInt| * n);
|
||
CheckOutputSeq(a + |0| + a[:^1]);
|
||
end;
|
||
|
||
'List1': begin
|
||
ClearOutputListFromSpaces;
|
||
CheckData(InitialOutput := |cInt|);
|
||
CheckOutput('Иванов','Петров','Сидоров');
|
||
end;
|
||
'List2': begin
|
||
FilterOnlyNumbersAndBools;
|
||
CheckData(Input := Empty);
|
||
CheckOutput(11,2,13,4,15);
|
||
end;
|
||
'List3': begin
|
||
FilterOnlyNumbersAndBools;
|
||
CheckData(Input := Empty);
|
||
CheckOutput(1,3,5,7);
|
||
end;
|
||
'List4': begin
|
||
FilterOnlyNumbersAndBools;
|
||
CheckData(Input := Empty);
|
||
CheckOutputSeq((1..7).Select(x->x*x));
|
||
end;
|
||
'List5': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateAutoTests(10);
|
||
|
||
var a := IntArr(n);
|
||
CheckOutputAfterInitialSeq(a.Where(x->x.IsEven));
|
||
end;
|
||
'List6': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateAutoTests(10);
|
||
|
||
var a := IntArr(n);
|
||
CheckOutputAfterInitialSeq(a.Where(x->x.IsEven)+a.Where(x->x.IsOdd));
|
||
end;
|
||
'List6a': begin
|
||
FilterOnlyNumbersAndBools;
|
||
CheckData(InitialInput := |cInt|*3);
|
||
GenerateAutoTests(10);
|
||
|
||
var a := IntArr(3);
|
||
CheckOutputSeq(|1,3,5|+a);
|
||
end;
|
||
'List6b': begin
|
||
FilterOnlyNumbersAndBools;
|
||
CheckData(Input := Empty);
|
||
CheckOutputSeq(|1,3,5,2,4,6,9,8,7|);
|
||
end;
|
||
'List7': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 20;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateAutoTests(5);
|
||
var a := IntArr(10);
|
||
var b := IntArr(10);
|
||
CheckOutputAfterInitialSeq(a.Interleave(b));
|
||
end;
|
||
'List8': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(InitialOutput := |cInt|*n);
|
||
var a := OutSliceIntArr(0,n-1);
|
||
var b := a.ToList;
|
||
b.Insert(2,555);
|
||
CheckOutputSeq(a+b);
|
||
end;
|
||
'List9': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(InitialOutput := |cInt|*n);
|
||
var a := OutSliceIntArr(0,n-1);
|
||
var b := a.ToList;
|
||
if b.Count>0 then
|
||
b.RemoveAt(2);
|
||
CheckOutputSeq(a+b);
|
||
end;
|
||
'List9a': begin
|
||
FilterOnlyNumbersAndBools;
|
||
CheckData(Input := Empty);
|
||
CheckOutputSeq((1..10));
|
||
end;
|
||
'List9b': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(InitialInput := |cInt|*n);
|
||
var a := IntArr(n);
|
||
CheckOutputSeq(a);
|
||
end;
|
||
|
||
'Sort1': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateAutoTests(5);
|
||
var a := IntArr(n);
|
||
CheckOutputSeq(a+a.Sorted);
|
||
end;
|
||
'Sort2': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(|cInt|*n, |cInt|*n);
|
||
GenerateAutoTests(5);
|
||
var a := IntArr(n);
|
||
CheckOutputSeq(a+a.SortedDescending);
|
||
end;
|
||
'Sort3': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 9;
|
||
CheckData(InitialOutput := |cInt|*n);
|
||
|
||
var a := OutSliceIntArr(0,n-1);
|
||
CheckOutputSeq(a + a.Sorted);
|
||
end;
|
||
'BubbleSort': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 10;
|
||
CheckData(InitialOutput := |cInt|*n);
|
||
|
||
var a := OutSliceIntArr(0,n-1);
|
||
var b := Copy(a);
|
||
for var j:=n-1 downto 1 do
|
||
if b[j-1] > b[j] then
|
||
Swap(b[j-1], b[j]);
|
||
CheckOutputSeq(a + b);
|
||
end;
|
||
'BubbleSort2': begin
|
||
FilterOnlyNumbersAndBools;
|
||
var n := 9;
|
||
CheckData(InitialOutput := |cInt|*n);
|
||
|
||
var a := OutSliceIntArr(0,n-1);
|
||
CheckOutputSeq(a+a.Sorted);
|
||
end;
|
||
end;
|
||
end;
|
||
|
||
initialization
|
||
CheckTask := CheckTaskT;
|
||
finalization
|
||
end. |