Главная Случайная страница Контакты | Мы поможем в написании вашей работы! | ||
|
ЗНАЧЕНИЕ ЦЕЛОЧИСЛЕННОЙ ПЕРЕМЕННОЙ S РАВНО: 81
ЗНАЧЕНИЕ ПЕРЕМЕННОЙ S РАВНО:0
_______________________________________________________________________________ гр.12 ______________________________________________________________________
1. предложения с определением переменных не являются операторами
2. в С++ операторы разделяются символом «;»
3. составной оператор – это последовательность операторов, заключенная в скобки { }
4. в C++ операторы разделяются символом «пробел»
5. список выбора в операторе switch открывает скобка {
6. список выбора в операторе switch заканчивает скобка }
7. в операторе switch в разных вариантах выбора возможно пересечение набора значений
1. условие1
2. условие2
1. арифметическое
2. логическое
3. отношения
1. перечисляемый
2. логический
3. целочисленный
4. вещественный
1. bx= ba || bb && bc;
2. bx= ba &&bb || bc;
3. bx= ba && bb && bc;
4. bx= ba || bb || bc;
1. абсолютно верна
2. верна, но лучше ее оптимизировать
3. неверна
1. абсолютно верна
2. верна, но лучше ее оптимизировать
3. неверна
1. абсолютно верна
2. верна, но лучше ее оптимизировать
3. абсолютно неверна
1. абсолютно верна
2. верна, но лучше ее оптимизировать
3. неверна
1. абсолютно верна
2. верна, но лучше ее оптимизировать
3. неверна
1. абсолютно верна
2. верна, но лучше ее оптимизировать
3. неверна
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);
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 ______________________________________________________________________
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
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 ______________________________________________________________________
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
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
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. оператор S выполнится 1 раз
2. оператор S не выполнится ни разу
3. компилятор выдаст ошибку
4. произойдет зацикливание программы
5. оператор S выполнится E2- E1+1 раз
6. оператор S выполнится E2- E1 раз
7. оператор S выполнится E2- E1-1 раз
1. оператор S выполнится 1 раз
2. оператор S не выполнится ни разу
3. компилятор выдаст ошибку
4. произойдет зацикливание программы
5. оператор S выполнится E2- E1+1 раз
6. оператор S выполнится E2- E1 раз
7. оператор S выполнится E2- E1-1 раз
1. оператор S выполнится 1 раз
2. оператор S не выполнится ни разу
3. компилятор выдаст ошибку
4. произойдет зацикливание программы
1. оператор S не выполнится ни разу
2. компилятор выдаст ошибку
3. произойдет зацикливание программы
4. оператор S выполнится |E1- E2|+1 раз
5. оператор S выполнится |E1- E2| раз
6. оператор S выполнится |E1- E2|-1 раз
1. оператор S не выполнится ни разу
2. компилятор выдаст ошибку
3. произойдет зацикливание программы
4. оператор S выполнится 1 раз
1. оператор S не выполнится ни разу
2. компилятор выдаст ошибку
3. произойдет зацикливание программы
4. оператор S выполнится 1 раз
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 ______________________________________________________________________
1. B - A +1
2. 0
3. В-А
1. B - A +1
2. 0
3. В-А
1.A - B +1
2. 0
3. В-А
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. изменения значения счетчика цикла на значения, выходящие за конечное значение
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 позволяет организовать переход от цикла с предусловием (или постусловием) к циклу со счетчиком
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 ______________________________________________________________________
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 ______________________________________________________________________
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 ______________________________________________________________________
/*_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
/*_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
/*_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
/*_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
/*_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
/*_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
/*_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. отсутствует тело цикла
Дата публикования: 2015-01-24; Прочитано: 849 | Нарушение авторского права страницы | Мы поможем в написании вашей работы!