Опыт работы с нейронными сетями и простой код на Ассемблере.

Ahimov, а какая у вас конфигурация компьютера ? Сколько обычной памяти в компьютере ( 128 GB или сколько?) и сколько видеопамяти содержит видеокарта (24 GB или сколько?) ? И какой у вас тариф ? Платный или бесплатный ?

 

Так, я все время ругал нейронные сети, но надо и похвалить.
Вот этот мой код нейронная сеть (alice.yandex) удачно конвертировала из PHP в C89.
Поиск всех путей на однонаправленном графе.
Исходник:

Код (Text):

1. <?php
2. /*Поиск всех путей на ориентированном графе из точки а в точку f
3. на основе упорядочивания массивов и элементов массива по возрастанию
4. Легко доработать до поиска кратчайшего пути.*/
5.  
6. function search_new_val_for_push_int_x($x, $j, $arr) {
7.     foreach($arr as $key => $val) {
8.         if($x[count($x) - 1] == $key)
9.             return $arr[$key];
10.     }
11. }
12.  
13. function search_val($x, $j, $arr) {
14.     foreach($arr as $key => $val) {
15.         if($x[$j - 1] == $key)
16.             return $arr[$key];
17.     }
18. }
19.  
20. // Упорядоченный граф
21. $a = array('b', 'c', 'd');
22. $b = array('d', 'e', 'f');
23. $c = array('d', 'e', 'f');
24. $d = array('e', 'f');
25. $e = array('f');
26. $f = array();
27.  
28. // Первый путь
29. $x = array('a', 'b', 'd', 'e', 'f');
30.  
31. // Массив соответствий
32. $arr = array('a' => $a, 'b' => $b, 'c' => $c, 'd' => $d, 'e' => $e, 'f' => $f);
33.  
34. // Печатаем первый маршрут
35. print_r($x);
36. print "\n";
37.  
38. $j = count($x) - 1;
39.  
40. while($j != 0) {
41.     // Ищем новое значение. Значение будет использовано в качестве имени массива.
42.     $ar = search_val($x, $j, $arr);
43.     $key = array_search($x[$j], $ar);
44.     //if (${$x[$j-1]}[$key+1] != '') {
45.  
46.     if (isset($ar[$key + 1])) {
47.         $x = array_slice($x, 0, $j);
48.         array_push($x, $ar[$key + 1]);
49.         //$z=$x[count($x)-1];
50.         //найдем все 0-ые индексы
51.         $z = search_new_val_for_push_int_x($x, $j, $arr)[0];
52.  
53.         while (1) {
54.             if ($x[count($x) - 1] == 'f') {
55.                 array_push($x, $z);
56.                 break;
57.             }
58.             array_push($x, $z);
59.             $z = search_new_val_for_push_int_x($x, $j, $arr)[0];
60.         }
61.         $j = count($x);
62.         print_r($x);
63.     }
64.     $j--;
65. }
66. ?>
67.  
68.  

Код конвертированный сетью:

Код (C):

1. #include <stdio.h>
2. #include <string.h>
3.  
4. /* Максимальное количество вершин в пути.
5.    Граф небольшой, 20 достаточно с запасом. */
6. #define MAX_PATH 26
7.  
8. /* Функция возвращает указатель на массив соседей для данной вершины.
9.    Вершины: 'a'..'f'. Возвращает NULL для неверной вершины. */
10. static const char *get_neighbors(char v) {
11.     switch (v) {
12.    case 'a': return "bcdz";
13.         case 'b': return "defz";
14.         case 'c': return "defz";
15.         case 'd': return "efz";
16.         case 'e': return "fz";
17.         case 'f': return "ghjz";
18.         case 'g': return "hijz";
19.         case 'h': return "ijkz";
20.         case 'i': return "jklz";
21.         case 'j': return "kmz";
22.         case 'k': return "lnoz";
23.         case 'l': return "mz";
24.         case 'm': return "noz";
25.         case 'n': return "oz";
26.         case 'o': return "pz";
27.         case 'p': return "qz";
28.         case 'q': return "rz";
29.         case 'r': return "sz";
30.         case 's': return "tuz";
31.         case 't': return "uvz";
32.         case 'u': return "vwz";
33.         case 'v': return "wz";
34.         case 'w': return "xyz";
35.         case 'x': return "yz";
36.         case 'y': return "z";
37.         case 'z': return "";
38.         default:  return NULL;
39.     }
40. }
41.  
42. /* Вспомогательная функция: найти индекс символа в строке.
43.    Возвращает -1, если не найден. */
44. static int str_index_of(const char *s, char c) {
45.     int i = 0;
46.     while (s[i] != '\0') {
47.         if (s[i] == c) return i;
48.         i++;
49.     }
50.     return -1;
51. }
52.  
53. int main(void) {
54.     int p =0;
55.     /* Первый путь (из PHP-скрипта) */
56.     char path[MAX_PATH];
57.     int path_len = 0;
58.  
59.     /* Инициализация первого пути: a -> b -> d -> e -> f */
60.     path[path_len++] = 'a';
61.     path[path_len++] = 'b';
62.     path[path_len++] = 'd';
63.     path[path_len++] = 'e';
64.     path[path_len++] = 'f';
65.     path[path_len++] = 'g';
66.     path[path_len++] = 'h';
67.     path[path_len++] = 'i';
68.     path[path_len++] = 'j';
69.     path[path_len++] = 'k';
70.     path[path_len++] = 'l';
71.     path[path_len++] = 'm';
72.     path[path_len++] = 'n';
73.     path[path_len++] = 'o';
74.     path[path_len++] = 'p';
75.     path[path_len++] = 'q';
76.     path[path_len++] = 'r';
77.     path[path_len++] = 's';
78.     path[path_len++] = 't';
79.     path[path_len++] = 'u';
80.     path[path_len++] = 'v';
81.     path[path_len++] = 'w';
82.     path[path_len++] = 'x';
83.     path[path_len++] = 'y';
84.     path[path_len++] = 'z';
85.  
86.     /* Вывод первого маршрута */
87.     {
88.         int i;
89.         for (i = 0; i < path_len; i++) {
90.             if (i > 0) printf(", ");
91.             printf("%c", path[i]);
92.         }
93.         printf("\n");
94.     }
95. p++;
96.     int j = path_len - 1;
97.  
98.     while (j > 0) {
99.  
100.         char current_v = path[j - 1];
101.         const char *neighbors = get_neighbors(current_v);
102.  
103.         /* В PHP: $ar = search_val($x, $j, $arr); */
104.         /* Здесь neighbors — это аналог $ar */
105.  
106.         int key = str_index_of(neighbors, path[j]);
107.  
108.         /* if (isset($ar[$key + 1])) */
109.         if ((key != -1) && (neighbors[key + 1] != '\0')) {
110.             /* $x = array_slice($x, 0, $j); */
111.             path_len = j;
112.  
113.             /* array_push($x, $ar[$key + 1]); */
114.             path[path_len++] = neighbors[key + 1];
115.  
116.             /* Достраиваем путь до 'f', всегда беря первого (нулевого) соседа */
117.             while (1) {
118.  
119.                 char last_v = path[path_len - 1];
120.                 if (last_v == 'z') {
121.                     break;
122.                 }
123.                 const char *next_neighbors = get_neighbors(last_v);
124.                 /* В PHP: search_new_val_for_push_int_x(...)[0] */
125.                 if (next_neighbors[0] != '\0') {
126.                     path[path_len++] = next_neighbors[0];
127.                 } else {
128.                     /* Если нет соседей, а мы не в 'f', дальше идти некуда.
129.                        В логике PHP это не обрабатывается явно, но предотвратим зацикливание. */
130.                     break;
131.                 }
132.             }
133.  
134.             j = path_len;
135.  
136.             /* print_r($x); */
137.             {
138.                 int i;
139.  
140.                 for (i = 0; i < path_len; i++) {
141.                     if (i > 0) printf(", ");
142.                     printf("%c", path[i]);
143.                 }
144.  
145.                 printf("\n");
146.                 p++;
147.  
148.  
149.             }
150.         }
151.  
152.         j--;
153.     }
154. printf("Количество путей: %d",p);
155.     return 0;
156. }
157.  

 

Подумал, неужели не смогу переписать код php на С89 (лень уже, конечно, было).
Порылася по справочниками и все-таки переписал руками.
Нейронная сеть мне будто вызов бросила. Мне кажется, handcraft code все-таки легче:

Код (C):

