ПРИМЕР оформления контрольной работы № 2

Вариант 11

Задача 1. Даны целые числа x и y. Вычислить сумму элементов массива А(35) таких, что x<Аi<y.

Исходные данные:

1. Целочисленные значения x и y - тип int;

2. Размер массива – целочисленная константа n=35

Можно воспользоваться объявлением const int n=35;

или препроцессорной директивой #define n 35

3. Т.к тип элементов массива не указан в задании, то для универсальности программы воспользуемся вещественным типом для элементов массива A(35) – float a[n];

Результирующие данные:

1. Сумма элементов массива (S), принадлежащих заданному интервалу, должна быть того же типа, что и элементы массива, т.е. float.

Т.к. в ходе обработки элементы массива не изменяются, то выводиться будет только найденная сумма.

Промежуточные переменные:

1. Целочисленная переменная i (int i;) – для организации циклов.

Используемые алгоритмы обработки данных:

1. Формирование массива вводом с клавиатуры.

2. Алгоритм отбора элементов, удовлетворяющих условию.

3. Алгоритм подсчета суммы.

Блок-схема алгоритма.

Листинг программы.

#include <stdio.h>

#include <conio.h>

#define n 10 // n 35

int main(void)

{

int x,y,i;

float A[n], s=0;

clrscr();

printf("vvedite x i y:\n");

printf("x="); scanf("%d",&x);

printf("y="); scanf("%d",&y);

printf("vvedite massiv:\n");

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

scanf("%f",&A[i]);

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

if (A[i]>x&&A[i]<y)

s+=A[i];

printf("s=%.2f",s);

getch();

return 0;

}

Задача 2. Удалить из массива А(25) все нули.

Исходные данные:

1. Размер массива – целочисленная константа N=25

Можно воспользоваться объявлением const int N=25;

или препроцессорной директивой #define N 25

2. Целочисленная переменная n ( int n) – для хранения фактического размера массива, первоначально совпадает с константой N, затем ее значение может уменьшиться при удалении элементов;

3. Т.к тип элементов массива не указан в задании, воспользуемся массивом типа int для хранения элементов – int A[N];

Результирующие данные:

1. Массив А после удаления элементов.

2. Сообщение о том, что в массиве не было нулевых элементов.

Промежуточные переменные:

1. Целочисленные переменные i и j (int i, j;) – для организации циклов.

Используемые алгоритмы обработки данных:

1. Формирование массива вводом с клавиатуры.

2. Алгоритм вывода массива на экран.

3. Алгоритм отбора элементов, удовлетворяющих условию.

4. Алгоритм сдвига влево.

Листинг программы.

#include <stdio.h>

#include <conio.h>

#define N 15 // N 25

int main(void)

{

int i,j, A[N],n=N;

clrscr();

printf("vvedite massiv:\n");

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

scanf("%d",&A[i]);

for (i=0;i<n;)

{

if (A[i]==0)

{

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

A[j]=A[j+1];

n--;

}

else

i++;

}

if (n==N) printf(“\nV massive net 0”);

else

{

printf(“\nNoviy massiv:\n”);

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

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

}

getch();

return 0;

}

Задача 3. Вычислить , где S_п и K_п – сумма и количество положительных элементов массива А (70), а S_о и K_о – сумма и количество отрицательных элементов того же массива.

Исходные данные:

1. Размер массива – целочисленная константа n=70

Можно воспользоваться объявлением const int n=70;

или препроцессорной директивой #define n 70

2. Т.к тип элементов массива не указан в задании, то для универсальности программы воспользуемся вещественным типом для элементов массива A(70) – float a[n];

Результирующие данные:

1. Вещественная переменная Z – тип float.

Т.к. в ходе обработки элементы массива не изменяются, то выводиться будет только найденное значение Z или сообщение о невозможности его вычисления (например, в случае, когда Kp=0 и Ko=0).

Промежуточные переменные:

1. Целочисленная переменная i (int i;) – для организации циклов.

2. Вещественные переменные Sp, So – float.

