До­пус­ка­ет­ся на­ли­чие в тек­сте про­грам­мы до трех син­так­си­че­ских оши­бок од­но­го из сле­ду­ю­щих видов:

1) про­пу­щен или не­вер­но ука­зан знак пунк­ту­а­ции;

2) не­вер­но на­пи­са­но или про­пу­ще­но за­ре­зер­ви­ро­ван­ное слово языка про­грам­ми­ро­ва­ния;

3) не опи­са­на или не­вер­но опи­са­на пе­ре­мен­ная;

4) при­ме­ня­ет­ся опе­ра­ция, не­до­пу­сти­мая для со­от­вет­ству­ю­ще­го типа дан­ных.

Если одна и та же ошиб­ка встре­ча­ет­ся не­сколь­ко раз, это счи­та­ет­ся за одну ошиб­ку.

Ко­ли­че­ство син­так­си­че­ских оши­бок (опи­сок) ука­зан­ных выше видов — не более пяти.

Ис­поль­зу­е­мая па­мять, воз­мож­но, за­ви­сит от ко­ли­че­ства про­чи­тан­ных чисел (на­при­мер, вход­ные дан­ные за­по­ми­на­ют­ся в мас­си­ве или дру­гой струк­ту­ре дан­ных (кон­тей­нер priority_queue, vector, set или map в С++)).

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

в «эк­зо­ти­че­ских» си­ту­а­ци­ях. Кроме того, до­пус­ка­ет­ся на­ли­чие одной ошиб­ки, при­над­ле­жа­щей к од­но­му из сле­ду­ю­щих видов оши­бок:

1) ошиб­ка при ини­ци­а­ли­за­ции ми­ни­му­мов;

2) не­вер­но об­ра­ба­ты­ва­ет­ся си­ту­а­ция, когда один или не­сколь­ко ми­ни­и­му­мов не опре­де­ле­ны;

3) до­пу­щен выход за гра­ни­цу мас­си­ва;

4) ис­поль­зу­ет­ся знак < вме­сто <=, or вме­сто and и т. п.

min := 2001;

for i := 1 to N - 1 do begin

for j := i + 1 to N do begin

if ((a[i]+a[j]) mod 2 = 1) and

(a[i]+a[j] < min) then min := a[i]+a[j];

end

end;

Про­грам­ма ра­бо­та­ет пра­виль­но в от­дель­ных част­ных слу­ча­ях. Из опи­са­ния ал­го­рит­ма и общей струк­ту­ры про­грам­мы видно, что эк­за­ме­ну­е­мый в целом пра­виль­но пред­став­ля­ет путь ре­ше­ния за­да­чи. До­пус­ка­ет­ся любое ко­ли­че­ство «опи­сок».

Про­грам­ма ра­бо­та­ет в целом верно, эф­фек­тив­но или нет, но в ре­а­ли­за­ции ал­го­рит­ма есть до трёх со­дер­жа­тель­ных оши­бок, до­пу­сти­мые виды оши­бок пе­ре­чис­ле­ны в кри­те­ри­ях на 3 балла.

Ко­ли­че­ство син­так­си­че­ских «опи­сок» не долж­но быть более семи.

Про­грам­ма может быть не­эф­фек­тив­на по вре­ме­ни. На­при­мер, все числа за­по­ми­на­ют­ся в мас­си­ве и пе­ре­би­ра­ют­ся все воз­мож­ные пары эле­мен­тов по­сле­до­ва­тель­но­сти:

max := 0;

    for i := 1 to N - 1 do begin

        for j := i + 1 to N do begin

            if ((a[i]+a[j]) mod 3 = 0) and (a[i]+a[j] > max) then max := a[i]+a[j];

    end

end;

Про­грам­ма в целом ра­бо­та­ет пра­виль­но для любых вход­ных дан­ных про­из­воль­но­го раз­ме­ра. Время ра­бо­ты про­пор­ци­о­наль­но ко­ли­че­ству введённых чисел, пра­виль­но ука­за­но, какие ве­ли­чи­ны долж­ны вы­чис­лять­ся по ходу чте­ния эле­мен­тов по­сле­до­ва­тель­но­сти чисел.

Ко­ли­че­ство син­так­си­че­ских оши­бок («опи­сок») ука­зан­ных выше видов – не более пяти.

Ис­поль­зу­е­мая па­мять, воз­мож­но, за­ви­сит от ко­ли­че­ства про­чи­тан­ных чисел (на­при­мер, вход­ные дан­ные за­по­ми­на­ют­ся в мас­си­ве, кон­тей­не­ре STL в C++ или дру­гой ана­ло­гич­ной струк­ту­ре дан­ных).

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

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

1. Ошиб­ка при ини­ци­а­ли­за­ции мак­си­му­мов.

2. Не­вер­но об­ра­ба­ты­ва­ет­ся си­ту­а­ция, когда один или не­сколь­ко мак­си­му­мов не опре­де­ле­ны.

3. Не­вер­но опре­де­ля­ет­ся кон­троль­ное зна­че­ние в си­ту­а­ции, когда нет сумм, крат­ных 3.