1.  
2. /*Поиск всех путей на однонаправленном графе. Переписан из кода PHP на язык C стандарта 89*/
3. #include <stdio.h>
4. #include <string.h>
5. /*Объявим граф глобально*/
6. char a[] = "bcdz";
7. char b[] = "defz";
8. char c[] = "defz";
9. char d[] = "efz";
10. char e[] = "fz";
11. char f[] = "ghjz";
12. char g[] = "hijz";
13. char h[] = "ijkz";
14. char i[] = "jklz";
15. char j[] = "kmz";
16. char k[] = "lnoz";
17. char l[] = "mz";
18. char m[] = "noz";
19. char n[] = "oz";
20. char o[] = "pz";
21. char p[] = "qz";
22. char q[] = "rz";
23. char r[] = "sz";
24. char s[] = "tuz";
25. char t[] = "uvz";
26. char u[] = "vwz";
27. char v[] = "wz";
28. char w[] = "xyz";
29. char x[] = "yz";
30. char y[] = "z";
31. char z[] = "";
32. /*Вернёт элемент, который потом допишем в массив x*/
33. char element_search_to_push ( char *first_way) {
34.  
35. char elem_to_push;
36.   if (first_way[strlen(first_way)-1] =='a')
37.    elem_to_push = a[0];
38.      if (first_way[strlen(first_way)-1] =='b')
39.    elem_to_push = b[0];
40.      if (first_way[strlen(first_way)-1] =='c')
41.    elem_to_push = c[0];
42.     if (first_way[strlen(first_way)-1] =='d')
43.    elem_to_push = d[0];
44.      if (first_way[strlen(first_way)-1] =='e')
45.    elem_to_push = e[0];
46.      if (first_way[strlen(first_way)-1] =='f')
47.    elem_to_push = f[0];
48.    if (first_way[strlen(first_way)-1] =='g')
49.   elem_to_push = g[0];
50. if (first_way[strlen(first_way)-1] =='h')
51.   elem_to_push = h[0];
52. if (first_way[strlen(first_way)-1] =='i')
53.   elem_to_push = i[0];
54. if (first_way[strlen(first_way)-1] =='j')
55.   elem_to_push = j[0];
56. if (first_way[strlen(first_way)-1] =='k')
57.   elem_to_push = k[0];
58. if (first_way[strlen(first_way)-1] =='l')
59.   elem_to_push = l[0];
60. if (first_way[strlen(first_way)-1] =='m')
61.   elem_to_push = m[0];
62. if (first_way[strlen(first_way)-1] =='n')
63.   elem_to_push = n[0];
64. if (first_way[strlen(first_way)-1] =='o')
65.   elem_to_push = o[0];
66. if (first_way[strlen(first_way)-1] =='p')
67.   elem_to_push = p[0];
68. if (first_way[strlen(first_way)-1] =='q')
69.   elem_to_push = q[0];
70. if (first_way[strlen(first_way)-1] =='r')
71.   elem_to_push = r[0];
72. if (first_way[strlen(first_way)-1] =='s')
73.   elem_to_push = s[0];
74. if (first_way[strlen(first_way)-1] =='t')
75.   elem_to_push = t[0];
76. if (first_way[strlen(first_way)-1] =='u')
77.   elem_to_push = u[0];
78. if (first_way[strlen(first_way)-1] =='v')
79.   elem_to_push = v[0];
80. if (first_way[strlen(first_way)-1] =='w')
81.   elem_to_push = w[0];
82. if (first_way[strlen(first_way)-1] =='x')
83.   elem_to_push = x[0];
84. if (first_way[strlen(first_way)-1] =='y')
85.   elem_to_push = y[0];
86. if (first_way[strlen(first_way)-1] =='z')
87.   elem_to_push = z[0];
88.  
89.    return elem_to_push;
90. }
91. /*Возвращает указатель на первый путь x*/
92. char *element_search ( char *first_way,  int j2 ) {
93.  
94. char *ar;
95.  if (first_way[j2-1] =='a')
96.    ar = a;
97.    if (first_way[j2-1] =='b')
98.    ar = b;
99.    if (first_way[j2-1] =='c')
100.    ar = c;
101.    if (first_way[j2-1] =='d')
102.    ar = d;
103.    if (first_way[j2-1] =='e')
104.    ar = e;
105.    if (first_way[j2-1] =='f')
106.    ar = f;
107.    if (first_way[j2-1] =='g')
108.   ar = g;
109. if (first_way[j2-1] =='h')
110.   ar = h;
111. if (first_way[j2-1] =='i')
112.   ar = i;
113. if (first_way[j2-1] =='j')
114.   ar = j;
115. if (first_way[j2-1] =='k')
116.   ar = k;
117. if (first_way[j2-1] =='l')
118.   ar = l;
119. if (first_way[j2-1] =='m')
120.   ar = m;
121. if (first_way[j2-1] =='n')
122.   ar = n;
123. if (first_way[j2-1] =='o')
124.   ar = o;
125. if (first_way[j2-1] =='p')
126.   ar = p;
127. if (first_way[j2-1] =='q')
128.   ar = q;
129. if (first_way[j2-1] =='r')
130.   ar = r;
131. if (first_way[j2-1] =='s')
132.   ar = s;
133. if (first_way[j2-1] =='t')
134.   ar = t;
135. if (first_way[j2-1] =='u')
136.   ar = u;
137. if (first_way[j2-1] =='v')
138.   ar = v;
139. if (first_way[j2-1] =='w')
140.   ar = w;
141. if (first_way[j2-1] =='x')
142.   ar = x;
143. if (first_way[j2-1] =='y')
144.   ar = y;
145. if (first_way[j2-1] =='z')
146.   ar = z;
147.    return ar;
148. }
149.  
150. static int array_search (const char *ar, char el) {
151.   int i = 0;
152.   while (ar[i] != '\0') {
153.   if (ar[i] == el) return i;
154.   i++;
155.   }
156.   return -1;
157. }
158.  
159. int main(void) {
160. int key;
161. /*Первый путь*/
162. char first_way[26] = "abdefghijklmnopqrstuvwxyz";
163. char elem_to_push;
164.  
165. int  j2 = strlen(first_way)-1;
166. int last_point = 'z';
167. int i2 = 0;
168. char *ar;
169. int first_way_len = 0;
170.  
171. /*Печать 1-го*/
172. for (i2=0; first_way[i2] != '\0'; i2++)
173. printf("%c", first_way[i2]);
174. printf("\n\r");
175. int all_ways_count = 1;
176.  
177.  
178. while ( j2 != 0 )
179.  {
180.   /*Поиск элемента*/
181.    ar=element_search (first_way,  j2 );
182.    /*Поиск ключа*/
183.   key =  array_search(ar, first_way[ j2]);
184.   if ((key != -1) && (ar[key + 1] != '\0')) {
185.        /*Ставим длину массива равной j2*/
186.       first_way_len = j2;
187.       /*Заменим substr*/
188.       first_way[j2+1]='\0';
189.       /*Пишем в массив x*/
190.       first_way[first_way_len++]= ar[key+1];
191.        elem_to_push=element_search_to_push(first_way);
192. while(1) {
193.      /*Если дошли до f выходим*/
194.      if ((first_way[strlen(first_way)-1] == last_point)) {
195.        /*Пишем в first_way*/
196.         first_way[first_way_len++] = elem_to_push;
197.         break;
198.       }
199.        /*Пишем в first_way*/
200.        first_way[first_way_len++] = elem_to_push;
201.      elem_to_push=element_search_to_push(first_way);
202.          }
203.          /*Переменную ставим равной массиву*/
204.           j2=strlen(first_way);
205.          /*Выводим*/
206.          printf("%s", first_way);
207.          printf("\n\r");
208.          all_ways_count++;
209.        }
210.  j2--;
211.      }
212.      printf("%d", all_ways_count);
213.  }
214.  
215.  
216.  
217.  
218.  

 

Похвалил ИИ, но придется снова отругать:
Ни Алиса ни deepai.org не могут посчитать количество элементов правильно.
Ни с какой попытки:

Код (Text):

1. "ab", "ac", "ad", "az",
2.     "bd", "be", "bf", "bz",
3.     "cd", "ce", "cf", "cz",
4.     "de", "df", "dz",
5.     "ef", "ez",
6.     "fg", "fh", "fj", "fz",
7.     "gh", "gi", "gj", "gz",
8.     "hi", "hj", "hk", "hz",
9.     "ij", "ik", "il", "iz",
10.     "jk", "jm", "jz",
11.     "kl", "kn", "ko", "kz",
12.     "lm", "lz",
13.     "mn", "mo", "mz",
14.     "no", "nz",
15.     "op", "oz",
16.     "pq", "pz",
17.     "qr", "qz",
18.     "rs", "rz",
19.     "st", "su", "sz",
20.     "tu", "tv", "tz",
21.     "uv", "uw", "uz",
22.     "vw", "vz",
23.     "wx", "wy", "wz",
24.     "xy", "xz",
25.     "yz"

 

Ещё подпилил рукотворный код и сам алгоритм. Убрал критические замечания:

Код (C):