3. Целочисленные значения Kp и Ko - тип int.

Используемые алгоритмы обработки данных:

1. Формирование массива вводом с клавиатуры.

2. Алгоритм отбора элементов, удовлетворяющих условию.

3. Алгоритм подсчета суммы.

4. Алгоритм подсчета количества.

Листинг программы.

#include <stdio.h>

#include <conio.h>

#define N 15 // N 70

int main(void)

{

int i,Kp=0,Ko=0;

float A[N],Sp=0,So=0,Z;

clrscr();

printf("vvedite massiv:\n");

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

scanf("%f",&A[i]);

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

{

if (A[i]>0)

{

Sp+=A[i];

Kp++;

}

else

if (A[i]<0)

{

So+=A[i];

Ko++;

}

}

if (Ko+Kp)

{

Z=(Sp+So)/(Kp+Ko);

printf("\nZ=%.3f",Z);

}

else

printf("\nV massive tolko 0");

getch();

return 0;

}

Задача 4. Дана матрица А(10х10). Расставить строки таким образом, чтобы элементы в первом столбце были упорядочены по убыванию.

Исходные данные:

1. Количество строк и столбцов двумерного массива для решения данной задачи совпадают, поэтому достаточно одной целочисленной константы n=10.

Можно воспользоваться объявлением const int n=10;

или препроцессорной директивой #define n 10

2. Т.к. тип элементов массива не указан в задании, то для универсальности программы воспользуемся вещественным типом для элементов массива:

float a[n] [n];

Результирующие данные:

1. Двумерный массив, упорядоченный по убыванию элементов первого столбца.

Промежуточные переменные:

1. Целочисленные переменные i, j,k (int i, j, k;) – для организации циклов.

2. Вещественная переменная tmp (float tmp) – для обмена значений.

Используемые алгоритмы обработки данных:

1. Формирование двумерного массива вводом с клавиатуры.

2. Вывод двумерного массива на экран.

3. Алгоритм обмена.

4. Алгоритм сортировки.

Блок-схема алгоритма

Листинг программы.

#include <stdio.h>

#include <conio.h>

#define n 7 // n 10

int main(void)

{

float a[n][n], tmp;

int i,j,k;

clrscr();

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

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

scanf("%f",&a[i][j]);

for(k=0;k<n-1;k++)

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

if (a[i][0]<a[i+1][0])

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

{

tmp=a[i][j];

a[i][j]=a[i+1][j];

a[i+1][j]=tmp;

}

printf("rezult massiv:\n");

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

{

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

printf("%7.2f",a[i][j]);

printf("\n");

}

getch();

return 0;

}

Еще один пример задачи 4.

Задача 4. Поменять местами максимальный элемент матрицы А (10х12) и элемент, индексы которого вводятся с клавиатуры.

Исходные данные:

1. Количество строк двумерного массива - целочисленная константа m=10.

2. Количество столбцов двумерного массива - целочисленная константа n=12.

Можно воспользоваться объявлением const int m=10, n=12;

или препроцессорными директивами

#define m 10

#define n 12

3. Т.к. тип элементов массива не указан в задании, то для универсальности программы воспользуемся вещественным типом для элементов массива:

float a[m] [n];

4. Индексы k и l элемента, который должен обменяться значениями с максимальным элементом.

Результирующие данные:

1. Двумерный массив, полученный после обработки.

Промежуточные переменные:

1. Целочисленные переменные i, j (int i, j;) – для организации циклов.

2. Вещественная переменная max (float max;) – для хранения максимального значения.

3. Целочисленные переменные imax и jmax (int imax, jmax;) – для хранения индексов, определяющих положение максимума в массиве.

4. Вещественная переменная tmp (float tmp) – для обмена значений.

Используемые алгоритмы обработки данных:

1. Формирование двумерного массива вводом с клавиатуры.

2. Вывод двумерного массива на экран.

3. Алгоритм поиска максимального элемента.

4. Алгоритм обмена.

Листинг программы.

#include <stdio.h>

#include <conio.h>

