Int main ()

{

char str[25];

int p;

gets(str);

Buk(str);

puts(str);

strlwr(str); //регистр

p=control(str);

print(p);

return 0;

}

27) Ввести с клавиатуры строку и найти в ней все повторяющиеся символы.

На 3:

#include <stdlib.h> #include <stdio.h> #include <string.h> #define N 26 int main() { int cut[N],c,max,i; char s[80],a='a'; printf("Vvedite slovo: \n"); scanf("%s",s); for (c=0;c<N;c++) cut[c]=0; for (c=0;c<N;c++) { for (i=0;i<strlen(s);i++) if ((char)(c+97)==s[i]) cut[c]++; } for (c=0;c<N;c++) if (cut[c]>1) printf("Povtorjajuschi'sja simvoli '%c'\n", (char)(c+97)); return 0; }

28) написать строку символов, является число восьмеричной системой счисления (похоже на 21, но там 16-ричная)

На 3:

#include <stdio.h> #include <stdlib.h> #include <string.h> int main() { char s1[81]; char s2[]="01234567"; int i,j,k; gets(s1); j=strlen(s1); k=0; for (i=0;i<j;i++) if (strchr(s2,s1[i])!=NULL) k=k+1; if (k==j) printf("\n Da\n"); else printf("\n Net\n"); return 0; }

На 4: (без функции вывода)

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <conio.h>

void proverka(char *s1,char *s2)

{ int i,j,k;

k=0;

j=strlen(s1);

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

if (strchr(s2,s1[i])!=NULL) k=k+1;

if (k==j) printf("\n Da\n");

else printf("\n Net\n");

}

Int main()

{

char s1[81];

char *s2="01234567";

gets(s1);

proverka(s1,s2);

return 0;

}

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

Между 3 и 4:

#include <stdio.h> #include <stdlib.h> #include <conio.h> #include <time.h> #include <math.h> #define N 8 #define M 7 void randomize () { srand(time(0)); } void Print (int c[M][N] ) { int i, j; printf("massiv\n"); for (i=0;i<M;i++) { for (j=0;j<N;j++) { c[i][j]=rand()%(31)-10; printf("%4d", c[i][j]); } printf("\n"); } } float sred(int c[M][N]) { int i,j,k=0; float S=0; for (i=0;i<M;i++) { for (j=0;j<N;j++) { S=S+c[i][j]; k++; } } S=S/k; return S; } void Nul(int c[M][N],float S) { int i, j; for (i=0;i<M;i++) { for (j=0;j<N;j++) { if(abs(c[i][j])>S) c[i][j]=0; } } } void Vivod(int c[M][N]) { int i, j; printf("\n"); for (i=0;i<M;i++) { for (j=0;j<N;j++) { printf("%d ",c[i][j]); } printf("\n"); } } int main() { float S; int mas[M][N]; randomize (); Print(mas); S = sred(mas); printf("\n %f",S); Nul(mas,S); Vivod(mas); return 0; }

Теория

Рандом

Rand()%(конец-начало+1)+начало,

например:

int N=10;

int m1[N];

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

{

m1[i]=rand()%10+1;

}

Сортировки

// 10 .Сортировка методом прямого поиска

void SearchSort ( int *c, int n )

{ int i, min, indexMin; int *p;

for ( i=0; i<n-1; i++) // Определить массив с индексами от i до n

{ p = (c+i); // Задать адрес начала массива

min = Min (p, n-i, &indexMin); // Найти минимум в массиве

// Обменять местами минимальный элемент с первым

Exchange ( p, 0, indexMin ); }

}

// 11 .Сортировка методом прямых обменов (пузырьковый)

void ExchSort ( int *c, int n )

{

int i,j, tmp;

for ( i=0; i<n-1; i++) // Определить массив с индексами от i до n

{

for ( j=n-1; j>i; j--) // Определить массив с индексами от i до n

{

if (c[j]<c[j-1])

Exchange ( c, j, j-1 ); // Обменять местами соседние элементы

/* {

tmp=c[j];

c[j]=c[j-1];

c[j-1]=tmp;

}*/

}

}

}

// 12 .Сортировка методом прямого включения

void InsertSort ( int *c, int n )

{

int i,j,k, tmp;

for ( i=2; i<n+1; i++) // Определить массив с индексами от i до n

{

/* k=0; //индекс места

while (c[i]>c[k]) //находим позицию, куда нужно включить элемент

{

k++;

}

// if (i!=k)

{

tmp = c[i]; //запоминаем включаемый элемент

for (j=i; j>k; j--) //сдвигаем элементы массива

c[j]=c[j-1];

c[k]=tmp; // включаем элемент

}

*/

tmp=c[i];

c[0]=c[i];

j=i-1;

while (tmp<c[j])

{

c[j+1]=c[j];

j--;

}

c[j+1]=tmp;

}

}

Файлы

сохраняем и загружаем int матрицу из файла

