first commit

Lect1/01_page_6.c

@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+
+int main(void) 
+{
+    int32_t x = 3, y = 8;//0b0011 = 3, 0b1000 = 8
+    (x & y) ? printf("True ") : printf("False ");//0b0011 & 0b1000 = 0b0000
+    (x && y) ? printf("True ") : printf("False ");//0b0011 && 0b1000 = 0b0001
+	
+	return 0;
+}

Lect1/02_page_8.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+
+int main(void) 
+{
+    uint8_t u = 0xF5; //беззнаковый тип 0b1111 0101
+    //u = u >> 1;
+    u >>= 1; // сдвиг вправо на 1 бит   0b0111 1010(1)
+    printf("u = 0x%" PRIx8 "\n", u);
+	
+	return 0;
+}

Lect1/03_page_8.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+
+int main(void) 
+{
+    int8_t u = 0xF5; //знаковый тип     0b1111 0101
+    u >>= 1; // сдвиг вправо на 1 бит   0b1111 1010(0)
+    //~ printf("u = 0x%"PRIx8 "\n", u);
+    printf("u = 0x%"PRIx8 "\n", u);
+	
+	return 0;
+}

Lect1/04_page_8.c

@@ -0,0 +1,7 @@
+uint8_t u = 0xF5; //беззнаковый тип 1111 0101
+u >>= 2; // сдвиг вправо на 1 бит
+printf("u = %" PRIx8 "\n", u);
+
+int8_t u = 0xF5; //знаковый тип 1111 0101
+u >>= 2; // сдвиг вправо на 1 бит
+printf("u = %" PRIx8 "\n", u);

Lect1/05_page_9.c

@@ -0,0 +1,20 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+int find_odd_element(int32_t arr[], size_t n) 
+{
+    int32_t res = 0;
+    for (size_t i = 0; i < n; i++)
+        res ^= arr[i];//А^B^A = A
+    return res;
+}
+int main(void) {
+    int32_t arr[] = {17,17,24,99,24,24,24};    
+    size_t n = sizeof(arr) / sizeof(arr[0]);
+    printf("The element is %" PRId32,
+           find_odd_element(arr, n));
+    return 0;
+}
+
+

Lect1/06_page_10.c

@@ -0,0 +1,10 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+
+int main(void) 
+{
+    int32_t x = 17;
+    (x & 1) ? printf("Odd") : printf("Even");
+}

Lect1/07_page_11.c

@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <stdint.h>
+
+int main(void) 
+{
+    uint32_t a = 60;    /* 60 = 0011 1100 */
+    uint32_t b = 13;    /* 13 = 0000 1101 */
+    int32_t  c = 0;
+    c = a & b;       /* 12 = 0000 1100 */
+    printf("Line 1 c = %u\n", c );
+    c = a | b;       /* 61 = 0011 1101 */
+    printf("Line 2 c = %u\n", c );
+    c = a ^ b;       /* 49 = 0011 0001 */
+    printf("Line 3 c = %u\n", c );
+    c = ~a;          /*-61 = 1100 0011 */
+    printf("Line 4 c = %d\n", c );
+    c = a << 2;     /* 240 = 1111 0000 */
+    printf("Line 5 c = %u\n", c );
+    c = a >> 2;     /* 15 = 0000 1111 */
+    printf("Line 6 c = %u\n", c );
+    return 0;
+}

Lect1/08_page_15.1.c

@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdint.h>
+
+struct date {
+  uint16_t day   : 5; // значение от 0 до 31 unsigned short
+  uint16_t month : 4; // значение 0 до 15
+  //~ uint16_t year;//: 7; если огранчить с 2000 до 2127 года
+  uint16_t year : 7; //если огранчить с 2000 до 2127 года
+};
+int main(void)
+{
+  //~ struct date dt = { 31, 12, 2021 };//{ 31, 12, 21 }
+  struct date dt = { 31, 12, 127 };
+  printf("Size is %llu\n",  sizeof(dt));
+  printf("Date is %u/%u/%u\n",dt.day, dt.month, dt.year);
+//+2000);
+  return 0;
+}

Lect1/08_page_15.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include <stdint.h>
+
+struct date {
+    uint16_t day   : 5; // значение от 0 до 31
+    uint16_t month : 4; // значение 0 до 15
+    uint16_t year;//: 7; если огранчить с 2000 до 2064 года
+};
+int main(void)
+{
+    struct date dt = { 31, 12, 2021 };
+    dt.month = 16;
+    printf("Date is %u/%u/%u", dt.day, dt.month, dt.year);
+}

Lect1/09_page_17.c

@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include <inttypes.h>
+
+union floatbit 
+{
+    float value;
+    struct {
+        uint32_t mant : 23;
+        uint32_t exp  : 8;
+        uint32_t sign : 1;
+    } bit;
+} f;
+
+int main()
+{
+    f.value = -4.1;
+    //~ f.value = 4.0;
+    printf("Memory size is %llu\n", sizeof(f));
+    printf("f.value  = %f\n",f.value );
+    printf("sign     = %#x\n",f.bit.sign);
+    printf("exp      = %d\n",f.bit.exp);
+    printf("mantissa = %#x\n",f.bit.mant);
+    return 0;
+}

Lect1/10_page_18.c

@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <inttypes.h>
+
+int main(void)
+{
+    int32_t a, sign;//-1 = 0b1111 1111
+    scanf("%d",&a);
+    sign = a>>31; // записываем маску >>8 = 1111 1111
+    printf("%x\n",a);   
+    a = a^sign; // если число отрицательное то инверсия
+    //~ a ^= sign; // если число отрицательное то инверсия
+    printf("%x\n",a);
+    a = a + (sign&0x1); // если число было отрицательное то +1
+    //~ a += sign&0x1; // если число было отрицательное то +1
+    printf("%d\n",a);
+    return 0;
+}

Lect1/11_page_19.c

@@ -0,0 +1,11 @@
+#include <stdio.h>
+_Bool isEqual(int a, int b) {
+    return !(a^b);
+}
+
+int main(void)
+{
+    int a = 3,b=5;
+    isEqual(a,b) ? printf("YES\n") : printf("NO\n");
+    return 0;
+}

Lect1/12_page_20.c

