Екзаменаційний білет № 1

1. Класифікація типів та їх внутрішнє подання у мові С++. Базовые типы: целочисленный, вещественный, символьный, логический, void.Производные типы: массивы, указатели, ссылки, перечисление.

Составной тип: структуры, объединения, классы.

Типы класса. Экземпляры этих типов называются объектами.

Существует четыре спецификатора типа данных, уточняющих внутреннее представление и диапазон базовых типов: short (короткий) long (длинный) signed (знаковый) unsigned (беззнаковый).

2. Задача з використанням динамічного виділення пам’яті у мові C++.

// Демонстрация выполнения операций с динамической памятью.

#include "stdafx.h"

#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[]){

int *pa, *pb;

pa = new int;

*pa = 21;

pb = pa;

cout << *pa << " " << *pb << "\n";

pb = new int;

*pb = 28;

cout << *pa << " " << *pb << "\n";

delete pa;

pa = pb;

cout << *pa << " " << *pb << "\n";

delete pa;

system("pause");

return 0;

}Результат выполнения программы:

21 21

21 28

28 28

Екзаменаційний білет № 2

1. Апарат влаштовування та перевантаження функцій.

Подставляемые или встраиваемые (inline) функции – это функции, код которых вставляется компилятором непосредственно на место вызова, вместо передачи управления единственному экземпляру функции. Если функция является подставляемой, компилятор не создает данную функцию в памяти, а копирует ее строки непосредственно в код программы по месту вызова. Это равносильно вписыванию в программе соответствующих блоков вместо вызовов функций. Таким образом, спецификатор inline определяет для функции так называемое внутреннее связывание, которое заключается в том, что компилятор вместо вызова функции подставляет команды ее кода. Подставляемые функции используют, если тело функции состоит из нескольких операторов.

Перегрузка функций – это создание нескольких функций с одним именем, но с разными параметрами. Под разными параметрами понимают, что должно быть разным количество аргументов функции и/или их тип. То есть перегрузка функций позволяет определять несколько функций с одним и тем же именем и типом возвращаемого значения. Благодаря использованию перегруженных функций, не следует беспокоиться о вызове в программе нужной функции, отвечающей типу передаваемых переменных. При вызове перегруженной функции компилятор автоматически определит, какой именно вариант функции следует использовать.

2. Задача з використанням одновимірних динамічних масивів.

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

#include "stdafx.h"

#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[]){

int *a, n, i;

cout << "Введите n: ";

cin >> n;

cout << ' ';

a = new int [n]; //Выделение памяти под массив

for (i=0; i<n; i++) {

cout << "Введите a[" << i << "]: ";

cin >> a[i];

cout << ' ';

} int *buf = new int [n];

//Выделение памяти под вспомогательный массив

int j = 0; //Индекс вспомогательного массива

for (i=0; i<n; i+=2) {

//Переписываем элементы с чётным индексом в новый массив

buf[j] = a[i];

j++; }

for (i=1; i<n; i+=2) {

//Переписываем элементы с нечётным индексом в новый массив

buf[j] = a[i];

j++;

}

cout << "Преобразованный: " << ' ';

for (i=0; i<n; i++)

cout << buf[i] << ' ';

delete [] a; //Освобождаем память

delete [] buf;

system("pause");

return 0;

}

Екзаменаційний білет № 3

1. 1.Поняття рекурсії, рекурсивних функцій у програмуванні, прийоми побудови рекурсивної тріади при розв’язуванні задач.

Рекурсивная триада – это этапы решения задач рекурсивным методом.

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

• параметризация – выделяют параметры, которые используются для описания условия задачи, а затем в решении;

• база рекурсии – определяют тривиальный случай, при котором решение очевидно, то есть не требуется обращение функции к себе;

• декомпозиция – выражают общий случай через более простые подзадачи с измененными параметрами.

Рекурсивная функция – это функция, которая в своем теле содержит обращение к самой себе с измененным набором параметров.

Рекурсия в программировании – это пошаговое разбиение задачи на подзадачи, подобные исходной.

2. 2. Задача з використанням двовимірних динамічних масивів