1. #include <stdio.h>
2. #include <string.h>
3. //Количество всех вершин
4. #define ALL_POINTS 26
5. // Объявим граф глобально
6. char a[] = "bcdz";
7. char b[] = "defz";
8. char c[] = "defz";
9. char d[] = "efz";
10. char e[] = "fz";
11. char f[] = "ghjz";
12. char g[] = "hijz";
13. char h[] = "ijkz";
14. char i[] = "jklz";
15. char j[] = "kmz";
16. char k[] = "lnoz";
17. char l[] = "mz";
18. char m[] = "noz";
19. char n[] = "oz";
20. char o[] = "pz";
21. char p[] = "qz";
22. char q[] = "rz";
23. char r[] = "sz";
24. char s[] = "tuz";
25. char t[] = "uvz";
26. char u[] = "vwz";
27. char v[] = "wz";
28. char w[] = "xyz";
29. char x[] = "yz";
30. char y[] = "z";
31. char z[] = "";
32. /* Массивы соответствий */
33. char *array_corresp[] = {a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,y,z};
34. char array_corresp2[] = "abcdefghijklmnopqrstuvwxyz";
35.  
36. //Рёбра
37. char *ribs[] = {
38. "ab", "ac", "ad", "az",
39.     "bd", "be", "bf", "bz",
40.     "cd", "ce", "cf", "cz",
41.     "de", "df", "dz",
42.     "ef", "ez",
43.     "fg", "fh", "fj", "fz",
44.     "gh", "gi", "gj", "gz",
45.     "hi", "hj", "hk", "hz",
46.     "ij", "ik", "il", "iz",
47.     "jk", "jm", "jz",
48.     "kl", "kn", "ko", "kz",
49.     "lm", "lz",
50.     "mn", "mo", "mz",
51.     "no", "nz",
52.     "op", "oz",
53.     "pq", "pz",
54.     "qr", "qz",
55.     "rs", "rz",
56.     "st", "su", "sz",
57.     "tu", "tv", "tz",
58.     "uv", "uw", "uz",
59.     "vw", "vz",
60.     "wx", "wy", "wz",
61.     "xy", "xz",
62.     "yz"
63. };
64. //Длины рёбeр
65. int ribs_count[] = { 12, 13, 14, 24, 25, 26, 34, 35, 36, 45, 46, 56,
66.     7,  8,  9, 10, 11, 15, 16, 17, 18, 19, 20, 21, 22,
67.     23, 27, 28, 29, 30, 31, 32, 33, 37, 38, 39, 40, 41,
68.     42, 43, 44, 47, 48, 49, 50, 51, 52, 53, 54, 55, 57,
69.     58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
70.     71, 72, 73, 74, 75, 17, 99, 67};
71. //Длина массива с длинами рёбер
72. int ribs_all_count = sizeof(ribs_count) / sizeof(ribs_count[0]);
73.  
74. /////////////////Функции//////////////////////////////////////////////////////
75. // Вернёт элемент, который потом допишем в массив x
76. char element_search_to_push(char *x) {
77.     char z;
78.     int i;
79.     int j = strlen(x) - 1;
80.     for (i = 0; i <  ALL_POINTS; i++) {
81.         if (x[j] == array_corresp2[i]) {
82.             z = array_corresp[i][0];
83.         }
84.     }
85.     return z;
86. }
87.  
88. // Возвращает указатель на первый путь x
89. char *element_search(char *x, int j) {
90.     char *arr;
91.     int i;
92.     for (i = 0; i <  ALL_POINTS; i++) {
93.         if (x[j - 1] == array_corresp2[i]) {
94.             arr = array_corresp[i];
95.         }
96.     }
97.     return arr;
98. }
99.  
100. static int array_search(const char *ar, char el) {
101.     int i = 0;
102.     while (ar[i] != '\0') {
103.         if (ar[i] == el) return i;
104.         i++;
105.     }
106.     return -1;
107. }
108.  
109. //Найдем длину каждого пути
110. int count_way_lenght(int rib_length , char *x) {
111.     int j =strlen(x) - 1;
112. rib_length  = 0;
113.     int i, y;
114.           for (y = 0; y < j; y++) {
115.                 for (i = 0; i < ribs_all_count; i++) {
116.                     if (x[y] == ribs[i][0] && x[y + 1] == ribs[i][1]) {
117.                         rib_length += ribs_count[i];
118.                     }
119.                 }
120.             }
121.     return rib_length;
122. }
123.  
124. /////////////////////////////////////////////////////////////////////////////////////////
125.  
126. int main() {
127.  
128.     char short_way_point[100];
129.     int y = 0;
130.     int rib_length = 0;
131.     int short_way = 1000;
132.     int key;
133.     //Первый путь задан
134.     char x[100] = "abdefghijklmnopqrstuvwxyz";
135.     char z;
136.     // Длина j
137.     int j = strlen(x) - 1;
138.     char last_point = 'z';
139.     int i = 0;
140.     char *ar;
141.     int x_len = 0;
142.     //Все пути. 1 потому что выводим 1-ый вне циклов
143.     int all = 1;
144.     // Печать 1-го
145. //////////////////////////////////////////////////
146.     for (i = 0; x[i] != '\0'; i++)
147.         printf("%c", x[i]);
148.  
149.     // Найдем длину первого пути
150.     rib_length = 0;
151.     for (y = 0; y < j; y++) {
152.         for (i = 0; i < ribs_all_count; i++) {
153.             if (x[y] == ribs[i][0] && x[y + 1] == ribs[i][1]) {
154.                 rib_length += ribs_count[i];
155.             }
156.         }
157.     }
158.     printf(" %d ", rib_length);
159.     printf("\n\r");
160. ///////////////////////////////////////////////////
161.  
162.     // Основной цикл поиска путей
163.     while (j != 0) {
164.         // Определяем и ищем элемент и его ключ
165.         ar = element_search(x, j);
166.         key = array_search(ar, x[j]);
167.  
168.         if ((key != -1) && (ar[key + 1] != '\0')) {
169.             // Задаем длину массива равной j
170.             x_len = j;
171.             // Заменяем substr
172.             x[j + 1] = '\0';
173.             // Пишем в массив x
174.             x[x_len++] = ar[key + 1];
175.  
176.             // Найдем z для записи
177.             z = element_search_to_push(x);
178.             while (1) {
179.                 // Если дошли до 'f', выходим
180.                 if (x[strlen(x) - 1] == last_point ) {
181.                     x[x_len++] = z;
182.                     break;
183.                 }
184.                 // Пишем в x
185.                 x[x_len++] = z;
186.                 // Ещё найдем z для записи
187.                 z = element_search_to_push(x);
188.             }
189.             // Обновляем j
190.             j = strlen(x);
191.             // Выводим текущий путь
192.             printf("%s", x);
193.              all++;
194.             // Пересчитываем длину пути
195.  
196.             rib_length=count_way_lenght(rib_length,  x);
197.             // Печать длины пути
198.             printf(" %d ", rib_length);
199.             printf("\n\r");
200.  
201.             // Обновляем кратчайший путь
202.             if (rib_length < short_way) {
203.                 //Сохраним кратчайший путь
204.                 strcpy(short_way_point, x);
205.                 short_way = rib_length;
206.             }
207.         }
208.         j--;
209.     }
210.  
211.     printf("Самый короткий путь: %d \n\r", short_way);
212.     printf("Лежит через эти точки: %s \n\r", short_way_point);
213.     printf("Все пути: %d \n\r", all);
214.  
215.     return 0;
216. }
217.  

 

Код (C):