@@ -0,0 +1,21 @@
+#include <stdio.h>
+#include <inttypes.h>
+
+void changeSign(float *f) {
+    union {
+        float f;
+        uint32_t u;
+    } tmp;
+    tmp.f = *f;
+    tmp.u = tmp.u ^ 0x80000000;//1000 0000 0000 0000 0000 0000 0000 0000 
+    *f = tmp.f;
+}
+
+
+int main(void)
+{
+    float f = 4.0;
+    changeSign(&f);
+    printf("%f\n",f);
+    return 0;
+}

Lect1/13_task_4_page_21.c

@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <stdint.h>
+
+int32_t inverse5bits(int n)
+{
+	return n ^ 0x1F;
+}
+
+int main () 
+{
+	int32_t a = 0xFF;
+	printf("%x\n", a);	
+	a = inverse5bits(a);
+	printf("%x\n", a);
+	a = inverse5bits(a);
+	printf("%x\n", a);
+
+	return 0;
+}

Lect1/14_page_22.c

@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <inttypes.h>
+
+_Bool difSign(int32_t a, int32_t b) {
+    return (a>>31)^(b>>31);
+}
+
+int main(void)
+{
+    int a = -3,b=5;
+    difSign(a,b) ? printf("YES\n") : printf("NO\n");
+    return 0;
+}

Lect1/15_task_6_page_23.c

@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <stdint.h>
+
+int div1IfEven(int a) {
+	return a - !(a&0x1);
+}
+
+int main () 
+{
+	int32_t a, res;
+	
+	scanf("%d",&a);
+	res = div1IfEven(a);
+	printf("%d", res);
+
+	return 0;
+}

Lect1/16_task_7_page_24.c

@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdint.h>
+
+int32_t unset_rightmost (uint32_t n)
+{
+	return n & (n - 1);
+}
+
+int main () 
+{
+	int32_t a, res;
+	
+	scanf("%d",&a);
+	res = unset_rightmost(a);
+	printf("%d", res);
+
+	return 0;
+}

Lect1/17_task_8_page_25.c

@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdint.h>
+
+_Bool isPowerOfFour(uint32_t n)
+{
+	return n != 0 && ((n&(n-1)) == 0) && !(n & 0xAAAAAAAA);
+}
+
+int main () 
+{
+	int32_t a;
+	
+	scanf("%d",&a);
+
+	printf("%s", isPowerOfFour(a) ? "YES" : "NO");
+
+	return 0;
+}

Lect1/18_task_9_page_26.c

@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <stdint.h>
+
+int leftRotate(uint32_t n, uint32_t rotate)
+{
+	return (n << rotate)|(n >> (32 - rotate));
+}
+int main () 
+{
+	int32_t a, rotate, res;
+	
+	scanf("%d %d",&a, &rotate);
+	res = leftRotate(a, rotate);
+	printf("%d", res);
+
+	return 0;
+}

Lect1/19_task_10_page_27.c

@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <stdint.h>
+
+int rightRotate(uint32_t n, uint32_t rotate)
+{
+	return (n >> rotate)|(n << (32 - rotate));
+}
+int main () 
+{
+	int32_t a, rotate, res;
+	
+	scanf("%d %d",&a, &rotate);
+	res = rightRotate(a, rotate);
+	printf("%d", res);
+
+	return 0;
+}

Lect1/20_task_11_page_28.c

@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <stdint.h>
+union floatbit {
+	float value;
+	struct {
+		uint32_t mant : 23;
+		uint32_t exp : 8;
+		uint32_t sign : 1;
+	} bit;
+} f;
+
+float mult4(float f) {
+	union floatbit tmp;
+	tmp.value = f;	
+	tmp.bit.exp += 2;
+	return tmp.value;
+}
+int main () 
+{
+	float a, res;
+	
+	scanf("%f",&a);
+	res = mult4(a);
+	printf("%.3f", res);
+
+	return 0;
+}

Lect1/21_task_13_page_30.c

@@ -0,0 +1,36 @@
+#include <stdio.h>
+#include <stdint.h>
+
+uint32_t reverseBits(uint32_t num)
+{
+	uint32_t NO_OF_BITS = sizeof(num) * 8;
+	uint32_t reverse_num = 0;
+	int32_t i;
+	for (i = 0; i < NO_OF_BITS; i++)
+	{
+		if((num & (1 << i)))
+			reverse_num |= 1 << ((NO_OF_BITS - 1) - i);
+	}
+	return reverse_num;
+}
+uint32_t bitRevers(uint32_t n) {
+	uint32_t r=0;
+	while(n) {
+		r <<= 1;
+		r |= n&0x1;
+		n >>= 1;
+	}
+	return r;
+}
+
+int main () 
+{
+	uint32_t a, res;
+	
+	scanf("%u",&a);
+	//res = reverseBits(a);
+	res = bitRevers(a);
+	printf("%u", res);
+
+	return 0;
+}

Lect1/22_page_34.1.c

@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <inttypes.h>
+
+
+int main(void)
+{
+    int i=123;
+    int *pi; //указатель на переменную      
+    pi = &i;
+
+    int **ppi;// указатель на указатель
+    ppi = &pi;
+    printf("**ppi = %d\n",**ppi);
+
+    struct s {
+        int i;
+        float f;
+    } st;
+    
+    struct s  *ps;
+    ps = &st; //указатель на структуру
+    printf("ps -> i = %d\n",ps->i);
+
+    int ar[5] = {1,2,3,4,5};
+    int *pa; //указатель на массив
+    pa = &ar[0]; // pa = ar;
+    printf("*pa = %d\n",*pa);
+    
+    int ar2[3][5] =  {{1,2,3,4,5}, {11,12,13,14,15}, {21,22,23,24,25}};
+    int (*pa2)[5]; //указатель массив из 5-и элементов
+    pa2 = ar2+1; //адрес 1-ой строки
+    printf("**pa2 = %d\n",**pa2);    
+    return 0;
+}

Lect1/22_page_34.c

@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <inttypes.h>
+
+struct s {
+    int i;
+    float f;
+} st = {10,3.14};
+
+int main(void)
+{
+  struct s  *ps;
+  ps = &st; //указатель на структуру
+  printf("ps -> i = %d\n",ps->i);
+  printf("(*ps).i = %d\n",(*ps).i);
+  return 0;
+}