#include <stdlib.h>

#include <time.h>

#define m 5

#define n 7

int main(void)

{

float a[m][n], tmp, max;

int i,j,imax,jmax,k,l;

clrscr();

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

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

scanf("%f",&a[i][j]);

max=a[0][0];

imax=0;

jmax=0;

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

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

{

if(a[i][j]>max)

{

max=a[i][j];

imax=i;

jmax=j;

}

}

printf("vvedite indexy elementa: ");

scanf("%d%d", &k,&l);

tmp=a[k][l];

a[k][l]=a[imax][jmax];

a[imax][jmax]=tmp;

printf("rezult massiv:\n");

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

{

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

printf("%7.2f",a[i][j]);

printf("\n");

}

getch();

return 0;

}

Решение с помощью указателей

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

#include <stdio.h>

#include <conio.h>

#include <stdlib.h>

#include <time.h>

#define m 5

#define n 7

int main(void)

{

int a[m][n], i,j,tmp,*max=NULL,k,l;

clrscr();

randomize();

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

{

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

{

a[i][j]=random(100);

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

}

printf("\n");

}

max=&a[0][0];

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

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

{

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

max=&a[i][j];

}

printf("vvedite indexy elementa: ");

scanf("%d%d", &k,&l);

tmp=a[k][l];

a[k][l]=*max;

*max=tmp;

printf("rezult massiv:\n");

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

{

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

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

printf("\n");

}

getch();

return 0;

}

Задача 5. Транспонированием квадратной матрицы называется такое ее преобразование, при котором строки и столбцы меняются ролями: i-й столбец становится i-й строкой. Дана квадратная матрица размера nxn. Получить транспонированную матрицу.

Исходные данные:

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

1. Количество строк и столбцов в квадратной матрице совпадают, поэтому для задания размера воспользуемся целочисленной переменной n (int n;) .

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

Результирующие данные:

1. Двумерный массив, полученный после транспонирования.

Промежуточные переменные:

1. Целочисленные переменные i, j (int i, j;) – для организации циклов.

2. Вещественная переменная tmp (float tmp) – для обмена значений.

Используемые алгоритмы обработки данных:

1. Выделение памяти под двумерный массив.

2. Освобождение памяти, занимаемой двумерным массивом.

3. Формирование двумерного массива вводом с клавиатуры.

4. Вывод двумерного массива на экран.

5. Алгоритм транспонирования.

6. Алгоритм обмена.

Листинг программы.

#include <stdio.h>

#include <conio.h>

#include <stdlib.h>

#include <time.h>

#define n 7

int main(void)

{

int **a, n, i,j,tmp;

clrscr();

printf(“Vvedite razmer matrici: ”);

randomize();

a=(int**)malloc(n*sizeof(int*));

if (a==NULL)

{

printf(“nedostatochno pamyati”);

return 1;

}

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

{

a[i]=(int*)malloc(n*sizeof(int));

if (a[i]==NULL)

{

printf(“nedostatochno pamyati”);

return 2;

}

}

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

{

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

{

a[i][j]=random(100);

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

}

printf("\n");

}

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

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

{

tmp=a[i][j];

a[i][j]=a[j][i];

a[j][i]=tmp;

}

printf("rezult massiv:\n");

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

{

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

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

printf("\n");

}

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

free (a[i]);

free (a);

getch();

return 0;

}

Задача 6. Дана строка символов. Удалить из нее все кратные рядом стоящие одинаковые символы, оставив по одному (АААВВССàАВС).

Исходные данные:

1. Символьный массив размера, достаточного для хранения строки, например:

char st[80];

Результирующие данные:

1. Строка st после удаления лишних символов.

Промежуточные переменные:

1. Целочисленные переменные i, j (int i, j;) – для организации циклов для прохода по строке и сдвига.

Используемые алгоритмы обработки данных:

1. Алгоритм сдвига влево элементов массива.

2. Алгоритм удаления элемента массива.

Листинг программы.

#include <stdio.h>

#include <conio.h>

#include <string.h>