// Сформируйте и выведите на экран единичную матрицу с целыми элементами, вводя ее порядок с клавиатуры.

#include "stdafx.h"

#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[]){

int n,i,j;

int **matr;//указатель для массива указателей

cout << "Input matrix order:";

cin >> n;

matr = new int *[n];

//выделение памяти под массив указателей

for(i=0; i<n; i++){

matr[i] = new int[n];

//выделение памяти для массива значений

for (j=0; j<n; j++) //заполнение матрицы

matr[i][j] = (i==j ? 1 : 0);

} cout << "Result: ";

for(i=0; i<n; i++){

cout << "\n";

for (j=0; j<n; j++)

cout << " " << matr[i][j];

delete matr[i];

//освобождение памяти из-под массива значений

} delete [] matr;

//освобождение памяти из-под массива указателей

system("pause");

return 0;

}

Екзаменаційний білет № 4

1. Класифікація похідних типів, тип покажчика й співвідношення між іменами, адресами та значеннями змінних.

В языке С++ производные типы данных классифицируют в зависимости от построения на производные и непосредственно производные.

Для экономии памяти и времени, затрачиваемого на обращение к данным, в программах используют указатели на объекты.

Указатель не является самостоятельным типом, он всегда связан с другим типом.

Указатель может быть константой или переменной, а также указывать на константу или переменную.

Указатель типа void указывает на область памяти любого размера. Разыменование такого указателя необходимо проводить с операцией приведения типов.Над указателями определены операции: разыменование, взятие адреса, декремент, инкремент, увеличение (уменьшение) на целую константу, разность, определение размера.

2. Задачі з використанням алгоритмів сортувань у динамічних масивах

#include "stdafx.h"

#include <iostream>

using namespace std;

#include <time.h>

void Initialization(int **mas, int *k, int *l,int **vmas);

void Print(int *mas, int k, int l);

void Work(int *mas, int k, int l,int *vmas);

void FindMax(int *mas, int k, int l,int *vmas);

void Obmen(int *mas,int k,int l,int i,int q);

void Distraction(int *mas,int *vmas);

int _tmain(int argc, _TCHAR* argv[]) {

int *mass, n, m, *vmass;

Initialization(&mass, &n, &m, &vmass);

cout << "Исходная матрица" << "\n";

Print(mass, n, m);

Work(mass, n, m, vmass);

cout << "Преобразованная матрица" << "\n";

Print(mass, n, m);

Distraction(mass, vmass);

system("pause");

return 0;

}

void Initialization(int **mas, int *k, int *l,int **vmas){

int i, j, a, b;

cout << "Введите размерность матрицы:" << "\n";

cout << "n = ";

cin >> *k;

cout << "m = ";

cin >> *l;

cout << "Введите границы генерации элементов

матрицы:"<<"\n";

cout << "a = ";

cin >> a;

cout << "b = ";

cin >> b;

srand(time(NULL)*1000);

*mas = new int[(*k)*(*l)];

*vmas = new int[(*l)];

for (i = 0; i < *k ; i++)

for (j = 0; j < *l ; j++)

(*mas)[i*(*l)+j] = rand()%(b-a)+a;

}void Print(int *mas, int k, int l){

int i, j;

for (i = 0; i < k ; i++){

for (j = 0; j < l ; j++)

cout << mas[i*l+j] << " ";

cout << "\n";

}}

void Work(int *mas, int k, int l,int *vmas){

int i, j, q, r;

FindMax(mas, k, l, vmas);

for( i=0; i < l; i++) { // i - номер текущего шага

q=i;

for( j=i+1; j < l; j++)

//цикл выбора наименьшего максимального элемента

if (vmas[j]<vmas[q])

q=j;//q - индекс наименьшего максимального элемента

r = vmas[q]; // меняем местами наименьший с vmas[i]

vmas[q] = vmas[i];

vmas[i] = r;

Obmen(mas, k, l, i, q);

//меняем местами столбцы с номерами i и q матрицы mas

}

}

void FindMax(int *mas, int k, int l,int *vmas){

int i, j;

for (j = 0; j < l; j++){

vmas[j] = mas[j];

for (i = 1; i < k; i++)

if (vmas[j] < mas[i*l+j])

vmas[j] = mas[i*l+j];

}

}