Lect1/23_page_36-38.c

@@ -0,0 +1,29 @@
+#include <stdio.h>
+
+struct student
+{
+    int id;
+    char name[20];
+    int group;
+};
+
+void func(struct student record)
+{
+    printf(" Id is: %d \n", record.id);
+    printf(" Name is: %s \n", record.name);
+    printf(" Group is: %d \n", record.group);
+}
+
+void pfunc(struct student *record)
+{
+    printf("Id is: %d \n", record->id);
+    printf("Name is: %s \n", record->name);
+    printf("Group is: %d \n", record->group);
+}
+
+int main(void) {
+    struct student record = {1, "Vasiliy", 102};
+    func(record);
+    pfunc(&record);
+    return 0;
+}

Lect1/24_page_40.1.c

@@ -0,0 +1,13 @@
+#include <stdio.h>
+
+int func(int n) {
+    printf("Hello func %d\n",n);
+    return n+1;
+}
+int main()
+{
+    int (*fp)(int);
+    fp = func;
+    fp(128);
+    return 0;
+}

Lect1/24_page_40.2.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+int func(int n) 
+{
+    printf("Hello func %d\n",n);
+    return n+1;
+}
+int main()
+{
+    int (*fp)(int);
+    fp = func;
+    fp(5);
+    return 0;
+}

Lect1/25_page_41.c

@@ -0,0 +1,18 @@
+#include <stdio.h>
+
+typedef struct  {
+    int id;
+    char name[20];
+    int group;
+} student;
+
+int main(void)
+{
+student s;
+    s.id = 1;
+
+typedef int iarr[10];
+    iarr a, b, c[5]; 
+// тоже самое int a[10], b[10], c[10][5];
+    return 0;
+}

Lect1/26_page_43_44.c

@@ -0,0 +1,60 @@
+/*В программе реализована структура данных:
+struct pack_array
+{
+    uint32_t array; // поле для хранения упакованного массива из 0 и 1
+    uint32_t count0 : 8; // счетчик нулей в array
+    uint32_t count1 : 8; // счетчик единиц в array
+}
+Необходимо написать программу, которая упаковывает переданный ей массив из 32-ух элементов 0 и 1 в указанную структуру данных.
+Функция должна строго соответствовать прототипу: void array2struct(int [], struct pack_array *)
+
+Пример №1
+Данные на входе:        1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+Данные на выходе:
+Поля структуры
+array = ffff0000
+count0 = 16
+count1 = 16
+
+Пример №2
+Данные на входе:        1 1 1 1 1 1 1 1 1 0 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1
+Данные на выходе:
+Поля струткуры
+array = ffa70009
+count0 = 17
+count1 = 15
+*/
+
+#include <stdio.h>
+#include <stdint.h>
+
+struct pack_array {
+uint32_t array;      // поле для хранения упакованного массива из 0 и 1
+uint32_t count0 : 8; // счетчик нулей в array
+uint32_t count1 : 8; // счетчик единиц в array
+};
+
+void array2struct(int origin[] , struct pack_array *res)
+{
+    for (int i =0; i<32; i++)
+    {
+        res->count1 += origin[i];
+        res->array  |= origin[i];
+        i<31 ? res->array<<=1 : 1;
+    }
+    res -> count0=32-res->count1;
+}
+
+int main ()
+{
+int arr[32];
+struct pack_array res;
+    for (int i=0; i<32; i++)
+    {
+        scanf("%d", arr+i);
+    }
+    array2struct(arr, &res);
+    printf("array: 0x%x\ncount0: %d\ncount1 %d\n", res.array, res.count0, res.count1);
+    return 0;
+}
+

Lect1/27_page_46.c

@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <stdint.h>
+
+int extractExp(float f) {
+    union {
+        float f;
+        struct {
+            uint32_t mantissa : 23;
+            uint32_t exp : 8;
+            uint32_t s : 1;
+        } field;
+    } fl;
+    fl.f = f;
+    return fl.field.exp;
+}
+
+int main(void)
+{
+    float f = 1.423;
+    printf("exp = %d\n",extractExp(f)-127);
+    return 0;
+}    

Lect2/08.c

@@ -0,0 +1,12 @@
+#include <stdio.h>
+
+int main(void)
+{
+    float f = 2.0;
+    int *p;
+    p = (int*)&f;
+    printf("*p = %x\n",*p);
+    *p = (127+3)<<23; // кладем в f 2^3 меняем порядок
+    printf("f = %f\n",f);
+    return 0;
+}

Lect2/10.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+int main(void)
+{
+    int *p = NULL; // 0 —  не указывает ни на что
+
+/*ОШИБКА! Попытка разыменовать нулевой указатель */
+    //~ if(*p)
+    if(p && *p) //правильно - ленивая логика
+        printf("True\n");
+    return 0;
+}
+
+

Lect2/10_1.c

@@ -0,0 +1,13 @@
+    #include <stdio.h>
+
+int main(void)
+{
+/* Нет ошибки */
+    int *p = NULL;
+    //~ if(p == &(*p))
+    //~ if(&(*p) != NULL)
+    //~ if(p == NULL)
+    if(!p)//(p!=0) (*p)
+        printf("True\n");
+    return 0;
+}

Lect2/13.c

@@ -0,0 +1,20 @@
+#include <stdio.h>
+#include <inttypes.h>
+
+
+//может сравнивать любые указатели
+_Bool is_same(void *a, void *b)
+{
+    //~ return *a = *b; // ОШИБКА! void * нельзя разыменовывать
+    return a == b; // Можно только сравнивать
+}
+
+int main(void)
+{
+    int a=5;
+    int b=5;
+    int *pa = &b;
+    float *pc=NULL;
+    is_same(&a, pc) ? printf("Same\n") : printf("Different\n");
+    return 0;
+}

Lect2/15.c

@@ -0,0 +1,13 @@
+#include <stdio.h>
+
+int main(void)
+{
+    int a[5] = {1,2,3,4,5}; // в памяти выделено 20 байт
+    //~ const int* const pa = &a[0]; // в памяти выделено 8 байт
+    int *pb = &a[0]; // в памяти выделено 8 байт
+    //~ a = &a[2];  // ОШИБКА!
+    pa = &a[1]; // Нельзя менять константный указатель
+    pb = &a[1];
+    pb[2] = 100;
+    return 0;
+}