4. До­пу­щен выход за гра­ни­цу мас­си­ва.

5. Ис­поль­зу­ет­ся знак < вме­сто <=, or вме­сто and и т. п.

До­пус­ка­ет­ся на­ли­чие в тек­сте про­грам­мы до трёх син­так­си­че­ских оши­бок од­но­го из сле­ду­ю­щих видов:

1) про­пу­щен или не­вер­но ука­зан знак пунк­ту­а­ции,

2) не­вер­но на­пи­са­но или про­пу­ще­но за­ре­зер­ви­ро­ван­ное слово языка про­грам­ми­ро­ва­ния,

3) не опи­са­на или не­вер­но опи­са­на пе­ре­мен­ная,

4) при­ме­ня­ет­ся опе­ра­ция, не­до­пу­сти­мая для со­от­вет­ству­ю­ще­го типа дан­ных.

Если одна и та же ошиб­ка встре­ча­ет­ся не­сколь­ко раз, это счи­та­ет­ся за одну ошиб­ку.

Про­грам­ма ра­бо­та­ет пра­виль­но в от­дель­ных част­ных слу­ча­ях. Из опи­са­ния ал­го­рит­ма и общей струк­ту­ры про­грам­мы видно, что эк­за­ме­ну­е­мый в целом пра­виль­но пред­став­ля­ет путь ре­ше­ния за­да­чи. До­пус­ка­ет­ся любое ко­ли­че­ство «опи­сок».

Про­грам­ма ра­бо­та­ет в целом верно, эф­фек­тив­но или нет, но в ре­а­ли­за­ции ал­го­рит­ма есть до трёх со­дер­жа­тель­ных оши­бок, до­пу­сти­мые виды оши­бок пе­ре­чис­ле­ны в кри­те­ри­ях на 3 балла.

Ко­ли­че­ство син­так­си­че­ских «опи­сок» не долж­но быть более семи.

Про­грам­ма может быть не­эф­фек­тив­на по вре­ме­ни. На­при­мер, все числа за­по­ми­на­ют­ся в мас­си­ве и пе­ре­би­ра­ют­ся все воз­мож­ные пары эле­мен­тов по­сле­до­ва­тель­но­сти:

max := 0;

    for i := 1 to N - 1 do begin

        for j := i + 1 to N do begin

            if ((a[i]+a[j]) mod 3 = 0) and (a[i]+a[j] > max) then max := a[i]+a[j];

    end

end;

Про­грам­ма в целом ра­бо­та­ет пра­виль­но для любых вход­ных дан­ных про­из­воль­но­го раз­ме­ра. Время ра­бо­ты про­пор­ци­о­наль­но ко­ли­че­ству введённых чисел, пра­виль­но ука­за­но, какие ве­ли­чи­ны долж­ны вы­чис­лять­ся по ходу чте­ния эле­мен­тов по­сле­до­ва­тель­но­сти чисел.

Ко­ли­че­ство син­так­си­че­ских оши­бок («опи­сок») ука­зан­ных выше видов – не более пяти.

Ис­поль­зу­е­мая па­мять, воз­мож­но, за­ви­сит от ко­ли­че­ства про­чи­тан­ных чисел (на­при­мер, вход­ные дан­ные за­по­ми­на­ют­ся в мас­си­ве, кон­тей­не­ре STL в C++ или дру­гой ана­ло­гич­ной струк­ту­ре дан­ных).

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

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

1. Ошиб­ка при ини­ци­а­ли­за­ции мак­си­му­мов.

2. Не­вер­но об­ра­ба­ты­ва­ет­ся си­ту­а­ция, когда один или не­сколь­ко мак­си­му­мов не опре­де­ле­ны.

3. Не­вер­но опре­де­ля­ет­ся кон­троль­ное зна­че­ние в си­ту­а­ции, когда нет сумм, крат­ных 3.

4. До­пу­щен выход за гра­ни­цу мас­си­ва.

5. Ис­поль­зу­ет­ся знак < вме­сто <=, or вме­сто and и т. п.

До­пус­ка­ет­ся на­ли­чие в тек­сте про­грам­мы до трёх син­так­си­че­ских оши­бок од­но­го из сле­ду­ю­щих видов:

1) про­пу­щен или не­вер­но ука­зан знак пунк­ту­а­ции,

2) не­вер­но на­пи­са­но или про­пу­ще­но за­ре­зер­ви­ро­ван­ное слово языка про­грам­ми­ро­ва­ния,

3) не опи­са­на или не­вер­но опи­са­на пе­ре­мен­ная,

4) при­ме­ня­ет­ся опе­ра­ция, не­до­пу­сти­мая для со­от­вет­ству­ю­ще­го типа дан­ных.

Если одна и та же ошиб­ка встре­ча­ет­ся не­сколь­ко раз, это счи­та­ет­ся за одну ошиб­ку.

До­пус­ка­ет­ся на­ли­чие в тек­сте про­грам­мы до трёх син­так­си­че­ских оши­бок од­но­го из сле­ду­ю­щих видов:

- про­пу­щен или не­вер­но ука­зан знак пунк­ту­а­ции;

