6 лаба
/**
     * bmpfilter.c -- программа для наложения фильтров на
     * изображение в формате BMP
     *
     * Copyright (c) 2015, Belyakov Sergey <putinlovesme@not.you>
     *
     * This code is licensed under a MIT-style license.
     */

    #include <stdio.h>
    #include <stdlib.h>

    /*
     * Структура заголовка файла в формате BMP
     */
    typedef struct {
      char id1;
      char id2;
      unsigned int file_size;
      unsigned int reserved;
      unsigned int bmp_data_offset;
      unsigned int bmp_header_size;
      unsigned int width;
      unsigned int height;
      unsigned short int planes;
      unsigned short int bits_per_pixel;
      unsigned int compression;
      unsigned int bmp_data_size;
      unsigned int h_resolution;
      unsigned int v_resolution;
      unsigned int colors;
      unsigned int important_colors;
    } bmp_header;

    void bmp_read(char *str, bmp_header *header, float **data);
    void bmp_write(char *str, bmp_header *header, float *data);
    void bmp_grayscale(float *bmpSrc, float *bmpDst, bmp_header *header);
    void bmp_blur(float *bmpSrc, float *bmpDst, bmp_header *header);


    int main(int argc, char **argv)
    {
      /* Заголовок файла в формате BMP */
      bmp_header header;

      /* Цвета пикселей входного и выходного файлов */
      float *data_in, *data_out, *data_out2;

      /* Число пикселей в одном цветовом слое */
      long int size;

      /* При запуске программы должны быть заданы имя входного
         и имя выходного файлов */
      if (argc != 3)
      {
        fprintf(stderr, "Usage: inout <InFile> <OutFile>\n\n");
        exit(EXIT_FAILURE);
      }

      /* Читаем заголовок и данные файла BMP, заданного argv[1] */
      bmp_read(argv[1], &header, &data_in);

      /* Вычисляем количество пикселей в одном цветовом слое */
      size = header.height * header.width;

      /* Выделяем память под цвета пикселей выходного файла */
      data_out= (float*)malloc(3 * size * sizeof(float));
      data_out2 = (float*)malloc(3 * size * sizeof(float));


      /* Преобразуем в черно-белую гамму */
      bmp_grayscale(data_in, data_out, &header);

      /*Делаем размытие*/
      bmp_blur(data_out, data_out2, &header);

      /* Записываем результат в файл, заданный argv[2]) */
      bmp_write(argv[2], &header,data_out2);
    }


    /*
     * Открывает файл изображения в формате BMP (24 бита на пиксель, True Color)
     * и извлекает заголовок и данные. Для дальнейшей обработки цвета распределяются
     * по трем цветовым плоскостям (RGB) и представляются числами с плавающей точкой.
     */
    void bmp_read(char *str, bmp_header *header, float **data)
    {
        FILE *bmp_file;
        unsigned long int size,i,j,w,h,m;
        unsigned char *ptr;

        /* Открываем файл в формате BMP */
        bmp_file = fopen(str,"r");

        /* Выводим диагностику, если файл открыть не удалось */
        if (bmp_file == NULL)
        {
            printf("File \"%s\" couldn't be opened.\n\n", str);
            exit(EXIT_FAILURE);
        }

        /* Считываем 56 байтов заголовка */
        i = fread(header, 54, 1, bmp_file);

        /* Копируем данные заголовка */
        for (i = 0; i < 51; i++)
        {
            ptr = (unsigned char*)(header) + (55 - i);
            *ptr = *(ptr - 2);
        }

        /* Выводим диагностику, если глубина цвета отлична от 24 bpp */
        if (header->bits_per_pixel != 24)
        {
            printf("Sorry, but this program can handle only 24-bit"
                   "true color mode pictures.\n\n");
            exit(EXIT_FAILURE);
        }

        size = header->width * header->height;

        (*data) = (float*)malloc(3 * size * sizeof(float));

        if ((*data) == NULL)
        {
            printf("Not enough memory for reading picture.\n\n");
            exit(EXIT_FAILURE);
        }

        fseek(bmp_file, 54, SEEK_SET);

        /* Считываем значения цветовых компонентов, преобразуя к виду
           с плавающей точкой */
	    w=header->width;
	    h=header->height;

	    /* m - кол-во пикселей, которые нужны для кол-ва, кратного 4  */
	    m = (4 - (w*3)%4)%4;

		/* Считываем цвета, записывая поочередно красный, зеленый, синий в один массив,
		преобразуя в числа с плавающей точкой */
		for(i = 0; i < h; i++){
			for(j=0; j < w; j++) {

				(*data)[i*w+j] = (float)fgetc (bmp_file) / 255;
				(*data)[i*w+j + size] = (float)fgetc (bmp_file) / 255;
				(*data)[i*w+j + 2 * size] = (float)fgetc (bmp_file) / 255;
	   }
			/* Считываем пустые байты, сколько не хватает до кол-ва, кратного 4 */
			if (m != 0) {
				for (j = 0; j < m; j++) {
					fgetc (bmp_file);
				}
			}
		}
		fclose(bmp_file);
	}


    /*
     *  Сохраняет изображение в файле формате BMP (24 бита на пиксель, True Color)
     */
    void bmp_write(char *str, bmp_header *header, float *data)
    {
        FILE *bmp_file;
        unsigned long int size,i,w,h,j,n,m;
        unsigned char *ptr, *buf;

        size = header->width * header->height;

        /* Открываем файл BMP */
        bmp_file = fopen(str,"w");

        /* Выводим диагностику, если открыть не удалось */
        if (bmp_file == NULL)
        {
            printf("File \"%s\" couldn't be opened.\n\n",str);
            exit(EXIT_FAILURE);
        }

	w=header->width;
	h=header->height;

        /* Удаляемы выравнивание заголовка */
        for (i = 2; i < 56; i++)
        {
            ptr=(unsigned char*)(header) + i;
            *ptr = *(ptr + 2);
        }

        /* Записываем заголовок */
        j = fwrite(header, 54, 1, bmp_file);

	/* Проверяем, сколько нужно пикс. до кол-ва, кратного 4 */
	m = (4 - (w*3) %4)%4;

        /* Записываем цвета пикселей в файл */
		for (i = 0; i < h; i++){
			for (j=0; j < w; j++){

				fputc ((int)(data[i*w + j] * 255), bmp_file);
				fputc ((int)(data[i*w+j + size] * 255), bmp_file);
				fputc ((int)(data[i*w+j + 2 * size] * 255), bmp_file);
			}
			if (m != 0) {
				for (n = 0; n < m; n++){
					/* Дополняем картинку нулевыми байтами для кратности ширины на 4 */
					fputc(0, bmp_file);
				}
			}
		}
		fclose(bmp_file);
		free(data);
	}


    /*
     * Преобразует цвета пикселей в черно-белую гамму
     * (30% красного + 59% зеленого + 11% синего)
     */
 void bmp_grayscale(float *bmp_src, float *bmp_dst, bmp_header *header)
    {
        unsigned int layer, i, j;

	/* Получаем линейные размеры изображения*/
        unsigned int w = header->width;
        unsigned int h = header->height;

	/* Для каждого цветового слоя*/
        for (layer = 0; layer < 3; layer++)
        {
            /* Для всех строк пикселей*/
            for (i = 0; i < h; i++)
            {
                /*Для каждого пикселя*/
                for(j = 0; j < w; j++)
                {
                    /* Преобразуем в черно-белое, константы 0, 1, 2
                       оставлены в явном виде для простоты понимания*/
                    bmp_dst[layer * h * w + i * w + j] =
                          0.11 * bmp_src[0 * h * w + i * w + j]
                        + 0.59 * bmp_src[1 * h * w + i * w + j]
                        + 0.30 * bmp_src[2 * h * w + i * w + j];
                }
            }
        }
    }

 /* Для размытия необходимо подсчитать вокруг пикселя в радиусе 3 пикселей, т.е. квадрат 7х7,
 среднее значение каждого цвета и записать в данный пиксель */