void load(int **a,char name[])

{

FILE *in; int i;

in=fopen(name,"rb"); //rb - read binary

if(in!=NULL)

{

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

fread(a[i],1,J*sizeof(int),in);

fclose(in);

}

else puts("error! file exist")

}

void save(int **a,char name[])

{

FILE *out; int i;

out=fopen(name,"wb"); //wb - write binary

if(out!=NULL)

{

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

fwrite(a[i],1,J*sizeof(int),out);

fclose(out);

}

else puts("error! file exist")

}

Вызов их:

load(a,"file.dat");

save(a,"file.dat");

// 4. Сохранение массива в файл

// Nr - количество строк, Nc - количество столбцов

// Name - имя файла

void Save( int **x, int Nr, int Nc, char Name[])

{ FILE *out; int i;

out = fopen(Name,"wb");

if (out != NULL)

{

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

fwrite (x[i], 1, Nc*sizeof(int), out);

fclose(out);

}

else puts("\nОшибка открытия файла для записи");

}

// 5. Загрузка массива из файла

// Nr - количество строк, Nc - количество столбцов

// Name - имя файла

void Load( int **x, int Nr, int Nc, char Name[])

{ FILE *in; int i;

in = fopen (Name,"rb");

if (in != NULL)

{

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

fread ( x[i], 1, Nc*sizeof(int), in);

fclose(in);

}

else puts("\nОшибка открытия файла для чтения");

}

Динамическая память

// 8. Создание дубликата массива в динамической памяти

int * Copy (int *c, int n)

{ int *m, i;

// Резервирование памяти под дубликат массива

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

// Копирование массива

for ( i = 0; i<n; i++ ) m[i] = c[i];

// Функция возвращает адрес нового массива

return m;

}

malloc принимает в качестве аргумента размер выделяемой области в байтах; возвращает нетипизированный указатель (void*) на область памяти заявленного размера или NULL в случае, если выделить память невозможно. Содержимое выделяемой области памяти не определено.

calloc принимает в качестве аргумента количество элементов и размер каждого элемента в байтах; возвращает нетипизированный указатель (void*) на область памяти заявленного размера или NULL в случае, если выделить память невозможно. Значения элементов устанавливаются в ноль. malloc работает быстрее, чем calloc, в связи с отсутствием функции обнуления выделяемой памяти.

Часто используемые функции (со строками и т.д.)

библиотека string.

void *strcat(char *s1,const char *s2) – дополняет строку s1 строкой s2.

char *strncat(char *s1,const char *s2, size_t n) – дополняет строку s1 символами из строки s2, но не более чем n штук.

char *strcpy(char *s1,const char *s2) – копирует строку, указанную указателем s2, на место, указанное указателем s1; возвращает s1.

char *stpcpy(char *dest, const char *src) – копирует строку, указанную указателем src, на место, указанное указателем dest; не копирует символ конца строки;

char *strncpy(char *s1, const char *s2, size_t n) – – копирует строку, указанную указателем s2, на место, указанное указателем s1; возвращает s1; копируется не более чем n символов.

int strcmp(const char *s1,const char *s2) – сравнивает строки, указанные указателями s1 и s2; символы строк сравнивают с помощью значений их кодов; функция возвращает 0, если строки одинаковы; значение, которое меньше 0, если первая строка меньше второй; и значение, превышающее 0, если первая строка больше второй.

int strncmp(const char *s1,const char *s2, size_t n ) – сравнивает первые n символов или до первого пустого символа строки, указанные указателями s1 и s2.

int stricmp(const char *s1,const char *s2) – сравнивает строки, указанные указателями s1 и s2, игнорируя регистр символов (строчные или заглавные);

int strcmpi(const char *s1,const char *s2) – сравнивает строки, указанные указателями s1 и s2, игнорируя регистр символов (строчные или заглавные);

chat *strchr(const chat *s, int c) – ищет первое появление c (преобразованного в char) в строке, указанной указателем s; пустой символ является частью строки; возвращает указатель на первое появление или NULL, если ничего не найдено.

chat *strrchr(const chat *s, int c) – ищет последнее появление символа c в строке, то есть поиск идет с конца строки, заданной указателем s; пустой символ является частью строки; возвращает указатель на первое появление или NULL, если ничего не найдено.

char *strstr(const chat *s1, const char *s2) – возвращает указатель на положение первого появления последовательности символов из s2 в строке s1 (исключая завершающие пробелы); возвращает NULL, если совпадений не найдено.

chat *strtok(chat *s1,const chat *s2) – эта функция переформирует строку s1 в отдельные знаки; строка s2 содержит символы, которые используются в качестве разделителей. Функция вызывается последовательно. Для первого вызова s1 должен указывать на строку, которую необходимо разбить на знаки. Функция находит разделитель, который следует за символом, не являющимся разделителем, и заменяет, его пробелом. Она возвращает указатель на строку, содержащую первый знак. Если ни оного знака не найдено, она возвращает NULL. Чтобы найти следующий знак в строке, необходимо вызвать функцию опять, но первым аргументом поставить NULL. Каждый последовательный вызов возвращает указатель на следующий знак или на NULL, если больше знаков не найдено.

