View difference between Paste ID: cy0N4PfP and uMb5MCbJ

 #include <stdio.h>
 #include <stdbool.h>
 #include <string.h>
 #include <ctype.h>
 #include <stdlib.h>
 
 #define strSize 1000 //  число строк/столбцов
 #define upDown 4
 #define left 1
 #define right 2
 
 //  структура карты
 typedef struct {
     int rows;
     int cols;
     unsigned char *cells;
 } Map;
 
 struct prirustek {
     int dr;
     int ds;
 };
 
 enum smery { vychod, sever, zapad, jih, POCET_SMERU };
 
     struct prirustek d[POCET_SMERU] = {
         {0, +1}, // vychod (0)
         {-1, 0}, // sever (1)
         {0, -1}, // zapad (2)
         {+1, 0}, // jih (3)
     };
 
 //  является ли строка числом
 bool isCharNum(char *argument) {
     int len = strlen(argument);
     bool result = true;
 
     for (int i = 0; i < len; i++) {
         if (!isdigit(argument[i])) {
             result = false;
         }
     }
     return result;
 }
 
 //  сколько слов в строке, без пробелов
 int wordsInStr(char *str) {
     int i;
     int words = 0;
 
     for (i = 0; i < strlen(str) - 1; i++) {
         if (str[i] == ' ' && str[i+1] != ' ') {
             words++;
         }
 
         if (str[0] != ' ' && i == 0) {
             words++;
         }
     }
 
     return words;
 }
 
 //  является ли формат файла txt или нет
 bool fileTxt(char *fileName) {
     if (
         (fileName[strlen(fileName) - 4] == '.') &&
         (fileName[strlen(fileName) - 3] == 't') &&
         (fileName[strlen(fileName) - 2] == 'x') &&
         (fileName[strlen(fileName) - 1] == 't')
     )
     {
         return true;
 	}
 	else
     {
         fprintf(stderr, "Error: file is not '.txt'");
         return false;
 	}
 }
 
 //  получение значения из ячейки стуктуры
 char getCell(Map *map, int row, int col) {
     return map->cells[ row * map->cols + col ];
 }
 
 //  проверка границы сверху или снизу
 bool hasBorderTopOrBottom(char cell) {
     return cell == '4' || cell == '5' || cell == '6' || cell == '7';
 }
 
 //  проверка границы слева
 bool hasBorderLeft(char cell) {
     return cell == '1' || cell == '3' || cell == '5' || cell == '7';
 }
 
 //проверка границы справа
 bool hasBorderRight(char cell) {
     return cell == '2' || cell == '3' || cell == '6' || cell == '7';
 }
 
 //  проверка конфликта двух рядом стоящих элементов по горизонтали
 bool hasHorizontalConflicts(char leftCell, char rightCell) {
     switch (rightCell){
         case '1' :
         case '3' :
         case '5' :
         case '7' : return leftCell == '1' || leftCell == '4' || leftCell == '5' || leftCell == '0';
         case '0' :
         case '2' :
         case '4' :
         case '6' : return leftCell == '2' || leftCell == '3' || leftCell == '6' || leftCell == '7';
     }
 }
 
 //  проверка конфликта двух рядом стоящих элементов по вертикали
 bool hasVerticalConflicts(char downCell, char upCell) {
     switch (downCell){
         case '1' :
         case '2' :
         case '3' :
         case '0' : return upCell == '4' || upCell == '5' || upCell == '6' || upCell == '7';
         case '4' :
         case '5' :
         case '6' :
         case '7' : return upCell == '1' || upCell == '2' || upCell == '3' || upCell == '0';
     }
 }
 
 //  проверка на конфликт значений элементов двух ячеек
 bool hasConflictCells(Map *map, int i, int j){
     bool error = false;
     if (j > 0){
         error = hasHorizontalConflicts(getCell(map, i, j-1), getCell(map, i, j));
 
     }
     if (i > 0 && (i + j) % 2 == 0 && !error){
         error = hasVerticalConflicts(getCell(map, i - 1, j), getCell(map, i, j));
     }
     return error;
 }
 
 
 
 //  проверка карты
 bool readAndTestMap(Map *map, char *fileName)
 {
     FILE *fp;
     fp = fopen(fileName, "r");
 
     //  проверка, что такой файл есть
     if (fp == NULL) {
         fprintf(stderr, "Can't open file '%s'\n", fileName);    //  не удалось открыть такой файл
         return false;
     } else {
         char str[strSize] = "";
         //  считываем первую строку из файла
         fgets(str, strSize, fp);
 
         //  проверяем, что в строке только 2 слова
         if (wordsInStr(str) == 2) {
             char *firstword = strtok(str, " ");
             char *secondword = strtok(NULL, "\n");
 
             //  проверка, что считаные элементы являются цифрами
             if (isCharNum(firstword) && isCharNum(secondword)) {
                 map->rows = atoi(firstword);    //  определяем количество строк
                 map->cols = atoi(secondword);   //  определяем количество столбцов
 
                 map->cells = malloc(map->rows * map->cols * sizeof(unsigned char) + 1); //  выделяем память под структуру
 
                 //  начинаем считывать строки из файла
                 for (int i = 0; i < map->rows; i++) {
                     fgets(str, strSize, fp);
 
                     //  проверяем, что количество слов в строке соответствует количеству столбцов
                     if (wordsInStr(str) != map->cols) {
                         fprintf(stderr, "Invalid\n");   //  не соответствует
                         return false;
                     }
 
                     //  меняем символ новой строки на символ конца строки
                     if (str[strlen(str)-1] == '\n') {
                         str[strlen(str)-1] = '\0';
                     }
 
                     int len = strlen(str);
 
                     firstword = strtok(str, " ");   //  дробим строку по пробелам
 
                     for (int j = 0; j < map->cols || firstword != NULL; j++) {
 
                         //  проверка, что число однозначное
                         if (firstword[1] != NULL) {
                             fprintf(stderr, "Invalid\n");   //  в числе более одного знака
                             return false;
                         } else {
 
                             //  проверка, что значения лежат в пределах от 0 до 7
                             if (firstword[0] >= '0' && firstword[0] <= '7') {
                                 char number = firstword[0];
                                 //  запись элемента в структуру
                                 map->cells[i*map->cols+j] = number;
                                 firstword = strtok(NULL, " ");  //  переход к новому слову
                             } else {
                                 fprintf(stderr, "Invalid\n");
                                 return false;
                             }
 
                         }
 
                     }
                 }
                 //  проверка, на соответствие массива количеству строк
                 if (fgets(str, strSize, fp)) {
                     fprintf(stderr, "Invalid\n");
                     return false;
                 }
 
                 bool isClose = true;    //  переменная для проверки на закрытость лабиринта
 
                 //  проверяем только нечетные позиции первой и последней строки на закрытость
                 for (int j = 0; j < map->cols; j = j + 2) {
                     if (
                         !hasBorderTopOrBottom(getCell(map, 0, j)) ||
                         !hasBorderTopOrBottom(getCell(map, map->rows - 1, j))
                     ) {
                         isClose = false;    //  есть открытая граница
 
                     }
                 }
 
                 //  проверка на  закрытость левой и правой границы массива
                 for (int j = 0; j < map->rows; j = j + 1) {
                     if (
                         !hasBorderLeft(getCell(map, j, 0)) ||
                         !hasBorderRight(getCell(map, j, map->cols - 1))
                     ) {
                         isClose = false;    //  есть открытая границы
 
                     }
                 }
 
                 //  если лабиринт закрыт, сообщаем об этом
                 if (isClose) {
                     fprintf(stderr, "Invalid\n");
                     return false;
                 }
 
                 //  проверка, что рядом стоящие числа не конфликтуют друг с другом
                 for (int i = 0; i < map->rows; i++){
                     for (int j = 0; j < map->cols; j++){
                         if (hasConflictCells(map, i, j)){
                              fprintf(stderr, "Invalid\n");
                              return false;
                         }
 
                     }
                 }
 
             } else {
                 fprintf(stderr, "Invalid\n");
                 return false;
             }
 
 
         }
     }
 
     return true;
 }
 
 bool isborder(Map *map, int r, int c, int border) {
     bool levo, pravo, verchNiz;
     levo = (getCell(map, r, c) - '0') & left;
     pravo = (getCell(map, r, c) - '0') & right;
     verchNiz = (getCell(map, r, c) - '0') & upDown;
     switch(border) {
         case sever :
         case jih : return verchNiz;
         case vychod : return pravo;
         case zapad : return levo;
 
     }
 }
 
 int start_border(Map *map, int r, int c, int leftright) {
     int smer;
     // right hand
     if (leftright == 0) {
         if ((r + c) % 2 == 0) {
             if (c == 0 && !isborder(map, r, c, zapad)) {
                 smer = vychod;
             }
             else if (c == map->cols - 1 && !isborder(map, r, c, vychod)) {
                 smer = sever;
             }
             else if (r == 0 && !isborder(map, r, c, sever)) {
                 smer = zapad;
             }
             else {
                 fprintf(stderr, "Bad vstup\n");
                 return -1;
             }
         }
         else {
             if (c == 0 && !isborder(map, r, c, zapad)) {
                 smer = jih;
             }
             else if (c == map->cols - 1 && !isborder(map, r, c, vychod)) {
                 smer = zapad;
             }
             else if (r == map->rows -1 && !isborder(map, r, c, jih)) {
                 smer = vychod;
             }
             else {
                 fprintf(stderr, "Bad vstup\n");
                 return -1;
             }
         }
     }
     //  left hand
     else {
         if ((r + c) % 2 == 0) {
             if (c == 0 && !isborder(map, r, c, zapad)) {
                 smer = sever;
             }
             else if (c == map->cols - 1 && !isborder(map, r, c, vychod)) {
                 smer = zapad;
             }
             else if (r == 0 && !isborder(map, r, c, sever)) {
                 smer = vychod;
             }
             else {
                 fprintf(stderr, "Bad vstup\n");
                 return -1;
             }
         }
         else {
             if (c == 0 && !isborder(map, r, c, zapad)) {
                 smer = vychod;
             }
             else if (c == map->cols - 1 && !isborder(map, r, c, vychod)) {
                 smer = jih;
             }
             else if (r == map->rows - 1 && !isborder(map, r, c, jih)) {
                 smer = zapad;
             }
             else {
                 fprintf(stderr, "Bad vstup\n");
-void walkInLabirinthleft(Map *map, int row, int col, int hand, int smer) {
+                return -1;
             }
         }
 
     }
     return smer;
 }
 
 
 void walkInLabirinthRight(Map *map, int row, int col, int hand, int smer) {
 
     while ((row < map->rows && col < map->cols) && (row >= 0 && col >= 0)) {
         while (isborder(map, row, col, smer)) {
             smer = (smer + 1) % POCET_SMERU;
             if ((row + col) % 2 == 0 && smer == jih) {
                 smer = (smer + 1) % POCET_SMERU;
             }
             else if ((row + col) % 2 != 0 && smer == sever) {
                 smer = (smer + 1) % POCET_SMERU;
             }
         }
         printf("%d,%d\n", row + 1, col + 1);
         row = row + d[smer].dr;
         col = col + d[smer].ds;
 
         if (((row + col) % 2 == 0 && smer == vychod) || ((row + col) % 2 != 0 && smer == zapad)){
         }
 
         else {
             smer = (smer + 3) % POCET_SMERU;
-    char *argv3 = "0";
+
-    char *argv1 = "--rpath";
+
-    char *argv2 = "0";
+
 }
 
 void walkInLabirinthLeft(Map *map, int row, int col, int hand, int smer) {
 
     while ((row < map->rows && col < map->cols) && (row >= 0 && col >= 0)) {
-        printf("--help - vypisuje napovedu\n");
+
             smer = (smer + 3) % POCET_SMERU;
             if ((row + col) % 2 == 0 && smer == jih) {
                 smer = (smer + 3) % POCET_SMERU;
             }
             else if ((row + col) % 2 != 0 && smer == sever) {
                 smer = (smer + 3) % POCET_SMERU;
             }
         }
         printf("%d,%d\n", row + 1, col + 1);
         row = row + d[smer].dr;
         col = col + d[smer].ds;
 
         if (((row + col) % 2 == 0 && smer == zapad) || ((row + col) % 2 != 0 && smer == vychod)){
         }
 
         else {
             smer = (smer + 1) % POCET_SMERU;
         }
 
     }
 }
 
 // int main(int argc, char *argv[]) {
 int main() {
     int argc = 5;
 
-            int startRows = atoi(argv2);
+    char *argv2 = "3";
-            int startCols = atoi(argv3);
+    char *argv3 = "7";
     char *argv1 = "--lpath";
-            if ((strcmp(argv1, "--rpath") == 0))// && (startRows > 0 && startRows <= map.rows) && (startCols > 0 && startCols <= map.cols))
+
     char *argv4 = "bludiste.txt";
 
     Map map;
     if (argc == 2 && (strcmp(argv1, "--help") == 0)) {
         printf("Napoveda!\nZadejte vstup, cislo radku a cislo sloupci!\nSpecialni komandy:\n");
         printf("-- help - vypisuje napovedu\n");
         printf("--test nazev_souboru.txt - zkontroluje, ze soubor dany druhym argumentem programu obsahuje radnou definici mapy bludiste\n");
-            else if ((strcmp(argv1, "--lpath") == 0) && (startRows > 0 && startRows <= map.rows) && (startCols > 0 && startCols <= map.cols))
+
         printf("--lpath R C nazev_souboru.txt - hleda pruchod bludistem, zadanym z souboru txt, na vstupu na rádku R a sloupci C. Pruchod hleda pomoci pravidla leve ruky (leva ruka vzdy na zdi)\n");
         printf("--shortest R C nazev_souboru.txt - hleda nejkratsi cestu z bludiste, zadanym z souboru txt, pri vstupu na radku R a sloupci C\n");
 
         return 0;
     }
 
     else if (argc == 3 && strcmp(argv1, "--test") == 0 && fileTxt(argv2)) {
         if (readAndTestMap(&map, argv2)) {
             printf("Valid\n");
         } else {
             printf("Invalid\n");
 
             return 0;
         }
     }
 
     //  основной цикл
     else if (argc == 5 && fileTxt(argv4))
     {
         readAndTestMap(&map, argv4);
         int leftright;
         //  правило правой руки
         if (isCharNum(argv2) && isCharNum(argv3))
         {
             int startRows = atoi(argv2) - 1;
             int startCols = atoi(argv3) - 1;
 
             if ((strcmp(argv1, "--rpath") == 0) && (startRows >= 0 && startRows < map.rows) && (startCols >= 0 && startCols < map.cols))
             {
                 leftright = 0;  //  правая рука
                 int smer = start_border(&map, startRows, startCols, leftright);
                 walkInLabirinthRight(&map, startRows, startCols, leftright, smer);
                 return 0;
             }
             //  правило левой руки
             else if ((strcmp(argv1, "--lpath") == 0) && (startRows >= 0 && startRows < map.rows) && (startCols >= 0 && startCols < map.cols))
             {
                 leftright = 1;  //  левая рука
                 int smer = start_border(&map, startRows, startCols, leftright);
                 walkInLabirinthLeft(&map, startRows, startCols, leftright, smer);
                 return 0;
             }
             /*  самый короткий путь
             else if((strcmp(argv1, "--shortest") == 0) && (startRows > 0 && startRows <= map.rows) && (startCols > 0 && startCols <= map.cols))
             {
                 //leftright =1;
                 return 0;
             }*/
             else
             {
             fprintf(stderr, "Error: chybna komanda\nPro napovedu napiste --help\n");
             return -1;
             }
         }
         else
         {
             fprintf(stderr, "Error: chybna komanda\nPro napovedu napiste --help\n");
             return -1;
         }
     }
     else
     {
         fprintf(stderr, "Error: chybna komanda\nPro napovedu napiste --help\n");
         return -1;
     }
 
     free(map.cells);
     return 0;
 }