Как написать код для ребуса: ДВА * ДВА = ЧЕТЫРЕ(1 решение)? , Смог решить ребус и получил следующее решение 459 * 459 = 210681, но не понимаю как написать код

[xande.R]

Подскажите пожалуйста как написать код решения ребуса ДВА * ДВА = ЧЕТЫРЕ(1 решение)?
Решение смог найти, у меня получилось так: 459 * 459 = 210681

Я никогда не понимал ребусы, и кое как смог решить этот, но как написать код тут не особо пойму.

Есть теория:
Математический ребус – логическая задача, где в арифметическом примере цифры заменены буквами (одинаковым цифрам соответствуют одинаковые буквы, разным – разные). Например, 123+456=579 можно закодировать как сом + лук = уха.

Решить математический ребус означает найти числа, которые были закодированы. Один из способов решения – перебор возможных значений для букв. Но полный перебор занимает много времени за счёт большого числа вложенных циклов, поэтому следует отсекать заведомо неподходящие значения. Например, очевидно, что с≠9, с≠,0, у≠,0, л≠9, л≠0. Таким образом, числа, закодированные словами «сом» и «лук» меняются от 100 до 800, а число, закодированное словом «уха» - от 200 до 999.

Числа нарезаются на цифры, которые помещаются в множество. Если мощность множества не равна 3 (цифры разные!), то число не подходит в качестве решения задачи и надо проверять следующее число.
И пример:

set<int> M;
    set<int> N;
    for(int i=10000; i < 44000; i++)
    {
        if(i % 5 != 0)
        {
            M = Set_From_Number(i);
            if (M.size() == 5) {
                for (int j = 200; j < 1000; j++) {
                    int t1 = j / 100;
                    int t2 = (j / 10) % 10;
                    if (t1%2 == 0 && i % 10 == t2) {
                        N = Set_From_Number(j);
                        if (N.size() == 3 && i * 2 == j * 100 + 10 * t2 + t1)
                            cout << i << " + " << i << " = " << i * 2 << endl;
                    }
                }
            }
        }
    }

[OpenGL]

Имхо, проще всего тупым перебором сделать. Рассмотрим, например, "сом + лук = уха". Составляем список различных букв (т.е. {'с', 'о', 'м', 'л', 'у', 'к', 'х', 'а'}). Если он длиннее 10, то решения нет. Иначе дополняем список до длины 10, добавляя какой-нибудь небуквенный символ (хоть '\0', пофиг вообще). Сортируем этот список. А дальше как-то так:

do
{
    // Буква на i-той позиции показывает, что данная буква означает цифру i.
    // Если на этой позиции '\0', то цифра не используется.
    // Подставляем цифры в пример и проверяем условие "числа не начинаются с 0 и выполняется равенство"
    
} while(std::next_permutation(list.begin(), list.end());

Сообщение отредактировано: OpenGL - 28.08.20, 10:57

[amk]

Цитата OpenGL @ 28.08.20, 10:55

Имхо, проще всего тупым перебором сделать.

Причём решение получается довольно быстро, поскольку существует всего 10! = 5040 комбинаций.

Только всё же немного быстрее получается, если перебирать не перестановки букв, сопоставляя их с цифрами, а сочетанияразмещения цифр (их меньше) с имеющимися буквами.

Сообщение отредактировано: amk - 30.08.20, 15:14

[OpenGL]

Ровно так же получится, т.к. в таком переборе лишние перестановки (т.е. такие, которые дают одинаковые итоговые примеры) не сгенерируются.

[ЫукпШ]

Цитата amk @ 29.08.20, 09:22

Цитата OpenGL @ 28.08.20, 10:55

Имхо, проще всего тупым перебором сделать.

Причём решение получается довольно быстро, поскольку существует всего 10! = 5040 комбинаций.

Не совсем понял..
Если имеется 8 цифр, каждая - одно из 10 значений,
тогда число переборов - 10^8 = 100000000.
Это без учёта ограничений на с,у,л.
Еси учитывать ограничения, тогда максимальное число переборов
будет меньше: 8*10*10*8*9*10*10*10.

[OpenGL]

Цитата ЫукпШ @ 29.08.20, 11:13

Если имеется 8 цифр, каждая - одно из 10 значений,
тогда число переборов - 10^8 = 100000000.

Зачем так сложно? Цифры же без повторов идут. Поэтому в реальности будет достаточно перебрать (число сочетаний из 10 по 8) * 8! = 10! / 2!. И это число всегда заведомо меньше 10!.

[amk]

Цитата OpenGL @ 29.08.20, 09:43

в таком переборе лишние перестановки (т.е. такие, которые дают одинаковые итоговые примеры) не сгенерируются.

Поэтому я и написал про сочетания.

[ЫукпШ]

Цитата OpenGL @ 29.08.20, 11:21

Зачем так сложно? Цифры же без повторов идут.

Наоборот, по моему я то как раз и предлагаю простой вариант.
А как ещё реализовать такой алгоритм ?
Каждому символу ставим в соответствие допустимый ему "алфавит" - массив цифр.
Размер и содержимое такого "алфавита" у символов разное.
Перебор - это фактически последовательное изменение индексов алфавитов.
(Ограничение по максимуму - это равенство всех индексов 0.)
---
Поскольку имеется дополнительное ограничение - разные символы не могут
иметь одно цифровое значение - то незачем считать формулу для
всех комбинаций. Перед формулой надо проверить допустимость
комбинации на совпадения значений. И всё.

Сообщение отредактировано: ЫукпШ - 30.08.20, 12:19

[amk]

10⁸ = 100000000
10! = 5040
Их отношение - почти 20000

У тебя только цикл перебора без каких-либо проверок будет исполняться дольше, чем весь поиск решения при использовании размещений (я там вверху их перепутал, в сочетаниях порядок не важен).

На всякий случай алгоритм поиска следующей перестановки, его не очень сложно переделать для перебора размещений

0. Начинаем с упорядоченной по возрастанию последовательности
На каждом шаге
1. Ищем в конце убывающую последовательность, если убывает весь набор - конец работы
2. Находим в найденной последовательности минимальное значение, большее того, что находится непосредственно перед ней
3. Обмениванием местами эти два значения (последовательность остаётся убывающей)
4. Разворачиваем последовательность

Средняя длина последовательности меньше двух, так что алгоритм весьма быстрый
Для приспособления его для перебора размещений надо перед каждым шагом дополнительно сортировать по убыванию неиспользуемые элементы (или просто разворачивать их в обратном порядке).

Сообщение отредактировано: amk - 30.08.20, 15:13

[ЫукпШ]

Нащёлкал исходник, посматривая в телевизор минут за 20.
Вместе с выводом в консоль программа работает ~820 [mc].
Кстати, это был полный перебор для формулы "сом + лук = уха".
Было найдено и напечатано 536 решений.
Исходники будешь смотреть ?

Сообщение отредактировано: ЫукпШ - 30.08.20, 21:43

[OpenGL]

Цитата ЫукпШ @ 30.08.20, 12:11

Наоборот, по моему я то как раз и предлагаю простой вариант.

"Сложный" в смысле "вычислительно сложный". Впрочем, если речь о С++, то и сложнее в реализации, т.к. самая сложная в моём случае часть - генерация следующей перестановки - уже есть в next_permutation, всё остальное же это всего лишь проверки текущих выбранных цифр.

Добавлено 31.08.20, 06:02
Т.е. схема любого алгоритма перебора выглядит так:
1) Предварительные действия
2) Генерируем очередной набор цифр. Если сгенерировался - п.3, иначе п.4
3) Проверяем его, и идём в п.2
4) Конец алгоритма

1) зависит от алгоритма перебора, 3) нужен всем. 2 для каждого случая индивидуальный, и у тебя он будет рекурсией или ещё чем-то громоздким, у меня же всего лишь одной строкой.

[ЫукпШ]

Цитата OpenGL @ 31.08.20, 05:54

2 для каждого случая индивидуальный, и у тебя он будет рекурсией или ещё чем-то громоздким, у меня же всего лишь одной строкой.

Почему - громоздкий ? Не понимаю.
Всё время говорим ни о чём.
Следующая последовательность у меня генерируется так:

 var1 = i1a[i1];
 var2 = i2a[i2];
 var3 = i3a[i3];
 var4 = i4a[i4];
 var5 = i5a[i5];
 var6 = i6a[i6];
 var7 = i7a[i7];
 var8 = i8a[i8];