int strlen(const char *s) – возвращает число символов (исключая завершающие пробелы) в строке s.

void setmem(void *dest, unsigned length, char value) – присваивает значение value диапазону памяти, начиная с адреса dest;

size_t strspn(const char *s1, const char *s2) – находит начальный сегмент строки s1, которая состоит из символов строки s2; возвращает длину найденного сегмента.

size_t strсspn(const char *s1, const char *s2) – находит начальный сегмент строки s1, которая не состоит из символов строки s2; возвращает длину найденного сегмента.

char *strdup(const char s) – резервирует оперативную память и помещает на это место копию строки s; возвращает указатель на зарезервированную область памяти.

char *strlwr(char *s) – преобразует все символы строки к нижнему регистру (от a до z); возвращает указатель на строку s.

char *strupr(char *s) – преобразует все символы строки к верхнему регистру (от A до Z); возвращает указатель на строку s.

char *strpbrk(const char *s1, const char *s2) – сканирует строку s1 на присутствие любого символа строки s2; возвращает указатель на найденный символ или NULL, если совпадение не найдено.

char *strrev(char *s) – переписывает символы в строке в обратной последовательности; возвращает указатель на строку s.

char *strset(char *s, int ch) – все символы в строке делает равными ch; возвращает указатель на строку s.

size_t strxfrm(char *s1, char *s2, size_t n) – символы строки s2 заменяет на соответствующие символы строки s1, но не более чем n символов; возвращает количество замененных символов.

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

int memcmp (const void *s1, const void *s2, size_t n) – сравнивает два блока памяти, начинающиеся с адресов s1 и s2, но не более, чем n байтов; возвращает 0, если блоки равны, число меньшее 0, если первый блок меньше второго, число большее 0, если первый блок больше второго.

void *memcpy (void *dest, const void *src, size_t n) – копирует блок памяти src в блок памяти dest, но не более, чем n байтов; если блоки пересекаются, то результат не определен.

void *memccpy(void *dest, const void *src, int c, size_t n) – копирует блок памяти src в блок памяти dest; копирование останавливается по достижении количества в n байтов или после копирования символа c.

void *memmove(void *dest, const void *src, size_t n) – копирует блок памяти src в блок памяти dest, но не более, чем n байтов; копирование корректное даже если блоки памяти пересекаются.

void *memchr (const void *s, int c, size_t n) – в блоке памяти в n байтов ищет символ c, начиная с адреса s; если символ найден – возвращается указатель на найденный элемент, в противном случае NULL.

/*

Ввести с клавиатуры две строки, первую строку переписать в новую третью строку, пропуская все символы второй строки;

Моисеев Владислав

ИСТбд-12

*/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

void InputStrings(char * input_file, char ** string1, char ** string2);

char * Processing(char * first, char * second);

void OutputString(char * output_file, char * string);

/*Вводим строки*/

void InputStrings(char * input_file, char ** string1, char ** string2)

{

*string1 = (char *)malloc(256*sizeof(char));

*string2 = (char *)malloc(256*sizeof(char));

FILE * file = fopen(input_file,"r");

fgets(*string1, 255, file);

fgets(*string2, 255, file);

fclose(file);

}

/*Выполняем вычисления*/

char * Processing(char * first, char * second)

{

char * txt = (char *)malloc(strlen(first) + 1);

int i, j;

int flag;

int newlength = 0;

for(i = 0; i < strlen(first); i++)

{

flag = 0;

for(j = 0; j < strlen(second); j++)

{

if(first[i] == second[j])

{

flag = 1;

break;

}

}

if(flag == 0)

{

txt[newlength] = first[i];

newlength++;

}

}

txt[newlength] = 0;

return txt;

}

/*Вывод строки*/

void OutputString(char * output_file, char * string)

{

FILE * file = fopen(output_file,"w");

fputs(string, file);

fclose(file);

}

int main(int argc, char ** argv)

{

char * txt1;

char * txt2;

char * input = (argc > 2) ? argv[1] : "text.in";

char * output = (argc > 2) ? argv[2] : (argc > 1) ? argv[1] : "text.out";

InputStrings(input, &txt1, &txt2);

char * txt3 = Processing(txt1, txt2);

OutputString(output, txt3);

free(txt1);

free(txt2);

free(txt3);

return 0;

}

/*

Заполнить двумерный массив случайными числами в диапазоне от –10 до 20, найти максимальное число среди отрицательных значений и минимальное среди положительных;

Моисеев Владислав

ИСТбд-12

*/

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#define RANDOM_MIN -10

#define RANDOM_MAX 20

void Randomize();

int Random(int min, int max);