int main(void)

{

char st[80];

int i,j;

clrscr();

puts("vvedite stroku:");

gets(st);

if (strlen(st)==0)

{

puts("vvedena pustaya stroka");

getch();

return 1;

}

for(i=0;i<strlen(st)-1;)

{

if (st[i+1]==st[i])

for(j=i+1;j<strlen(st);j++)

st[j]=st[j+1];

else i++;

}

puts(st);

getch();

return 0;

}

Задача 7. Дана строка символов. Удалить из нее все слова нечетной длины. Слова отделяются друг от друга одним пробелом.

Исходные данные:

1. Символьный массив размера, достаточного для хранения строки, например:

char st[80];

Результирующие данные:

1. Строка st после удаления лишних слов.

Промежуточные переменные:

1. Целочисленные переменные i, j (int i, j;) – для организации циклов для прохода по строке и сдвига.

2. Вспомогательный символьный массив st1 (char st1[80]).

3. Переменная-указатель на символ s (char * s;) – для выделения отдельных слов с помощью функции strtok (библиотеки string).

Используемые алгоритмы обработки данных:

1. Алгоритм разбиения строки на слова – реализован с помощью функции strtok().

2. Cравнение строк – используется стандартная функция strcmp().

3. Копирование строки - используется стандартная функция strcpy().

4. Конкатенация строк - используется стандартная функция strcat().

5. Определение длины строки – strlen().

Блок-схема алгоритма

Листинг программы.

#include <stdio.h>

#include <conio.h>

#include <string.h>

#include <ctype.h>

int main(void)

{

char st[80],st1[80]="",*s=st;

int i,k;

clrscr();

puts("input string:");

gets(st);

s=strtok(s," ");

do

{

if (strlen(s)%2==0)

{

if (strcmp(st1,"")) strcat(st1," ");

strcat(st1,s);

}

s=strtok(NULL," ");

}while (s);

strcpy(st,st1);

st1[0]='\0';

puts("new string");

puts(st);

puts("press any key");

getch();

return 0;

}

2-й вариант решения (вместо использования библиотечных функций применяется алгритм сдвига влево на заданное число позиций):

#include <conio.h>

#include <string.h>

#include <ctype.h>

int main(void)

{

char st[80];

int i,j,d;

clrscr();

puts("input string:");

gets(st);

for(i=0,d=0;st[i]!='\0';)

{

if (st[i]!=' ')

{

d++;

i++;

}

else

{

if (d%2)

{

i++;

d++;

for (j=i-d;j<strlen(st)-d+1&&st[j];j++)

st[j]=st[j+d];

i=i-d;

}

else i++;

d=0;

}

}

if (d%2)

st[i-d]='\0';

puts("new string:");

puts(st);

puts("press any key");

getch();

return 0;

}

Еще один пример задачи 7.

Задача 7. Дана строка символов до точки. Подсчитать в ней число латинских букв.

Исходные данные:

1. Символьный массив размера, достаточного для хранения строки, например:

char st[80];

Результирующие данные:

1. Целочисленная переменная k (int k;) – количество латинских букв.

Промежуточные переменные:

1. Целочисленная переменная I (int i;) – для организации циклов для прохода по строке.

Используемые алгоритмы обработки данных:

1. Алгоритм подсчета количества.

2. Для проверки того, что символ является латинской буквой используется стандартная функция библиотеки ctype - isalpha().

3. Определение длины строки – strlen().

Листинг программы.

#include <stdio.h>

#include <conio.h>

#include <string.h>

#include <ctype.h>

int main(void)

{

char st[80];

int i,k;

clrscr();

puts("vvedite stroku:");

gets(st);

for(i=0,k=0;i<strlen(st);i++)

if (isalpha(st[i])) k++;

printf("k=%d",k);

getch();

return 0;

}

Задача 8. Сформировать массив, содержащий сведения о клиентах одного кредитора. Структура записи: ФИО, номер телефона, возраст, сумма. Получить сведения о самом старшем клиенте, задолжавшем более указанной суммы.