- не­вер­но на­пи­са­но или про­пу­ще­но за­ре­зер­ви­ро­ван­ное слово языка про­грам­ми­ро­ва­ния;

- не опи­са­на или не­вер­но опи­са­на пе­ре­мен­ная:

- при­ме­ня­ет­ся опе­ра­ция, не­до­пу­сти­мая для со­от­вет­ству­ю­ще­го типа дан­ных (если одна и та же ошиб­ка встре­ча­ет­ся

не­сколь­ко раз, то это счи­та­ет­ся за одну ошиб­ку).

Ко­ли­че­ство син­так­си­че­ских оши­бок («опи­сок») ука­зан­ных выше видов - не более пяти

Ис­поль­зу­е­мая па­мять, воз­мож­но, за­ви­сит от ко­ли­че­ства про­чи­тан­ных чисел (на­при­мер, вход­ные дан­ные за­по­ми­на­ют­ся в мас­си­ве или дру­гой струк­ту­ре дан­ных (кон­тей­нер priority queue, vector, set или map в С++)).

До­пус­ка­ет­ся ошиб­ка при вводе дан­ных, не­вер­ный или не­пол­ный вывод ре­зуль­та­тов или не­вер­ная ра­бо­та про­грам­мы в «эк­зо­ти­че­ских» си­ту­а­ци­ях. На­при­мер, при ис­поль­зо­ва­нии 16-бит­но­го це­ло­го (integer в BPascal или Qbasic) умно­жа­ют­ся два числа этого типа (ре­зуль­тат по усло­вию может не по­ме­щать­ся в 16 бит).

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

1) Ошиб­ка при ини­ци­а­ли­за­ции мак­си­му­мов.

2) Не­вер­но об­ра­ба­ты­ва­ет­ся си­ту­а­ция, когда один или не­сколь­ко мак­си­му­мов не опре­де­ле­ны.

3) Не­вер­но об­ра­ба­ты­ва­ет­ся си­ту­а­ция, когда мак­си­маль­ное про­из­ве­де­ние по­лу­ча­ет­ся умно­же­ни­ем оди­на­ко­вых чисел (но раз­ных эле­мен­тов вход­ной по­сле­до­ва­тель­но­сти).

4) При вы­чис­ле­нии мак­си­му­мов учи­ты­ва­ют­ся про­из­ве­де­ния вида а[i]*а[i].

5) До­пу­щен выход за гра­ни­цу мас­си­ва.

6) До­пу­ще­на ошиб­ка в ре­а­ли­за­ции ал­го­рит­ма сор­ти­ров­ки.

7) Ис­поль­зу­ет­ся знак "<" вме­сто "<=". "or" вме­сто "and" и т п.

Ко­ли­че­ство син­так­си­че­ских «опи­сок» не долж­но быть более семи.

Про­грам­ма может быть не­эф­фек­тив­на по вре­ме­ни. На­при­мер, все

числа за­по­ми­на­ют­ся в мас­си­ве (ниже п - ко­ли­че­ство про­чи­тан­ных

чисел), и пе­ре­би­ра­ют­ся все воз­мож­ные пары эле­мен­тов

по­сле­до­ва­тель­но­сти.

На­при­мер, так:

max := 0;

for i := 1 to n - 1 do

for j := i + 1 to n do

if ((a[i]*a[j]) mod 14 = 0) and ((a[i] *a[j]) > max) then max := a[i]*a[j];

При этом вы­пол­не­но одно из двух усло­вий.

1. Из опи­са­ния ал­го­рит­ма и общей струк­ту­ры про­грам­мы видно, что эк­за­ме­ну­е­мый в целом пра­виль­но пред­став­ля­ет путь ре­ше­ния за­да­чи.

2. Про­грам­ма пра­виль­но ра­бо­та­ет в одном из важ­ных част­ных слу­ча­ев, на­при­мер в слу­чае, когда ис­ко­мое про­из­ве­де­ние - это про­из­ве­де­ние наи­боль­ше­го числа, ко­то­рое де­лит­ся на 2, и наи­боль­ше­го числа, ко­то­рое де­лит­ся на 7.

До­пус­ка­ет­ся любое число син­так­си­че­ских оши­бок.

До­пус­ка­ет­ся на­ли­чие в тек­сте про­грам­мы до трёх син­так­си­че­ских оши­бок од­но­го из сле­ду­ю­щих видов:

- про­пу­щен или не­вер­но ука­зан знак пунк­ту­а­ции;

- не­вер­но на­пи­са­но или про­пу­ще­но за­ре­зер­ви­ро­ван­ное слово языка про­грам­ми­ро­ва­ния;

- не опи­са­на или не­вер­но опи­са­на пе­ре­мен­ная:

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

Ко­ли­че­ство син­так­си­че­ских оши­бок («опи­сок») ука­зан­ных выше видов - не более пяти

Ис­поль­зу­е­мая па­мять, воз­мож­но, за­ви­сит от ко­ли­че­ства про­чи­тан­ных чисел (на­при­мер, вход­ные дан­ные за­по­ми­на­ют­ся в мас­си­ве или дру­гой струк­ту­ре дан­ных (кон­тей­нер priority queue, vector, set или map в С++)).