void InputIntegers(char * input_file, int * rows, int * cols);

int ** FillArray(int x, int y);

void WriteArray(FILE * file, int ** a, int x, int y);

int GetMaxOtr (int ** a, int x, int y);

int GetMinPol (int ** a, int x, int y);

void PrintResult (char * output_file, int ** array, int x, int y);

/*Цепочка случайных чисел*/

void Randomize()

{

srand(time(NULL));

}

/*Вывод случ. значения из отрезка*/

int Random(int min, int max)

{

return min + rand() % (max - min + 1);

}

/*Ввод значений*/

void InputIntegers(char * input_file, int * rows, int * cols)

{

FILE * file = fopen(input_file, "r");

fscanf (file, "%d %d", rows, cols);

fclose(file);

}

/*заполнение массива*/

int ** FillArray(int x, int y)

{

int i,j;

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

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

{

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

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

{

a[i][j] = Random (RANDOM_MIN, RANDOM_MAX);

}

}

return a;

}

/*вывод массива*/

void WriteArray(FILE * file, int ** a, int x, int y)

{

int i,j;

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

{

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

{

fprintf(file, "%4d", a[i][j]);

}

fprintf(file, "\n");

}

}

/*получить максимальный отрицательный*/

int GetMaxOtr (int ** a, int x, int y)

{

int i;

int j;

int max_otr = 0;

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

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

{

if (a[i][j] < 0)

{

max_otr = a[i][j];

break;

}

}

if (max_otr == 0)

return 0;

else

{

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

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

{

if ((a[i][j] > max_otr) && (a[i][j] < 0))

max_otr = a[i][j];

}

}

return max_otr;

}

/*получить минимальный положительный*/

int GetMinPol (int ** a, int x, int y)

{

int i;

int j;

int min_pol = 0;

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

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

{

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

{

min_pol = a[i][j];

break;

}

}

if (min_pol == 0)

return 0;

else

{

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

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

{

if ((a[i][j] < min_pol) && (a[i][j] > 0))

min_pol = a[i][j];

}

}

return min_pol;

}

/*Выводит результат*/

void PrintResult (char * output_file, int ** array, int x, int y)

{

FILE * file = fopen(output_file, "w");

WriteArray (file, array, x, y);

fputs("Result:", file);

fprintf(file, "\nMaximum < 0 = %d", GetMaxOtr (array, x, y));

fprintf(file, "\nMinimum > 0 = %d", GetMinPol (array, x, y));

fclose(file);

}

int main(int argc, char ** argv)

{

int x,y;

char * input = (argc > 2) ? argv[1] : "text.in";

char * output = (argc > 2) ? argv[2] : (argc > 1) ? argv[1] : "text.out";

InputIntegers(input, &x, &y);

Randomize();

int ** massiv = FillArray (x, y);

PrintResult (output, massiv, x, y);

free(massiv);

return 0;

}

/*

Два одномерных массива, содержащих одинаковое количество элементов, заполнить случайными числами в диапазоне от –20 до 10, сформировать третий массив, каждый элемент которого равен сумме соответствующих элементов первых двух массивов;

Моисеев Владислав

ИСТбд-12

*/

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#define RANDOM_MIN -20

#define RANDOM_MAX 10

void Randomize();

int Random(int min, int max);

void InputIntegers(char * input_file, int * elements);

int * CreateArray (int elements);

void FillArray (int a[], int n);

void PrintArray (FILE * file, int a[], int n);

int * Sum (int a[], int b[], int n);

void PrintResult (char * output_file, int * array1, int * array2, int * array3, int elements);

/*Цепочка случайных чисел*/

void Randomize()

{

srand(time(NULL));

}

/*Вывод случ. значения из отрезка*/

int Random(int min, int max)

{

return min + rand() % (max - min + 1);

}

/*Вводит данные*/

void InputIntegers(char * input_file, int * elements)

{

FILE * file = fopen(input_file, "r");

fscanf (file, "%d", elements);

fclose(file);

}

/*Создаёт массив*/

int * CreateArray (int elements)

{

return malloc (elements * sizeof (int));

}

/*Заполняет массив*/

void FillArray (int a[], int n)

{

int i;

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

a[i] = Random (RANDOM_MIN, RANDOM_MAX);

}

/*Выводит массив*/

void PrintArray (FILE * file, int a[], int n)

{

int i;

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

fprintf(file, "%4d", a[i]);

fprintf(file, "\n");

}

/*сумма элементов в новый массив*/

int * Sum (int a[], int b[], int n)

{

int *x;

int i;

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

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

x[i] = a[i] + b[i];

return x;

}

/*Выводит результат*/

void PrintResult (char * output_file, int * array1, int * array2, int * array3, int elements)

{

FILE * file = fopen(output_file, "w");

fprintf(file, "\nArray 1: ");

PrintArray(file, array1, elements);

fprintf(file, "\nArray 2: ");

PrintArray(file, array2, elements);

fprintf(file, "\nArray 3: ");

PrintArray(file, array3, elements);

fclose(file);

}