void Obmen(int *mas,int k,int l,int i,int q){

int j, r;

for (j = 0; j < k; j++){

r = mas[j*l+i];

mas[j*l+i] = mas[j*l+q];

mas[j*l+q] = r;

}

}

void Distraction(int *mas,int *vmas){

delete(vmas);

delete(mas);

}

Екзаменаційний білет № 5

1. 1.Поняття покажчика на функції та методи передачі функції як параметрів.

Указатель на функцию – переменная, которая содержит адрес некоторой функции. Соответственно, косвенное обращение по этому указателю представляет собой вызов функции. тип_функции(*имя_указателя)(спецификация_параметров)

где тип_функции – определяет тип возвращаемого функцией значения; имя_указателя – идентификатор; спецификация_параметров – определяет состав и типы параметров функции.

Указатели на функции как параметры позволяют создавать функции, реализующие тот или иной метод обработки другой функции, которая заранее не определена. Например, можно определить функцию для вычисления определенного интеграла от произвольной функции. Подынтегральная функция может быть передана в функцию вычисления интеграла с помощью параметра-указателя.

2. 2.Задачі з використанням алгоритмів пошуку у динамічних масивах

#include "stdafx.h"

#include <iostream>

#include <time.h>

using namespace std;

void Initialization(int **mas, int *k, int *l,int **vmas);

void Print(int *mas, int k, int l);

void Work(int *mas, int k, int l,int *vmas);

void FindMax(int *mas, int k, int l,int *vmas);

void Obmen(int *mas,int k,int l,int i,int q);

void Distraction(int *mas,int *vmas);

int _tmain(int argc, _TCHAR* argv[]) {

int *mass, n, m, *vmass;

Initialization(&mass, &n, &m, &vmass);

cout << "Исходная матрица" << "\n";

Print(mass, n, m);

cout << "Naibolshij element:";

Work(mass, n, m, vmass);

Distraction(mass, vmass);

system("pause");

return 0;

}

void Initialization(int **mas, int *k, int *l,int **vmas){

int i, j, a, b;

cout << "Введите размерность матрицы:" << "\n";

cout << "n = ";

cin >> *k;

cout << "m = ";

cin >> *l;

cout << "Введите границы генерации элементов матрицы:"<<"\n";

cout << "a = ";

cin >> a;

cout << "b = ";

cin >> b;

srand(time(NULL)*1000);

*mas = new int[(*k)*(*l)];

*vmas = new int[(*l)];

for (i = 0; i < *k ; i++)

for (j = 0; j < *l ; j++)

(*mas)[i*(*l)+j] = rand()%(b-a)+a;

}

void Print(int *mas, int k, int l){

int i, j;

for (i = 0; i < k ; i++){

for (j = 0; j < l ; j++)

cout << mas[i*l+j] << " ";

cout << "\n";

}}

void Work(int *mas, int k, int l,int *vmas){

int i, j, q, r;

FindMax(mas, k, l, vmas);

for( i=0; i < l; i++) { // i - номер текущего шага

q=i;

for( j=i+1; j < l; j++)

//цикл выбора наименьшего максимального элемента

if (vmas[j]<vmas[q])

q=j;//q - индекс наименьшего максимального элемента

r = vmas[q]; // меняем местами наименьший с vmas[i]

vmas[q] = vmas[i];

vmas[i] = r;

Obmen(mas, k, l, i, q);

//меняем местами столбцы с номерами i и q матрицы mas

}

cout<<vmas[q];

}

void FindMax(int *mas, int k, int l,int *vmas){

int i, j;

for (j = 0; j < l; j++){

vmas[j] = mas[j];

for (i = 1; i < k; i++)

if (vmas[j] < mas[i*l+j])

vmas[j] = mas[i*l+j];

} }

void Obmen(int *mas,int k,int l,int i,int q){

int j, r;

for (j = 0; j < k; j++){

r = mas[j*l+i];

mas[j*l+i] = mas[j*l+q];

mas[j*l+q] = r;

}

}