До­пус­ка­ет­ся ошиб­ка при вводе дан­ных, не­вер­ный или не­пол­ный вывод ре­зуль­та­тов или не­вер­ная ра­бо­та про­грам­мы в «эк­зо­ти­че­ских» си­ту­а­ци­ях. На­при­мер, при ис­поль­зо­ва­нии 16-бит­но­го це­ло­го (integer в BPascal или Qbasic) умно­жа­ют­ся два числа этого типа (ре­зуль­тат по усло­вию может не по­ме­щать­ся в 16 бит).

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

1) Ошиб­ка при ини­ци­а­ли­за­ции мак­си­му­мов.

2) Не­вер­но об­ра­ба­ты­ва­ет­ся си­ту­а­ция, когда один нлн не­сколь­ко мак­си­му­мов не опре­де­ле­ны.

3) Не­вер­но об­ра­ба­ты­ва­ет­ся си­ту­а­ция, когда мак­си­маль­ное про­из­ве­де­ние по­лу­ча­ет­ся умно­же­ни­ем оди­на­ко­вых чисел (но раз­ных эле­мен­тов вход­ной по­сле­до­ва­тель­но­сти).

4) При вы­чис­ле­нии мак­си­му­мов учи­ты­ва­ют­ся про­из­ве­де­ния вида a[i]*а[i].

5) До­пу­щен выход за гра­ни­цу мас­си­ва.

6) До­пу­ще­на ошиб­ка в ре­а­ли­за­ции ал­го­рит­ма сор­ти­ров­ки.

7) Ис­поль­зу­ет­ся знак "<" вме­сто "<=". "or" вме­сто "and" и т п.

Ко­ли­че­ство син­так­си­че­ских «опи­сок» не долж­но быть более семи.

Про­грам­ма может быть не­эф­фек­тив­на по вре­ме­ни. На­при­мер, все числа за­по­ми­на­ют­ся в мас­си­ве (ниже n - ко­ли­че­ство про­чи­тан­ных чисел), и пе­ре­би­ра­ют­ся все воз­мож­ные пары эле­мен­тов по­сле­до­ва­тель­но­сти.

На­при­мер, так:

mах := 0;

for i := 1 to n - 1 do

for j := i + 1 to n do

if ((a[i]*a[j]) mod 14 = 0) and

((a[i] *a[j]) > max) then

max := a[i]*a[j];

При этом вы­пол­не­но одно из двух усло­вий.

1. Из опи­са­ния ал­го­рит­ма и общей струк­ту­ры про­грам­мы видно, что эк­за­ме­ну­е­мый в целом пра­виль­но пред­став­ля­ет путь ре­ше­ния за­да­чи.

2. Про­грам­ма пра­виль­но ра­бо­та­ет в одном из важ­ных част­ных слу­ча­ев, на­при­мер в слу­чае, когда ис­ко­мое про­из­ве­де­ние - это про­из­ве­де­ние наи­боль­ше­го числа, ко­то­рое де­лит­ся на 2, и наи­боль­ше­го числа, ко­то­рое де­лит­ся на 7.

До­пус­ка­ет­ся любое число син­так­си­че­ских оши­бок.

До­пус­ка­ет­ся на­ли­чие в тек­сте про­грам­мы до трёх син­так­си­че­ских оши­бок од­но­го из сле­ду­ю­щих видов:

- про­пу­щен или не­вер­но ука­зан знак пунк­ту­а­ции;

- не­вер­но на­пи­са­но или про­пу­ще­но за­ре­зер­ви­ро­ван­ное слово языка про­грам­ми­ро­ва­ния;

- не опи­са­на или не­вер­но опи­са­на пе­ре­мен­ная;

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

Ко­ли­че­ство син­так­си­че­ских оши­бок («опи­сок») ука­зан­ных выше видов - не более пяти. Ис­поль­зу­е­мая па­мять, воз­мож­но, за­ви­сит от ко­ли­че­ства про­чи­тан­ных чисел (на­при­мер, вход­ные дан­ные за­по­ми­на­ют­ся в мас­си­ве или дру­гой струк­ту­ре дан­ных (кон­тей­нер priority queue, vector, set или map в С++)). До­пус­ка­ет­ся ошиб­ка при вводе дан­ных, не­вер­ный или не­пол­ный вывод ре­зуль­та­тов или не­вер­ная ра­бо­та про­грам­мы в «эк­зо­ти­че­ских» си­ту­а­ци­ях. На­при­мер, при ис­поль­зо­ва­нии 16-бит­но­го це­ло­го (integer в BPascal или Qbasic) умно­жа­ют­ся два числа этого типа (ре­зуль­тат по усло­вию может не по­ме­щать­ся в 16 бит).

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

1) Ошиб­ка при ини­ци­а­ли­за­ции мак­си­му­мов.

2) Не­вер­но об­ра­ба­ты­ва­ет­ся си­ту­а­ция, когда один или не­сколь­ко мак­си­му­мов не опре­де­ле­ны.