void bmp_blur(float *bmp_src, float *bmp_dst, bmp_header *header){

    /*счетчики*/
    int i, j,k,l;
	unsigned long int size;
	unsigned int w = header->width;
    unsigned int h = header->height;

	size=w*h;
	for (i=0; i < h; i++){
	    for(j=0; j< w; j++){
		/*переменные, в которые будут помещены цвета каждого цвета*/
		float red = 0;
		float green = 0;
		float blue = 0;
		/*счетчик кол-ва пикселей*/
		int f= 0;
		/*границы квадрата вокруг пикселя*/
		int left, right, up, down;

		/* Находим границу слева */
		if(-j < - 3){
		    left = -3;
		}
		else{
		    left = -j;
		}

		/* Находим границу справа */
		if( w-j-1 > 3){
		    right = 3;
		}
		else {
		    right = w-j-1;
		}
		/* Находим границу сверху */
		if(-i < - 3){
		    up = -3;
		}
		else{
		    up = i;
		}

		/* Находим границу снизу */
		if( h-i-1 > 3){
		    down = 3;
		}
		else{
		    down = h-i-1;
		}


		for (k=up; k <=down ; k++){  /* Обходим квадрат по вертикали */
		    for (l=left; l <= right; l++){ /*Обходим квадрат по горизонтали */
			red +=bmp_src[(i+k)*w+j+l];  /* Складываем все красные цвета */
			green +=bmp_src[(i+k)*w+j+l+size];  /* Складываем все зеленые цвета */
			blue +=bmp_src[(i+k)*w+j+l+2*size];  /* Складываем все синие цвета */
			f++;   /*Считаем кол-во пикселей*/
		    }
		}


		/* Ищем среднее значение для каждого цвета */
		red=red/f;
		green=green/f;
		blue=blue/f;


		/* Записываем ср.значения в данный пиксель */
		bmp_dst[i*w+j]=red;
		bmp_dst[i*w+j+size]=green;
		bmp_dst[i*w+j+2*size]=blue;
	    }
	}
}