Lect2/16-17.c

@@ -0,0 +1,15 @@
+#include <stdio.h>
+
+char *strcpy(char *dst, const char *src ) {
+    char *d = dst;
+    while (*dst++ = *src++);//!=0
+    return d;
+}
+int main()
+{
+    char a[]="Hello!", b[7];
+    a[6] = '*';
+    strcpy(b,a);
+    printf("b = %s\n",b);
+    return 0;
+}

Lect2/21-22.c

@@ -0,0 +1,36 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+    double sum=0,v;//сумма и введенное значение
+    int arr_size=0, arr_u=0;//размер массива и текущая позиция
+    double *arr = NULL;//память под динамический массив
+    arr_size = 16;//задаем начальный размер
+    if (!(arr = (double*) malloc(arr_size * sizeof(arr[0]))))//выделяем память NULL
+        goto out_of_mem;//не смогли выделить память
+    while (scanf("%lf", &v) == 1)//пока приходят данные
+    {
+        if (arr_u == arr_size)//если достигли конца массива
+        {
+           arr_size *= 2;//увеличиваем размер в двое и выделяем память
+           if (!(arr = (double*) realloc(arr, arr_size * sizeof(arr[0]))))
+               goto out_of_mem;//не смогли выделить память
+        }
+        sum += v;//находим сумму
+        arr[arr_u] = v;//сохраняем значение в текущую позицию
+        arr_u++;//сдвигаем текущую позицию в массиве
+    }
+    if (!arr_u)//не было введено ни одного значения
+       return 0;
+    double average = sum/arr_u;//находим среднее значение
+    printf("%lf\n", average);
+    for(int i=0; i < arr_u; i++)
+        if(arr[i] <= average)//лучше сравнивать с определенной точностью
+            printf("%lf\n", arr[i]);//печатаем числа, не превышающие среднее
+    free(arr);//освобождаем память
+    return 0;//выходим с хорошим кодом завершения
+out_of_mem:
+    fprintf(stderr, "Can't allocate memory\n");
+    return 1;//выходим с аварийным кодом завершения
+}

Lect2/24.c

@@ -0,0 +1,10 @@
+#include <stdio.h>
+
+int main(void)
+{
+  int *p1, p2;
+  int n = 30;
+  p1 = &n;
+  p2 = &n; // ОШИБКА
+  return 0;
+}

Lect2/25.c

@@ -0,0 +1,24 @@
+#include <stdio.h>
+
+int main(void)
+{
+
+    {
+        int *p1; // указывает на случайную область памяти
+        int n = *p1; // ОШИБКА разыменования
+        printf("%d\n", n);
+    }
+
+
+    {
+        int* p1;
+        int m;
+        p1 = &m; // указатель ссылается на
+             // неинициализированную
+             // переменную
+        int n = *p1;
+        printf("%d\n", n);
+    }
+    return 0;
+}
+

Lect2/26.c

@@ -0,0 +1,10 @@
+#include <stdio.h>
+
+int main(void)
+{
+    int *p1;
+    int m = 100;//mmap
+    p1 = m; // ОШИБКА
+//вместо адреса присвоили //значение
+    return 0;
+}

Lect2/27.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+int main(void)
+{
+    int *p1;
+    int m = 100;
+    p1 = &m; // присваиваем адрес m
+    *p1++;   // ОШИБКА! увеличение
+             //адреса, а не значения
+    //~ (*p1)++;
+
+    printf("%d",*p1);
+    return 0;
+}

Lect2/28.c

@@ -0,0 +1,12 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+
+int main(void)
+{
+    int* p1;
+    int m = 100;
+    p1 = &m;
+    free(p1); //ОШИБКА! Попытка освободить стековую память      
+    return 0;  
+}

Lect2/29.c

@@ -0,0 +1,21 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+    {
+        int* p1;
+        p1 = malloc(sizeof(int));
+        *p1 = 99;
+        free(p1);
+        *p1 = 100; // ОШИБКА! память не определена
+    }
+    {
+        int* p1;
+        p1 = malloc(sizeof(int));
+        *p1 = 99;
+        *p1 = 100;
+        free(p1);
+    }
+    return 0;  
+}

Lect2/30.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(void)
+{
+    char *str1 = malloc(strlen("Hello world") + 1);
+    strcpy(str1, "Hello world");
+    //...
+    free(str1);  // Первый раз free
+    //...
+    free(str1); // ОШИБКА! второй раз free  
+    return 0;  
+}

Lect2/31.c

@@ -0,0 +1,11 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+    int *p;
+    p = malloc(4); // ОШИБКА!
+    // нарушение переносимости
+    p = malloc(sizeof(int));
+    return 0;  
+}

Lect2/32.c

@@ -0,0 +1,25 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+    {
+        int* p = malloc(sizeof(int)); 
+        *p = 5;
+        p = malloc(sizeof(int)); //ОШИБКА!
+        // Предыдущий блок все еще
+        // занимает память
+    }
+    {
+        int* p = malloc(sizeof(int)); 
+        *p = 5;
+        free(p);
+        p = malloc(sizeof(int));    
+    }
+    
+    return 0;  
+}
+
+
+
+

Lect2/33.c

@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(void) 
+{
+    struct st { char *s; } t1, t2;
+    t1.s = malloc(10);
+    strcpy (t1.s, "Hello ");
+    t2 = t1;//будет скопирована ссылка на память
+    printf ("%s", t2.s);
+    strcpy (t1.s, "world!");
+    printf ("%s", t2.s);//поменялась
+    printf ("%s", t1.s);//поменялась
+    return 0;  
+}   

Lect2/34.c

@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(void)
+{
+    struct st { char s[10]; } t1, t2;
+    strcpy (t1.s, "Hello ");
+    t2 = t1;//память будет скопирована
+    printf ("%s", t2.s);
+    strcpy (t1.s, "world!");
+    printf ("%s", t2.s);//не поменялась
+    printf ("%s", t1.s);//поменялась
+    printf ("%s", t2.s);
+    return 0;  
+}   