3) Не­вер­но об­ра­ба­ты­ва­ет­ся си­ту­а­ция, когда мак­си­маль­ное про­из­ве­де­ние по­лу­ча­ет­ся умно­же­ни­ем оди­на­ко­вых чисел (но раз­ных эле­мен­тов вход­ной по­сле­до­ва­тель­но­сти).

4) При вы­чис­ле­нии мак­си­му­мов учи­ты­ва­ют­ся про­из­ве­де­ния вида a[i]*a[i],

5) До­пу­щен выход за гра­ни­цу мас­си­ва.

6) До­пу­ще­на ошиб­ка в ре­а­ли­за­ции ал­го­рит­ма сор­ти­ров­ки.

7) Ис­поль­зу­ет­ся знак "<" вме­сто "<=", "or" вме­сто "and" и т.п.

На­при­мер, так:

max := 0;

for i := 1 to n - 1 do for j := i + 1 to n do

if ( (a[i]*a [ j] ) mod 33 = 0) and t(a[i]*a[j]) > max) then max := a[i]* a [ j] ;

1. Из опи­са­ния ал­го­рит­ма и общей струк­ту­ры про­грам­мы видно, что эк­за­ме­ну­е­мый в целом пра­виль­но пред­став­ля­ет путь ре­ше­ния за­да­чи.

2. Про­грам­ма пра­виль­но ра­бо­та­ет в одном из важ­ных част­ных слу­ча­ев, на­при­мер в слу­чае, когда ис­ко­мое про­из­ве­де­ние — это про­из­ве­де­ние наи­боль­ше­го числа, ко­то­рое де­лит­ся на 3, и наи­боль­ше­го числа, ко­то­рое де­лит­ся на 11.

До­пус­ка­ет­ся любое ко­ли­че­ство син­так­си­че­ских оши­бок.

До­пус­ка­ет­ся на­ли­чие в тек­сте про­грам­мы до трёх син­так­си­че­ских оши­бок од­но­го из сле­ду­ю­щих видов:

- про­пу­щен или не­вер­но ука­зан знак пунк­ту­а­ции;

- не­вер­но на­пи­са­но или про­пу­ще­но за­ре­зер­ви­ро­ван­ное слово языка про­грам­ми­ро­ва­ния;

- не опи­са­на или не­вер­но опи­са­на пе­ре­мен­ная;

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

Ко­ли­че­ство син­так­си­че­ских оши­бок («опи­сок») ука­зан­ных выше видов — не более пяти. Ис­поль­зу­е­мая па­мять, воз­мож­но, за­ви­сит от ко­ли­че­ства про­чи­тан­ных чисел (на­при­мер, вход­ные дан­ные за­по­ми­на­ют­ся в мас­си­ве или дру­гой струк­ту­ре дан­ных (кон­тей­нер priority queue, vector, set или map в С++)). До­пус­ка­ет­ся ошиб­ка при вводе дан­ных, не­вер­ный или не­пол­ный вывод ре­зуль­та­тов или не­вер­ная ра­бо­та про­грам­мы в «эк­зо­ти­че­ских» си­ту­а­ци­ях. На­при­мер, при ис­поль­зо­ва­нии 16-бит­но­го це­ло­го (integer в BPascal или Qbasic) умно­жа­ют­ся два числа этого типа (ре­зуль­тат по усло­вию может не по­ме­щать­ся в 16 бит).

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

1) Ошиб­ка при ини­ци­а­ли­за­ции мак­си­му­мов.

2) Не­вер­но об­ра­ба­ты­ва­ет­ся си­ту­а­ция, когда один или не­сколь­ко мак­си­му­мов не опре­де­ле­ны.

3) Не­вер­но об­ра­ба­ты­ва­ет­ся си­ту­а­ция, когда мак­си­маль­ное про­из­ве­де­ние по­лу­ча­ет­ся умно­же­ни­ем оди­на­ко­вых чисел (но раз­ных эле­мен­тов вход­ной по­сле­до­ва­тель­но­сти).

4) При вы­чис­ле­нии мак­си­му­мов учи­ты­ва­ют­ся про­из­ве­де­ния вида a[i]*a[i],

5) До­пу­щен выход за гра­ни­цу мас­си­ва.

6) До­пу­ще­на ошиб­ка в ре­а­ли­за­ции ал­го­рит­ма сор­ти­ров­ки.

7) Ис­поль­зу­ет­ся знак "<" вме­сто "<=", "or" вме­сто "and" и т.п.

На­при­мер, так:

max := 0;

for i := 1 to n - 1 do for j := i + 1 to n do

if ( (a[i]*a [ j] ) mod 35 = 0) and t(a[i]*a[j]) > max) then max := a[i]*a[ j];

1. Из опи­са­ния ал­го­рит­ма и общей струк­ту­ры про­грам­мы видно, что эк­за­ме­ну­е­мый в целом пра­виль­но пред­став­ля­ет путь ре­ше­ния за­да­чи.