Исходные данные:

1. Размер массива N – целочисленная константа (воспользуемся препроцессорной директивой #define N 5).

2. Структура person, включающая следующие поля: имя – char name[30] (строка длиной не более 29 символов); телефон – char phone[11] (строка длиной до 10 символов); возраст – int age; задолженность – float money.

3. Массив структур client заданного размера N:

struct person client[N];

4. Пороговое значение задолженности - float money.

Результирующие данные:

1. Массив структур, выведенный на экран в виде таблицы.

2. Структура, содержащая сведения о самом старшем клиенте, имеющем задолженность, превышающую заданное пороговое значение.

Промежуточные переменные:

1. Целочисленная переменная i (int i;) – для организации циклов.

2. Целочисленная переменная int max_age – для поиска максимального возраста.

3. Указатель на структуру struct person *pos – для определения позиции искомого клиента.

Используемые алгоритмы обработки данных:

1. Формирование структуры.

2. Формирование массива.

3. Вывод массива на экран.

4. Поиск максимального элемента в массиве.

Листинг программы.

#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

#include <string.h>

#define N 3

struct person

{

char name[30];

char phone[11];

int age;

float money;

};

int main (void)

{

struct person client[N],*pos;

int i;

float money;

int max_age=0;

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

{

puts ("Name");

gets (client[i].name);

if (strcmp(client[i].name,"")==0) gets (client[i].name);

puts ("Phone");

gets (client[i].phone);

puts ("Age");

scanf ("%d", &client[i].age);

puts ("Money");

scanf ("%f", &client[i].money);

}

getch();

clrscr();

puts ("| N | Name | phone | age | money |");

puts ("-----------------------------------------------------------------");

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

printf("|%3d|%30s|%11s|%5d|%10.2f|\n",i+1,client[i].name,

client[i].phone, client[i].age, client[i].money);

getch();

//clrscr();//system ("CLS");

puts ("Money?");

scanf ("%f",&money);

max_age = 0;

pos = NULL;

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

{

k++;

if (client[i].money > money && client[i].age > max_age)

{

max_age = client[i].age;

pos = &client[i];

}

}

if (max_age == 0||pos==NULL) puts ("Net takih");

else

printf ("Name: %s\nPhone: %s\nAge: %d\nMoney: %.2f\n",

pos->name, pos->phone, pos->age, pos->money);

getch();

return 0;

}

Задача 9. В текстовом файле хранятся целые числа. Вывести в другой текстовый файл данные в виде:

Номер1 число1

Номер2 число2

………………………

Номер N числоN

Исходные данные:

1. Текстовый файл «files1.txt».

Результирующие данные:

1. Текстовый файл «files1_o.txt».

Промежуточные переменные:

1. Целочисленная переменная n (int n;) – для подсчета номера строки.

Используемые алгоритмы обработки данных:

1. Алгоритм чтения из файла данных заданного формата с помощью функции scanf().

Листинг программы.

//files1.c

#include <stdio.h>

FILE *fin, *fout;

int main(void)

{

int a,n=0;

fin=fopen("files1.txt","rt");

fout=fopen("files1_o.txt","wt");

while (fscanf(fin,"%d",&a)==1)

{

n++;

fprintf(fout,"%d\t%d\n",n,a);

}

fclose(fin);

fclose(fout);

return 0;

}

Задача 10. В текстовом файле хранится несколько предложений, каждое из которых заканчивается точкой, вопросительным или восклицательным знаком. Вывести на экран предложения, содержащие слово «привет».

Исходные данные:

1. Текстовый файл «files5_i.txt».

Результирующие данные:

1. Строки, содержащие слово «привет».

Промежуточные переменные:

1. Символьный массив st (char st[255]="";) – для хранения одного предложения.

2. Символьная переменная ch (char ch;) – для хранения считанного из файла символа.

3. Целочисленная переменная i (int i;) – для хранения индекса символа в строке.

Используемые алгоритмы обработки данных:

1. Алгоритм посимвольного чтения из текстового файла.

2. Алгоритм проверки вхождения слова в строку.

3. Алгоритм сравнения строк – используется стандартная функция strcmp().

Листинг программы.

#include <stdio.h>

#include <conio.h>

#include <string.h>

FILE *fin;

int prov(char * s)

{

int otvet=0;

strtok(s," ");

while (s)

{

if (strcmp(s,"privet")==0||

strcmp(s," privet")==0||

strcmp(s," privet")==0||

strcmp(s,"privet")==0)

otvet=1;

s=strtok(NULL," ");

}

return otvet;

}

int main(void)

{

char ch, st[255]="";

int i=0;

fin=fopen("files5_i.txt","rt");

if (fin==NULL){puts("error");return 1;}

ch=getc(fin);

while (ch!=EOF)

{

st[i]=ch;

if (ch=='.'||ch=='!'||ch=='?')

{

st[i+1]='\0';

if(prov(st)) puts(st);

i=0;

st[i]='\0';

}

else

i++;

ch=getc(fin);

}

st[i]='\0';

puts(st);

fclose(fin);

getch();

return 0;

}

Задача 11. В первой строке текстового файла указаны 2 целых числа – количество строк и столбцов матрицы. В последующих строках записаны элементы матрицы. Поменять местами столбцы матрицы, содержащие min и max элементы. Результат записать в новый файл.

Исходные данные:

1. Целочисленные переменные m, n (int m, n;) – количество строк и столбцов двумерного массива.

2. Текстовый файл «files4_i.txt».

Результирующие данные:

1. Текстовый файл «files4_o.txt».

Промежуточные переменные:

1. Файловый указатель *fin на поток, открытый для чтения.

2. Файловый указатель *fout на поток, открытый для записи.

3. Указатель на целочисленный двумерный массив в динамической памяти a (int **a;).

4. Переменная min - для поиска минимального значения в матрице.

5. Переменная max - для поиска максимального значения в матрице.

6. Переменные jmin и jmax – для поиска индексов столбцов, содержащих соответственно минимальный и максимальный элементы.

7. Переменная tmp – для обмена значений.

8. Целочисленные переменные i и j (int i, j;) – для организации циклов обработки двумерного массива.

Используемые алгоритмы обработки данных:

1. Алгоритмы выделения и освобождения динамической памяти под двумерный массив.

2. Алгоритм формирования двумерного массива.

3. Алгоритм вывода двумерного массива.

4. Алгоритм поиска максимального/минимального элементов.

5. Алгоритм обмена.

Листинг программы.

#include <stdio.h>

FILE *fin, *fout;

int main(void)

{

int **a, m,n,i,j,jmin,jmax,min,max,tmp;

// открытие файлов

fin=fopen("files4_i.txt", "rt");

fout=fopen("files4_o.txt", "wt");

if (fin==NULL||fout==NULL)

{puts(“file ne otkryt”); getch();return 1;}

fscanf(fin,"%d%d",&m,&n);

// выделение памяти

a=(int**)malloc(m*sizeof(int*));

if (a==NULL)

{ printf(“nedostatochno pamyati”);return 2;}

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

{

a[i]=(int*)malloc(n*sizeof(int));

if (a[i]==NULL)

{ printf(“nedostatochno pamyati”);return 2;}

}

//чтение массива из файла

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

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

fscanf(fin,"%d",&a[i][j]);

//обработка

max=min=a[0][0];

jmin=jmax=0;

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

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

{

if (a[i][j]<min) { min=a[i][j]; jmin=j;}

if (a[i][j]>max) { max=a[i][j]; jmax=j;}

}

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

{

tmp=a[i][jmin];

a[i][jmin]=a[i][jmax];

a[i][jmax]=tmp;

}

//вывод результирующего массива в файл

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

{

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

fprintf(fout,"%5d",a[i][j]);

fprintf(fout,"\n");

}

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

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

free (a[i]);

free (a);

fclose(fin);

fclose(fout);

return 0;

}

Задача 12. Запишите в бинарный файл несколько массивов, содержащих по 7 элементов. В текстовый файл перепишите массивы, хранящиеся в бинарном файле, и максимальные значения каждого массива.

Исходные данные:

1. Бинарный файл «files6_i.dat», содержащий несколько массивов по 7 элементов в каждом (создается отдельной программой).

Результирующие данные:

1. Текстовый файл «files6_o.txt», содержащий массивы из исходного файла и максимальные значения этих массивов.

Промежуточные переменные:

1. Файловый указатель *fin на поток, открытый для чтения.

2. Файловый указатель *fout на поток, открытый для записи.

3. Вспомогательный массив mas (double mas[7];) – буфер для считывания данных.

4. Целочисленная переменная i (int i;) – для организации циклов.

5. Переменная max (double max;) – для поиска максимума в массиве.

Используемые алгоритмы обработки данных:

1. Алгоритм создания бинарного файла – реализован в виде отдельной программы.

2. Алгоритм просмотра содержимого бинарного файла – реализован в виде отдельной программы.

3. Алгоритмы формирования и вывода массива.

4. Алгоритм поиска максимального значения.

Листинг программы.

В папке с файлами есть два варианта решения: файлы 6 и 6_2 содержат программы без использования функций, файлы 6_1 и 6_3 – решение с использованием функций.

//files6.c – создание бинарного файла

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#define N 7

FILE *f;

int main(void)

{

double mas[N];

int i,j,kol;

f=fopen("files6_i.dat","wb");

if(f==NULL)

{

puts("file not open");

return 1;

}

//srand();

randomize();

printf("Vvedite kolichestvo massivov: ");

scanf("%d",&kol);

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

{

for (j=0; j<N; J++)

{mas[j]=rand()%1000/100.0-10;

printf("%.2lf\t",mas[j]);

}

printf("\n");

fwrite(mas,sizeof(double),N,f);

}

fclose(f);

return 0;

}

//files6_2.c – чтение из бинарного, обработка и запись в текстовый файл

#include <stdio.h>

#define N 7

FILE *fin,*fout;

int main(void)

{

double mas[N],max;

int i;

fin=fopen("files6_i.dat","rb");

fout=fopen("files6_o.txt","wt");

if(fin==NULL||fout==NULL)

{

puts("file not open");

return 1;

}

while(fread(mas,sizeof(double)*N,1,fin)==1)

{

max=mas[0];

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

{

if(mas[i]>max) max=mas[i];

fprintf(fout,"%5.2lf\t",mas[i]);

}

fprintf(fout,"max=%5.2lf\n",max);

}

fclose(fin);

fclose(fout);

return 0;

}

Задача 13. Создать бинарный файл, содержащий вещественные числа.

А) Переписать в новый бинарный файл сначала все отрицательные, затем - нулевые, в конце – все положительные элементы, сохраняя порядок их следования.