int main(int argc, char ** argv)

{

int x;

int * array_1;

int * array_2;

int * array_result;

char * input = (argc > 2) ? argv[1] : "text.in";

char * output = (argc > 2) ? argv[2] : (argc > 1) ? argv[1] : "text.out";

Randomize();

InputIntegers(input, &x);

array_1 = CreateArray (x);

array_2 = CreateArray (x);

array_result = CreateArray (x);

FillArray(array_1, x);

FillArray(array_2, x);

array_result = Sum(array_1,array_2,x);

PrintResult(output, array_1, array_2, array_result, x);

free(array_1);

free(array_2);

free(array_result);

return 0;

}

/*

Исходный массив 6х4, заполненный действительными числами в диапазоне от –10 до 15 распечатать в виде прямоугольных матриц 6х4, 8х3, 12х2;

Моисеев Владислав

ИСТбд-12

*/

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#define MATRIX_ROWS 4

#define MATRIX_COLS 6

#define RANDOM_MIN -10

#define RANDOM_MAX 15

void Randomize();

int Random(int min, int max);

int ** CreateMatrix ();

void FillMatrix (int ** matrix);

void PrintMatrix(FILE * file, int ** matrix, int width);

void Free (int ** matrix);

/*Цепочка случайных чисел*/

void Randomize()

{

srand(time(NULL));

}

/*Вывод случ. значения из отрезка*/

int Random(int min, int max)

{

return min + rand() % (max - min + 1);

}

/*Создаёт матрицу*/

int ** CreateMatrix ()

{

int ** matrix = (int **) malloc (MATRIX_ROWS * sizeof (int *));

int i;

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

matrix[i] = (int *) malloc (MATRIX_COLS * sizeof (int));

return matrix;

}

/*Заполняет матрицу*/

void FillMatrix (int ** matrix)

{

int i;

int j;

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

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

matrix[i][j] = Random(RANDOM_MIN, RANDOM_MAX);

}

/*Печатает матрицу*/

void PrintMatrix(FILE * file, int ** matrix, int width)

{

int i;

int j;

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

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

{

if(((i * MATRIX_COLS + j) % width) == 0)

fprintf(file, "\n");

fprintf(file, "%4d",matrix[i][j]);

}

fprintf(file, "\n");

}

/*Очищает память*/

void Free (int ** matrix)

{

int i;

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

free(matrix[i]);

free(matrix);

}

int main (int argc, char ** argv)

{

int ** matrix = CreateMatrix ();

FillMatrix (matrix);

FILE * file = fopen((argc > 1) ? argv[1] : "text.out", "w");

PrintMatrix (file, matrix, 6);

PrintMatrix (file, matrix, 8);

PrintMatrix (file, matrix, 12);

fclose(file);

Free(matrix);

return 0;

}

/*

Два одномерных массива, содержащих одинаковое количество элементов, заполнить случайными числами в диапазоне от –20 до 10, сформировать третий массив, элементы которого берутся поочередно из элементов первых двух массивов;

Моисеев Владислав

ИСТбд-12

*/

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#define RANDOM_MIN -20

#define RANDOM_MAX 10

void Randomize();

int Random(int min, int max);

int * CreateArray (int elements);

int GetElements(char * input_file);

void FillArray(int * array, int elements);

int * Processing (int * array1, int * array2, int elements);

void WriteArray (FILE * file, int * array, int elements);

void PrintResult (char * output_file, int * array1, int * array2, int * array3, int elements);

/*Цепочка случайных чисел*/

void Randomize()

{

srand(time(NULL));

}

/*Вывод случ. значения из отрезка*/

int Random(int min, int max)

{

return min + rand() % (max - min + 1);

}

/*Создаёт массив*/

int * CreateArray (int elements)

{

return malloc (elements * sizeof (int));

}

/*Сколько элементов делать массив*/

int GetElements(char * input_file)

{

int elements = 0;

FILE * file = fopen(input_file, "r");

fscanf (file, "%d", &elements);

fclose(file);

return elements;

}

/*Заполнить массив*/

void FillArray (int * array, int elements)

{

int i;

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

array[i] = Random(RANDOM_MIN, RANDOM_MAX);

}

/*Составляет третий массив*/

int * Processing (int * array1, int * array2, int elements)

{

int * result_array = CreateArray(elements);

int i;

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

if ((i % 2) == 0)

result_array[i] = array1[i];

else

result_array[i] = array2[i];

return result_array;

}

/*Вывести массив*/

void WriteArray (FILE * file, int * array, int elements)

{

int i;

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

fprintf(file, "%4d",array[i]);

fprintf(file, "\n");

}

/*Выводит результат*/

void PrintResult (char * output_file, int * array1, int * array2, int * array3, int elements)