Lect2/35.c

@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(void)
+{    
+    int len = strlen("Hello");
+    char *str1 = malloc(len + 1);
+    strcpy(str1, "Hello");
+    char *str2 = str1;
+    printf("%s\n", str1);
+    // ... много кода
+    free(str1);
+    // .. много кода
+    printf("%s\n", str2); // ОШИБКА! Эта память уже не определена
+    return 0;  
+}   

Lect2/36.c

@@ -0,0 +1,12 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+    const size_t SIZE = 10;
+    int *arr;
+    arr = malloc(sizeof(int) * SIZE);
+    arr[SIZE] = 100; // ОШИБКА! выход за
+                     // границу массива
+    return 0;  
+}   

Lect2/37.c

@@ -0,0 +1,11 @@
+#include <stdio.h>
+
+int main(void)
+{
+int  num = 2147483647;// 0x7fffffff
+    int   *pi = &num;
+    short *ps = (short*)pi;
+    printf("pi: %p  Value(16): %x  Value(10): %d\n", pi, *pi, *pi);
+    printf("ps: %p  Value(16): %hx  Value(10): %hd\n", ps, *ps, *ps);
+    return 0;  
+}   

Lect2/38.c

@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+int main(void)
+{
+    int len = strlen("Hello");
+    char* str1 = malloc(len + 1);
+    strcpy(str1, "Hello");
+    char* str2 = malloc(len + 1);
+    strcpy(str2, "Hello");
+    if (str1 == str2)    
+    {
+        printf("Strings are equal\n");
+    }   
+    else    
+    {
+        printf("Strings are NOT equal\n");
+    }
+    return 0;  
+}

Lect2/40-1.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+void print_array(int a[5]) {
+/* ОШИБКА! 
+   Размер массива теряется */
+  int size = sizeof(a)/sizeof(int); 
+  for(int i=0; i<size;i++)
+    printf("a[%d]=%d ",i,a[i]);
+}
+int main(void) {
+    int a[5] = {1,2,3,4,5};   
+    print_array(a);
+    return 0;
+}

Lect2/40-2.c

@@ -0,0 +1,16 @@
+#include <stdio.h>
+void print_array(int a[], int size) {
+    /* Так можно */
+    for( int i=0; i<size; i++ )
+        printf("a[%d]=%d ",i,a[i]);
+    printf("\n");
+}
+int main(void) {
+    int a[5] = {1,2,3,4,5};
+    print_array(a, 5);
+    /*  Так тоже можно */
+    for(int i=0; i<sizeof(a)/sizeof(int); i++) {
+          printf("a[%d]=%d ",i,a[i]);
+    }
+    return 0;
+}

Lect2/41.c

@@ -0,0 +1,21 @@
+#include <stdio.h>
+
+void print_matrix(int n, int m, void *a) {
+    int (*pa)[m] = a; // Указатель на строку из 
+                      // m элементов типа int
+    for( int i=0; i<n; i++ ) {
+        for( int j=0; j<m; j++ ) {
+            printf("%4d ",pa[i][j]);//двухмерный массив
+        }
+        printf("\n");
+    }
+}
+int main(void) {
+    int a[2][3] =
+    {
+        {1,2,3},
+        {4,5,6}
+    };
+    print_matrix(2,3,a);
+    return 0;
+}

Lect2/42.c

@@ -0,0 +1,21 @@
+#include <stdio.h>
+
+void print_matrix(int n, int m, int a[][m]) { // Важен только размер строки
+    for( int i=0; i<n; i++ ) {
+        for( int j=0; j<m; j++ ) {
+            printf("%4d ",a[i][j]);
+        }
+        printf("\n");
+    }
+}
+
+
+int main(void) {
+    int a[2][3] =
+    {
+        {1,2,3},
+        {4,5,6}
+    };
+    print_matrix(2,3,a);
+    return 0;
+}

Lect2/43.c

@@ -0,0 +1,10 @@
+#include <stdio.h>
+
+int ar[] = {1,2,3,4,5};
+int *par = ar;
+
+int main(void) {
+    par[3] = 123;
+    ar[2] = 321;
+    return 0;
+}

Lect2/45.bat

@@ -0,0 +1,3 @@
+gcc -c -o main.o main.c
+gcc -c -o arr.o arr.c
+gcc -o prog main.o arr.o

Lect2/47.c

@@ -0,0 +1,15 @@
+#include <stdio.h>
+
+int main(void)
+{
+    {
+        char s[] = "Hello world";
+        s[0] = 'A'; // Так можно
+    }
+    {
+        char *s = "Hello world";
+        s[0] = 'A'; // ОШИБКА! read-only string
+    }
+    return 0;  
+}
+

Lect2/49-52.c

@@ -0,0 +1,88 @@
+#include <stdio.h>
+#include <stdlib.h>
+//список о выделенной памяти
+typedef struct list {
+    void *address;
+    size_t size;
+    char comment[64];
+    struct list *next;
+} list;
+
+list *memlist = NULL;
+
+//добавление  информация в однонаправленный список о новом блоке выделенной памяти
+void insert(list **head, void *address, size_t size, char *comment) {
+    list *tmp = malloc(sizeof(list));
+    tmp->next = *head;
+    tmp->address = address;
+    tmp->size = size;
+    sprintf(tmp->comment,"%s",comment);
+    *head = tmp;
+}
+
+_Bool delete(list **head, void *address) {
+    if(*head == NULL)//если списко пустой - выходим 
+        return 0;
+    list *del = NULL;
+    if( (*head)->address == address) {
+        del = *head;
+        *head = (*head)->next;
+        free(del);
+        return  1;
+    }
+    list *tmp = *head;
+    while( tmp->next ) {
+        if(tmp->next->address == address ) {
+            del = tmp->next;
+            tmp->next = del->next;
+            free(del);
+            return 1;
+        }
+        tmp=tmp->next;
+    }
+    return 0;
+}
+
+void printList(list *head) {
+    if(head == NULL) {
+        printf("No memory leak detect\n");
+    }
+    while(head) {
+        printf("%s\n",head->comment);//выводим диагностику
+        head = head->next;
+    }
+}
+
+void* my_malloc(size_t size, const char *file, int line, const char *func)
+{
+    void *ptr = malloc(size);
+    char coment[64] = {0};
+    sprintf (coment,"Allocated = %s, %i, %s, %p[%lli]", file, line, func, ptr, size);    
+    insert(&memlist,ptr,size,coment);   
+    return ptr;
+}
+
+void my_free(void *ptr, const char *file, int line, const char *func)
+{
+    delete(&memlist, ptr);
+    free(ptr);
+}
+
+
+//макрос, который заменяет стандартный вызов функции malloc() на вызов функции  my_malloc() и аналогичный макрос для вызова функции free()
+#define malloc(X) my_malloc( (X), __FILE__, __LINE__, __FUNCTION__)
+#define free(X) my_free( (X), __FILE__, __LINE__, __FUNCTION__)
+
+
+int main(void) {
+    int *p  = malloc( sizeof(int) );//my_malloc
+    //~ int *p  = my_malloc( sizeof(int), __FILE__, __LINE__, __FUNCTION__ );//my_malloc
+    int *ar = malloc(sizeof(int)*10);
+    *p = 5;
+    free(p);
+    p = malloc(sizeof(int));
+
+    free(p);
+    printList(memlist);
+    return 0;
+}