1. #include <stdio.h>
2. #include <string.h>
3.  
4. // Количество всех вершин
5. #define ALL_POINTS 26
6.  
7. // Объявим граф глобально
8. char a[] = "bcdz";
9. char b[] = "defz";
10. char c[] = "defz";
11. char d[] = "efz";
12. char e[] = "fz";
13. char f[] = "ghjz";
14. char g[] = "hijz";
15. char h[] = "ijkz";
16. char i[] = "jklz";
17. char j[] = "kmz";
18. char k[] = "lnoz";
19. char l[] = "mz";
20. char m[] = "noz";
21. char n[] = "oz";
22. char o[] = "pz";
23. char p[] = "qz";
24. char q[] = "rz";
25. char r[] = "sz";
26. char s[] = "tuz";
27. char t[] = "uvz";
28. char u[] = "vwz";
29. char v[] = "wz";
30. char w[] = "xyz";
31. char x[] = "yz";
32. char y[] = "z";
33. char z[] = "";
34.  
35. /* Массивы соответствий */
36. char *array_corresp[] = {
37.     a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z
38. };
39. char array_corresp2[] = "abcdefghijklmnopqrstuvwxyz";
40.  
41. /* Рёбра */
42. char *ribs[] = {
43.     "ab", "ac", "ad", "az",
44.     "bd", "be", "bf", "bz",
45.     "cd", "ce", "cf", "cz",
46.     "de", "df", "dz",
47.     "ef", "ez",
48.     "fg", "fh", "fj", "fz",
49.     "gh", "gi", "gj", "gz",
50.     "hi", "hj", "hk", "hz",
51.     "ij", "ik", "il", "iz",
52.     "jk", "jm", "jz",
53.     "kl", "kn", "ko", "kz",
54.     "lm", "lz",
55.     "mn", "mo", "mz",
56.     "no", "nz",
57.     "op", "oz",
58.     "pq", "pz",
59.     "qr", "qz",
60.     "rs", "rz",
61.     "st", "su", "sz",
62.     "tu", "tv", "tz",
63.     "uv", "uw", "uz",
64.     "vw", "vz",
65.     "wx", "wy", "wz",
66.     "xy", "xz",
67.     "yz"
68. };
69.  
70. /* Длины рёбер */
71. int ribs_count[] = {
72.     12, 13, 14, 24, 25, 26, 34, 35, 36, 45, 46, 56,
73.     7, 8, 9, 10, 11, 15, 16, 17, 18, 19, 20, 21, 22,
74.     23, 27, 28, 29, 30, 31, 32, 33, 37, 38, 39, 40, 41,
75.     42, 43, 44, 47, 48, 49, 50, 51, 52, 53, 54, 55, 57,
76.     58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
77.     71, 72, 73, 74, 75, 17, 99, 67
78. };
79.  
80. // Длина массива с длинами рёбер
81. int ribs_all_count = sizeof(ribs_count) / sizeof(ribs_count[0]);
82.  
83. /////////////////Функции//////////////////////////////////////////////////////
84.  
85. int print_way(char *first_x_way, int rib_length) {
86.     // Выводим текущий путь
87.     printf("%s", first_x_way);
88.     // Печать длины пути
89.     printf(" %d ", rib_length);
90.     printf("\n");
91.     return 0;
92. }
93.  
94. // Вернёт элемент, который потом допишем в массив first_x_way
95. char search_element_to_push(char *first_x_way) {
96.     char z;
97.     int i;
98.     int j = strlen(first_x_way) - 1;
99.     for (i = 0; i < ALL_POINTS; i++) {
100.         if (first_x_way[j] == array_corresp2[i]) {
101.             z = array_corresp[i][0];
102.         }
103.     }
104.     return z;
105. }
106.  
107. // Возвращает указатель на первый путь first_x_way
108. char *element_search(char *first_x_way, int j) {
109.     char *arr;
110.     int i;
111.     for (i = 0; i < ALL_POINTS; i++) {
112.         if (first_x_way[j - 1] == array_corresp2[i]) {
113.             arr = array_corresp[i];
114.         }
115.     }
116.     return arr;
117. }
118.  
119. // Поиск ключа элемента
120. static int array_search(const char *ar_for_element_search, char el) {
121.     int i = 0;
122.     while (ar_for_element_search[i] != '\0') {
123.         if (ar_for_element_search[i] == el) return i;
124.         i++;
125.     }
126.     return -1;
127. }
128.  
129. // Найдем длину каждого пути
130. int count_way_length(int rib_length, char *first_x_way) {
131.     int j = strlen(first_x_way) - 1;
132.     rib_length = 0;
133.     int i, y;
134.     for (y = 0; y < j; y++) {
135.         for (i = 0; i < ribs_all_count; i++) {
136.             if (first_x_way[y] == ribs[i][0] && first_x_way[y + 1] == ribs[i][1]) {
137.                 rib_length += ribs_count[i];
138.             }
139.         }
140.     }
141.     return rib_length;
142. }
143.  
144. /////////////////////////////////////////////////////////////////////////////////////////
145.  
146. int main() {
147.     char first_x_way[100] = "abdefghijklmnopqrstuvwxyz";
148.     char element_to_push;
149.     char short_way_point[100];
150.     char last_point = 'z';
151.     char *ar_for_element_search;
152.     int i, y, key;
153.     int rib_length = 0;
154.     int all = 1;
155.     // Вспомогательная переменная для определения самого короткого пути
156.     int short_way = 5000;
157.     // Первый путь задан
158.     // Длина j
159.     int j = strlen(first_x_way) - 1;
160.     int first_x_way_len = 0;
161.  
162.     // Все пути. 1 потому что выводим 1-ый вне циклов
163.     // Печать первого пути
164.     for (i = 0; first_x_way[i] != '\0'; i++)
165.         printf("%c", first_x_way[i]);
166.  
167.     // Найдем длину первого пути
168.     rib_length = 0;
169.     for (y = 0; y < j; y++) {
170.         for (i = 0; i < ribs_all_count; i++) {
171.             if (first_x_way[y] == ribs[i][0] && first_x_way[y + 1] == ribs[i][1]) {
172.                 rib_length += ribs_count[i];
173.             }
174.         }
175.     }
176.     printf(" %d ", rib_length);
177.     printf("\n");
178.  
179.     // Основной цикл поиска путей
180.     while (j > 0) {
181.         /* Определяем и ищем элемент и его ключ */
182.         ar_for_element_search = element_search(first_x_way, j);
183.         key = array_search(ar_for_element_search, first_x_way[j]);
184.  
185.         if ((key != -1) && (ar_for_element_search[key + 1] != '\0')) {
186.             /* Задаем длину массива равной j */
187.             first_x_way_len = j;
188.             /* Режем первый путь */
189.             first_x_way[j + 1] = '\0';
190.             /* Пишем в массив first_x_way */
191.             first_x_way[first_x_way_len++] = ar_for_element_search[key + 1];
192.             /* Найдем element_to_push для записи */
193.             element_to_push = search_element_to_push(first_x_way);
194.  
195.             while (1) {
196.                 /* Если дошли до последнего символа, выходим */
197.                 if (first_x_way[strlen(first_x_way) - 1] == last_point) {
198.                     first_x_way[first_x_way_len++] = element_to_push;
199.                     break;
200.                 }
201.                 /* Пишем в first_x_way */
202.                 first_x_way[first_x_way_len++] = element_to_push;
203.                 /* Ещё найдем element_to_push для записи */
204.                 element_to_push = search_element_to_push(first_x_way);
205.             }
206.             /* Обновляем j */
207.             j = strlen(first_x_way);
208.             all++;
209.             /* Пересчитываем длину пути */
210.             rib_length = count_way_length(rib_length, first_x_way);
211.             /* Печать */
212.             print_way(first_x_way, rib_length);
213.             /* Обновляем кратчайший путь */
214.             if (rib_length < short_way) {
215.                 /* Сохраним кратчайший путь */
216.                 strcpy(short_way_point, first_x_way);
217.                 short_way = rib_length;
218.             }
219.         }
220.         j--;
221.     }
222.  
223.     /* Тут результаты */
224.     printf("Самый короткий путь: %d \n", short_way);
225.     printf("Лежит через эти точки: %s \n", short_way_point);
226.     printf("Все пути: %d \n", all);
227.  
228.     return 0;
229. }
230.  

 

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

Это похоже фича бям, как и неспособность видеть фантомы(иллюзии).

На этой задаче он понимает что она детермин., знает кодировку и формат isa, но мозг" у него выносит полностью
- "я запутался, задача ад, используйте z3 солвер и тп."

 

Мой рукотворный селектор тоже проанализировать не смогли. Deeapai так и написал, слишком сложный. Но правда, и на Лоре не все смогли понять.

--- Сообщение объединено, 30 июн 2026 в 21:30 ---

Это ещё интерактиваности нет.
А вот если добавитью

Код (C):