2. Про­грам­ма пра­виль­но ра­бо­та­ет в одном из важ­ных част­ных слу­ча­ев, на­при­мер в слу­чае, когда ис­ко­мое про­из­ве­де­ние — это про­из­ве­де­ние наи­боль­ше­го числа, ко­то­рое де­лит­ся на 5, и наи­боль­ше­го числа, ко­то­рое де­лит­ся на 7.

До­пус­ка­ет­ся любое число син­так­си­че­ских оши­бок

- про­пу­щен или не­вер­но ука­зан знак пунк­ту­а­ции;

- не­вер­но на­пи­са­но или про­пу­ще­но за­ре­зер­ви­ро­ван­ное слово языка про­грам­ми­ро­ва­ния;

- не опи­са­на или не­вер­но опи­са­на пе­ре­мен­ная;

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

Ко­ли­че­ство син­так­си­че­ских оши­бок («опи­сок») ука­зан­ных выше видов — не более пяти.

Ис­поль­зу­е­мая па­мять, воз­мож­но, за­ви­сит от ко­ли­че­ства про­чи­тан­ных чисел (на­при­мер, вход­ные дан­ные за­по­ми­на­ют­ся в мас­си­ве или дру­гой струк­ту­ре дан­ных (кон­тей­нер priority queue, vector, set или map в С++)). До­пус­ка­ет­ся ошиб­ка при вводе дан­ных, не­вер­ный или не­пол­ный вывод ре­зуль­та­тов или не­вер­ная ра­бо­та про­грам­мы в «эк­зо­ти­че­ских» си­ту­а­ци­ях. На­при­мер, при ис­поль­зо­ва­нии 16-бит­но­го це­ло­го (integer в BPascal или Qbasic) умно­жа­ют­ся два числа этого типа (ре­зуль­тат по усло­вию может не по­ме­щать­ся в 16 бит). Кроме того, до­пус­ка­ет­ся на­ли­чие одной ошиб­ки, при­над­ле­жа­щей к од­но­му из сле­ду­ю­щих видов оши­бок.

1) Ошиб­ка при ини­ци­а­ли­за­ции мак­си­му­мов.

2) Не­вер­но об­ра­ба­ты­ва­ет­ся си­ту­а­ция, когда один или не­сколь­ко мак­си­му­мов не опре­де­ле­ны.

3) Не­вер­но об­ра­ба­ты­ва­ет­ся си­ту­а­ция, когда мак­си­маль­ное про­из­ве­де­ние по­лу­ча­ет­ся умно­же­ни­ем оди­на­ко­вых чисел (но раз­ных эле­мен­тов вход­ной по­сле­до­ва­тель­но­сти).

4) При вы­чис­ле­нии мак­си­му­мов учи­ты­ва­ют­ся про­из­ве­де­ния вида a[i]*a[i],

5) До­пу­щен выход за гра­ни­цу мас­си­ва.

6) До­пу­ще­на ошиб­ка в ре­а­ли­за­ции ал­го­рит­ма сор­ти­ров­ки.

7) Ис­поль­зу­ет­ся знак "<" вме­сто "<=", "or" вме­сто "and" и т.п.

max := 0;

for i := 1 to n - 1 do for j := i + 1 to n do

if ( (a[i]*a [ j] ) mod 21 = 0) and t(a[i]*a[j]) > max) then max := a[i]* a [ j] ;.

1. Из опи­са­ния ал­го­рит­ма и общей струк­ту­ры про­грам­мы видно, что эк­за­ме­ну­е­мый в целом пра­виль­но пред­став­ля­ет путь ре­ше­ния за­да­чи.

2. Про­грам­ма пра­виль­но ра­бо­та­ет в одном из важ­ных част­ных слу­ча­ев, на­при­мер в слу­чае, когда ис­ко­мое про­из­ве­де­ние - это про­из­ве­де­ние наи­боль­ше­го числа, ко­то­рое де­лит­ся на 3, и наи­боль­ше­го числа, ко­то­рое де­лит­ся на 7.

До­пус­ка­ет­ся любое ко­ли­че­ство син­так­си­че­ских оши­бок.

- про­пу­щен или не­вер­но ука­зан знак пунк­ту­а­ции;

- не­вер­но на­пи­са­но или про­пу­ще­но за­ре­зер­ви­ро­ван­ное слово языка про­грам­ми­ро­ва­ния;

- не опи­са­на или не­вер­но опи­са­на пе­ре­мен­ная;

- при­ме­ня­ет­ся опе­ра­ция, не­до­пу­сти­мая для со­от­вет­ству­ю­ще­го типа дан­ных (если одна и та же ошиб­ка встре­ча­ет­ся не­сколь­ко раз, то это счи­та­ет­ся за одну ошиб­ку)