Lect2/arr.c

@@ -0,0 +1 @@
+int ar[5];

Lect2/main.c

@@ -0,0 +1,11 @@
+#include <stdio.h>
+extern int *ar;
+
+int ar[5];
+
+int main(void) {
+    ar[3] = 123;
+    printf("%d",ar[3]);
+    return 0;
+}
+

Lect3/17.c

@@ -0,0 +1,11 @@
+#include <stdio.h>
+
+char s1[] = "Hello ";
+char s2[] = "world!";
+
+int main(void) {
+    scanf("%s",s1);
+    printf("s1 = %s\n",s1);
+    printf("s2 = %s\n",s2);
+    return 0;
+}

Lect3/18.c

@@ -0,0 +1,11 @@
+#include <stdio.h>
+
+char s1[] = "Hello ";
+char s2[] = "world!";
+
+int main(void) {
+    scanf("%6s",s1);
+    printf("s1 = %s\n",s1);
+    printf("s2 = %s\n",s2);
+    return 0;
+}

Lect3/19.c

@@ -0,0 +1,18 @@
+#include <stdio.h>
+
+char s1[] = "Hello ";
+char s2[] = "world!";
+
+int main(void)
+{
+    char c;
+    printf("===Enter q to quit===\n");
+    do
+    {
+        printf("Enter a symbol\n");
+        scanf("%c", &c);
+        printf("%c\n", c);
+    }
+    while (c != 'q');
+    return 0;
+}

Lect3/20.c

@@ -0,0 +1,18 @@
+#include <stdio.h>
+
+char s1[] = "Hello ";
+char s2[] = "world!";
+
+int main(void)
+{
+    char c;
+    printf("===Enter q to quit===\n");
+    do
+    {
+        printf("Enter a symbol\n");
+        scanf(" %c", &c);
+        printf("%c\n", c);
+    }
+    while (c != 'q');
+    return 0;
+}

Lect3/22_1.c

@@ -0,0 +1,9 @@
+#include <stdio.h>
+#include <string.h>
+int main() {
+    char str1[] = "Small string.";
+    char str2[15];
+    strcpy(str2, str1);
+    puts(str1);
+    return 0;
+}

Lect3/22_2.c

@@ -0,0 +1,10 @@
+#include <stdio.h>
+#include <string.h>
+//ОШИБКА! Переполнение буфера
+int main() {
+    char str1[] = "This is very big string.";
+    char str2[15];
+    strcpy(str2, str1);
+    puts(str1);
+    return 0;
+}

Lect3/24.c

@@ -0,0 +1,10 @@
+#include <stdio.h>
+#include <assert.h>
+
+int main(){
+  int x = 7;
+  x = 9;
+  assert(x==7); // Условие проверки
+// будет напечатано сообщение в stderr
+  return 0;
+}

Lect3/25.c

@@ -0,0 +1,12 @@
+#include <stdio.h>
+#include <assert.h>
+
+int main() {
+    int n;
+    printf("Input natural number: ");
+    scanf("%d", &n);
+    assert(n > 0); // Ожидаемое число
+    int arr[n];
+
+    return 0;
+}

Lect3/28.c

@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <locale.h> //setlocale() 
+#include <inttypes.h>
+#include <wchar.h> //«широкие» символы
+int main(void)
+{
+    char* res = setlocale(LC_ALL,"en_US.UTF-8");
+    printf("%s\n",res);
+    wchar_t str1[] = L"Привет";
+    printf("str1 = %S\n", str1);
+    printf("sizeof str1 = %llu\n", sizeof(str1));
+    char str2[] = "Привет";
+    printf("str2 = %s\n",str2);
+    printf("sizeof str2 = %llu\n", sizeof(str2));
+    char str3[] = "Hello!";
+    printf("str3 = %s\n",str3);
+    printf("sizeof str3 = %llu\n", sizeof(str3));
+    return 0;
+}

Lect3/29.c

@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <locale.h> //setlocale() 
+#include <inttypes.h>
+#include <wchar.h> //«широкие» символы
+int main(void)
+{
+    char* res = setlocale(LC_ALL,"en_US.UTF-8");    
+    printf("%s\n",res);    
+    printf("%ls\n", L"Hello"); // Напечатать строку из  wchar_t
+    printf("%s\n", "Hello"); // Напечатать строку из  char
+
+    wchar_t str[] = L"Привет";
+    wprintf(L"%ls\n",str);
+    return 0;
+}

Lect3/30.c

@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <locale.h> //setlocale()
+#include <inttypes.h>
+#include <wchar.h> //«широкие» символы
+int main(void)
+{
+    char* res = setlocale(LC_ALL,"en_US.UTF-8");
+    printf("%s\n",res);
+
+    setlocale(LC_ALL,"en_US.UTF-8");
+    wchar_t str[] = L"БГ";
+    printf("%ls\n",str);
+    printf("sizeof(wchar_t) = %llu\n",sizeof(wchar_t));
+    printf("str[0] = %x\n", str[0]);
+    printf("str[1] = %x\n", str[1]);
+    return 0;
+}