7 лаба

/**
* bwt.c — программа вычисления преобразования Барроуза-Уилера входной
* строки
*
* Copyright (c) 2015, Belyakov Sergey  <putinlovesme@not.you>
*
* This code is licensed under a MIT-style license.
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Максимально допустимое количество байт (однобайтовых символов)
* входной строки, включая символ перевода строки и терминальный нуль,
* т.е. реально обрабатываются строки длиной не более MAXLINE - 2 байт
*/

#define MAXLINE 255

int main()
{
/* Таблица преобразования */
char transform_table [MAXLINE][MAXLINE] = { 0 };
/* Вспомогательный массив номеров строк для сортировки */
char row_numbers [MAXLINE];

/* Исходная строка */
char source_line [MAXLINE];
/* Длина исходной строки */
int source_length;

/* Счетчики */
int i, j, k;

/* Получаем входную строку, контролируя длину вводимых данных */
fgets (source_line, MAXLINE, stdin);

source_length = strlen (source_line);

/* Анализируем, помещается ли введенная строка в буфер целиком */
if (source_line [source_length - 1] != '\n') {
    fprintf (stderr, "Вами введена слишком длинная входная строка\n");
    fprintf (stderr, "Максимально допустимое количество символов: %d\n", MAXLINE - 2);
    exit (EXIT_FAILURE);
}

/* Обрезаем завершающий символ перевода строки */
source_line [--source_length] = '\0';

/* Инициализируем массив номеров строк таблицы преобразования */
for (i = 0; i < source_length; i++) {
     row_numbers [i] = i;
}

/* Строим таблицу преобразования (циклических сдвигов)
РЕАЛИЗУЙТЕ САМОСТОЯТЕЛЬНО */
printf("Transform_table:\n");
for (i = 0; i < source_length; i++) {
     for (j = 0; j < source_length; j++) {
           transform_table[i][j] = source_line[j];
	   printf("%c", transform_table[i][j]);
}

printf("\n");
int temp = source_line[0];
for (j = 0; j < source_length; j++) {
     source_line[j] = source_line[j+1];
}

source_line[source_length-1] = temp;
};

strcpy(row_numbers, transform_table[0]);

/* Сортируем таблицу преобразования, используя вспомогательный массив
номеров строк РЕАЛИЗУЙТЕ САМОСТОЯТЕЛЬНО */
char temp2[MAXLINE] = {0};
int check = 1;
while (check)
{
check = 0;
for (i = 0; i < (source_length - 1); i++) {
    // printf("%d, %s\n",i ,transform_table[i]);
    if (strcmp(transform_table[i], transform_table[i + 1]) > 0)
{
strcpy(temp2, transform_table[i]);
strcpy(transform_table[i], transform_table[i + 1]);
strcpy(transform_table[i + 1], temp2);
check = 1;
}
}
}

printf("\nresult: ");

/* Вывод результата преобразования: элементов последнего столбца таблицы */
for (i = 0; i < source_length; i++) {
printf ("%c", transform_table [i][source_length - 1]);
}
printf ("\n");
return 0;
}