void Distraction(int *mas,int *vmas){

delete(vmas);

delete(mas);

}

Екзаменаційний білет № 6

1. Функції із змінною кількістю параметрів та прийомів побудови програм.

Синтаксис определения функции с переменным числом параметров:

тип имя (спецификация_явных_параметров,...){

тело_функции

}

где тип – тип, возвращаемого функцией значения; имя – имя функции; спецификация_явных_параметров – список спецификаций параметров, количество и типы которых фиксированы и известны в момент компиляции. Эти параметры можно назвать обязательными.

В прототипе функции с переменным числом параметров описываются спецификации обязательных параметров, список необязательных параметров обозначается многоточием.

Для функций с переменным числом параметров существуют два основных способа контроля количества параметров в списке: через передачу количества параметров и по признаку конца списка параметров.

2. Задачі з використанням алгоритмів переставлень у динамічних масивах

//Дан массив целых чисел из n элементов. Инвертировать этот массив

#include <iostream>

using namespace std;

int main()

{   int i, j, n;

   int *x;

   int c;

   // Задаём размер будущего массива

   do {      cout << "n=";

      cin >> n;

   } while(n < 1);   // Динамически выделяем память под массив   x = new int[n];

   // Ввод массива с клавиатуры

   cout << "Input " << n << " numbers:" << endl;

   for(i = 0; i < n; i++)

      cin >> x[i];

   // Перестановка элементов массива

 for(i = 0, j = n - 1; i < j; i++, j--)

   {      c = x[i];

      x[i] = x[j];

      x[j] = c;

   }   // Вывод массива на экран монитора

   cout << "Otvet:" << endl;

   for(i = 0; i < n; i++)

      cout << x[i] << endl;

   // Освобождение динамической памяти, отводимой под массив

   delete [] x;

   return 0;

}

Екзаменаційний білет № 7

1. Властивості внутрішнього подання символьних даних та рядків.

Для представления текстовой информации в С++ используются символьные данные и строки.

В С++ не определен строковый тип данных, и строка представляется как массив символов.

Инициализировать строку можно как массив символов.

Обратиться к элементу строки можно по индексу, который соответствует порядковому номеру элемента.

В С++ предусмотрены различные способы ввода и вывода одиночных символов и строк: с помощью стандартных функций, с помощью потокового или форматированного ввода/вывода. При считывании строки с клавиатуры признак конца строки добавляется автоматически.

2. Задача з використанням алгоритму вставки елемента у динамічних масивах

Екзаменаційний білет № 8

1. Синтаксис та семантику стандартних функцій для роботи із рядками.

Функции для работы со строками – файл stdlib.h

Функции преобразовующие строку в другой тип или наоборот:

atof atoi atol itoa ltoa ultoa

Функции для работы со строками – файл string.h

Существует множество функций для роботы со строками:

Strcat приписывает одну строку к другой строке.

strchr ищет в строке первое вхождение символа

strlen вычисляет длину строки

strlwr преобразует буквы верхнего регистра в строке в соответствующие буквы нижнего регистра

strupr преобразует буквы нижнего регистра в строке str в буквы верхнего регистра

2. Задача з використанням динамічних структур мови C++

Приведем функции перечисленных основных операций при работе с циклическим однонаправленным списком.

/*вставка элемента после заданного номера в циклический однонаправленный список*/

Circle_Single_List* Insert_Item_Circle_Single_List(Circle_Single_List* Head,

int Number, int DataItem){

Circle_Single_List *Current = Head;

//встали на первый элемент

Circle_Single_List *NewItem = new(Circle_Single_List);

//создали новый элемент

NewItem->Data = DataItem;

if (Head == NULL) {//список пуст

NewItem->Next = NewItem;

Head = NewItem;

}

else {//список не пуст

for (int i = 1; i < Number; i++)

Current = Current->Next;

NewItem->Next = Current->Next;

Current->Next = NewItem;

}

return Head;

}

/*удаление элемента с заданным номером из циклического однонаправленного списка*/

Circle_Single_List* Delete_Item_Circle_Single_List