Lect3/34/lib.c

@@ -0,0 +1,8 @@
+#include "lib.h"
+
+int max(int a, int b){
+    return (a>b)?a:b;
+}
+int max3(int a, int b, int c) {
+    return max(a,max(b,c));
+}

Lect3/34/lib.h

@@ -0,0 +1,2 @@
+int max(int a, int b);
+int max3(int a, int b, int c);

Lect3/34/main.c

@@ -0,0 +1,11 @@
+// main.c
+#include <stdio.h>
+#include "lib.h"
+
+
+int main(){
+    int a,b,c;
+    scanf("%d%d%d",&a,&b,&c);
+    printf("max3 = %d\n",max3(a,b,c));
+    return 0;
+}

Lect3/35/35.txt

@@ -0,0 +1,6 @@
+gcc -c lib.c
+ar -r libmy1.a lib.o
+Windows
+gcc -o prog1 main.c -L ./ c:\geekbrains.ru\Projects\C\MIPI_AC_Git\MIPI_AdvancedC\Lect3\35\libmy1.a
+Linux
+gcc -o prog2 main.c -L ./ -lmy2 -rpath /home/user/mylib2/

Lect3/35/lib.c

@@ -0,0 +1,9 @@
+#include "lib.h"
+
+
+int max(int a, int b){
+    return (a>b)?a:b;
+}
+int max3(int a, int b, int c) {
+    return max(a,max(b,c));
+}

Lect3/35/lib.h

@@ -0,0 +1,2 @@
+int max(int a, int b);
+int max3(int a, int b, int c);

Lect3/35/main.c

@@ -0,0 +1,11 @@
+// main.c
+#include <stdio.h>
+#include "lib.h"
+
+
+int main(){
+    int a,b,c;
+    scanf("%d%d%d",&a,&b,&c);
+    printf("max3 = %d\n",max3(a,b,c));
+    return 0;
+}

Lect3/36.c

@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <locale.h> //setlocale() 
+#include <inttypes.h>
+#include <wchar.h> //«широкие» символы
+int main(void)
+{
+uint8_t ch[] = {0xd0,0x90,0xd0,0x91,0}; // "АБ"
+uint32_t ch32[] = {0x91d090d0,0}; // "АБ"
+
+char* res = setlocale(LC_ALL,"en_US.UTF-8");    
+    printf("%s\n",res); 
+
+    printf("%x %x %x %x = %s\n",ch[0],ch[1],ch[2],ch[3],ch);
+    printf("%x = %s\n",ch32[0], ch32);
+    return 0;    
+}    

Lect3/36/36.txt

@@ -0,0 +1,6 @@
+gcc -c -fPIC lib.c
+gcc -shared -o libmy2.so lib.o
+Windows:
+gcc -o prog2 main.c -L ./ c:\geekbrains.ru\Projects\C\MIPI_AC_Git\MIPI_AdvancedC\Lect3\36\libmy2.so
+Linux:
+gcc -o prog2 main.c -L ./ -lmy2 -rpath /home/user/mylib2/

Lect3/36/lib.c

@@ -0,0 +1,9 @@
+#include "lib.h"
+
+
+int max(int a, int b){
+    return (a>b)?a:b;
+}
+int max3(int a, int b, int c) {
+    return max(a,max(b,c));
+}

Lect3/36/lib.h

@@ -0,0 +1,2 @@
+int max(int a, int b);
+int max3(int a, int b, int c);

Lect3/36/main.c

@@ -0,0 +1,11 @@
+// main.c
+#include <stdio.h>
+#include "lib.h"
+
+
+int main(){
+    int a,b,c;
+    scanf("%d%d%d",&a,&b,&c);
+    printf("max3 = %d\n",max3(a,b,c));
+    return 0;
+}

Lect3/38-39.c

@@ -0,0 +1,40 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int numberOfBytesInChar(unsigned char val);
+int utf8strlen(char *s);
+
+int main(void){
+    char s[] = "Hello world";
+    char s2[] = "Привет Мир";
+    printf("strlen(s) = %llu\n",strlen(s));
+    printf("strlen(s2) = %llu\n",strlen(s2));
+    printf("utf8strlen(s) = %d\n",utf8strlen(s));
+    printf("utf8strlen(s2) = %d\n",utf8strlen(s2));
+    return 0;
+}
+
+int numberOfBytesInChar(unsigned char val) {
+    if (val < 0x80) 
+        return 1;
+    else if (val < 0xE0) 
+        return 2;
+    else if (val < 0xF0) 
+        return 3;
+    else 
+        return 4;
+}
+
+int utf8strlen(char *s) 
+{
+    char *tmp = s;
+    int len = 0;
+    while( *tmp ) 
+    {
+        tmp += numberOfBytesInChar(*tmp);
+        len++;
+    }
+    return len;
+}

Lect3/45.c

@@ -0,0 +1,12 @@
+#include <stdio.h>
+#include <time.h>
+int main(void)
+{
+    time_t mytime = time(NULL);
+    struct tm *now = localtime(&mytime);
+    printf("Date: %d.%d.%d\n", now->tm_mday,
+           now->tm_mon + 1, now->tm_year + 1900);
+    printf("Time: %d:%d:%d\n", now->tm_hour,
+           now->tm_min, now->tm_sec);
+    return 0;
+}

Lect3/46.c

@@ -0,0 +1,11 @@
+#include <stdio.h>
+#include <time.h>
+double DELAY = 3;
+int main()
+{
+   clock_t begin = clock();
+   while((double)(clock() - begin)/CLOCKS_PER_SEC<DELAY)
+   {/*printf("%4d\n",clock());*/ }
+   printf("Hello World %d",CLOCKS_PER_SEC);
+   return 0;
+}

Lect3/49.c

@@ -0,0 +1,18 @@
+#include <curses.h>
+
+int main()
+{   
+    int ch;  
+    initscr();  // Начать curses mode
+    raw();      // Отключаем buffering. Ctrl+C не завершит программу
+    noecho(); // Отключаем echo() режим пока считываем символы getch
+    printw("Type text: \n");
+    while( (ch = getch()) != '.')
+    {
+        printw("%c", ch);
+    }
+    //refresh(); // Печатаем это на экран
+    getch();   // Ждем пока пользователь нажмет клавишу
+    endwin();  // Завершить curses mode
+    return 0;
+}