8 лаба

/**
 * elephant.c -- поиск слова в игре Дуплеты
 *
 * Copyright (c) 2015, Belyakov Sergey <putinlovesme@not.you>
 *
 * This code is licensed under a MIT-style license.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_WORDS 1000
#define WORDS_LENGHT 10

int main(int argc, char*argv[])
{
    /* Файл словаря */
    FILE* dict = NULL;
    /* Файл цепочки */
    FILE* chain = stdin;
    /* Число слов в цепочке */
    int chain_number = 0;
    /* Цепочка */
    char chain_words[MAX_WORDS][WORDS_LENGHT];
    /* Текущее слово */
    char current_word[WORDS_LENGHT];
    /* Признак успешного поиска подходящего слова для цепочки */
    int found = 0;
    /* Проверяем, указан ли файл словаря */
    if(argc < 2) {
        fprintf(stderr, "Не задан файл словаря\n");
        exit(EXIT_FAILURE);
    }
    /* Открываем файл словаря, контролируя ошибки */
    dict = fopen(argv[1], "r");
    if (dict == NULL) {
        fprintf (stderr, "Не удалось открыть файл словаря\n");
        exit(EXIT_FAILURE);
    }
    /* Проверяем, задан ли файл цепочки */
    if (argc >= 3) {
        chain = fopen(argv[2], "r");
        if (chain == NULL ){
            fprintf(stderr, "Не удалось открыть файл цепочки слов\n");
            exit (EXIT_FAILURE);
        }
    }
    /* Считываем цепочку слов, сразу печатая их на стандартный вывод */
    while (fscanf(chain, "%s", chain_words[chain_number]) > 0) {
        printf("%s\n", chain_words[chain_number]);
        chain_number++;
    }
    /* Выполняем поиск подходящего слова в словаре */
    while (fscanf(dict, "%s", current_word) > 0) {
        /* Сравниваем очередное слово со всеми словами цепочки */
        int i;
        for(i = 0; i < chain_number; i++) {
            if(strcmp(current_word, chain_words[i]) == 0) {
                break;
            }
        }
        /* Если слово встречается в цепочке, игнорируем его */
        if(i < chain_number) continue;
        /* Проверяем, что новое слово отличается одной буквой */
        int diff = 0;
        int len = strlen(current_word);
        diff = test(diff, len, chain_number, current_word, chain_words);
        if(diff > 1) continue;
        //Если слово подошло, завершаем обработку словаря
        found = 1;
        break;
    }
        if (found) {
        printf("%s\n", current_word);
    } else {
	    printf("-\n");}
    /* Завершаем работу с файлами */
    fclose(dict);
    if (chain != stdin) {
        fclose(chain);
    }
    return 0;
}
/*функция находит кол-во различий между словами*/
int test(int diff, int len, int chain_number, char *current_word, char chain_words[MAX_WORDS][WORDS_LENGHT])
{
    int i;
    for(i = 0; i < len; i++) {
        if(current_word[i] != chain_words[chain_number - 1][i]) {
            diff++;
        }
    }
    return diff;}