(Circle_Single_List* Head, int Number){

if (Head != NULL){

Circle_Single_List *Current = Head;

if (Head->Next != Head){

for (int i = 1; i < Number; i++)

Current = Current->Next;

Circle_Single_List *ptr = Head;

while (ptr->Next != Current)

ptr = ptr->Next;

//непосредственное удаление элемента

ptr->Next = Current->Next;

if (Head = Current) Head = Current->Next;

delete(Current);

}

else{

Head = NULL;

delete(Current);

}

}

return Head;

}

//поиск элемента в циклическом однонаправленном списке

bool Find_Item_Circle_Single_List(Circle_Single_List* Head,

int DataItem){

Circle_Single_List *ptr = Head;

//вспомогательный указатель

do {

if (DataItem == ptr->Data) return true;

else ptr = ptr->Next;

}

while (ptr != Head);

return false;

}

Екзаменаційний білет № 9

1. Принципи роботи із рядками та покажчиками на рядки, алгоритми розв’язування задач на оброблення строкових даних.

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

Строки передаются в функции в качестве параметров как массивы символов или как указатели типа char.

Обращение к конкретному элементу строки можно осуществить посредством адресации индексированного имени строки.

При формировании строки без использования стандартных функций требуется дописывать символ конца строки.

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

2. Задачі на розроблення алгоритму із використанням списків.

#include "stdafx.h"

#include <stdio.h>

#include <iostream>

#include<stdlib.h>

using namespace std;

class List

{public:

struct Node

{

Node(const int& data, Node* next=0):data(data),next(next) {}

Node* next;

int data;

};

List() : head(0) {}

List(const List& L) : head(0)

{

for ( const Node* i = L.begin(); i!= L.end(); i=i->next )

push_front(i->data);

reverse();

}

void reverse()

{

Node* p = 0; Node* i = begin(); Node* n;

while (i)

{

n = i->next;

i->next = p;

p = i; i = n;

}

head = p;

}

void swap(List& x)

{

Node* tmp = head; head = x.head; x.head = tmp;

}

List& operator=(const List& x)

{

List tmp(x);

swap(tmp);

return *this;

}

~List() { clear(); }

void clear() { while (!empty()) pop_front(); }

bool empty() { return ! head; }

void push_front(const int& x) {

Node* tmp = new Node(x,head); head = tmp;

}

void pop_front() {

if (head) { Node* tmp = head; head=head->next; delete tmp; }

}

void insert_after(Node* x, const int& data)

{

Node* tmp = new Node(data, x->next);

x->next = tmp;

}

void erase_after(Node* x)

{

Node* tmp = x->next;

if (tmp)

{

x->next = x->next->next;

delete tmp;

}

}

int& front() { return head->data; }

const int& front() const { return head->data; }

Node* begin() { return head; }

Node* end() { return 0; }

const Node* begin() const { return head; }

const Node* end() const { return 0; }

private:

Node* head;

};

#include <iostream>

using namespace std;

int main()

{

List X;

X.push_front(3);

X.push_front(2);

X.push_front(1);

for (List::Node* it = X.begin(); it; it = it->next )

cout << it->data << endl;

X.reverse();

for (List::Node* it = X.begin(); it; it = it->next )

cout << it->data << endl;

return 0;

}

Екзаменаційний білет № 10

1. Поняття, особливості внутрішнього подання, способів генерування та виведення одновимірних масивів.

Существует две основные формы объявления массивов: с указанием и без указания размера. Безразмерный массив объявляется, если: он инициализируется при объявлении, является формальным параметром функции, объявлен как ссылка на массив.

Стандартными способами генерация массивов являются:

• ввод данных с клавиатуры,

• формирование значений через генератор случайных чисел,

• вычисление значений по формуле,

• ввод данных из файла.

2. Задачі на розроблення алгоритму із використанням статичного масиву.

/*Генерация целочисленного массива числами с клавиатуры и вывод массива в строку*/

#include "stdafx.h" #include <iostream>

using namespace std;

#define max 20

void gen (int k,int *pp);//прототип функции генерации массива

void out (int k,int x[max]);//прототип функции вывода мас сива int _tmain(int argc, _TCHAR* argv[]){