1. #include <stdio.h>
2. #include <string.h>
3.  
4. // Количество всех вершин
5. #define ALL_POINTS 26
6.  
7. // Объявим граф глобально
8. char a[] = "bcdz";
9. char b[] = "defz";
10. char c[] = "defz";
11. char d[] = "efz";
12. char e[] = "fz";
13. char f[] = "ghjz";
14. char g[] = "hijz";
15. char h[] = "ijkz";
16. char i[] = "jklz";
17. char j[] = "kmz";
18. char k[] = "lnoz";
19. char l[] = "mz";
20. char m[] = "noz";
21. char n[] = "oz";
22. char o[] = "pz";
23. char p[] = "qz";
24. char q[] = "rz";
25. char r[] = "sz";
26. char s[] = "tuz";
27. char t[] = "uvz";
28. char u[] = "vwz";
29. char v[] = "wz";
30. char w[] = "xyz";
31. char x[] = "yz";
32. char y[] = "z";
33. char z[] = "";
34.  
35. /* Массивы соответствий */
36. char *array_corresp[] = {
37.     a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z
38. };
39. char array_corresp2[] = "abcdefghijklmnopqrstuvwxyz";
40.  
41. /* Рёбра */
42. char *ribs[] = {
43.     "ab", "ac", "ad", "az",
44.     "bd", "be", "bf", "bz",
45.     "cd", "ce", "cf", "cz",
46.     "de", "df", "dz",
47.     "ef", "ez",
48.     "fg", "fh", "fj", "fz",
49.     "gh", "gi", "gj", "gz",
50.     "hi", "hj", "hk", "hz",
51.     "ij", "ik", "il", "iz",
52.     "jk", "jm", "jz",
53.     "kl", "kn", "ko", "kz",
54.     "lm", "lz",
55.     "mn", "mo", "mz",
56.     "no", "nz",
57.     "op", "oz",
58.     "pq", "pz",
59.     "qr", "qz",
60.     "rs", "rz",
61.     "st", "su", "sz",
62.     "tu", "tv", "tz",
63.     "uv", "uw", "uz",
64.     "vw", "vz",
65.     "wx", "wy", "wz",
66.     "xy", "xz",
67.     "yz"
68. };
69.  
70. /* Длины рёбер */
71. int ribs_count[] = {
72.     12, 13, 14, 24, 25, 26, 34, 35, 36, 45, 46, 56,
73.     7, 8, 9, 10, 11, 15, 16, 17, 18, 19, 20, 21, 22,
74.     23, 27, 28, 29, 30, 31, 32, 33, 37, 38, 39, 40, 41,
75.     42, 43, 44, 47, 48, 49, 50, 51, 52, 53, 54, 55, 57,
76.     58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
77.     71, 72, 73, 74, 75, 17, 99, 67
78. };
79.  
80. // Длина массива с длинами рёбер
81. int ribs_all_count = sizeof(ribs_count) / sizeof(ribs_count[0]);
82.  
83. /////////////////Функции//////////////////////////////////////////////////////
84.  
85. int print_way(char *first_x_way, int rib_length) {
86.     // Выводим текущий путь
87.     printf("%s", first_x_way);
88.     // Печать длины пути
89.     printf(" %d ", rib_length);
90.     printf("\n");
91.     return 0;
92. }
93.  
94. // Вернёт элемент, который потом допишем в массив first_x_way
95. char search_element_to_push(char *first_x_way) {
96.     char z;
97.     int i;
98.     int j = strlen(first_x_way) - 1;
99.     for (i = 0; i < ALL_POINTS; i++) {
100.         if (first_x_way[j] == array_corresp2[i]) {
101.             z = array_corresp[i][0];
102.         }
103.     }
104.     return z;
105. }
106.  
107. // Возвращает указатель на первый путь first_x_way
108. char *element_search(char *first_x_way, int j) {
109.     char *arr;
110.     int i;
111.     for (i = 0; i < ALL_POINTS; i++) {
112.         if (first_x_way[j - 1] == array_corresp2[i]) {
113.             arr = array_corresp[i];
114.         }
115.     }
116.     return arr;
117. }
118.  
119. // Поиск ключа элемента
120. static int array_search(const char *ar_for_element_search, char el) {
121.     int i = 0;
122.     while (ar_for_element_search[i] != '\0') {
123.         if (ar_for_element_search[i] == el) return i;
124.         i++;
125.     }
126.     return -1;
127. }
128.  
129. // Найдем длину каждого пути
130. int count_way_length(int rib_length, char *first_x_way) {
131.     int j = strlen(first_x_way) - 1;
132.     rib_length = 0;
133.     int i, y;
134.     for (y = 0; y < j; y++) {
135.         for (i = 0; i < ribs_all_count; i++) {
136.             if (first_x_way[y] == ribs[i][0] && first_x_way[y + 1] == ribs[i][1]) {
137.                 rib_length += ribs_count[i];
138.             }
139.         }
140.     }
141.     return rib_length;
142. }
143.  
144. /////////////////////////////////////////////////////////////////////////////////////////
145.  
146. int main() {
147.  
148.     char first_x_way[100] = "abdefghijklmnopqrstuvwxyz";
149.     char element_to_push;
150.     char short_way_point[100];
151.     char last_point = 'z';
152.     char *ar_for_element_search;
153.     char allws_short[100][100];
154.     char enter_press_to_show_all_small_ways;
155.     int allws_short_lenght[1000];
156.     int xxx=0;
157.     int i, y, key;
158.     int rib_length = 0;
159.     int all = 1;
160.     // Вспомогательная переменная для определения самого короткого пути
161.     int short_way = 5000;
162.     // Первый путь задан
163.     // Длина j
164.     int j = strlen(first_x_way) - 1;
165.     int first_x_way_len = 0;
166.     int all_shorts_way_to_show = 0;
167.  
168.   /*Сохраним пути меньше введенного числа*/
169.    printf("Сохранить все пути меньше [введите число от 1 до 150]  или 0? ");
170.    scanf("%d", &all_shorts_way_to_show);
171.     if ( all_shorts_way_to_show  >  150)
172.     all_shorts_way_to_show = 0;
173.  
174.     // Все пути. 1 потому что выводим 1-ый вне циклов
175.     // Печать первого пути
176.     for (i = 0; first_x_way[i] != '\0'; i++)
177.         printf("%c", first_x_way[i]);
178.  
179.     // Найдем длину первого пути
180.     rib_length = 0;
181.     for (y = 0; y < j; y++) {
182.         for (i = 0; i < ribs_all_count; i++) {
183.             if (first_x_way[y] == ribs[i][0] && first_x_way[y + 1] == ribs[i][1]) {
184.                 rib_length += ribs_count[i];
185.             }
186.         }
187.     }
188.     printf(" %d ", rib_length);
189.     printf("\n");
190.  
191.     // Основной цикл поиска путей
192.     while (j > 0) {
193.         /* Определяем и ищем элемент и его ключ */
194.         ar_for_element_search = element_search(first_x_way, j);
195.         key = array_search(ar_for_element_search, first_x_way[j]);
196.  
197.         if ((key != -1) && (ar_for_element_search[key + 1] != '\0')) {
198.             /* Задаем длину массива равной j */
199.             first_x_way_len = j;
200.             /* Режем первый путь */
201.             first_x_way[j + 1] = '\0';
202.             /* Пишем в массив first_x_way */
203.             first_x_way[first_x_way_len++] = ar_for_element_search[key + 1];
204.             /* Найдем element_to_push для записи */
205.             element_to_push = search_element_to_push(first_x_way);
206.  
207.             while (1) {
208.                 /* Если дошли до последнего символа, выходим */
209.                 if (first_x_way[strlen(first_x_way) - 1] == last_point) {
210.                     first_x_way[first_x_way_len++] = element_to_push;
211.                     break;
212.                 }
213.                 /* Пишем в first_x_way */
214.                 first_x_way[first_x_way_len++] = element_to_push;
215.                 /* Ещё найдем element_to_push для записи */
216.                 element_to_push = search_element_to_push(first_x_way);
217.             }
218.             /* Обновляем j */
219.             j = strlen(first_x_way);
220.             all++;
221.             /* Пересчитываем длину пути */
222.             rib_length = count_way_length(rib_length, first_x_way);
223.             /* Печать */
224.             print_way(first_x_way, rib_length);
225.             //Найдем все пути меньше 50
226.                if (rib_length < all_shorts_way_to_show && (all_shorts_way_to_show  != 0)) {
227.                    strcpy(allws_short[xxx], first_x_way);
228.                  allws_short_lenght[xxx]=rib_length;
229.                  xxx++;
230.                 }
231.  
232.             /* Обновляем кратчайший путь */
233.             if (rib_length < short_way) {
234.                 /* Сохраним кратчайший путь */
235.                 strcpy(short_way_point, first_x_way);
236.                 short_way = rib_length;
237.  
238.             }
239.         }
240.         j--;
241.     }
242.     /* Тут результаты */
243.     printf("Самый короткий путь: %d \n", short_way);
244.     printf("Лежит через эти точки: %s \n", short_way_point);
245.     printf("Все пути: %d \n", all);
246.  
247.    printf("Показать все пути меньше  %d ? y/n" , all_shorts_way_to_show);
248.    scanf("%c", &enter_press_to_show_all_small_ways);
249.    scanf("%c", &enter_press_to_show_all_small_ways);
250.    allws_short_lenght[xxx++]='\0';
251.     if (enter_press_to_show_all_small_ways == 'y') {
252.     for (i=0; allws_short_lenght[i] !='\0'; i++)
253.     printf("Путь: < %d  %s \n", allws_short_lenght[i], allws_short[i]);
254. } else {
255.         printf("\nВыходим...!\n");
256. }
257.     return 0;
258. }
259.  

 

Так более правильно. Но почему бывает глюк сохранением длин пути, пока понять не могу:

Код (C):