9 лаба

/**
 * romandate.c -- вывод даты в римском представлении
 *
 * Copyright (c) 2015, Belyakov Sergey <putinlovesme@not.you>
 *
 * This code is licensed under a MIT-style license.
 */


#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/** convert_dec_to_roman -- преобразует целое число в строковое представление
 *
 * Параметры:
 *   roman - строка для записи результата преобразования
 *   decimal - исходное целое
 *   n - ограничение на длину результата
 * Возвращаемое значение:
 *   функция возвращает -1 при любой ошибке
 */
int convert_dec_to_roman (char *roman, unsigned int decimal, size_t n)
{
    const int arabar[13] = {1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000};
    const char romanar[13][2] = {"I", "IV", "V", "IX", "X", "XL", "L", "XC", "C", "CD", "D", "CM", "M"};
    char romanin[n];
    int i, j = 0;
    for (i = 0; i < n; i++) {romanin[i] = NULL;}
    for (i = 13; i >= 0; i--) {
        while (arabar[i] <= decimal) {
              romanin[j++] = romanar[i][0];
              if (romanar[i][1] != NULL) {romanin[j++] = romanar[i][1];}
              decimal -= arabar[i];
        }
    }
    strcpy(roman, romanin);
}

/** get_roman_date -- преобразует дату в строковое представление
 *
 * Параметры:
 *   romandate - строка для записи даты римскими числами
 *   now - структура времени
 *   n - ограничение на длину результата
 * Возвращаемое значение:
 *   функция возвращает -1 при любой ошибке
 */
int get_roman_date (char *romandate, struct tm *now, size_t n)
{
    int dec = now;
    convert_dec_to_roman(romandate, dec, n);
}

int main (int argc, char *argv[])
{
    /* Код программы */
    // time_t a = time(NULL);
    // printf("%d\n", a);
    struct tm* tme = localtime(&a);
    printf("%d/%d/%d %d:%d:%d \n",tme->tm_year+1900, tme->tm_mon+1, tme->tm_mday, tme->tm_hour, tme->tm_min, tme->tm_sec);

    char roman[100];
    int date;
    //Записываем дату римскими цифрами в формате ДЕНЬ.МЕСЯЦ.ГОД ЧАСЫ:МИНУТЫ
    date = tme->tm_mday; // Получаем день и преобраз. его
    get_roman_date(roman, date, 100);
    printf("%s.", roman);

    date = tme->tm_mon+1; // Получаем месяц и преобраз.
    get_roman_date(roman, date, 100);
    printf("%s.", roman);

    date = tme->tm_year+1990; // получаем год и преобраз.
    get_roman_date(roman, date, 100);
    printf("%s", roman);

    date = tme->tm_hour; // получаем час и преобраз.
    get_roman_date(roman, date, 100);
    printf(" %s:", roman);

    date = tme->tm_min; // получаем минуты и преобразов.
    get_roman_date(roman, date, 100);
    printf("%s\n", roman);

    printf("%d.%d.%d %d:%d\n",tme->tm_mday, tme->tm_mon+1, tme->tm_year+1900, tme->tm_hour, tme->tm_min); //дата в стандартном формате арабскими цифрами

    system("pause");
    return EXIT_SUCCESS;
}