Лекция: ЗНАЧЕНИЕ ПЕРЕМЕННОЙ S РАВНО:0
ЗНАЧЕНИЕ ЦЕЛОЧИСЛЕННОЙ ПЕРЕМЕННОЙ S РАВНО: 81
- В РЕЗУЛЬТАТЕ ВЫПОЛНЕНИЯ ОПЕРАТОРОВ ПРОГРАММЫ
int S= 0, i=1;
for(int j= 1; j<= 3; j++)
S= i + j;
ЗНАЧЕНИЕ ЦЕЛОЧИСЛЕННОЙ ПЕРЕМЕННОЙ S РАВНО:4
- В РЕЗУЛЬТАТЕ ВЫПОЛНЕНИЯ ОПЕРАТОРОВ ПРОГРАММЫ
int S = 128;
for (int i= 1; i<= 4;i++ )
S = S – 3;
ЗНАЧЕНИЕ ЦЕЛОЧИСЛЕННОЙ ПЕРЕМЕННОЙ S РАВНО:116
- В РЕЗУЛЬТАТЕ ВЫПОЛНЕНИЯ ОПЕРАТОРОВ ПРОГРАММЫ
for (int i= 1; i <=3; i++)
{
int S = 0;
for(int j =1; j <=3; j++)
S = i + j;
}
ЗНАЧЕНИЕ ЦЕЛОЧИСЛЕННОЙ ПЕРЕМЕННОЙ S РАВНО:6
- В РЕЗУЛЬТАТЕ ВЫПОЛНЕНИЯ АЛГОРИТМА
int S= 0, i =0;
while (i < 3)
{ i= i + 1;
S = S + i * i;
}
ЗНАЧЕНИЕ ЦЕЛОЧИСЛЕННОЙ ПЕРЕМЕННОЙ S РАВНО:14
- В РЕЗУЛЬТАТЕ ВЫПОЛНЕНИЯ АЛГОРИТМА
int S = 0, i =1;
while ( i > 1)
{ S = S + 1/ i;
i = i – 1;
}
ЗНАЧЕНИЕ ПЕРЕМЕННОЙ S РАВНО:0
_______________________________________________________________________________гр.12______________________________________________________________________
- ИСТИННЫЕ ВЫСКАЗЫВАНИЯ:
1. предложения с определением переменных не являются операторами
2. в С++ операторы разделяются символом «;»
3. составной оператор – это последовательность операторов, заключенная в скобки { }
4. в C++ операторы разделяются символом «пробел»
5. список выбора в операторе switch открывает скобка {
6. список выбора в операторе switch заканчивает скобка }
7. в операторе switch в разных вариантах выбора возможно пересечение набора значений
- ВО ВЛОЖЕННОМ УСЛОВНОМ ОПЕРАТОРЕ
if (условие1)
if (условие2) оператор1
else оператор2;
else ОТНОСИТСЯ К ОПЕРАТОРУ if, содержащему:
1. условие1
2. условие2
- В УСЛОВНОM ОПЕРАТОРЕ if В КАЧЕСТВЕ УСЛОВИЯ ДОПУСТИМО ВЫРАЖЕНИЕ:
1. арифметическое
2. логическое
3. отношения
- РЕЗУЛЬТАТ ВЫРАЖЕНИЯ, АНАЛИЗИРУЕМОГО В УСЛОВИИ ОПЕРАТОРА if, МОЖЕТ ИМЕТЬ ТИП:
1. перечисляемый
2. логический
3. целочисленный
4. вещественный
- УСЛОВНЫЙ ОПЕРАТОР
bool ba, bb, bc, bx;
if (ba) bx= true else
if( bb) bx=bc; else bx=false;
ЭКВИВАЛЕНТЕН ОПЕРАТОРУ ПРИСВАИВАНИЯ:
1. bx= ba || bb && bc;
2. bx= ba &&bb || bc;
3. bx= ba && bb && bc;
4. bx= ba || bb || bc;
- ЕСЛИ ПЕРЕМЕННАЯ b — логического типа, ТО ЗАПИСЬ
if ( b == true) .....:
1. абсолютно верна
2. верна, но лучше ее оптимизировать
3. неверна
- ЕСЛИ ПЕРЕМЕННАЯ b — логического типа, ТО ЗАПИСЬ
if ( b) .....:
1. абсолютно верна
2. верна, но лучше ее оптимизировать
3. неверна
- ЕСЛИ ПЕРЕМЕННАЯ k – целого типа, ТО ЗАПИСЬ
if ( k) .....:
1. абсолютно верна
2. верна, но лучше ее оптимизировать
3. абсолютно неверна
- ЕСЛИ ПЕРЕМЕННАЯ х – вещественного типа, ТО ЗАПИСЬ
if ( х) .....:
1. абсолютно верна
2. верна, но лучше ее оптимизировать
3. неверна
- ЕСЛИ bool bb; unsigned ux, uy;
ТО ЗАПИСЬ
if (ux==uy) bb=true; :
1. абсолютно верна
2. верна, но лучше ее оптимизировать
3. неверна
- ЕСЛИ bool bb; unsigned ux, uy;
ТО ЗАПИСЬ
bb= (ux==uy); :
1. абсолютно верна
2. верна, но лучше ее оптимизировать
3. неверна
- ЕСЛИ ПЕРЕМЕННЫЕ ia, ib, ix — целочисленного типа, ТО ЗАПИСЬ ВЫРАЖЕНИЯ
if (ia & ib) ix=ia; :
1. верна
2. можно исправить на if (ia & ib) bool(ix)=ia;
3. неверна
4. можно исправить на if( bool(ia & ib)) ix=ia;
5. можно исправить на if( bool(ia) & bool (ib)) ix=ia;
6. можно исправить на if (ia & ib) ix= bool(ia);
- ОПЕРАТОРУ if (x> 15) x= x-15;
РАВНОСИЛЬНЫ ОПЕРАТОРЫ:
1. x = x-15 * unsigned(x>15);
2. x= x-15 * int (x-15);
3. x = x-15 * bool(x>15);
4. x = x-15 * bool(x-15);
5. x = (x-15) * unsigned(x>15);
6. x= (x-15) * int (x-15);
7. x = (x-15) * bool(x>15);
8. x = (x-15) * bool(x-15);
_______________________________________________________________________________гр.13______________________________________________________________________
- ВЫЧИСЛИТЬ z=x*y, ПОЛЬЗУЯСЬ ТОЛЬКО ОПЕРАЦИЕЙ СЛОЖЕНИЯ, МОЖНО С ПОМОЩЬЮ ОПЕРАТОРОВ:
1. x++;
2. z=0; c=1;
3. while (с <= y) {
4. while (z <= y) {
5. z +=x;
6. c++;
7. int c, z, x=2, y=3;
8. z +=x;}
9. c++;}
1. 7, 2, 3, 5, 9
2. 7, 2, 3, 6, 8
3. 2, 7, 3, 5, 9
4. 2, 7, 3, 6, 8
5. 7, 2, 4, 5, 9
6. 7, 2, 4, 6, 8
7. 2, 7, 4, 5, 9
8. 2, 7, 4, 6, 8
- ВИД ТРЕУГОЛЬНИКА ПО ТРЕМ ЕГО СТОРОНАМ a, b, c
(a>0, b>0, c >0 и удовлетворяют неравенству треугольника)
ПОЗВОЛЯЮТ ОПРЕДЕЛИТЬ ОПЕРАТОРЫ:
1. if ((a==b) && (b==c)) cout << «ravnostor»; else
2. if ((a==b) || (b==c) || (a==c)) cout << «ravnobedr»;
3. else cout << «raznostor»;
4. if ((a==b) || (b==c)) cout << «ravnostor»; else
5. if ((a==b) && (b==c) || (a==c)) cout << «ravnobedr»;
6. if ((a==b) || (b==c) || (a==c)) cout << «ravnobedr»; else
7. if ((a==b) && (b==c)) cout << «ravnostor» ;
1. 1, 2, 3
2. 6, 7, 3
3. 7, 2, 3
4. 4, 2, 3
- В РЕЗУЛЬТАТЕ ВЫПОЛНЕНИЯ ФРАГМЕНТА КОДА
int main()
{double a=1, b=1, c=1.5;
if ((a==b) && (b==c)) cout << «ravnostor» << endl;
if ((a==b) || (b==c) || (a==c)) cout << «ravnobedr»;
else cout << «raznostor»;
_getch();
return 0;
}
БУДЕТ НАПЕЧАТАНО:
1. ravnostor
ravnobedr
2. ravnostor
3. ravnobedr
4. raznostor
5. ничего не напечатается
- В РЕЗУЛЬТАТЕ ВЫПОЛНЕНИЯ ФРАГМЕНТА КОДА
int main()
{int a=1, b=1, c=1.5;
if ((a==b) && (b==c)) cout << «ravnostor» << endl;
if ((a==b) || (b==c) || (a==c)) cout << «ravnobedr»;
else cout << «raznostor»;
_getch();
return 0;
}
БУДЕТ НАПЕЧАТАНО:
1. ravnostor
ravnobedr
2. ravnostor
3. ravnobedr
4. raznostor
5. ничего не напечатается
_______________________________________________________________________________гр.14______________________________________________________________________
- СЕМАНТИКА ОПЕРАТОРА while :
1. проверка «условия» цикла при входе в цикл
2. если результат выражения в «условии»,
приведенный к типу bool, равен true, то выполнение тела цикла
3. модификация в теле цикла значений переменных, используемых в «условии» цикла
4. переход на проверку «условия» цикла
5. инициализация до цикла значений переменных, используемых в «условии» цикла
6. если результат выражения в «условии»,
приведенный к типу bool, равен false, товыход из цикла
7. инициализация в цикле значений переменных, используемых в «условии» цикла
1. 5, 1, 2, 6, 3, 4
2. 5, 1, 6, 2, 3, 4
3. 1, 7, 2, 6, 3, 4
4. 1, 7, 6, 2, 3, 4
5. 7, 2, 6, 3, 4
6. 7, 6, 2, 3, 4
7. 5, 1, 3, 6, 2, 4
8. 5, 1, 3, 2, 6, 4
- СЕМАНТИКА ОПЕРАТОРА do…while:
1. выполнение собственно тела цикла
2. если результат выражения в «условии»,
приведенный к типу bool, равен true, товыполнение тела цикла
3. модификация в теле цикла значений переменных, используемых в «условии» цикла
4. переход на проверку «условия» цикла
5. инициализация до цикла значений переменных, используемых в «условии» цикла
6. если результат выражения в «условии»,
приведенный к типу bool, равен false, то выход из цикла
7. инициализация в цикле значений переменных, используемых в «условии» цикла
1. 5, 1, 3, 4, 2, 6
2. 5, 1, 3, 4, 6, 2
3. 5, 3, 1, 4, 6, 2,
4. 5, 3, 1, 4, 2, 6
5. 5, 1, 4, 2, 6, 3
6. 5, 1, 4, 6, 2, 3
7. 1, 7, 4, 2, 6, 3
8. 1, 7, 4, 6, 2, 3
- СЕМАНТИКА ОПЕРАТОРА for
1. проверка «условия» цикла
2. если результат выражения в «условии»,
приведенный к типу bool, равен true, то выполнение тела цикла
3. модификация значений переменных, используемых в «условии» цикла
4. переход на проверку «условия» цикла
5. инициализация до цикла значений переменных, используемых в «условии» цикла
6. если результат выражения в «условии»,
приведенный к типу bool, равен false, товыход из цикла
7. инициализация в заголовке цикла значений переменных, используемых в «условии» цикла
1. 5, 1, 2, 6, 3, 4
2. 5, 1, 6, 2, 3, 4
3. 1, 7, 2, 6, 3, 4
4. 1, 7, 6, 2, 3, 4
5. 7, 1, 2, 6, 3, 4
6. 7, 1, 6, 2, 3, 4
7. 5, 1, 3, 6, 2, 4
8. 5, 1, 3, 2, 6, 4
_______________________________________________________________________________гр.15______________________________________________________________________
- ИСТИННЫЕ ВЫСКАЗЫВАНИЯ:
1. в операторе switch безразлична последовательность размещения вариантов выбора
2. в операторе switch размещение наиболее вероятных вариантов выбора перед остальными позволит повысить эффективность работы
3. символ «;» завершает оператор в C++
4. в тело цикла нельзя войти, минуя его заголовок
5. досрочный выход из цикла недопустим
6. количество операторов в теле цикла ограничено
7. цикл while может содержать вложенные циклы
- ИСТИННЫЕ ВЫСКАЗЫВАНИЯ:
1. в операторе цикла с постусловием ключевые слова do и while выполняют роль операторных скобок { и }
2. оператор do…while можно использовать для записи циклов, в которых тело цикла не должно выполняться ни разу
3. оператор for имеет менее широкую сферу применения, чем операторы while и do…while
4. тело цикла с предусловием не выполнится ни разу, если условие с самого начала имеет значение false
5. цикл с предусловием может использоваться при вычислении сумм и произведений с неизвестным числом слагаемых или сомножителей
6. цикл с постусловием удобно использовать для организации проверки вводимых данных
7. истинность выражения в цикле с постусловием является условием завершения цикла
- ИСТИННЫЕ ВЫСКАЗЫВАНИЯ:
1. для оператора for инициализация счетчика цикла происходит до цикла
2. для оператора for данные для инициализации счетчика цикла указываются в заголовке цикла
3. счетчик цикла в операторе for может иметь перечисляемый тип
4. в операторе for изменение значения счетчика цикла в теле цикла программистом не допускается
5. счетчик цикла в операторе for должен иметь целочисленный тип
6. для оператора цикла while инициализация значения условия выполнения цикла делается до цикла
7. в операторе for изменение значения переменной цикла на 1 происходит автоматически
- ЕСЛИ Е1 < Е2, ТО В ОПЕРАТОРЕ ЦИКЛА for (int v=E1; v <= E2; v++) S; :
1. оператор S выполнится 1 раз
2. оператор S не выполнится ни разу
3. компилятор выдаст ошибку
4. произойдет зацикливание программы
5. оператор S выполнится E2- E1+1 раз
6. оператор S выполнится E2- E1 раз
7. оператор S выполнится E2- E1-1 раз
- ЕСЛИ Е1 = Е2, ТО В ОПЕРАТОРЕ ЦИКЛА for (int v=E1; v <= E2; v++) S;:
1. оператор S выполнится 1 раз
2. оператор S не выполнится ни разу
3. компилятор выдаст ошибку
4. произойдет зацикливание программы
5. оператор S выполнится E2- E1+1 раз
6. оператор S выполнится E2- E1 раз
7. оператор S выполнится E2- E1-1 раз
- ЕСЛИ Е1 > Е2, ТО В ОПЕРАТОРЕ ЦИКЛА for (int v=E1; v <= E2; v++) S; :
1. оператор S выполнится 1 раз
2. оператор S не выполнится ни разу
3. компилятор выдаст ошибку
4. произойдет зацикливание программы
- ЕСЛИ Е1 > Е2, ТО В ОПЕРАТОРЕ ЦИКЛА for (int v=E1; v <= E2; v--) S; :
1. оператор S не выполнится ни разу
2. компилятор выдаст ошибку
3. произойдет зацикливание программы
4. оператор S выполнится |E1- E2|+1 раз
5. оператор S выполнится |E1- E2| раз
6. оператор S выполнится |E1- E2|-1 раз
- ЕСЛИ Е1 = Е2, ТО В ОПЕРАТОРЕ ЦИКЛА for (int v=E1; v <= E2; v--) S; :
1. оператор S не выполнится ни разу
2. компилятор выдаст ошибку
3. произойдет зацикливание программы
4. оператор S выполнится 1 раз
- ЕСЛИ Е1< Е2, ТО В ОПЕРАТОРЕ ЦИКЛА for (int v=E1; v <= E2; v--) S; :
1. оператор S не выполнится ни разу
2. компилятор выдаст ошибку
3. произойдет зацикливание программы
4. оператор S выполнится 1 раз
- ПОСЛЕ ЗАВЕРШЕНИЯ ОПЕРАТОРА ЦИКЛА for ЗНАЧЕНИЕ СЧЕТЧИКА ЦИКЛА:
1.равно его последнему значению
2. равно его первому значению
3. не определено
4. зависит от компилятора
- «ПОКА УСЛОВИЕ ИСТИННО» ВЫПОЛНЯЕТСЯ ЦИКЛ:
1. for
2. while
3. do…while
- ПОСЛЕДОВАТЕЛЬНЫЙ ХОД ВЫПОЛНЕНИЯ ОПЕРАТОРОВ ТЕЛА ЦИКЛА МОЖЕТ НАРУШИТЬ:
1. break
2. continue
3. exit()
4. if
5. switch
6. return
7. goto
- ИСТИННЫЕ ВЫСКАЗЫВАНИЯ:
1. внутренний и внешний циклы могут быть реализованы операторами цикла разных видов
2. вещественная переменная может быть счетчиком цикла оператора for
3. в качестве счетчиков вложенных циклов for нельзя использовать одну и ту же переменную
4. любой цикл for можно реализовать при помощи цикла while
5. любой цикл while можно реализовать при помощи цикла for
6. модификация в теле цикла значений переменных условия есть возможность завершения цикла
_______________________________________________________________________________гр.16______________________________________________________________________
- ЕСЛИ B > A-1, ТО ЧИСЛО ПОВТОРЕНИЙ ЦИКЛА for (int i = A; i<= B; i++) РАВНО:
1. B — A +1
2. 0
3. В-А
- ЕСЛИ B < A, ТО ЧИСЛО ПОВТОРЕНИЙ ЦИКЛА for (int i = A; i<= B; i++) РАВНО:
1. B — A +1
2. 0
3. В-А
- ЕСЛИ A>= B-1, ТО ЧИСЛО ПОВТОРЕНИЙ ЦИКЛА for (int i = A; i<= B; i++) РАВНО:
1.A — B +1
2. 0
3. В-А
- ЕСЛИ A< B, ТО ЧИСЛО ПОВТОРЕНИЙ ЦИКЛА for (int i = A; i<= B; i++) РАВНО:
1. B — A +1
2. 0
3. В-А
- ПРИМЕРЫ БЕСКОНЕЧНОГО ЦИКЛА:
1. do…while (true);
2. do…while (false);
3. while (false)….;
4. while (true)….;
5. for (; ;);
6. for (int i=0, ii=0; i<100; ii++);
7. for (int i=4; i<=5; i--);
8. for(int i=false; i<=true; i++);
- НИ РАЗУ НЕ ВЫПОЛНИТСЯ ТЕЛО ЦИКЛА:
1. for (int i=0; i<10; i++);
2. for (int i=10; i<=10; i++);
3. for (int i=10; i>=0; i--);
4. for (int i=true; i<=false; i++);
5. for(int i=false; i<=true; i++);
6. for (int i=5; i<4; i++);
7. for (int i=5; i<=5; i++);
8. for (int i=4; i<=5; i--);
- ОДИН РАЗ БУДЕТ ВЫПОЛНЯТЬСЯ ТЕЛО ЦИКЛА:
1 for (int i=5; i<=5; i++);
2. for (int i=n; i<=n; i++);
3. for (int i=4; i>=4; i--);
4. for (int i=0; i<=1; i++);
5. for (int i=1; i>=0; i--);
6. for(int i=false; i<true; i++);
_______________________________________________________________________________гр.17______________________________________________________________________
- ИСТИННЫЕ ВЫСКАЗЫВАНИЯ:
1. в теле цикла со счетчиком значение счетчика не должно изменяться программистом
2. при организации цикла с параметром с помощью цикла с предусловием шаг приращения параметра определяется программистом
3. итерационный цикл можно организовать с помощью цикла со счетчиком
4. итерационный цикл можно организовать с помощью цикла с постусловием
5. нельзя полагаться на факт, что после завершения цикла for счетчик цикла будет равен конечному значению
6. конструкция оператора цикла for (int i=1; i<=78; i=i+2); является ошибочной
7. оператор цикла do…while по отношению к оператору цикла while не даст выигрыша во времени
- ИЗ ЦИКЛА МОЖНО ВЫЙТИ ДОСРОЧНО С ПОМОЩЬЮ:
1. return
2. continue
3. break
4. exit()
5. изменения значения счетчика цикла на значения, выходящие за конечное значение
- ПЕРЕХОД К ВЫПОЛНЕНИЮ СЛЕДУЮЩЕЙ ИТЕРАЦИИ В ЦИКЛЕ for ОБЕСПЕЧИТ:
1. continue
2. break
3. exit()
4. goto
- ЧИСЛО ПОВТОРЕНИЙ ЦИКЛА СО СЧЕТЧИКОМ ПРИ ТАБУЛИРОВАНИИ ФУНКЦИИ НА ОТРЕЗКЕ:
(a, b, h>0 есть нижняя, верхняя границы и шаг изменения переменной):
1. i= int ((b-a)/h)+1
2. i= floor ((b-a)/h)+1
3. i= ceil ((b-a)/h)+1
- ИСТИННЫЕ ВЫСКАЗЫВАНИЯ:
1. количество повторений цикла со счетчиком определяется значениями нижней и верхней границ и шага изменения переменной
2. оператор цикла for по отношению к операторам while и do дает выигрыш во времени на 10-15%
3. содержимое тела цикла c предусловием должно обязательно влиять на значение переменных условия цикла
4. для цикла с предусловием условие цикла должно состоять из корректных выражений и значений, определенных еще до первого выполнения тела цикла
5. для всех видов циклов необходимо позаботиться oб инициализации переменной, в которой накапливается результат
6. в условии цикла с предусловием должна использоваться переменная только целого типа
7. формула i=[(b-a)/h]+1 позволяет организовать переход от цикла с предусловием (или постусловием) к циклу со счетчиком
- ЦИКЛ for ПОЗВОЛЯЕТ:
1. использовать в качестве счетчика цикла переменные только целого и вещественного типов
2. включать в спецификацию цикла несколько инициализирующих и модифицирующих выражений, используя операцию запятая
3. использовать приращение, отличное от 1
4. изменять значение счетчика цикла в геометрической прогрессии
5. использовать выражения для вычисления значения счетчика цикла
6. проверять в заголовке цикла любое другое условие, отличное от проверки числа итераций
7. использовать неполный список выражений в заголовке цикла
8. вводить значения счетчика цикла прямо в заголовке цикла
9. изменять в теле цикла переменные, входящие в выражение спецификации цикла
- ЗАВЕРШАЕТ ВЫПОЛНЕНИЕ ПРОГРАММЫ :
1. return
2. _getch()
3. exit()
4. break
- ЗАВЕРШАЕТ ВЫПОЛНЕНИЕ ПРОГРАММНОГО БЛОКА :
1. return
2. _getch()
3. exit()
4. break
_______________________________________________________________________________гр.18______________________________________________________________________
- ИСТИННЫЕ ВЫСКАЗЫВАНИЯ:
1. для корректного входа в цикл while необходима инициализация переменных условия цикла
2. для корректного завершения цикла while в его теле должны присутствовать операторы, модифицирующие значение переменной условия цикла
3. цикл while завершается, когда значение условия цикла становится ложным
4. цикл while обязательно выполняется как минимум один раз
5. независимо от количества операторов в теле цикла while, использование составного оператора не требуется
6. цикл while повторяется пока значение условия цикла истинно
7. цикл while не выполнится ни разу, если при входе в цикл значение условия цикла ложно
- ИСТИННЫЕ ВЫСКАЗЫВАНИЯ:
1. для корректного входа в цикл do..while необходима инициализация переменных условия цикла
2. для корректного выполнения цикла do…while, в его теле необходимо модифицировать значение переменной условия цикла
3. цикл do…while завершается, когда значение условия цикла становится ложным
4. цикл do…while выполняется, как минимум, один раз
5. независимо от количества операторов в теле цикла do…while, использование фигурных скобок не требуется
6. цикл do…while работает пока значение условия повторения ложно
7. цикл do…while не выполнится ни разу, если исходное значение условия повторения при входе в цикл равно true
- ИСТИННЫЕ ВЫСКАЗЫВАНИЯ:
1. для корректного выполнения циклов while и do…while необходима инициализация переменных условия цикла
2. в теле циклов while и do…while должны присутствовать операторы, модифицирующие значение переменных в условии цикла так, чтобы цикл смог завершиться
3. цикл while и цикл do…while завершаются, когда условие повторения становится ложным
4. циклы while и do…while обязательно выполняются как минимум один раз
5. независимо от количества операторов в теле цикла while и цикла do…while, использование фигурных скобок не требуется
6. циклы while и do…while работают пока условие повторения истинно
7. циклы while и do…while не выполнятся ни разу, если исходное значение условия повторения при входе в цикл равно false
- ИСТИННЫЕ ВЫСКАЗЫВАНИЯ:
1. инициализация счетчика цикла for до заголовка цикла не требуется
2. для корректного завершения цикла for в его теле должны присутствовать операторы, модифицирующие значение счетчика цикла
3. изменение счетчика цикла for в теле цикла не допускается
4. цикл for обязательно выполняется как минимум один раз
5. работа цикла for может быть нарушена использованием break и continue
6. цикл for не выполнится ни разу, если начальное значение счетчика цикла превосходит конечное
_______________________________________________________________________________гр.19______________________________________________________________________
- ДЛЯ ОБЕСПЕЧЕНИЯ ВОЗМОЖНОСТИ ПРИ ВЫЧИСЛЕНИИ n! УВЕЛИЧЕНИЯ ВЫЧИСЛЯЕМОГО ЗНАЧЕНИЯ n НЕОБХОДИМО И ДОСТАТОЧНО:
1. изменение типа результата
2. изменение типа n
3. изменение типа результата и типа n
- ОПТИМИЗАЦИЯ ФРАГМЕНТА ПРОГРАММЫ
for (j=1; j<=dim; j++) {
s1=0.0; s2= 0.0; dt=1.5;
x1[j] =0; y1[j]=0;
for (k=0; k<= bound; k++) {
x1[j] =x1[j] + dt* mult1[k] * slope1[k][j];
y1[j] =y1[j] + dt* mult2[k] * slope2[j];
}
error[j]:= x1[j]+y1[j];
}
ВОЗМОЖНА ЗА СЧЕТ:
1. вынесения операции суммирования при вычислении x1[j] и y1[j] из внутреннего цикла во внешний
2. вынесения множителя dt из внутреннего цикла
3. замены значений x1[j] и y1[j] на некоторые вспомогательные переменные, вычисляемые в цикле по j
4. вынесения множителя slope2[j] во внешний цикл
5. замены конечного значения параметра цикла
- ОПТИМИЗАЦИЯ ФРАГМЕНТА ПРОГРАММЫ
for (i=0; i<= bound; i++) {
s=0.0;
for (j=1; j<=dim; j++)
for (k=0; k<= i-1; k++) {
s = s + dt * weight[i][k] * slope[k][j];
z[i][j] = x0[j]+ 2.314* y;
}
f (t0+abscissa[i] * dt, z[i], slope[i], s);
}
ВОЗМОЖНА ЗА СЧЕТ:
1. вынесения из внутреннего цикла в средний операции суммирования при вычислении s
2. вынесения из внутреннего цикла во внешний операции суммирования при вычислении s
3. вынесения из внутреннего цикла в средний операции умножения на dt при вычислении s
4. вынесения из внутреннего цикла во внешний операции умножения на dt при вычислении s
5. вынесения из внутреннего цикла в средний вычисления z[i][j]
6. замены слагаемого 2.314* y на переменную, вычисленную вне циклов
7. замены порядка вложенности циклов на i, k, j
- ОПТИМИЗАЦИЯ ФРАГМЕНТА ПРОГРАММЫ
t=t0;
for (i=0; i<= 3000; i++)
for (k=0; i<= 3; i++) {
x[k][1]=cos(t) + 0.1* h1*k;
x[k][2]=sin(t) + 0.01* h2*k;
f(t, x[k], dx[k]);
}
ВОЗМОЖНА ЗА СЧЕТ:
1. изменения порядка вложенности циклов
2. вычисления значений cos(t) и sin(t) вне циклов
3. вычислений значений 0.1* h1 и 0.01* h2 вне циклов
4. вынесения вычисления x[k][1] и x[k][2] во внешний цикл по k
5. вынесения вызова функции во внешний цикл по k
6. представления тела внутреннего цикла пустым оператором
7. вычисления вне циклов операции суммирования
- ОПТИМИЗАЦИЯ ВЫЧИСЛЕНИЙ ПРИ РАЗЛОЖЕНИИ ФУНКЦИИ В РЯД ТЕЙЛОРА ВОЗМОЖНА ЗА СЧЕТ:
1. последовательного вычисления значений каждого слагаемого полностью
2. определения рекуррентного соотношения для вычисления последующих членов ряда через предыдущие
3. накопления отдельных слагаемых в массиве
4. организации цикла с параметром
5. определения и использования любых закономерностей при вычислении суммы ряда
_______________________________________________________________________________гр.20______________________________________________________________________
- ВВЕДЕНИЕ ОПЕРАТОРА if В СЛЕДУЮЩЕМ ФРАГМЕНТЕ ПРОГРАММЫ
for (i=1; i<= N; i++) {
if (i== 1) {
sx=0; sy=0; sxy=0;
}
cin >> x>> y;
sx=sx+x;
sy=sy+y;
sxy=sxy+ x*y;
}
ЯВЛЯЕТСЯ:
1. правильным
2. неправильным
3. цикл «утяжеляется»
4. при изменении программы это убережет от повторного входа в цикл без инициализации
5. ничего не изменяющим
- ЗАМЕЧАНИЯ ПО ФРАГМЕНТУ ПРОГРАММЫ:
double s;
int i;
double stepen (int n, int i) {
s=0;
for (int i=1; i<= 64; i++) {
s= s+ stepen (2, i-1);
if (s > 1E9) i=100;
}
cout << s << endl;
}
1. параметр цикла i изменяется в его теле
2. нельзя использовать локальную переменную с тем же именем, что и глобальная
3. нельзя использовать оператор cout
4. в функции повторно инициализируется параметр-значение i
5. в теле функции нет завершающего оператора return
6. в функции не используется параметр-значение n
7. в функции нет ограничивающего условия на рекурсию
8. в функции повторно определяется параметр-значение i
- ОПТИМИЗАЦИЯ ФРАГМЕНТА ПРОГРАММЫ
for (int i=1; i<= n; i++) {
for (int k=1; k<= p; k++)
for (int m=1; m<= q; m++) {
a[k][m] = sqrt(x*k*m-i) + abs(u*i-x*m+k);
b[k][m] = sin(x*k*i) + abs(u*i*m+k);
}
am=0; bm=0;
for (int k=1; k<= p; k++)
for (int m=1; m<= q; m++) {
am= am + a[k][m] / c[k];
bm= bm + a[k][m] / c[k];
}
}
ВОЗМОЖНА ЗА СЧЕТ:
1. вынесения множителя 1/c[k] при вычислении am и bm из внутреннего цикла по m в средний цикл по k с заменой его на переменную
2. удаления из внутреннего цикла по m операции + и выполнение суммирования для вычисления am и bm вне циклов
3. вынесения из внутреннего цикла по m в средний цикл по k вычисления слагаемого sin(x*k*i)
4. изменения цикла с параметром на цикл с предусловием
5. изменения порядка вложенности циклов на i, m, k
- ИЗ ФРАГМЕНТОВ ПРОГРАММЫ
1. int summa = 0;
for (int j=1; j<= 1000; j++)
summa = summa + a*x[i];
2. int summa = 0;
for (int j=1; j<= 1000; j++)
summa = summa + x[i];
summa = a* summa;
ОПТИМАЛЬНЫМ ЯВЛЯЕТСЯ:
1. фрагмент номер 1
2. фрагмент номер 2
3. так как имеет более короткую форму записи операторов
4. так как имеет оптимальную логику вычислений
5. так как выполняет 1000 сложений
6. так как выполняет 1000 умножений
7. так как выполняет одно умножение
8. так как выполняет одно присваивание
- ИЗ ПРЕДСТАВЛЕННЫХ ФРАГМЕНТОВ ПРОГРАММЫ:
1: for(int j=1; j <= 100000; j++)
for(int k=1; k <=1000; k++)
a=1;
2: for(int j=1; j <= 1000; j++)
for(int k=1; k <=100000; k++)
a=1;
БОЛЕЕ ЭФФЕКТИВНА ПОСЛЕДОВАТЕЛЬНОСТЬ ОПЕРАТОРОВ:
1. 1
2. 2
3. так как обработка заголовка внутреннего цикла с целью инициализации цикла выполняется меньшее количество раз
4. так как обработка заголовка внутреннего цикла с целью инициализации цикла выполняется большее количество раз
_______________________________________________________________________________гр.21______________________________________________________________________
- ЕСЛИ а=0, b≠0, с≠0, ТО ПОСЛЕДОВАТЕЛЬНОСТЬ
ПРОХОЖДЕНИЯ ОПЕРАТОРОВ ФРАГМЕНТА ПРОГРАММЫ
/*_1_*/ if (a==0) { cout << “11111”<< endl; exit(1); }
/*_2_*/ if (b==0) { cout << “22222”<< endl; exit(2); }
/*_3_*/ if (c==0) { cout << “33333”<< endl; exit(3); }
/*_4_*/ cout << “44444”<< endl;
/*_5_*/ return 0;
СЛЕДУЮЩАЯ:
1. 1, 2, 3, 4, 5
2. 1, 4, 5
3. 1, 2, 4, 5
4. 1
- ЕСЛИ а=0, b≠0, с≠0, ТО ПОСЛЕДОВАТЕЛЬНОСТЬ
ПРОХОЖДЕНИЯ ОПЕРАТОРОВ ФРАГМЕНТА ПРОГРАММЫ
/*_1_*/ if (a==0) { cout << “11111”<< endl; }
/*_2_*/ if (b==0) { cout << “22222”<< endl; exit(2); }
/*_3_*/ if (c==0) { cout << “33333”<< endl; exit(3); }
/*_4_*/ cout << “44444”<< endl;
/*_5_*/ return 0;
СЛЕДУЮЩАЯ:
1. 1, 2, 3, 4, 5
2. 1, 4, 5
3. 1, 2, 4, 5
4. 1, 2, 5
5. 1, 5
- ЕСЛИ а=0, b≠0, с≠0, ТО ПОСЛЕДОВАТЕЛЬНОСТЬ
ПРОХОЖДЕНИЯ ОПЕРАТОРОВ ФРАГМЕНТа ПРОГРАММЫ
/*_1_*/ if (a==0) { cout << “11111”<< endl; }
/*_2_*/ if (b==0) { cout << “22222”<< endl; }
/*_3_*/ if (c==0) { cout << “33333”<< endl; }
/*_4_*/ cout << “44444”<< endl;
/*_5_*/ return 0;
СЛЕДУЮЩАЯ:
1. 1, 2, 3, 4, 5
2. 1, 4, 5
3. 1, 2, 4, 5
4. 1, 2, 3, 5
- ЕСЛИ b=0, a≠0, с≠0, ТО ПОСЛЕДОВАТЕЛЬНОСТЬ
ПРОХОЖДЕНИЯ ОПЕРАТОРОВ В ФРАГМЕНТЕ ПРОГРАММЫ
/*_1_*/ if (a==0) { cout << “11111”<< endl; exit(1); }
/*_2_*/ if (b==0) { cout << “22222”<< endl; exit(2); }
/*_3_*/ if (c==0) { cout << “33333”<< endl; exit(3); }
/*_4_*/ cout << “44444”<< endl;
/*_5_*/ return 0;
СЛЕДУЮЩАЯ:
1. 1, 2, 3, 4, 5
2. 1, 2, 3
3. 1, 2
4. 1, 2, 3, 5
5. 1
- ЕСЛИ b=0, a≠0, с≠0,0, ТО ПОСЛЕДОВАТЕЛЬНОСТЬ
ПРОХОЖДЕНИЯ ОПЕРАТОРОВ ФРАГМЕНТА ПРОГРАММЫ
/*_1_*/ if (a==0) { cout << “11111”<< endl; exit(1); }
/*_2_*/ if (b==0) { cout << “22222”<< endl; }
/*_3_*/ if (c==0) { cout << “33333”<< endl; exit(3); }
/*_4_*/ cout << “44444”<< endl;
/*_5_*/ return 0;
СЛЕДУЮЩАЯ:
1. 1, 2, 3, 4, 5
2. 1, 2, 4, 5
3. 1, 4, 5
4. 1, 2, 3
5. 1
- ЕСЛИ c=0, a≠0, b≠0, ТО ПОСЛЕДОВАТЕЛЬНОСТЬ
ПРОХОЖДЕНИЯ ОПЕРАТОРОВ ФРАГМЕНТА ПРОГРАММЫ
/*_1_*/ if (a==0) { cout << “11111”<< endl; exit(1); }
/*_2_*/ if (b==0) { cout << “22222”<< endl; exit(2); }
/*_3_*/ if (c==0) { cout << “33333”<< endl; exit(3); }
/*_4_*/ cout << “44444”<< endl;
/*_5_*/ return 0;
СЛЕДУЮЩАЯ:
1. 1, 2, 3, 4, 5
2. 1, 2, 3
3. 1, 4, 5
4. 1
5. 1, 2
- ЕСЛИ c=0, a≠0, b≠0, ТО ПОСЛЕДОВАТЕЛЬНОСТЬ
ПРОХОЖДЕНИЯ ОПЕРАТОРОВ ФРАГМЕНТА ПРОГРАММЫ
/*_1_*/ if (a==0) { cout << “11111”<< endl; exit(1); }
/*_2_*/ if (b==0) { cout << “22222”<< endl; exit(2); }
/*_3_*/ if (c==0) { cout << “33333”<< endl; }
/*_4_*/ cout << “44444”<< endl;
/*_5_*/ return 0;
СЛЕДУЮЩАЯ:
1. 1, 2, 3, 4, 5
2. 1, 2, 4, 5
3. 1, 4, 5
4. 1
5. 1, 2
_______________________________________________________________________________гр.22______________________________________________________________________
- ПОСЛЕДОВАТЕЛЬНОСТЬ ДАННЫХ В ПРОГРАММЕ:
1. можно всю сохранять в памяти и выполнять обработку ее как массива
2. можно не сохранять всю в памяти и выполнять ее обработку сразу, при вводе с клавиатуры отдельного значения, как обычной переменной
3. можно всю сохранять в памяти и выполнять обработку ее как строки
4. можно всю сохранять в файле и выполнять ее обработку при чтении из него в переменную некоторого типа
5. можно всю сохранять в файле и выполнять ее обработку как массива, при чтении из файла в массив
- ПОСЛЕДОВАТЕЛЬНОСТЬ ДАННЫХ ЛУЧШЕ НЕ ЗАДАВАТЬ ПУТЕМ ВВОДА С КЛАВИАТУРЫ ПО ОДНОМУ ЭЛЕМЕНТУ, ПОТОМУ ЧТО:
1. она может «уйти» за границу экрана
2. при выводе последовательности на экран не всегда возможно проверить правильность вычислений, так как может быть не видна введенная последовательность
3. таким способом можно ввести только 128 символов
- ФРАГМЕНТ ПРОГРАММЫ
int main(){
int i=1, f=1;
do {
i++;
f=f*i;
} while(f <= INT_MAX / i);
cout << i << " " << f << endl;;
_getch();
return 0;
}
РЕАЛИЗУЕТ:
1. нахождение середины диапазона чисел, представимых на данном компьютере
2. нахождение самого большого целого числа, до которого можно вычислить сумму чисел на данном компьютере
3. нахождение самого большого целого числа, до которого (включая его) можно вычислить факториал на данном компьютере
4. нахождение самого большого целого числа, до которого (исключая его) можно вычислить произведение натуральных чисел на данном компьютере
_______________________________________________________________________________гр.23______________________________________________________________________
- Результат выполнения программы
main()
{
int x, y = 1, z;
if (y != 0) x = 5;
printf (“%d\n”, x);
return (0);
}5
- Результат выполнения программы
main()
{
int x, y = 1, z;
if (y == 0) x = 3;
else x = 5;
printf (“%d\n”, x);
return (0);
}
5
- Результат выполнения программы
main()
{
int x, y =1, z;
x=1;
if (y < 0) if (y > 0) x = 3;
else x = 5;
printf (“%d\n”, x);
return (0);
}
1
- Результат выполнения программы
main()
{
int x, y = 1, z;
if (z = y < 0) x = 3;
else if (y == 0) x = 5;
else x = 7;
printf (“%d,%d\n”, x, z);
return (0);
}
1. 7,0
2. 5,0
3. 3,0
4. 7 0
5. 5 0
6. 3 0
- Результат выполнения программы
main()
{
int x, y =1, z;
if (z = (y == 0)) x = 5;
x = 3;
printf (“%d,%d\n”, x, z);
return (0);
}
1. 3,0
2. 3 0
3. 5,0
4. 5 0
- Результат выполнения программы
main()
{
int x, y = 1, z;
if (x = z = y); x = 3;
printf (“%d,%d\n”, x, z);
return (0);
}
1. 3,1
2. 0,1
3. 1,1
4. 3 1
5. 0 1
6. 1 1
- Результат выполнения программы
main()
{
int x, y, z;
x = y = 0;
while (y < 10) ++y; x += y;
printf (“%d,%d\n”, x, y);
return (0);
}
(ответ вводите без пробелов, разделяя значения запятой)
- Результат выполнения программы
main()
{
int x, y, z;
x = y = 0;
while (y < 10) x += ++y;
printf (“%d,%d\n”, x, y);
return (0);
}
(ответ вводите без пробелов, разделяя значения запятой)
- Результат выполнения программы
main()
{
int x, y, z;
y=1;
while (y < 10) {
x = y++; z = ++y;
}
printf (“%d,%d,%d\n”, x, y, z);
return (0);
}
(ответ вводите без пробелов, разделяя значения запятой)
- Результат выполнения программы
main()
{
int x, y, z;
for (y = 1; y < 10; y++) x = y;
printf (“%d,%d\n”, x, y);
return (0);
}
(ответ вводите без пробелов, разделяя значения запятой)
- Результат выполнения программы
main()
{
int x, y, z;
for (y = 1; (x = y) < 10; y++);
printf (“%d,%d\n”, x, y);
return (0);
}
(ответ вводите без пробелов, разделяя значения запятой)
- Результат выполнения программы
main()
{
int x, y, z;
for (x = 0, y = 1000; y > 1; x++, y /=10);
printf (“%d,%d\n”, x, y);
return (0);
}
(ответ вводите без пробелов, разделяя значения запятой)
- Результат выполнения программы
main()
{
int x, y, z;
for (x = 0, y = 1000; y > 1; x++, y /= 10)
printf (“%d,%d\n”, x, y);
return (0);
}
1. 0,1000
2. 1,100
3. 2,10
- истинные высказывания:
1. if (n>0) if (a>b) z = a; else z = b;
2. if (a > b) z=a; else z=b;
3. if (n==0) a = 0; else if (n==1) a = 1; else if (n==2) a =2; else a=3;
4. if (n==0) a = 0; else if (n==1) a = 1; else if (n==2) a =2;
- Результат выполнения программы
main()
{
int i=1, rez=1;
while ( i++ <=5 && rez !=25)
{cout << ”input rez=25”;
cin >> rez;}
return 0;
}
1. обеспечение пяти попыток ввода значения i
2. обеспечение четырех попыток ввода значения i
3. обеспечение пяти попыток ввода значения rez
4. обеспечение четырех попыток ввода значения rez
5. не равного 25
6. равного 25
- Одинаковые результаты обеспечивают циклы:
(int a=1; int a1[10]={1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; )
1. for(int i=0, s=0; i <10; i++) s+=a;
2. for(int i=1, s=0; i <=10; i++) s+=a;
3. for(int i=0, s=0; i <10; i++) s+=a[i];
4. for(int i=1, s=0; i <=10; i++) s+=a[i];
_______________________________________________________________________________гр.24______________________________________________________________________
- Исполнитель алгоритма:
1. человек
2. робот
3. станок
4. компьютер
5. группа людей
6. несколько компьютеров
7. алгоритмический язык
8. программа
- Исполнитель алгоритма:
1. умеет выполнять некоторые команды
2. имеет систему команд
3. может выполнять некоторую программу работы
4. программа работы исполнителя предназначена только компьютеру
5. исполнителем алгоритма может быть компьютер
- Подходы к разработке алгоритмов:
1.операциональный
2. структурный
3. модульный
4. объектно-ориентированный
5. циклический
6. логический
- Операциональный подход:
1. ориентирован на непосредственно выполняемые компьютером операции
2. делал программирование ненадежным
3. делал программы очень понятными
4. приводил к трудности отладки
5. делал программирование дорогостоящим
6. делал легкой модификацию программы
7. обеспечивал представление программы в виде иерархической структуры блоков
- структурный подход:
1. ориентирован на непосредственно выполняемые компьютером операции
2. вызвал к жизни механизм подпрограмм
3. повысил эффективность и надежность программы
4. ухудшил читабельность программы
5. обеспечил простоту тестирования и отладки
6. делал легкой модификацию программы
7. обеспечивал представление программы в виде иерархической структуры блоков
8. обеспечил возможность коллективной разработки программ
- правила нисходящего структурного проектирования:
1. утверждают, что в самом общем виде алгоритм может быть представлен структурой следования
2. утверждают, что каждый блок структуры алгоритма может быть впоследствии уточнен
3. требуют, чтобы каждый логический фрагмент алгоритма оформлялся функцией
4. предполагают, что каждый логический блок алгоритма может быть заменен некоторой управляющей структурой
5. обеспечивают простоту тестирования и отладки
6. делают легкой модификацию программы
7. предполагают, что в процессе разработки функции-заглушки последовательно заменяются на реально работающие функции
8. предполагают использование функций–«заглушек», имитирующих верную работу функций
- технологические принципы структурного программирования:
1. утверждают, что логическая структура алгоритма любой программы может быть выражена комбинацией трех базовых управляющих структур
2. утверждают, что для выражения в алгоритме логики решения любой задачи базовые управляющие структуры можно комбинировать путем организации их следований
3. утверждают, что для выражения в алгоритме логики решения любой задачи базовые управляющие структуры можно комбинировать путем организации вложений одной структуры в другую
4. утверждают, что базовые управляющие структуры – это ветвление и цикл
5. обеспечивают простоту тестирования и отладки
6. предполагают, что для выражения в алгоритме логики решения задачи никаких других средствуправления последовательностью выполнения операций, кроме комбинирования базовых управляющих структур, не предусматривается
7. предполагают, что подпрограмма реализует только одну логическую функцию
8. предполагают, что разработка программы ведется пошагово
- ТРЕБОВАНИЯ СТРУКТУРНОЙ МЕТОДОЛОГИИ К ОФОРМЛЕНИЮ ТЕКСТА ПРОГРАММ:
1. программа (подпрограмма) начинается с комментариев
2. в одной строке записывается, как правило, не более одного оператора
3. если для записи оператора требуется больше одной строки, все последующие строки записываются с отступами
4. тела операторов цикла, ветвления, выбора записываются с отступами
5. идентификаторы всех объектов программы должны быть смысловыми
- МОДУЛЬНЫЙ ПОДХОД:
1. утверждает, что модульное программирование – это еще один механизм организации программы как совокупности независимых блоков
2. предполагает, что отдельно компилируемый модуль выступает механизмом структурирования, средством обеспечения независимой разработки отдельной части проекта
3. утверждает, что для взаимодействия модулей программисту необходимо продумать только взаимодействие (интерфейс) сконструированных модулей в основной программе
4. предполагает, что модуль – независимый блок, код которого физически и логически отделен от кода других модулей.
5. предполагает, что модуль предназначен для функционально законченной обработки данных
- ИСТИННЫЕ ВЫСКАЗЫВАНИЯ:
1. следование – простейшая алгоритмическая структура, предполагающая последовательное выполнение команд
2. линейные алгоритмы строятся на основе структуры «следование»
3. отдельное возможное направление выполнения последовательности действий в развилке называют ветвью
4. выделяют циклы с параметром и циклы итерационные
5. параметр цикла – переменная, которая монотонно изменяется при каждом выполнении цикла
6. параметр – это управляющая переменная цикла
- ДЛЯ ИТЕРАЦИОННЫХ ЦИКЛОВ ХАРАКТЕРНО:
1. конечное значение управляющей переменнойнеизвестно
2. число повторений цикла заранее неизвестно, а определяется лишь в ходе вычислений, в зависимости от получаемых результатов
3. цикл завершается, когда значения, полученные на следующей итерации, отличаются от полученных на предыдущей итерации, не больше чем на заданную величину
4. для принятия решения о завершении цикла задается условие, выполнение которого надо проверять в ходе каждой итерации
5. результат предыдущего выполнения цикла используется в качестве исходного при последующем выполнении цикла
6. отсутствует подготовка к очередному шагу выполнения цикла
7. отсутствует тело цикла