---
Нет у тебя никакого алгоритма перестановки.
И не может в данном случае быть.
Чтобы он был, надо, чтобы
1. число букв исходной формулы было равно диапазону цифр.
2. у всех букв исходной формулы диапазон был одинаковым.
Оба этих условия не соблюдаются, поэтому можно говорить
о гибридном варианте из перебора и перестановок.
И вот тут как раз и сложность - можно легко
пропустить какую-нибудь комбинацию или даже группу комбинаций.
Сложный алгоритм именно у тебя.
---
Вот он весь исходник:

Скрытый текст

// --------------------------------------------------------------------------
// сом + лук = уха
//static const TCHAR dat[] = {_T('с'), _T('о'), _T('м'), _T('л'), _T('у'), _T('к'), _T('х'), _T('а')} ;
//                            0,9                        0,9          0
 
int iCount;
// номера индексов:
// 1-с 2-о 3-м 4-л 5-у 6-к 7-х 8-а
int i1,i2,i3,i4,i5,i6,i7,i8;
int var1,var2,var3,var4,var5,var6,var7,var8;
 
// алфавиты. -1 - маркер конца.
static const int i1a[] = {1,2,3,4,5,6,7,8,-1};     // с
static const int i2a[] = {0,1,2,3,4,5,6,7,8,9,-1}; // о
static const int i3a[] = {0,1,2,3,4,5,6,7,8,9,-1}; // м
static const int i4a[] = {1,2,3,4,5,6,7,8,-1};     // л
static const int i5a[] = {1,2,3,4,5,6,7,8,9,-1};   // у
static const int i6a[] = {0,1,2,3,4,5,6,7,8,9,-1}; // к
static const int i7a[] = {0,1,2,3,4,5,6,7,8,9,-1}; // х
static const int i8a[] = {0,1,2,3,4,5,6,7,8,9,-1}; // а
 
// --------------------------------------------------------------------------
void ПечатьРезультата(void)
{
 ++iCount;
 _tprintf(_T("%d. %d%d%d + %d%d%d = %d%d%d\n"),iCount,var1,var2,var3,var4,var5,var6,var5,var7,var8);
}
// --------------------------------------------------------------------------
bool ТестФормулы (void)
{
 int varA = var1*100 + var2*10 + var3; // сом
 int varB = var4*100 + var5*10 + var6; // лук
 int varC = var5*100 + var7*10 + var8; // уха
 
 if((varA + varB) == varC) return true;
 return false;
}
// --------------------------------------------------------------------------
bool ТестКомбинации(void)
{
 var1 = i1a[i1];
 var2 = i2a[i2];
 var3 = i3a[i3];
 var4 = i4a[i4];
 var5 = i5a[i5];
 var6 = i6a[i6];
 var7 = i7a[i7];
 var8 = i8a[i8];
 
 if(var1 == var2) return false;
 
 if(var3 == var1) return false;
 if(var3 == var2) return false;
 
 if(var4 == var1) return false;
 if(var4 == var2) return false;
 if(var4 == var3) return false;
 
 if(var5 == var1) return false;
 if(var5 == var2) return false;
 if(var5 == var3) return false;
 if(var5 == var4) return false;
 
 if(var6 == var1) return false;
 if(var6 == var2) return false;
 if(var6 == var3) return false;
 if(var6 == var4) return false;
 if(var6 == var5) return false;
 
 if(var7 == var1) return false;
 if(var7 == var2) return false;
 if(var7 == var3) return false;
 if(var7 == var4) return false;
 if(var7 == var5) return false;
 if(var7 == var6) return false;
 
 if(var8 == var1) return false;
 if(var8 == var2) return false;
 if(var8 == var3) return false;
 if(var8 == var4) return false;
 if(var8 == var5) return false;
 if(var8 == var6) return false;
 if(var8 == var7) return false;
 
 return true;
}
// --------------------------------------------------------------------------
bool IncIndex(void)
{
 if(i1a[++i1] < 0)
 {
  i1=0;
  if(i2a[++i2] < 0)
  {
   i2=0;
   if(i3a[++i3] < 0)
   {
    i3=0;
    if(i4a[++i4] < 0)
    {
     i4=0;
     if(i5a[++i5] < 0)
     {
      i5=0;
      if(i6a[++i6] < 0)
      {
       i6=0;
       if(i7a[++i7] < 0)
       {
        i7=0;
        if(i8a[++i8] < 0)
        {
         i8=0;
        }
       }
      }
     }    
    }
   }
  }
 }
 
 if(i1) return false;
 if(i2) return false;
 if(i3) return false;
 if(i4) return false;
 if(i5) return false;
 if(i6) return false;
 if(i7) return false;
 if(i8) return false;
 
 return true;
}
// --------------------------------------------------------------------------
int __cdecl _tmain(int argc, char **argv)
{
 _tprintf(_T("\tHello, world!\n"));
 
 
 
// сом + лук = уха
 DWORD t2 = 0;
 DWORD t1 = ::GetTickCount();
 
 iCount=0;
 i1=i2=i3=i4=i5=i6=i7=i8=0;
 for(;;)
 {
  if(ТестКомбинации())
  {
   if(ТестФормулы())
   {
    ПечатьРезультата();
//    break;  // закомментируем, если хотим полный перебор
   }
  }
 
  if(IncIndex())
  {
 
   break;
  }
 
 }
 
 t2 = ::GetTickCount();
 _tprintf(_T("End work, %d [mc]\n"),t2-t1);
}