Ко­ли­че­ство син­так­си­че­ских оши­бок («опи­сок») ука­зан­ных выше видов - не более пяти. Ис­поль­зу­е­мая па­мять, воз­мож­но, за­ви­сит от ко­ли­че­ства про­чи­тан­ных чисел (на­при­мер, вход­ные дан­ные за­по­ми­на­ют­ся в мас­си­ве или дру­гой струк­ту­ре дан­ных (кон­тей­нер priority queue, vector, set или map в С++)). До­пус­ка­ет­ся ошиб­ка при вводе дан­ных, не­вер­ный или не­пол­ный вывод ре­зуль­та­тов или не­вер­ная ра­бо­та про­грам­мы в «эк­зо­ти­че­ских» си­ту­а­ци­ях. На­при­мер, при ис­поль­зо­ва­нии 16-бит­но­го це­ло­го (integer в BPascal или Qbasic) умно­жа­ют­ся два числа этого типа (ре­зуль­тат по усло­вию может не по­ме­щать­ся в 16 бит). Кроме того, до­пус­ка­ет­ся на­ли­чие одной ошиб­ки, при­над­ле­жа­щей к од­но­му из сле­ду­ю­щих видов оши­бок.

1) Ошиб­ка при ини­ци­а­ли­за­ции мак­си­му­мов.

2) Не­вер­но об­ра­ба­ты­ва­ет­ся си­ту­а­ция, когда один или не­сколь­ко мак­си­му­мов не опре­де­ле­ны.

3) Не­вер­но об­ра­ба­ты­ва­ет­ся си­ту­а­ция, когда мак­си­маль­ное про­из­ве­де­ние по­лу­ча­ет­ся умно­же­ни­ем оди­на­ко­вых чисел (но раз­ных эле­мен­тов вход­ной по­сле­до­ва­тель­но­сти).

4) При вы­чис­ле­нии мак­си­му­мов учи­ты­ва­ют­ся про­из­ве­де­ния вида a[i]*a[i],

5) До­пу­щен выход за гра­ни­цу мас­си­ва.

6) До­пу­ще­на ошиб­ка в ре­а­ли­за­ции ал­го­рит­ма сор­ти­ров­ки.

7) Ис­поль­зу­ет­ся знак "<" вме­сто "<=", "or" вме­сто "and" и т.п.

max := 0;

for i := 1 to n - 1 do for j := i + 1 to n do

if ( (a[i]*a [ j] ) mod 22 = 0) and t(a[i]*a[j]) > max) then max := a[i]* a [ j] ;

1. Из опи­са­ния ал­го­рит­ма и общей струк­ту­ры про­грам­мы видно, что эк­за­ме­ну­е­мый в целом пра­виль­но пред­став­ля­ет путь ре­ше­ния за­да­чи.

2. Про­грам­ма пра­виль­но ра­бо­та­ет в одном из важ­ных част­ных слу­ча­ев, на­при­мер в слу­чае, когда ис­ко­мое про­из­ве­де­ние — это про­из­ве­де­ние наи­боль­ше­го числа, ко­то­рое де­лит­ся на 2, и наи­боль­ше­го числа, ко­то­рое де­лит­ся на 11.

До­пус­ка­ет­ся любое ко­ли­че­ство син­так­си­че­ских оши­бок.

- про­пу­щен или не­вер­но ука­зан знак пунк­ту­а­ции;

- не­вер­но на­пи­са­но или про­пу­ще­но за­ре­зер­ви­ро­ван­ное слово языка про­грам­ми­ро­ва­ния;

- не опи­са­на или не­вер­но опи­са­на пе­ре­мен­ная;

- при­ме­ня­ет­ся опе­ра­ция, не­до­пу­сти­мая для со­от­вет­ству­ю­ще­го типа дан­ных (если одна и та же ошиб­ка встре­ча­ет­ся не­сколь­ко раз, то это счи­та­ет­ся за одну ошиб­ку)

Про­грам­ма в целом ра­бо­та­ет пра­виль­но для любых вход­ных дан­ных про­из­воль­но­го раз­ме­ра. Время ра­бо­ты про­пор­ци­о­наль­но ко­ли­че­ству введённых чисел. Ко­ли­че­ство син­так­си­че­ских оши­бок («опи­сок») ука­зан­ных выше видов – не более пяти.

Ис­поль­зу­е­мая па­мять, воз­мож­но, за­ви­сит от ко­ли­че­ства про­чи­тан­ных чисел (на­при­мер, вход­ные дан­ные за­по­ми­на­ют­ся в мас­си­ве или дру­гой струк­ту­ре дан­ных(кон­тей­нерpriority_queue,

vector, set илиmap в С++)).

До­пус­ка­ет­ся ошиб­ка при вводе дан­ных, не­вер­ный или не­пол­ный вывод ре­зуль­та­тов или не­вер­ная ра­бо­та про­грам­мы в «эк­зо­ти­че­ских» си­ту­а­ци­ях. На­при­мер, при ис­поль­зо­ва­нии 16-бит­но­го це­ло­го (integer вBPascal илиQbasic) умно­жа­ют­ся два числа этого типа(ре­зуль­тат по усло­вию может не по­ме­щать­ся в16 бит).

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

1. До­пу­ще­на ошиб­ка при ини­ци­а­ли­за­ции мак­си­му­мов.

2. Не­вер­но об­ра­ба­ты­ва­ет­ся си­ту­а­ция, когда один или не­сколь­ко мак­си­му­мов не опре­де­ле­ны.