1. #include <stdio.h>
2. #include <string.h>
3.  
4. // Количество всех вершин
5. #define ALL_POINTS 26
6.  
7. // Объявим граф глобально
8. char a[] = "bcdz";
9. char b[] = "defz";
10. char c[] = "defz";
11. char d[] = "efz";
12. char e[] = "fz";
13. char f[] = "ghjz";
14. char g[] = "hijz";
15. char h[] = "ijkz";
16. char i[] = "jklz";
17. char j[] = "kmz";
18. char k[] = "lnoz";
19. char l[] = "mz";
20. char m[] = "noz";
21. char n[] = "oz";
22. char o[] = "pz";
23. char p[] = "qz";
24. char q[] = "rz";
25. char r[] = "sz";
26. char s[] = "tuz";
27. char t[] = "uvz";
28. char u[] = "vwz";
29. char v[] = "wz";
30. char w[] = "xyz";
31. char x[] = "yz";
32. char y[] = "z";
33. char z[] = "";
34.  
35. /* Массивы соответствий */
36. char *array_corresp[] = {
37.     a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z
38. };
39. char array_corresp2[] = "abcdefghijklmnopqrstuvwxyz";
40.  
41. /* Рёбра */
42. char *ribs[] = {
43.     "ab", "ac", "ad", "az",
44.     "bd", "be", "bf", "bz",
45.     "cd", "ce", "cf", "cz",
46.     "de", "df", "dz",
47.     "ef", "ez",
48.     "fg", "fh", "fj", "fz",
49.     "gh", "gi", "gj", "gz",
50.     "hi", "hj", "hk", "hz",
51.     "ij", "ik", "il", "iz",
52.     "jk", "jm", "jz",
53.     "kl", "kn", "ko", "kz",
54.     "lm", "lz",
55.     "mn", "mo", "mz",
56.     "no", "nz",
57.     "op", "oz",
58.     "pq", "pz",
59.     "qr", "qz",
60.     "rs", "rz",
61.     "st", "su", "sz",
62.     "tu", "tv", "tz",
63.     "uv", "uw", "uz",
64.     "vw", "vz",
65.     "wx", "wy", "wz",
66.     "xy", "xz",
67.     "yz"
68. };
69.  
70. /* Длины рёбер */
71. int ribs_count[] = {
72.     12, 13, 14, 24, 25, 26, 34, 35, 36, 45, 46, 56,
73.     7, 8, 9, 10, 11, 15, 16, 17, 18, 19, 20, 21, 22,
74.     23, 27, 28, 29, 30, 31, 32, 33, 37, 38, 39, 40, 41,
75.     42, 43, 44, 47, 48, 49, 50, 51, 52, 53, 54, 55, 57,
76.     58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
77.     71, 72, 73, 74, 75, 17, 99, 67
78. };
79.  
80. // Длина массива с длинами рёбер
81. int ribs_all_count = sizeof(ribs_count) / sizeof(ribs_count[0]);
82.  
83. /////////////////Функции//////////////////////////////////////////////////////
84.  
85. int print_way(char *first_x_way, int rib_length) {
86.     // Выводим текущий путь
87.     printf("%s", first_x_way);
88.     // Печать длины пути
89.     printf(" %d ", rib_length);
90.     printf("\n");
91.     return 0;
92. }
93.  
94. // Вернёт элемент, который потом допишем в массив first_x_way
95. char search_element_to_push(char *first_x_way) {
96.     char z;
97.     int i;
98.     int j = strlen(first_x_way) - 1;
99.     for (i = 0; i < ALL_POINTS; i++) {
100.         if (first_x_way[j] == array_corresp2[i]) {
101.             z = array_corresp[i][0];
102.         }
103.     }
104.     return z;
105. }
106.  
107. // Возвращает указатель на первый путь first_x_way
108. char *element_search(char *first_x_way, int j) {
109.     char *arr;
110.     int i;
111.     for (i = 0; i < ALL_POINTS; i++) {
112.         if (first_x_way[j - 1] == array_corresp2[i]) {
113.             arr = array_corresp[i];
114.         }
115.     }
116.     return arr;
117. }
118.  
119. // Поиск ключа элемента
120. static int array_search(const char *ar_for_element_search, char el) {
121.     int i = 0;
122.     while (ar_for_element_search[i] != '\0') {
123.         if (ar_for_element_search[i] == el) return i;
124.         i++;
125.     }
126.     return -1;
127. }
128.  
129. // Найдем длину каждого пути
130. int count_way_length(int rib_length, char *first_x_way) {
131.     int j = strlen(first_x_way) - 1;
132.     rib_length = 0;
133.     int i, y;
134.     for (y = 0; y < j; y++) {
135.         for (i = 0; i < ribs_all_count; i++) {
136.             if (first_x_way[y] == ribs[i][0] && first_x_way[y + 1] == ribs[i][1]) {
137.                 rib_length += ribs_count[i];
138.             }
139.         }
140.     }
141.     return rib_length;
142. }
143.  
144. /////////////////////////////////////////////////////////////////////////////////////////
145.  
146. int main() {
147.  
148.     char first_x_way[100] = "abdefghijklmnopqrstuvwxyz";
149.     char element_to_push;
150.     char short_way_point[100];
151.     char last_point = 'z';
152.     char *ar_for_element_search;
153.     char allws_short[100][100];
154.     char enter_press_to_show_all_small_ways;
155.     int allws_short_lenght[1000];
156.     int xxx=0;
157.     int i, y, key;
158.     int rib_length = 0;
159.     int all = 1;
160.     // Вспомогательная переменная для определения самого короткого пути
161.     int short_way = 5000;
162.     // Первый путь задан
163.     // Длина j
164.     int j = strlen(first_x_way) - 1;
165.     int first_x_way_len = 0;
166.     int all_shorts_way_to_show = 0;
167.  
168.   /*Сохраним пути меньше введенного числа*/
169.    printf("Сохранить все пути меньше [введите число от 1 до 150]  или 0? ");
170.    scanf("%d", &all_shorts_way_to_show);
171.     if ( all_shorts_way_to_show  >  150)
172.     all_shorts_way_to_show = 0;
173.  
174.     // Все пути. 1 потому что выводим 1-ый вне циклов
175.     // Печать первого пути
176.     for (i = 0; first_x_way[i] != '\0'; i++)
177.         printf("%c", first_x_way[i]);
178.  
179.     // Найдем длину первого пути
180.     rib_length = 0;
181.     for (y = 0; y < j; y++) {
182.         for (i = 0; i < ribs_all_count; i++) {
183.             if (first_x_way[y] == ribs[i][0] && first_x_way[y + 1] == ribs[i][1]) {
184.                 rib_length += ribs_count[i];
185.             }
186.         }
187.     }
188.     printf(" %d ", rib_length);
189.     printf("\n");
190.  
191.     // Основной цикл поиска путей
192.     while (j > 0) {
193.         /* Определяем и ищем элемент и его ключ */
194.         ar_for_element_search = element_search(first_x_way, j);
195.         key = array_search(ar_for_element_search, first_x_way[j]);
196.  
197.         if ((key != -1) && (ar_for_element_search[key + 1] != '\0')) {
198.             /* Задаем длину массива равной j */
199.             first_x_way_len = j;
200.             /* Режем первый путь */
201.             first_x_way[j + 1] = '\0';
202.             /* Пишем в массив first_x_way */
203.             first_x_way[first_x_way_len++] = ar_for_element_search[key + 1];
204.             /* Найдем element_to_push для записи */
205.             element_to_push = search_element_to_push(first_x_way);
206.  
207.             while (1) {
208.                 /* Если дошли до последнего символа, выходим */
209.                 if (first_x_way[strlen(first_x_way) - 1] == last_point) {
210.                     first_x_way[first_x_way_len++] = element_to_push;
211.                     break;
212.                 }
213.                 /* Пишем в first_x_way */
214.                 first_x_way[first_x_way_len++] = element_to_push;
215.                 /* Ещё найдем element_to_push для записи */
216.                 element_to_push = search_element_to_push(first_x_way);
217.             }
218.             /* Обновляем j */
219.             j = strlen(first_x_way);
220.             all++;
221.             /* Пересчитываем длину пути */
222.             rib_length = count_way_length(rib_length, first_x_way);
223.             /* Печать */
224.             print_way(first_x_way, rib_length);
225.             //Найдем все пути меньше 50
226.                if (rib_length < all_shorts_way_to_show && (all_shorts_way_to_show  != 0)) {
227.                    strcpy(allws_short[xxx], first_x_way);
228.                  allws_short_lenght[xxx]=rib_length;
229.                  xxx++;
230.                 }
231.  
232.             /* Обновляем кратчайший путь */
233.             if (rib_length < short_way) {
234.                 /* Сохраним кратчайший путь */
235.                 strcpy(short_way_point, first_x_way);
236.                 short_way = rib_length;
237.  
238.             }
239.         }
240.         j--;
241.     }
242.     /* Тут результаты */
243.     printf("Самый короткий путь: %d \n", short_way);
244.     printf("Лежит через эти точки: %s \n", short_way_point);
245.     printf("Все пути: %d \n", all);
246.  
247.    printf("Показать все пути меньше  %d ? y/n" , all_shorts_way_to_show);
248.    scanf(" %c", &enter_press_to_show_all_small_ways);
249.  
250.     if (enter_press_to_show_all_small_ways == 'y') {
251.     for (i=xxx; i !=0; i--)
252.     printf("Путь: < %d  %s \n", allws_short_lenght[i], allws_short[i]);
253. } else {
254.         printf("\nВыходим...!\n");
255. }
256.     return 0;
257. }
258.  

--- Сообщение объединено, 2 июл 2026 в 00:43 ---

Совсем диакая дичь. Можно сохранить пути меньше заданного (поставил 750 - предел, такак на 1000 на моем компе stack smashing):

Код (C):