Lect3/52.c

@@ -0,0 +1,14 @@
+#include <curses.h>
+#include <unistd.h>
+
+int main() {
+    initscr();
+    printw("Hello World !!!");
+    printw("\nPress any key to continue... ");
+    // refresh(); // по
+    пробуйте включить и выключить
+    sleep(3);
+    getch();
+    endwin();
+    return 0;
+}

Lect3/52_1.c

@@ -0,0 +1,14 @@
+#include <curses.h>
+#include <unistd.h>
+
+int main() {
+    initscr();
+    char string[]="Hello world!";
+    int x=10,y=10;
+    printw(string); /* Напечатать на стандартном экране stdscr */
+                    /* в текущей позиции курсора  */
+    mvprintw(y, x, string);/* Напечатать в позиции (y, x)  */
+    getch();
+    endwin();
+    return 0;
+}

Lect3/snake_seminar_2.c

@@ -0,0 +1,161 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <ncurses/ncurses.h>
+#include <inttypes.h>
+#include <string.h>
+#include <unistd.h>
+
+#define MIN_Y  2
+enum {LEFT=1, UP, RIGHT, DOWN, STOP_GAME=KEY_F(10)};
+enum {MAX_TAIL_SIZE=100, START_TAIL_SIZE=3, MAX_FOOD_SIZE=20, FOOD_EXPIRE_SECONDS=10};
+
+
+// Здесь храним коды управления змейкой
+struct control_buttons
+{
+    int down;
+    int up;
+    int left;
+    int right;
+}control_buttons;
+
+struct control_buttons default_controls = {KEY_DOWN, KEY_UP, KEY_LEFT, KEY_RIGHT};
+
+/*
+ Голова змейки содержит в себе
+ x,y - координаты текущей позиции
+ direction - направление движения
+ tsize - размер хвоста
+ *tail -  ссылка на хвост
+ */
+typedef struct snake_t
+{
+    int x;
+    int y;
+    int direction;
+    size_t tsize;
+    struct tail_t *tail;
+    struct control_buttons controls;
+} snake_t;
+
+/*
+ Хвост это массив состоящий из координат x,y
+ */
+typedef struct tail_t
+{
+    int x;
+    int y;
+} tail_t;
+
+void initTail(struct tail_t t[], size_t size)
+{
+    struct tail_t init_t={0,0};
+    for(size_t i=0; i<size; i++)
+    {
+        t[i]=init_t;
+    }
+}
+void initHead(struct snake_t *head, int x, int y)
+{
+    head->x = x;
+    head->y = y;
+    head->direction = RIGHT;
+}
+
+void initSnake(snake_t *head, size_t size, int x, int y)
+{
+tail_t*  tail  = (tail_t*) malloc(MAX_TAIL_SIZE*sizeof(tail_t));
+    initTail(tail, MAX_TAIL_SIZE);
+    initHead(head, x, y);
+    head->tail = tail; // прикрепляем к голове хвост
+    head->tsize = size+1;
+    head->controls = default_controls;
+}
+
+/*
+ Движение головы с учетом текущего направления движения
+ */
+void go(struct snake_t *head)
+{
+    char ch = '@';
+    int max_x=0, max_y=0;
+    getmaxyx(stdscr, max_y, max_x); // macro - размер терминала
+    mvprintw(head->y, head->x, " "); // очищаем один символ
+    switch (head->direction)
+    {
+        case LEFT:
+            if(head->x <= 0) // Циклическое движение, чтобы не
+// уходить за пределы экрана
+                head->x = max_x;
+            mvprintw(head->y, --(head->x), "%c", ch);
+        break;
+        case RIGHT:
+            mvprintw(head->y, ++(head->x), "%c", ch);
+        break;
+        case UP:
+            mvprintw(--(head->y), head->x, "%c", ch);
+        break;
+        case DOWN:
+            mvprintw(++(head->y), head->x, "%c", ch);
+        break;
+        default:
+        break;
+    }
+    refresh();
+}
+
+void changeDirection(struct snake_t* snake, const int32_t key)
+{
+    if (key == snake->controls.down)
+        snake->direction = DOWN;
+    else if (key == snake->controls.up)
+        snake->direction = UP;
+    else if (key == snake->controls.right)
+        snake->direction = RIGHT;
+    else if (key == snake->controls.left)
+        snake->direction = LEFT;
+}
+
+/*
+ Движение хвоста с учетом движения головы
+ */
+void goTail(struct snake_t *head)
+{
+    char ch = '*';
+    mvprintw(head->tail[head->tsize-1].y, head->tail[head->tsize-1].x, " ");
+    for(size_t i = head->tsize-1; i>0; i--)
+    {
+        head->tail[i] = head->tail[i-1];
+        if( head->tail[i].y || head->tail[i].x)
+            mvprintw(head->tail[i].y, head->tail[i].x, "%c", ch);
+    }
+    head->tail[0].x = head->x;
+    head->tail[0].y = head->y;
+}
+
+int main()
+{
+snake_t* snake = (snake_t*)malloc(sizeof(snake_t));
+    initSnake(snake,START_TAIL_SIZE,10,10);
+    initscr();
+    keypad(stdscr, TRUE); // Включаем F1, F2, стрелки и т.д.
+    raw();                // Откдючаем line buffering
+    noecho();            // Отключаем echo() режим при вызове getch
+    curs_set(FALSE);    //Отключаем курсор
+    mvprintw(0, 0,"Use arrows for control. Press 'F10' for EXIT");
+    timeout(0);    //Отключаем таймаут после нажатия клавиши в цикле
+    int key_pressed=0;
+    while( key_pressed != STOP_GAME )
+    {
+        key_pressed = getch(); // Считываем клавишу
+        go(snake);
+        goTail(snake);
+        timeout(100); // Задержка при отрисовке
+        changeDirection(snake, key_pressed);
+    }
+    free(snake->tail);
+    free(snake);
+    endwin(); // Завершаем режим curses mod
+    return 0;
+}