3. Не­вер­но об­ра­ба­ты­ва­ет­ся си­ту­а­ция, когда мак­си­маль­ное про­из­ве­де­ние по­лу­ча­ет­ся умно­же­ни­ем оди­на­ко­вых чисел (но раз­ных эле­мен­тов вход­ной по­сле­до­ва­тель­но­сти).

4. При вы­чис­ле­нии мак­си­му­мов учи­ты­ва­ют­ся про­из­ве­де­ния вида a[i]*a[i].

5. До­пу­щен выход за гра­ни­цу мас­си­ва.

6. До­пу­ще­на ошиб­ка в ре­а­ли­за­ции ал­го­рит­ма сор­ти­ров­ки.

7. Ис­поль­зу­ет­ся знак“<” вме­сто“<=”, “or” вме­сто“and” и т.п.

Про­грам­ма ра­бо­та­ет в целом верно, эф­фек­тив­но или нет, но в ре­а­ли­за­ции ал­го­рит­ма со­дер­жит­ся до двух со­дер­жа­тель­ных оши­бок, до­пу­сти­мые виды оши­бок пе­ре­чис­ле­ны в кри­те­ри­ях на 3 балла.

Ко­ли­че­ство син­так­си­че­ских«опи­сок» не долж­но быть более семи. Про­грам­ма может быть не­эф­фек­тив­на по вре­ме­ни. На­при­мер, все числа за­по­ми­на­ют­ся в мас­си­ве (ниже n – ко­ли­че­ство про­чи­тан­ных чисел), и пе­ре­би­ра­ют­ся все воз­мож­ные пары эле­мен­тов по­сле­до­ва­тель­но­сти.

На­при­мер, так:

max := 0;

for i := 1 to n - 1 do

for j := i + 1 to n do

if ((a[i]*a[j]) mod 21 = 0) and

((a[i]*a[j]) > max) then

max := a[i]*a[j];

При этом вы­пол­не­но одно из двух усло­вий.

1. Из опи­са­ния ал­го­рит­ма и общей струк­ту­ры про­грам­мы видно, что эк­за­ме­ну­е­мый в целом пра­виль­но пред­став­ля­ет путь ре­ше­ния за­да­чи.

2. Про­грам­ма пра­виль­но ра­бо­та­ет в одном из важ­ных част­ных слу­ча­ев, на­при­мер в слу­чае, когда ис­ко­мое про­из­ве­де­ние – это про­из­ве­де­ние наи­боль­ше­го числа, ко­то­рое де­лит­ся на3, и наи­боль­ше­го числа, ко­то­рое де­лит­ся на 7.

До­пус­ка­ет­ся любое ко­ли­че­ство син­так­си­че­ских оши­бок

Про­грам­ма может со­дер­жать не более трёх син­так­си­че­ских оши­бок сле­ду­ю­щих видов:

− про­пу­щен или не­вер­но ука­зан знак пунк­ту­а­ции (за­пя­тая, точка с за­пя­той, скоб­ки и т.д.);

− не­вер­но на­пи­са­но или про­пу­ще­но слу­жеб­ное слово языка про­грам­ми­ро­ва­ния;

− не опи­са­на или не­вер­но опи­са­на пе­ре­мен­ная;

− при­ме­ня­ет­ся опе­ра­ция, не до­пу­сти­мая для со­от­вет­ству­ю­ще­го типа дан­ных.

К син­так­си­че­ским ошиб­кам при­рав­ни­ва­ет­ся ис­поль­зо­ва­ние не­вер­но­го типа дан­ных (на­при­мер, ис­поль­зо­ва­ние це­ло­го типа вме­сто ве­ще­ствен­но­го для пред­став­ле­ния дан­ных при вводе и об­ра­бот­ке).

Если одна и та же ошиб­ка встре­ча­ет­ся не­сколь­ко раз, она счи­та­ет­ся за одну ошиб­ку.

Про­грам­ма может со­дер­жать не более пяти син­так­си­че­ских и при­рав­нен­ных к ним оши­бок, опи­сан­ных в кри­те­ри­ях на 4 балла. Кроме того, до­пус­ка­ет­ся на­ли­чие не более одной «со­дер­жа­тель­ной» ошиб­ки из числа сле­ду­ю­щих:

− не­вер­ная ини­ци­а­ли­за­ция при по­ис­ке ми­ни­маль­но­го зна­че­ния;

− не­вер­ная об­ра­бот­ка на­чаль­ных эле­мен­тов дан­ных, ко­то­рая может, на­при­мер, при­ве­сти к по­лу­че­нию оши­боч­но­го от­ве­та при 6 < N < 12;

− не­точ­ное опре­де­ле­ние гра­ниц мас­си­ва, выход за гра­ни­цу мас­си­ва (на­при­мер, опи­сан мас­сив с гра­ни­ца­ми от 1 до 6, а ре­аль­но ис­поль­зу­ет­ся от 0 до 5 или на­о­бо­рот);

− вы­чис­лен­ный ин­декс эле­мен­та мас­си­ва на 1 от­ли­ча­ет­ся от вер­но­го;

− ис­поль­зу­ет­ся знак “<” вме­сто “<=”, “or” вме­сто “and” и т. п.