Б) Найти в файле максимальный и минимальный элементы и поменять их местами.

В) Удалить из файла все нулевые элементы.

Исходные данные:

1. Бинарный файл «files7_i.dat», содержащий несколько вещественных чисел (создается отдельной программой).

Результирующие данные:

1. Бинарный файл «files7_o.txt», содержащий элементы исходного файла в указанном порядке (задание А).

2. Бинарный файл «files7_o.txt», полученный после обмена значений максимального и минимального элементов (задание Б).

3. Бинарный файл «files7_i.txt», полученный после удаления из него всех нулевых элементов (задание В).

Промежуточные переменные:

1. Файловый указатель *fin на поток, открытый для чтения.

2. Файловый указатель *fout на поток, открытый для записи.

3. Вспомогательная переменная buf (double buf;) – буфер для считывания данных.

4. Целочисленная переменная i (int i;) – для организации циклов.

5. Переменные max и min (double max, min;) – для поиска максимума и минимума в файле.

6. Переменные posmax и posmin (long int posmax, posmin;) – для поиска позиций максимума и минимума в файле.

Используемые алгоритмы обработки данных:

1. Алгоритм создания бинарного файла – реализован в виде отдельной программы.

2. Алгоритм просмотра содержимого бинарного файла – реализован в виде отдельной программы.