{

FILE * file = fopen (output_file, "w");

fputs ("Array 1:", file);

WriteArray (file, array1, elements);

fputs ("Array 2:", file);

WriteArray (file, array2, elements);

fputs ("Array 3:", file);

WriteArray (file, array3, elements);

fclose(file);

}

int main (int argc, char ** argv)

{

char * input = (argc > 2) ? argv[1] : "text.in";

char * output = (argc > 2) ? argv[2] : (argc > 1) ? argv[1] : "text.out";

int elements = GetElements(input);

int * arr1 = CreateArray(elements);

int * arr2 = CreateArray(elements);

FillArray(arr1, elements);

FillArray(arr2, elements);

int * arr3 = Processing(arr1, arr2, elements);

PrintResult (output, arr1, arr2, arr3, elements);

free(arr1);

free(arr2);

free(arr3);

return 0;

}

/*

Заполнить случайными целыми числами одномерный массив, элементы, отличающиеся между собой ровно на 10 поменять местами;

Моисеев Владислав

ИСТбд-12

*/

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#define RANDOM_MIN -20

#define RANDOM_MAX 10

void Randomize();

int Random(int min, int max);

int * CreateArray (int elements);

int GetElements(char * input_file);

void FillArray(int * array, int elements);

void Processing (int * array, int elements);

void WriteArray (FILE * file, int * array, int elements);

void ChangePlaces (int * element1, int * element2);

void PrintResult (char * output_file, int * array, int elements);

/*Цепочка случайных чисел*/

void Randomize()

{

srand(time(NULL));

}

/*Вывод случ. значения из отрезка*/

int Random(int min, int max)

{

return min + rand() % (max - min + 1);

}

/*Создаёт массив*/

int * CreateArray (int elements)

{

return malloc (elements * sizeof (int));

}

/*Сколько элементов делать массив*/

int GetElements(char * input_file)

{

int elements = 0;

FILE * file = fopen(input_file, "r");

fscanf (file, "%d", &elements);

fclose(file);

return elements;

}

/*Заполнить массив*/

void FillArray (int * array, int elements)

{

int i;

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

array[i] = Random(RANDOM_MIN, RANDOM_MAX);

}

/*Выполняет вычисления*/

void Processing (int * array, int elements)

{

int i;

int j;

for(i = 0; i < (elements - 1); i++)

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

if (abs (array[i] - array[j]) == 10)

ChangePlaces(&(array[i]), &(array[j]));

}

/*Вывести массив*/

void WriteArray (FILE * file, int * array, int elements)

{

int i;

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

fprintf (file, "%8d",array[i]);

fprintf (file, "\n");

}

/*Поменять элементы по указателям*/

void ChangePlaces (int * element1, int * element2)

{

int i1 = *(element1);

int i2 = *(element2);

*(element1) = i2;

*(element2) = i1;

}

/*Выводит результат*/

void PrintResult (char * output_file, int * array, int elements)

{

FILE * file = fopen(output_file, "w");

fputs("Before:", file);

WriteArray (file, array, elements);

Processing(array, elements);

fputs("Result:", file);

WriteArray (file, array, elements);

fclose(file);

}

int main (int argc, char ** argv)

{

char * input = (argc > 2) ? argv[1] : "text.in";

char * output = (argc > 2) ? argv[2] : (argc > 1) ? argv[1] : "text.out";

int elements = GetElements(input);

int * array = CreateArray(elements);

FillArray(array, elements);

PrintResult (output, array, elements);

free(array);

return 0;

}

/*

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

Моисеев Владислав

ИСТбд-12

*/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

char * GetString(char * file_name);

void ProcessAndWrite(char * file_name, char * string);

/*Считывает строку*/

char * GetString(char * file_name)

{

FILE * file = fopen(file_name, "r");

char * string = (char *) calloc(256, sizeof(char));

fgets (string, 256, file);

fclose (file);

return string;

}

/*Вычисляет и записывает в файл*/

void ProcessAndWrite(char * file_name, char * string)

{

FILE * file = fopen(file_name, "w");

char abc[] = "QWRTPSDFGHJKLZXCVBNMqwrtpsdfghjklzxcvbnm";

int * flags = (int *) calloc(strlen(abc), sizeof(int));

int i;

char * finded_char = NULL;

for(i = 0; i < strlen(abc); i++)

flags[i] = 0;

for(i = 0; i < strlen(string); i++)

{

finded_char = strchr(abc, string[i]);

if(finded_char != NULL)

flags[(finded_char - abc)]++;

}

for(i = 0; i < strlen(abc); i++)

if(flags[i] > 0)

fprintf(file, "%c - %d time(s)\n", abc[i], flags[i]);

fclose(file);

}

int main(int argc, char ** argv)

{

char * input = (argc > 2) ? argv[1] : "text.in" ;

char * output = (argc > 2) ? argv[2] : (argc > 1) ? argv[1] : "text.out";

char * string = GetString(input);

ProcessAndWrite(output, string);

free(string);

return 0;

}