1. #include <stdio.h>
2. #include <string.h>
3.  
4. // Количество всех вершин
5. #define ALL_POINTS 26
6.  
7. // Объявим граф глобально
8. char a[] = "bcdz";
9. char b[] = "defz";
10. char c[] = "defz";
11. char d[] = "efz";
12. char e[] = "fz";
13. char f[] = "ghjz";
14. char g[] = "hijz";
15. char h[] = "ijkz";
16. char i[] = "jklz";
17. char j[] = "kmz";
18. char k[] = "lnoz";
19. char l[] = "mz";
20. char m[] = "noz";
21. char n[] = "oz";
22. char o[] = "pz";
23. char p[] = "qz";
24. char q[] = "rz";
25. char r[] = "sz";
26. char s[] = "tuz";
27. char t[] = "uvz";
28. char u[] = "vwz";
29. char v[] = "wz";
30. char w[] = "xyz";
31. char x[] = "yz";
32. char y[] = "z";
33. char z[] = "";
34.  
35. /* Массивы соответствий */
36. char *array_corresp[] = {
37.     a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z
38. };
39. char array_corresp2[] = "abcdefghijklmnopqrstuvwxyz";
40.  
41. /* Рёбра */
42. char *ribs[] = {
43.     "ab", "ac", "ad", "az",
44.     "bd", "be", "bf", "bz",
45.     "cd", "ce", "cf", "cz",
46.     "de", "df", "dz",
47.     "ef", "ez",
48.     "fg", "fh", "fj", "fz",
49.     "gh", "gi", "gj", "gz",
50.     "hi", "hj", "hk", "hz",
51.     "ij", "ik", "il", "iz",
52.     "jk", "jm", "jz",
53.     "kl", "kn", "ko", "kz",
54.     "lm", "lz",
55.     "mn", "mo", "mz",
56.     "no", "nz",
57.     "op", "oz",
58.     "pq", "pz",
59.     "qr", "qz",
60.     "rs", "rz",
61.     "st", "su", "sz",
62.     "tu", "tv", "tz",
63.     "uv", "uw", "uz",
64.     "vw", "vz",
65.     "wx", "wy", "wz",
66.     "xy", "xz",
67.     "yz"
68. };
69.  
70. /* Длины рёбер */
71. int ribs_count[] = {
72.     12, 13, 14, 24, 25, 26, 34, 35, 36, 45, 46, 56,
73.     7, 8, 9, 10, 11, 15, 16, 17, 18, 19, 20, 21, 22,
74.     23, 27, 28, 29, 30, 31, 32, 33, 37, 38, 39, 40, 41,
75.     42, 43, 44, 47, 48, 49, 50, 51, 52, 53, 54, 55, 57,
76.     58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
77.     71, 72, 73, 74, 75, 17, 99, 67
78. };
79.  
80. // Длина массива с длинами рёбер
81. int ribs_all_count = sizeof(ribs_count) / sizeof(ribs_count[0]);
82.  
83. /////////////////Функции//////////////////////////////////////////////////////
84.  
85. int print_way(char *first_x_way, int rib_length) {
86.     // Выводим текущий путь
87.     printf("%s", first_x_way);
88.     // Печать длины пути
89.     printf(" %d ", rib_length);
90.     printf("\n");
91.     return 0;
92. }
93.  
94. // Вернёт элемент, который потом допишем в массив first_x_way
95. char search_element_to_push(char *first_x_way) {
96.     char z;
97.     int i;
98.     int j = strlen(first_x_way) - 1;
99.     for (i = 0; i < ALL_POINTS; i++) {
100.         if (first_x_way[j] == array_corresp2[i]) {
101.             z = array_corresp[i][0];
102.         }
103.     }
104.     return z;
105. }
106.  
107. // Возвращает указатель на первый путь first_x_way
108. char *element_search(char *first_x_way, int j) {
109.     char *arr;
110.     int i;
111.     for (i = 0; i < ALL_POINTS; i++) {
112.         if (first_x_way[j - 1] == array_corresp2[i]) {
113.             arr = array_corresp[i];
114.         }
115.     }
116.     return arr;
117. }
118.  
119. // Поиск ключа элемента
120. static int array_search(const char *ar_for_element_search, char el) {
121.     int i = 0;
122.     while (ar_for_element_search[i] != '\0') {
123.         if (ar_for_element_search[i] == el) return i;
124.         i++;
125.     }
126.     return -1;
127. }
128.  
129. // Найдем длину каждого пути
130. int count_way_length(int rib_length, char *first_x_way) {
131.     int j = strlen(first_x_way) - 1;
132.     rib_length = 0;
133.     int i, y;
134.     for (y = 0; y < j; y++) {
135.         for (i = 0; i < ribs_all_count; i++) {
136.             if (first_x_way[y] == ribs[i][0] && first_x_way[y + 1] == ribs[i][1]) {
137.                 rib_length += ribs_count[i];
138.             }
139.         }
140.     }
141.     return rib_length;
142. }
143.  
144. /////////////////////////////////////////////////////////////////////////////////////////
145.  
146. int main() {
147.  
148.     char first_x_way[100] = "abdefghijklmnopqrstuvwxyz";
149.     char element_to_push;
150.     char short_way_point[100];
151.     char last_point = 'z';
152.     char *ar_for_element_search;
153.     char allws_short[22000][ALL_POINTS];
154.     char enter_press_to_show_all_small_ways;
155.     int allws_short_lenght[22000];
156.     int incrx=0;
157.     int i, y, key;
158.     int rib_length = 0;
159.     int all = 1;
160.     // Вспомогательная переменная для определения самого короткого пути
161.     int short_way = 5000;
162.     // Первый путь задан
163.     // Длина j
164.     int j = strlen(first_x_way) - 1;
165.     int first_x_way_len = 0;
166.     int all_shorts_way_to_show = 0;
167.  
168.   /*Сохраним пути меньше введенного числа*/
169.    printf("Сохранить все пути меньше [введите число от 1 до 750]  или 0? ");
170.    scanf("%d", &all_shorts_way_to_show);
171.     if ( all_shorts_way_to_show  >  750)
172.     all_shorts_way_to_show = 0;
173.  
174.     // Все пути. 1 потому что выводим 1-ый вне циклов
175.     // Печать первого пути
176.     for (i = 0; first_x_way[i] != '\0'; i++)
177.         printf("%c", first_x_way[i]);
178.  
179.     // Найдем длину первого пути
180.     rib_length = 0;
181.     for (y = 0; y < j; y++) {
182.         for (i = 0; i < ribs_all_count; i++) {
183.             if (first_x_way[y] == ribs[i][0] && first_x_way[y + 1] == ribs[i][1]) {
184.                 rib_length += ribs_count[i];
185.             }
186.         }
187.     }
188.     printf(" %d ", rib_length);
189.     printf("\n");
190.  
191.     // Основной цикл поиска путей
192.     while (j > 0) {
193.         /* Определяем и ищем элемент и его ключ */
194.         ar_for_element_search = element_search(first_x_way, j);
195.         key = array_search(ar_for_element_search, first_x_way[j]);
196.  
197.         if ((key != -1) && (ar_for_element_search[key + 1] != '\0')) {
198.             /* Задаем длину массива равной j */
199.             first_x_way_len = j;
200.             /* Режем первый путь */
201.             first_x_way[j + 1] = '\0';
202.             /* Пишем в массив first_x_way */
203.             first_x_way[first_x_way_len++] = ar_for_element_search[key + 1];
204.             /* Найдем element_to_push для записи */
205.             element_to_push = search_element_to_push(first_x_way);
206.  
207.             while (1) {
208.                 /* Если дошли до последнего символа, выходим */
209.                 if (first_x_way[strlen(first_x_way) - 1] == last_point) {
210.                     first_x_way[first_x_way_len++] = element_to_push;
211.                     break;
212.                 }
213.                 /* Пишем в first_x_way */
214.                 first_x_way[first_x_way_len++] = element_to_push;
215.                 /* Ещё найдем element_to_push для записи */
216.                 element_to_push = search_element_to_push(first_x_way);
217.             }
218.             /* Обновляем j */
219.             j = strlen(first_x_way);
220.             all++;
221.             /* Пересчитываем длину пути */
222.             rib_length = count_way_length(rib_length, first_x_way);
223.             /* Печать */
224.             print_way(first_x_way, rib_length);
225.  
226.             //Найдем все пути меньше all_shorts_way_to_show
227.                if (rib_length < all_shorts_way_to_show && (all_shorts_way_to_show  != 0)) {
228.                     allws_short_lenght[incrx]=rib_length;
229.                    strcpy(allws_short[incrx], first_x_way);
230.                  incrx++;
231.  
232.                 }
233.  
234.  
235.             /* Обновляем кратчайший путь */
236.             if (rib_length < short_way) {
237.                 /* Сохраним кратчайший путь */
238.                 strcpy(short_way_point, first_x_way);
239.                 short_way = rib_length;
240.  
241.             }
242.         }
243.         j--;
244.     }
245.     /* Тут результаты */
246.     printf("Самый короткий путь: %d \n", short_way);
247.     printf("Лежит через эти точки: %s \n", short_way_point);
248.     printf("Все пути: %d \n", all);
249.  
250.    printf("Показать все пути меньше  %d ? y/n" , all_shorts_way_to_show);
251.    scanf(" %c", &enter_press_to_show_all_small_ways);
252.  
253.  
254.     if (enter_press_to_show_all_small_ways == 'y') {
255.     for (i=0; i < incrx-1; i++)
256.     printf("Путь: < %d  %s \n", allws_short_lenght[i], allws_short[i]);
257. } else {
258.         printf("\nВыходим...!\n");
259. }
260.  
261.     return 0;
262. }
263.  

--- Сообщение объединено, 2 июл 2026 в 02:35 ---

Вот. Допилил до примитивной игры:

Код (C):