3. Алгоритмы поиска максимума/минимума в файле.

4. Алгоритм обмена значений в бинарном файле.

5. Алгоритм удаления данных из бинарного файла.

Листинг программы.

//files7_1.c – создание бинарного файла

#include <stdio.h>

FILE *f;

int main(void)

{

int n,i;

double buf;

f=fopen("files7_i.dat","wb");

if (f==NULL)

{

puts("file not open");

return 1;

}

printf("input amount of numbers: ");

scanf("%d",&n);

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

{

printf("input %d number: ",i+1);

scanf("%lf",&buf);

fwrite(&buf,sizeof(double),1,f);

}

fclose(f);

return 0;

}

//files7_5.c – вывод бинарного файла на экран

#include <stdio.h>

FILE *fin;

int main(void)

{

double buf;

char filename[10];

puts("input file name (files7_i.dat, files7_o.dat):");

gets(filename);

fin=fopen(filename,"rb");

if (fin==NULL)

{

puts("file not open for reading");

return 1;

}

puts(filename);

while(fread(&buf,sizeof(double),1,fin)==1)

printf("%lf\n",buf);

fclose(fin);

return 0;

}

//files7_2.c – пункт А)

#include <stdio.h>

FILE *fin,*fout;

int main(void)

{

double buf;

fin=fopen("files7_i.dat","rb");

if (fin==NULL)

{

puts("file not open for reading");

return 1;

}

fout=fopen("files7_o.dat","wb");

if (fout==NULL)

{

puts("file not open for writing");

return 2;

}

while(fread(&buf,sizeof(double),1,fin)==1)

{

if (buf<0.0) //negative numbers at first

fwrite(&buf,sizeof(double),1,fout);

}

rewind(fin);

while(fread(&buf,sizeof(double),1,fin)==1)

{

if (buf==0.0) //0 numbers at second

fwrite(&buf,sizeof(double),1,fout);

}

rewind(fin);

while(fread(&buf,sizeof(double),1,fin)==1)

{

if (buf>0.0) //pozitive numbers at the end

fwrite(&buf,sizeof(double),1,fout);

}

fclose(fin);

fclose(fout);

return 0;

}