/*

С клавиатуры ввести три слова, проверить их на наличие одинаковых букв и распечатать эти буквы на экране;

Моисеев Владислав

ИСТбд-12

*/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

char * CreateString(int length);

void GetString(char * file_name, char * str1, char * str2, char * str3);

int Process(char * str1, char * str2, char * str3);

void WriteString(char * file_name, char * str1, int len);

/*Cоздание строки*/

char * CreateString(int length)

{

return (char *) calloc(length, sizeof(char));

}

/*Получение строк*/

void GetString(char * file_name, char * str1, char * str2, char * str3)

{

FILE * file = fopen(file_name, "r");

fscanf(file, "%s %s %s", str1, str2, str3);

}

/*Вычисление*/

int Process(char * str1, char * str2, char * str3)

{

int len = strlen(str1);

int i, j;

for(i = 0; i < (len - 1); i++)

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

if(str1[i] == str1[j])

str1[j] = '\0';

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

if((str1[i] != '\0') && ((strchr(str2, str1[i]) == NULL) || (strchr(str3, str1[i]) == NULL)))

str1[i] = '\0';

return len;

}

/*Запись в файл*/

void WriteString(char * file_name, char * str1, int len)

{

FILE * file = fopen(file_name, "w");

int i;

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

if(str1[i] != '\0')

fprintf(file, "%c ", str1[i]);

fclose(file);

}

int main(int argc, char ** argv)

{

char * input = (argc > 2) ? argv[1] : "text.in" ;

char * output = (argc > 2) ? argv[2] : (argc > 1) ? argv[1] : "text.out";

char * s1 = CreateString(256);

char * s2 = CreateString(256);

char * s3 = CreateString(256);

GetString(input, s1, s2, s3);

WriteString(output, s1, Process(s1, s2, s3));

return 0;

}

/*

Введите с клавиатуры двумерный массив чисел, определите минимум и максимум введенных значений, найдите среднее арифметическое ненулевых значений;

Моисеев Владислав

ИСТбд-12

*/

#include <stdio.h>

#include <stdlib.h>

int ** GetArray(char * file_name, int * rows, int * cols);

int GetMax(int ** a, int rows, int cols);

int GetMin(int ** a, int rows, int cols);

float GetAvgNotNull(int ** a, int rows, int cols);

void PrintArray(FILE * file, int ** a, int rows, int cols);

void PrintData(char * file_name, int ** a, int rows, int cols, int max, int min, float avg);

/*Считывание двумерного массива из файла*/

int ** GetArray(char * file_name, int * rows, int * cols)

{

FILE * file = fopen(file_name, "r");

int i, j;

fscanf(file, "%d %d\n", rows, cols);

int ** array = (int **) malloc(sizeof(int *)*(*(rows)));

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

array[i] = (int *) malloc(sizeof(int)*(*(cols)));

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

{

for(j = 0; j < (*cols - 1); j++)

fscanf(file, "%d ",&array[i][j]);

fscanf(file, "%d\n",&array[i][j]);

}

fclose (file);

return array;

}

/*Получить максимум*/

int GetMax(int ** a, int rows, int cols)

{

int max = a[0][0];

int i, j;

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

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

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

max = a[i][j];

return max;

}

/*Получить минимум*/

int GetMin(int ** a, int rows, int cols)

{

int min = a[0][0];

int i, j;

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

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

if(a[i][j] < min)

min = a[i][j];

return min;

}

/*Получить среднее ненулевых элементов*/

float GetAvgNotNull(int ** a, int rows, int cols)

{

float sum = 0.;

int count = 0;

int i, j;

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

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

if(a[i][j] != 0)

{

sum += (float) a[i][j];

count++;

}

return (sum / count);

}

/*Вывод массива*/

void PrintArray(FILE * file, int ** a, int rows, int cols)

{

int i, j;

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

{

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

fprintf(file, "%4d", a[i][j]);

fprintf(file, "\n");

}

}

/*Печать данных в файл*/

void PrintData(char * file_name, int ** a, int rows, int cols, int max, int min, float avg)

{

FILE * file = fopen(file_name, "w");

fputs("Array:\n", file);

PrintArray(file, a, rows, cols);

fprintf(file, "Min is %d\nMax is %d\nAgerage of elements != 0 is %.3f", min, max, avg);

fclose(file);

}

int main(int argc, char ** argv)

{

char * input = (argc > 2) ? argv[1] : "text.in";

char * output = (argc > 2) ? argv[2] : (argc > 1) ? argv[1] : "text.out";

int r, c;

float avg;

int ** array = GetArray(input, &r, &c);

int max, min;

max = GetMax(array, r, c);

min = GetMin(array, r, c);

avg = GetAvgNotNull(array, r, c);

PrintData(output, array, r, c, max, min, avg);

return 0;

}