Сообщение отредактировано: ЫукпШ - 31.08.20, 10:50

[OpenGL]

Цитата ЫукпШ @ 31.08.20, 10:42

Почему - громоздкий ?

Вот именно поэтому. Ты писал какой-то говнокод под названием IncIndex (говнокод потому что нормальная реализация этого пишется значительно проще), и ещё тебе нужна ТестКомбинации, в моём же случае оба эти метода заменяются одним next_permutation, который сразу даёт то, что нужно

Добавлено 31.08.20, 11:36

Цитата ЫукпШ @ 31.08.20, 10:42

Нет у тебя никакого алгоритма перестановки.
И не может в данном случае быть.
Чтобы он был, надо, чтобы
1. число букв исходной формулы было равно диапазону цифр.
2. у всех букв исходной формулы диапазон был одинаковым.

А это вообще какой-то набор фраз, лишённый смысла.

[Black_Dragon]

Как-то так на Prolog-е

clauses
    write_list_one([]).
    write_list_one([H | T]) :- write(H), write_list_one(T).
 
    get_n_l([X | L], X, L).
    get_n_l([X | L], X2, [X | L2]) :- get_n_l(L, X2, L2).
 
clauses
    formula1(L0) :-
        get_n_l(L0, Д, L1), Д <> 0,
        get_n_l(L1, В, L2),
        get_n_l(L2, А, L3),
        get_n_l(L3, Ч, L4), Ч <> 0,
        get_n_l(L4, Е, L5),
        get_n_l(L5, Т, L6),
        get_n_l(L6, Ы, L7),
        get_n_l(L7, Р, _),
        X = Д * 100 + В * 10 + А,
        Y = Ч * 100000 + Е * 10000 + Т * 1000 + Ы * 100 + Р * 10 + Е,
        Y = X * X,
        write_list_one([Д, В, А]), write(" * "), write_list_one([Д, В, А]), write(" = "), write_list_one([Ч, Е, Т, Ы, Р, Е]), nl,
        fail or succeed.
    formula2(L0) :-
        get_n_l(L0, С, L1), С <> 0,
        get_n_l(L1, О, L2),
        get_n_l(L2, М, L3),
        get_n_l(L3, Л, L4), Л <> 0,
        get_n_l(L4, У, L5), У <> 0,
        get_n_l(L5, К, L6),
        get_n_l(L6, Х, L7),
        get_n_l(L7, А, _),
        X = С * 100 + О * 10 + М,
        Y = Л * 100 + У * 10 + К,
        Z = У * 100 + Х * 10 + А,
        Z = X + Y,
        write_list_one([С, О, М]), write(" + "), write_list_one([Л, У, К]), write(" = "), write_list_one([У, Х, А]), nl,
        fail or succeed.
 
clauses
    work() :-
        L0 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
        write("!!! Start !!!"), nl,
        write("Formula 1"), nl,
        formula1(L0),
        write("Formula 2"),  nl,
        formula2(L0),
        write("!!! Stop !!!"), nl.

Результат