1. #include <stdio.h>
2. #include <string.h>
3. #include <stdlib.h>
4. // Количество всех вершин
5. #define ALL_POINTS 26
6.  
7. // Объявим граф глобально
8. char a[] = "bcdz";
9. char b[] = "defz";
10. char c[] = "defz";
11. char d[] = "efz";
12. char e[] = "fz";
13. char f[] = "ghjz";
14. char g[] = "hijz";
15. char h[] = "ijkz";
16. char i[] = "jklz";
17. char j[] = "kmz";
18. char k[] = "lnoz";
19. char l[] = "mz";
20. char m[] = "noz";
21. char n[] = "oz";
22. char o[] = "pz";
23. char p[] = "qz";
24. char q[] = "rz";
25. char r[] = "sz";
26. char s[] = "tuz";
27. char t[] = "uvz";
28. char u[] = "vwz";
29. char v[] = "wz";
30. char w[] = "xyz";
31. char x[] = "yz";
32. char y[] = "z";
33. char z[] = "";
34.  
35. /* Массивы соответствий */
36. char *array_corresp[] = {
37.     a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z
38. };
39. char array_corresp2[] = "abcdefghijklmnopqrstuvwxyz";
40.  
41. /* Рёбра */
42. char *ribs[] = {
43.     "ab", "ac", "ad", "az",
44.     "bd", "be", "bf", "bz",
45.     "cd", "ce", "cf", "cz",
46.     "de", "df", "dz",
47.     "ef", "ez",
48.     "fg", "fh", "fj", "fz",
49.     "gh", "gi", "gj", "gz",
50.     "hi", "hj", "hk", "hz",
51.     "ij", "ik", "il", "iz",
52.     "jk", "jm", "jz",
53.     "kl", "kn", "ko", "kz",
54.     "lm", "lz",
55.     "mn", "mo", "mz",
56.     "no", "nz",
57.     "op", "oz",
58.     "pq", "pz",
59.     "qr", "qz",
60.     "rs", "rz",
61.     "st", "su", "sz",
62.     "tu", "tv", "tz",
63.     "uv", "uw", "uz",
64.     "vw", "vz",
65.     "wx", "wy", "wz",
66.     "xy", "xz",
67.     "yz"
68. };
69.  
70. /* Длины рёбер */
71. int ribs_count[] = {
72.     12, 13, 14, 24, 25, 26, 34, 35, 36, 45, 46, 56,
73.     7, 8, 9, 10, 11, 15, 16, 17, 18, 19, 20, 21, 22,
74.     23, 27, 28, 29, 30, 31, 32, 33, 37, 38, 39, 40, 41,
75.     42, 43, 44, 47, 48, 49, 50, 51, 52, 53, 54, 55, 57,
76.     58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
77.     71, 72, 73, 74, 75, 17, 99, 67
78. };
79.  
80. // Длина массива с длинами рёбер
81. int ribs_all_count = sizeof(ribs_count) / sizeof(ribs_count[0]);
82.  
83. /////////////////Функции//////////////////////////////////////////////////////
84.  
85. int print_way(char *first_x_way, int rib_length) {
86.     // Выводим текущий путь
87.     printf("%s", first_x_way);
88.     // Печать длины пути
89.     printf(" %d ", rib_length);
90.     printf("\n");
91.     return 0;
92. }
93.  
94. // Вернёт элемент, который потом допишем в массив first_x_way
95. char search_element_to_push(char *first_x_way) {
96.     char z;
97.     int i;
98.     int j = strlen(first_x_way) - 1;
99.     for (i = 0; i < ALL_POINTS; i++) {
100.         if (first_x_way[j] == array_corresp2[i]) {
101.             z = array_corresp[i][0];
102.         }
103.     }
104.     return z;
105. }
106.  
107. // Возвращает указатель на первый путь first_x_way
108. char *element_search(char *first_x_way, int j) {
109.     char *arr;
110.     int i;
111.     for (i = 0; i < ALL_POINTS; i++) {
112.         if (first_x_way[j - 1] == array_corresp2[i]) {
113.             arr = array_corresp[i];
114.         }
115.     }
116.     return arr;
117. }
118.  
119. // Поиск ключа элемента
120. static int array_search(const char *ar_for_element_search, char el) {
121.     int i = 0;
122.     while (ar_for_element_search[i] != '\0') {
123.         if (ar_for_element_search[i] == el) return i;
124.         i++;
125.     }
126.     return -1;
127. }
128.  
129. // Найдем длину каждого пути
130. int count_way_length(int rib_length, char *first_x_way) {
131.     int j = strlen(first_x_way) - 1;
132.     rib_length = 0;
133.     int i, y;
134.     for (y = 0; y < j; y++) {
135.         for (i = 0; i < ribs_all_count; i++) {
136.             if (first_x_way[y] == ribs[i][0] && first_x_way[y + 1] == ribs[i][1]) {
137.                 rib_length += ribs_count[i];
138.             }
139.         }
140.     }
141.     return rib_length;
142. }
143.  
144. /////////////////////////////////////////////////////////////////////////////////////////
145.  
146. int main() {
147.  
148.     char first_x_way[100] = "abdefghijklmnopqrstuvwxyz";
149.     char element_to_push;
150.     char short_way_point[100];
151.     char last_point = 'z';
152.     char *ar_for_element_search;
153.     char allws_short[22000][ALL_POINTS];
154.     char enter_press_to_show_all_small_ways;
155.     char max_way[100];
156.     int allws_short_lenght[22000];
157.     int rrandd = 0;
158.     int max_rib = 0;
159.     int incrx=0;
160.     int i, y, key;
161.     int rib_length = 0;
162.     int all = 1;
163.     int play_game = 0;
164.     // Вспомогательная переменная для определения самого короткого пути
165.     int short_way = 5000;
166.     // Первый путь задан
167.     // Длина j
168.     int j = strlen(first_x_way) - 1;
169.     int first_x_way_len = 0;
170.     int all_shorts_way_to_show = 0;
171.  
172.   /*Сохраним пути меньше введенного числа*/
173.    printf("Сохранить все пути меньше [введите число от 1 до 750]  или 0? ");
174.    scanf("%d", &all_shorts_way_to_show);
175.     if ( all_shorts_way_to_show  >  750)
176.     all_shorts_way_to_show = 0;
177.  
178.     // Все пути. 1 потому что выводим 1-ый вне циклов
179.     // Печать первого пути
180.     for (i = 0; first_x_way[i] != '\0'; i++)
181.         printf("%c", first_x_way[i]);
182.  
183.     // Найдем длину первого пути
184.     rib_length = 0;
185.     for (y = 0; y < j; y++) {
186.         for (i = 0; i < ribs_all_count; i++) {
187.             if (first_x_way[y] == ribs[i][0] && first_x_way[y + 1] == ribs[i][1]) {
188.                 rib_length += ribs_count[i];
189.             }
190.         }
191.     }
192.     printf(" %d ", rib_length);
193.     printf("\n");
194.  
195.     // Основной цикл поиска путей
196.     while (j > 0) {
197.         /* Определяем и ищем элемент и его ключ */
198.         ar_for_element_search = element_search(first_x_way, j);
199.         key = array_search(ar_for_element_search, first_x_way[j]);
200.  
201.         if ((key != -1) && (ar_for_element_search[key + 1] != '\0')) {
202.             /* Задаем длину массива равной j */
203.             first_x_way_len = j;
204.             /* Режем первый путь */
205.             first_x_way[j + 1] = '\0';
206.             /* Пишем в массив first_x_way */
207.             first_x_way[first_x_way_len++] = ar_for_element_search[key + 1];
208.             /* Найдем element_to_push для записи */
209.             element_to_push = search_element_to_push(first_x_way);
210.  
211.             while (1) {
212.                 /* Если дошли до последнего символа, выходим */
213.                 if (first_x_way[strlen(first_x_way) - 1] == last_point) {
214.                     first_x_way[first_x_way_len++] = element_to_push;
215.                     break;
216.                 }
217.                 /* Пишем в first_x_way */
218.                 first_x_way[first_x_way_len++] = element_to_push;
219.                 /* Ещё найдем element_to_push для записи */
220.                 element_to_push = search_element_to_push(first_x_way);
221.             }
222.             /* Обновляем j */
223.             j = strlen(first_x_way);
224.             all++;
225.             /* Пересчитываем длину пути */
226.             rib_length = count_way_length(rib_length, first_x_way);
227.             /* Печать */
228.             print_way(first_x_way, rib_length);
229.  
230.             //Найдем все пути меньше all_shorts_way_to_show
231.                if (rib_length < all_shorts_way_to_show && (all_shorts_way_to_show  != 0)) {
232.                    allws_short_lenght[incrx]=rib_length;
233.                    strcpy(allws_short[incrx], first_x_way);
234.                  incrx++;
235.                 }
236.  
237.                 if (rib_length > max_rib) {
238.                  max_rib = rib_length;
239.                  strcpy(max_way, first_x_way);
240.                 }
241.  
242.             /* Обновляем кратчайший путь */
243.             if (rib_length < short_way) {
244.                 /* Сохраним кратчайший путь */
245.                 strcpy(short_way_point, first_x_way);
246.                 short_way = rib_length;
247.             }
248.         }
249.         j--;
250.     }
251.     /* Тут результаты */
252.     printf("Самый короткий путь: %d \n", short_way);
253.     printf("Лежит через эти точки: %s \n", short_way_point);
254.     printf("Все пути: %d \n", all);
255.     printf("\nСамый долгий путь %d %s !\n", max_rib, max_way);
256.     printf("Показать все пути меньше  %d ? y/n" , all_shorts_way_to_show);
257.    scanf(" %c", &enter_press_to_show_all_small_ways);
258.  
259.  
260.     if (enter_press_to_show_all_small_ways == 'y') {
261.     for (i=0; i < incrx-1; i++)
262.     printf("Путь: < %d  %s \n", allws_short_lenght[i], allws_short[i]);
263. } else {
264.         printf("\nВыходим...!\n");
265.  
266. }
267.  
268.    printf("Сыграем в игру     ? y/n");
269.    scanf(" %c", &enter_press_to_show_all_small_ways);
270.  
271.        if (enter_press_to_show_all_small_ways == 'y') {
272.          rrandd =  (rand() % incrx-1);
273.            printf("Какой путь был выбран?! [введи число]");
274.            scanf(" %d", &play_game);
275.            if (play_game == allws_short_lenght[rrandd]) {
276.               printf("\nУгадал...!%d %s\n", allws_short_lenght[rrandd], allws_short[rrandd]);
277.           }
278.               else {
279.                 printf("\n Не угадал...!%d %s\n", allws_short_lenght[rrandd], allws_short[rrandd]);
280.             }
281. } else {
282.         printf("\nВыходим...!\n");
283.  
284. }
285.  
286.     return 0;
287. }
288.