/*

Заполнить двумерный массив размером 6х8 случайными числами в диапазоне от –10 до 20, определите номер строки и номер столбца максимального и минимального элементов

Моисеев Владислав

ИСТбд-12

*/

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#define RANDOM_MIN -99

#define RANDOM_MAX 99

typedef struct TElement

{

int x;

int y;

} TElement;

void Randomize();

int Random(int min, int max);

void GetElements(char * file_name, int * rows, int * cols);

int ** CreateArray(int rows, int cols);

void FillArray(int ** a, int rows, int cols);

void WriteArray(FILE * file, int ** a, int rows, int cols);

void WriteData(char * file_name, int ** a, int rows, int cols, TElement * max, TElement * min);

TElement * GetMax (int ** a, int rows, int cols);

TElement * GetMin (int ** a, int rows, int cols);

void Free (int ** array, int rows);

/*Цепочка случайных чисел*/

void Randomize()

{

srand(time(NULL));

}

/*Вывод случ. значения из отрезка*/

int Random(int min, int max)

{

return min + rand() % (max - min + 1);

}

/*Получить значения*/

void GetElements(char * file_name, int * rows, int * cols)

{

FILE * file = fopen(file_name, "r");

fscanf (file, "%d %d", rows, cols);

fclose(file);

}

/*Создаёт массив*/

int ** CreateArray(int rows, int cols)

{

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

int i;

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

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

return a;

}

/*Заполняет массив*/

void FillArray(int ** a, int rows, int cols)

{

int i, j;

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

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

a[i][j] = Random(RANDOM_MIN, RANDOM_MAX);

}

/*Выводит массив*/

void WriteArray(FILE * file, int ** a, int rows, int cols)

{

int i, j;

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

{

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

fprintf(file, "%4d", a[i][j]);

fprintf(file, "\n");

}

}

/*Выводит в файл*/

void WriteData(char * file_name, int ** a, int rows, int cols, TElement * max, TElement * min)

{

FILE * file = fopen(file_name, "w");

WriteArray (file, a, rows, cols);

fprintf(file, "\nMax element - a[row - %d][col - %d] = %d", max->x+1, max->y+1, a[max->x][max->y]);

fprintf(file, "\nMin element - a[row - %d][col - %d] = %d", min->x+1, min->y+1, a[min->x][min->y]);

fclose(file);

}

/*Получить максимум*/

TElement * GetMax (int ** a, int rows, int cols)

{

TElement * element = (TElement *) malloc (sizeof(TElement));

int i = 0;

int j = 0;

int flag = 0;

element->x = 0;

element->y = 0;

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

{

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

if (a[i][j] > a[element->x][element->y])

{

element->x = i;

element->y = j;

if(a[i][j] == RANDOM_MAX)

{

flag = 1;

break;

}

}

if(flag == 1)

break;

}

return element;

}

/*Получить минимум*/

TElement * GetMin (int ** a, int rows, int cols)

{

TElement * element = (TElement *) malloc (sizeof(TElement));

int i = 0;

int j = 0;

int flag = 0;

element->x = 0;

element->y = 0;

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

{

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

if (a[i][j] < a[element->x][element->y])

{

element->x = i;

element->y = j;

if(a[i][j] == RANDOM_MIN)

{

flag = 1;

break;

}

}

if(flag == 1)

break;

}

return element;

}

/*Очищает память*/

void Free (int ** array, int rows)

{

int i;

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

free(array[i]);

free(array);

}

int main(int argc, char ** argv)

{

char * input = (argc > 2) ? argv[1] : "text.in";

char * output = (argc > 2) ? argv[2] : (argc > 1) ? argv[1] : "text.out";

int rows, cols;

GetElements(input, &rows, &cols);

int ** a = CreateArray(rows, cols);

FillArray(a, rows, cols);

TElement * max = GetMax(a, rows, cols);

TElement * min = GetMin(a, rows, cols);

WriteData(output, a, rows, cols, max, min);

Free(a, rows);

return 0;

}

РЕЗДЕЛЕНИЕ НА СЛОВА

int selw(char *st,char *sp,char w[][N]) { char *p=strtok(st,sp); int i=0; while(p) { strcpy(w[i++],p); p=strtok(NULL,sp); } return i; } void outw(char w[][N],int i,int n) { for(;i<n;) printf("%s ",w[i++]); printf("\n"); } int srchvmax(char w[][N],char *vs,int n) { char *p; int i=0,va,t1=0,t2; for(;i<n;++i) { va=0; p=strpbrk(w[i],vs); while(p) { p=strpbrk(++p,vs); ++va; } if(t1<va) { t1=va; t2=i; } } return t2; } char st[N],w[N][N],*sp="`!;:,.?- _",*vs="aeiouy"; int i=0; gets(st); i=selw(st,sp,w); outw(w,0,i); i=srchvmax(w,vs,i); outw(w,i,i+1);