!!! Start !!!
Formula 1
459 * 459 = 210681
Formula 2
103 + 459 = 562
103 + 569 = 672
103 + 679 = 782
104 + 568 = 672
104 + 569 = 673
104 + 679 = 783
105 + 679 = 784
106 + 239 = 345
107 + 238 = 345
107 + 239 = 346
107 + 349 = 456
108 + 237 = 345
108 + 239 = 347
108 + 349 = 457
108 + 459 = 567
108 + 564 = 672
109 + 236 = 345
109 + 237 = 346
109 + 238 = 347
109 + 347 = 456
109 + 348 = 457
109 + 453 = 562
109 + 458 = 567
109 + 563 = 672
109 + 564 = 673
109 + 673 = 782
109 + 674 = 783
109 + 675 = 784
123 + 456 = 579
123 + 457 = 580
123 + 564 = 687
123 + 567 = 690
123 + 675 = 798
123 + 684 = 807
124 + 563 = 687
124 + 579 = 703
124 + 683 = 807
124 + 685 = 809
125 + 673 = 798
125 + 684 = 809
126 + 349 = 475
126 + 453 = 579
126 + 457 = 583
126 + 578 = 704
127 + 453 = 580
127 + 456 = 583
127 + 459 = 586
127 + 563 = 690
128 + 576 = 704
129 + 346 = 475
129 + 457 = 586
129 + 574 = 703
132 + 457 = 589
132 + 458 = 590
132 + 574 = 706
132 + 576 = 708
134 + 572 = 706
135 + 467 = 602
135 + 689 = 824
136 + 572 = 708
137 + 452 = 589
137 + 465 = 602
137 + 468 = 605
138 + 452 = 590
138 + 467 = 605
138 + 469 = 607
139 + 468 = 607
139 + 685 = 824
142 + 796 = 938
145 + 687 = 832
146 + 239 = 385
146 + 792 = 938
147 + 239 = 386
147 + 359 = 506
147 + 685 = 832
148 + 359 = 507
149 + 236 = 385
149 + 237 = 386
149 + 357 = 506
149 + 358 = 507
152 + 346 = 498
152 + 687 = 839
152 + 796 = 948
153 + 467 = 620
153 + 687 = 840
153 + 689 = 842
154 + 236 = 390
156 + 234 = 390
156 + 238 = 394
156 + 247 = 403
156 + 342 = 498
156 + 792 = 948
157 + 246 = 403
157 + 249 = 406
157 + 463 = 620
157 + 682 = 839
157 + 683 = 840
158 + 236 = 394
158 + 249 = 407
158 + 469 = 627
159 + 247 = 406
159 + 248 = 407
159 + 468 = 627
159 + 683 = 842
162 + 578 = 740
163 + 245 = 408
163 + 579 = 742
165 + 243 = 408
168 + 359 = 527
168 + 572 = 740
169 + 358 = 527
169 + 573 = 742
183 + 467 = 650
183 + 469 = 652
183 + 579 = 762
184 + 579 = 763
186 + 249 = 435
187 + 249 = 436
187 + 359 = 546
187 + 463 = 650
189 + 246 = 435
189 + 247 = 436
189 + 357 = 546
189 + 463 = 652
189 + 573 = 762
189 + 574 = 763
192 + 356 = 548
192 + 683 = 875
193 + 682 = 875
196 + 352 = 548
203 + 468 = 671
204 + 357 = 561
204 + 579 = 783
204 + 687 = 891
205 + 468 = 673
206 + 139 = 345
207 + 138 = 345
207 + 139 = 346
207 + 354 = 561
207 + 684 = 891
208 + 137 = 345
208 + 139 = 347
208 + 359 = 567
208 + 463 = 671
208 + 465 = 673
209 + 136 = 345
209 + 137 = 346
209 + 138 = 347
209 + 358 = 567
209 + 574 = 783
213 + 465 = 678
213 + 467 = 680
213 + 576 = 789
213 + 684 = 897
213 + 694 = 907
213 + 695 = 908
214 + 356 = 570
214 + 576 = 790
214 + 589 = 803
214 + 683 = 897
214 + 693 = 907
215 + 463 = 678
215 + 693 = 908
216 + 354 = 570
216 + 358 = 574
216 + 573 = 789
216 + 574 = 790
216 + 578 = 794
216 + 587 = 803
217 + 463 = 680
217 + 586 = 803
217 + 589 = 806
218 + 356 = 574
218 + 576 = 794
219 + 584 = 803
219 + 587 = 806
231 + 467 = 698
231 + 475 = 706
231 + 478 = 709
235 + 471 = 706
236 + 479 = 715
237 + 461 = 698
238 + 471 = 709
239 + 476 = 715
241 + 356 = 597
241 + 357 = 598
241 + 367 = 608
241 + 368 = 609
241 + 589 = 830
241 + 697 = 938
246 + 139 = 385
246 + 351 = 597
247 + 139 = 386
247 + 351 = 598
247 + 361 = 608
247 + 368 = 615
247 + 589 = 836
247 + 691 = 938
248 + 361 = 609
248 + 367 = 615
248 + 369 = 617
249 + 136 = 385
249 + 137 = 386
249 + 368 = 617
249 + 581 = 830
249 + 587 = 836
251 + 479 = 730
251 + 697 = 948
254 + 136 = 390
256 + 134 = 390
256 + 138 = 394
256 + 147 = 403
257 + 146 = 403
257 + 149 = 406
257 + 691 = 948
258 + 136 = 394
258 + 149 = 407
259 + 147 = 406
259 + 148 = 407
259 + 471 = 730
261 + 478 = 739
263 + 145 = 408
265 + 143 = 408
268 + 471 = 739
271 + 369 = 640
271 + 589 = 860
274 + 589 = 863
279 + 361 = 640
279 + 581 = 860
279 + 584 = 863
281 + 369 = 650
281 + 479 = 760
281 + 693 = 974
281 + 694 = 975
283 + 476 = 759
283 + 691 = 974
284 + 367 = 651
284 + 691 = 975
286 + 149 = 435
286 + 473 = 759
287 + 149 = 436
287 + 364 = 651
289 + 146 = 435
289 + 147 = 436
289 + 361 = 650
289 + 471 = 760
291 + 367 = 658
291 + 583 = 874
293 + 475 = 768
293 + 581 = 874
295 + 473 = 768
297 + 361 = 658
302 + 479 = 781
304 + 257 = 561
304 + 587 = 891
305 + 476 = 781
306 + 475 = 781
306 + 479 = 785
307 + 149 = 456
307 + 254 = 561
307 + 584 = 891
308 + 149 = 457
308 + 259 = 567
309 + 147 = 456
309 + 148 = 457
309 + 258 = 567
309 + 472 = 781
309 + 476 = 785
312 + 478 = 790
312 + 584 = 896
312 + 594 = 906
312 + 596 = 908
314 + 256 = 570
314 + 582 = 896
314 + 592 = 906
315 + 487 = 802
316 + 254 = 570
316 + 258 = 574
316 + 489 = 805
316 + 592 = 908
317 + 485 = 802
317 + 489 = 806
318 + 256 = 574
318 + 472 = 790
319 + 486 = 805
319 + 487 = 806
321 + 475 = 796
321 + 485 = 806
321 + 486 = 807
325 + 471 = 796
325 + 481 = 806
326 + 149 = 475
326 + 481 = 807
326 + 489 = 815
327 + 489 = 816
329 + 146 = 475
329 + 486 = 815
329 + 487 = 816
341 + 256 = 597
341 + 257 = 598
341 + 267 = 608
341 + 268 = 609
346 + 251 = 597
347 + 159 = 506
347 + 251 = 598
347 + 261 = 608
347 + 268 = 615
348 + 159 = 507
348 + 261 = 609
348 + 267 = 615
348 + 269 = 617
349 + 157 = 506
349 + 158 = 507
349 + 268 = 617
352 + 146 = 498
356 + 142 = 498
361 + 489 = 850
362 + 489 = 851
368 + 159 = 527
369 + 158 = 527
369 + 481 = 850
369 + 482 = 851
371 + 269 = 640
371 + 489 = 860
372 + 489 = 861
379 + 261 = 640
379 + 481 = 860
379 + 482 = 861
381 + 269 = 650
382 + 594 = 976
384 + 267 = 651
384 + 592 = 976
387 + 159 = 546
387 + 264 = 651
389 + 157 = 546
389 + 261 = 650
391 + 267 = 658
391 + 485 = 876
392 + 156 = 548
395 + 481 = 876
396 + 152 = 548
397 + 261 = 658
402 + 379 = 781
403 + 159 = 562
403 + 268 = 671
405 + 268 = 673
405 + 376 = 781
406 + 375 = 781
406 + 379 = 785
408 + 159 = 567
408 + 263 = 671
408 + 265 = 673
409 + 153 = 562
409 + 158 = 567
409 + 372 = 781
409 + 376 = 785
412 + 378 = 790
413 + 265 = 678
413 + 267 = 680
415 + 263 = 678
415 + 387 = 802
416 + 389 = 805
417 + 263 = 680
417 + 385 = 802
417 + 389 = 806
418 + 372 = 790
419 + 386 = 805
419 + 387 = 806
421 + 375 = 796
421 + 385 = 806
421 + 386 = 807
423 + 156 = 579
423 + 157 = 580
425 + 371 = 796
425 + 381 = 806
426 + 153 = 579
426 + 157 = 583
426 + 381 = 807
426 + 389 = 815
427 + 153 = 580
427 + 156 = 583
427 + 159 = 586
427 + 389 = 816
429 + 157 = 586
429 + 386 = 815
429 + 387 = 816
431 + 267 = 698
431 + 275 = 706
431 + 278 = 709
432 + 157 = 589
432 + 158 = 590
435 + 167 = 602
435 + 271 = 706
436 + 279 = 715
437 + 152 = 589
437 + 165 = 602
437 + 168 = 605
437 + 261 = 698
438 + 152 = 590
438 + 167 = 605
438 + 169 = 607
438 + 271 = 709
439 + 168 = 607
439 + 276 = 715
451 + 279 = 730
453 + 167 = 620
457 + 163 = 620
458 + 169 = 627
459 + 168 = 627
459 + 271 = 730
461 + 278 = 739
461 + 389 = 850
462 + 389 = 851
468 + 271 = 739
469 + 381 = 850
469 + 382 = 851
471 + 389 = 860
472 + 389 = 861
479 + 381 = 860
479 + 382 = 861
481 + 279 = 760
483 + 167 = 650
483 + 169 = 652
483 + 276 = 759
486 + 273 = 759
487 + 163 = 650
489 + 163 = 652
489 + 271 = 760
491 + 385 = 876
493 + 275 = 768
495 + 273 = 768
495 + 381 = 876
503 + 169 = 672
504 + 168 = 672
504 + 169 = 673
504 + 279 = 783
504 + 387 = 891
507 + 384 = 891
508 + 164 = 672
509 + 163 = 672
509 + 164 = 673
509 + 274 = 783
512 + 384 = 896
512 + 394 = 906
512 + 396 = 908
513 + 276 = 789
514 + 276 = 790
514 + 289 = 803
514 + 382 = 896
514 + 392 = 906
516 + 273 = 789
516 + 274 = 790
516 + 278 = 794
516 + 287 = 803
516 + 392 = 908
517 + 286 = 803
517 + 289 = 806
518 + 276 = 794
519 + 284 = 803
519 + 287 = 806
523 + 164 = 687
523 + 167 = 690
524 + 163 = 687
524 + 179 = 703
526 + 178 = 704
527 + 163 = 690
528 + 176 = 704
529 + 174 = 703
532 + 174 = 706
532 + 176 = 708
534 + 172 = 706
536 + 172 = 708
541 + 289 = 830
547 + 289 = 836
549 + 281 = 830
549 + 287 = 836
562 + 178 = 740
563 + 179 = 742
568 + 172 = 740
569 + 173 = 742
571 + 289 = 860
574 + 289 = 863
579 + 281 = 860
579 + 284 = 863
582 + 394 = 976
583 + 179 = 762
584 + 179 = 763
584 + 392 = 976
589 + 173 = 762
589 + 174 = 763
591 + 283 = 874
593 + 281 = 874
603 + 179 = 782
604 + 179 = 783
604 + 287 = 891
605 + 179 = 784
607 + 284 = 891
609 + 173 = 782
609 + 174 = 783
609 + 175 = 784
613 + 284 = 897
613 + 294 = 907
613 + 295 = 908
614 + 283 = 897
614 + 293 = 907
615 + 293 = 908
623 + 175 = 798
623 + 184 = 807
624 + 183 = 807
624 + 185 = 809
625 + 173 = 798
625 + 184 = 809
635 + 189 = 824
639 + 185 = 824
641 + 297 = 938
645 + 187 = 832
647 + 185 = 832
647 + 291 = 938
651 + 297 = 948
652 + 187 = 839
653 + 187 = 840
653 + 189 = 842
657 + 182 = 839
657 + 183 = 840
657 + 291 = 948
659 + 183 = 842
681 + 293 = 974
681 + 294 = 975
683 + 291 = 974
684 + 291 = 975
692 + 183 = 875
693 + 182 = 875
742 + 196 = 938
746 + 192 = 938
752 + 196 = 948
756 + 192 = 948
!!! Stop !!!

Сообщение отредактировано: Black_Dragon - 01.09.20, 10:52