int a[max],n,*p; do { printf("\nВведите количество элементов массива n (n<=20):");

scanf ("%d",&n);

} while (n>max); //проверка выхода за границы массива p=a;

gen(n,p);

out(n,a);

system("pause");

return 0;}//Описание функции генерации массива с клавиатурыvoid gen(int k,int *pp){

/*передача указателя как параметра позволяет вернуть

сформированный массив в основную программу*/

int i;

printf("\nВведите значения %d элементов массива: \n",k);

for (i=0;i<k;i++){

printf("x[%d]= ",i);

scanf("%d",pp++);

}}//Описание функции вывода массива в строку

void out (int k,int x[max]){

int i;

printf("\nВывод значений %d элементов массива в строку: \n",k);

for (i=0;i<k;i++)

printf("%d\t",x[i]);

}

Билет №11

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

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

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

2. #include "stdafx.h"

#include <cstdlib>

#include <iostream>

#include <math.h>

using namespace std;

double vremja(double h)

{ int c; double a;

c=int(h/60); a=h;

h=int(a-c*60); cout<<c<<"chas(ov) "<<h<<"minut(a)"<<endl; return 0;

}

int vremja(int c, int h)

{ int v;

v=c*60+h;

cout<<v<<"minut(a)"<<endl;

return 0;

}

int _tmain(int argc, _TCHAR* argv[])

{ int k;

cout<<"Vuberite sposob: /n 1 - s minut v chas /n 2 - iz chasa v minuti"<<endl;

cin>>k;

if (k==1){ double x;

cout<<"Vvedite minuti:"<<endl;

cin>>x;

vremja(x);

} else {

int y; int z;

cout<<"Vvedite chas i minuti:"<<endl;

cin>>y>>z;

vremja(y,z);}

return 0;

}

Билет №12

1. Сортировка – это упорядочивание набора однотипных данных по возрастанию или убыванию.

 Ключ сортировки– это часть данных, определяющая порядок элементов. Для того, чтобы отсортировать данные, можно вызывать стандартную функцию qsort(), входящую в библиотеку С++. Однако различные подходы к сортировке обладают разными характеристиками. Использование функции qsort() не является универсальным решением для всех задач сортировки. Во-первых, функцию общего назначения, такую какqsort(), невозможно применить во всех ситуациях. Во-вторых, qsort() – параметризованная функция, благодаря чему она может обрабатывать широкий набор типов данных, но вследствие этого она работает медленнее, чем эквивалентная функция, рассчитанная на какой-то один тип данных. В-третьих, алгоритм быстрой сортировки, примененный в функции qsort(), может оказаться не самым эффективным алгоритмом в некоторых конкретных ситуациях.Ключ сортировки – это часть данных, определяющая порядок элементов.

Сортировка – это упорядочивание набора днотипных данных по возрастанию или убыванию.

Сортировка методом "пузырька" – это алгоритм попарного сравнения элементов одномерного массива.Сортировка методом простого включения – это алгоритм последовательного помещения элемента массива в отсортированную часть в соответствии с ключом сортировки.

Сортировка методом простого выбора – это алгоритм последовательного обмена минимального и первого элементов неотсортированной части массива.

2. #include "stdafx.h"#include <iostream>

#include <time.h> using namespace std;

#define r 100void gen (int k,int a, int b,int x[r]);

void out (int k,int x[r]);

int maximum (int k,int x[r]);

int _tmain(int argc, _TCHAR* argv[]){

int mas[r],n; do { printf("\nВведите количество элементов массива n (n<=100):"); scanf ("%d",&n);

} while (n>r); gen(n,-100,100,mas); out(n,mas);

printf ("\nНаименьший элемент в массиве равен %d", maximum(n,mas)); system("pause"); return 0;

}void gen(int k,int a, int b, int x[r]){ int i; srand(time(NULL)*1000); for (i=0;i<k;i++){

x[i]= rand()%(b-a)+a; }}

void out (int k,int x[r]){

int i; printf("\nВывод значений %d элементов массива в строку: \n",k); for (i=0;i<k;i++)

printf("%-6d",x[i]);}