//files7_3.c – пункт Б)

#include <stdio.h>

FILE *fin,*fout;

int main(void)

{

int posmax=0,posmin=0;

double buf,max,min;

fin=fopen("files7_i.dat","r+b");

if (fin==NULL)

{

puts("file not open for reading");

return 1;

}

if (fread(&buf,sizeof(double),1,fin)==1)

{

max=buf;

min=buf;

}

else

{

fclose(fin);

return 2;

}

while(fread(&buf,sizeof(double),1,fin)==1)

{

if (buf<min)

{

min=buf;

posmin=ftell(fin)-sizeof(double);

}

if (buf>max)

{

max=buf;

posmax=ftell(fin)-sizeof(double);

}

}

fseek(fin,posmax,SEEK_SET);

fwrite(&min,sizeof(double),1,fin);

fseek(fin,posmin,SEEK_SET);

fwrite(&max,sizeof(double),1,fin);

fclose(fin);

return 0;

}

//files7_4.c – пункт В)

#include <stdio.h>

FILE *fin,*fout;

int main(void)

{

double buf;

fin=fopen("files7_i.dat","rb");

if (fin==NULL)

{

puts("file not open for reading");

return 1;

}

fout=fopen("files7_o.dat","wb");

if (fout==NULL)

{

puts("file not open for writing");

return 2;

}

while(fread(&buf,sizeof(double),1,fin)==1)

{

if (buf!=0.0)

fwrite(&buf,sizeof(double),1,fout);

}

fclose(fin);

fclose(fout);

remove("files7_i.dat");

rename("files7_o.dat","files7_i.dat");

return 0;

}

Дата добавления: 2014-11-24; просмотров: 471; Нарушение авторских прав

Мы поможем в написании ваших работ!