int maximum (int k,int x[r]) { int i,max=x[0];

for (i=1;i<k;i++) if (max<x[i]) max=x[i];

return max;}

Билет №13

Вопрос 1

Объявление двумерных массивов

Синтаксис определения массива без дополнительных спецификаторов и модификаторов имеет два формата:Тип ИмяМассива[ВыражениеТипаКонстанты][ВыражениеТипаКонстанты];илиТип ИмяМассива[][];

ИмяМассива – идентификатор массива.

Тип – тип элементов объявляемого массива. Элементами массива не могут быть функции, файлы и элементы типаvoid.

ВыражениеТипаКонстанты – задает количество элементов (размерность) массива. Выражение константного типа вычисляется на этапе компиляции. Данное константное выражение может быть опущено в случаях если:при объявлении массив инициализируется;массив объявлен как формальный параметр функции;массив объявлен как ссылка на массив, явно определенный в другом файле.

Генерация двумерных массивов

Принцип генерации двумерных массивов такой же, как и одномерных.

//Описание функции генерации массива

void gen(int str,int slb, int a, int b, int m[max_x][max_y]){

int i,j; srand(time(NULL)*1000);

//устанавливает начальную точку генерации случайных чисел

for (i=0;i<str;i++) for (j=0;j<slb;j++)

m[i][j]=rand()%(b-a)+a);

//функция генерации случайных чисел на [a,b)

}Вывод двумерных массивов

Двумерные массивы выводятся на экран так же, как и одномерные. Для наглядности вывода целесообразно разделять элементы массива на строки и столбцы.

//Описание функции вывода массива

void out (int str,int slb, int m[max_x][max_y]){

int i,j; for (i=0;i<str;i++) { for (j=0;j<slb;j++)

printf("%4d",m[i][j]); printf("\n"); }}

2. #include "stdafx.h"

#include <cstdlib>

#include <iostream>

#include <math.h>

using namespace std;

int factorial(int n){

if(n==0){return 1;}

return n*factorial(n-1);}

int _tmain(int argc, _TCHAR* argv[])

{ double n; double m;

cout<<"Vvedite chislo"<<endl;

cin>>n;

cout<<factorial(n);

return 0;

}

Билет №14

Вопрос 1

Задачи перестановок в двумерных массивах – это тип задач, предполагающий обмен значениями элементов массива в зависимости от условия.

Задачи сортировок в двумерных массивах – это тип задач, предполагающий упорядочивание по указанному ключу одномерных массивов, из которых построен двумерный массив.

Пример 1. Сортировка в двумерном целочисленном массиве элементов k-той строки по невозрастанию.

void sort_dn(int k,int slb, int m[max][max]) {

int i,j,buf;

for (i=0;i<slb;i++)

for (j=slb-1;j>i;j--)

if (m[k][j]>m[k][j-1]){

//фиксированная строка с номером k

buf= m[k][j];

m[k][j]= m[k][j-1];

m[k][j-1]=buf;

} }

Пример 2. Обмен значениями элементов диагоналей квадратной матрицы, расположенных в одной строке.void obmen(int strslb, int m[max][max]) {

int i,buf,t; for (i=0;i<strslb;i++){

//номера строки и столбца элемента главной диагонали равны

buf= m[i][i];

//t-номер столбца соответствующего элемента побочной диагонали

t= abs(strslb-i-1);

m[i][i]= m[i][t];

m[i][t]=buf;

}}

2. #include "stdafx.h"

#include <cstdlib>

#include <iostream>

#include <math.h>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])

{struct Node {char *Name;

int Value;

Node *Next;

};

Node *PNode; //объявляется указатель

PNode = new Node; //выделяется память

PNode->Name = "STO"; //присваиваются значения

PNode->Value = 28;

PNode->Next = NULL;

cout<<"Imja: "<<PNode->Name;

delete PNode; // освобождение памяти

}

Билет №15

1. Структура – это составной объект, в который входят элементы любых типов, за исключением функций. В отличие от массива, который является однородным объектом (все элементы относятся к одному типу данных), структура может быть неоднородной. Таким образом, структура – это тип данных, сформированный из объектов однородных либо разнообразных типов данных.

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