кортежи последовательных простых. ключ к 19-252

[Dmitriy40]

Yadryara в сообщении #1636990 писал(а):

Dmitriy40 Догадываетесь уже как считать cg?

Пока нет. Ясно лишь как по ww[] можно посчитать vc[] для следующего простого не сохраняя результат обратно в ww[]. Это несложно встроить в мою программу, убрав для последнего простого запись в ww[] и считать сразу vc[] для него. Но это позволяет посчитать лишь 113# по 109#, не более того. Один шаг не интересен, он делается проще этих заморочек.
В показанном примере, как имея лишь ww[] для 11#, получить не просто vc[] для 13#, а vc[] для 17#, пусть даже имея vc[] и cg[] и g2[] (но не ww[]! в этом весь смысл) для 13#? Пока не вижу другого способа кроме обычного перебора всех комбинаций остатков по 13# и 17# по КТО. Для 19-252 так на асме получается лишь перейти от 41# с ww[] (31млн вариантов загрязнений) до 67# только vc[]. Будет путь перехода сильно дальше - допишу прогу чтобы считалось ww[] для 43#, но не дальше (памяти не хватит). От ww[] для 43# до vc[] для 113# надо сделать 16 шагов без обновления ww[] (на что вся надежда) или перебрать порядка 2.3e28 вариантов комбинаций остатков (что абсолютно нереально).

Yadryara в сообщении #1637007 писал(а):

Например, найдены такие значения:

А надо 17# -> 19# не имея при этом ww[] для 17# и 13#, только для 11#. И не перебирая все варианты остатков по 13# и 17# и 19# по КТО. Один шаг не интересен, он делается проще, без cg[] и g2[].

[Yadryara]

Правильно ли я понимаю, что как только расстановка возникает, для неё сразу вычисляется маска и в этой маске зашифровано достаточно, чтобы заранее, за несколько шагов до того или иного модуля уже понимать, какие числа по этому модулю будут выбиты?

Dmitriy40 в сообщении #1637008 писал(а):

Yadryara в сообщении #1636990 писал(а):

Dmitriy40 Догадываетесь уже как считать cg?

Пока нет.

Нужно рассмотреть те #v остатков, которые раньше отбрасывались.

[Dmitriy40]

Yadryara в сообщении #1637023 писал(а):

Правильно ли я понимаю, что как только расстановка возникает, для неё сразу вычисляется маска и в этой маске зашифровано достаточно, чтобы заранее, за несколько шагов до того или иного модуля уже понимать, какие числа по этому модулю будут выбиты?

Я не вполне понимаю вопрос.
Маска - это просто удобный короткий способ кодирования списка элементов массива a[].
В vc[] накапливаем число вариантов расстановки чисел в массиве a[] заданной длины.
При обработке каждого модуля и каждого остатка по нему число вариантов увеличивается. Потому растёт sum.
Но многие варианты повторяются и потому число уникальных вариантов (суммарная длина всех ww[k]) на первой же окейной строке расти перестаёт.
По каждому модулю вариантов выбивания чисел ровно столько сколько разных допустимых остатков по этому модулю. Но учитывая что что-то из массива выбивалось и предыдущими модулями, то при выбивании появляются повторы (потому и количество уникальных вариантов меньше общего количества вариантов). И это не только те что с 0 в выведенных таблицах, и некоторые с 1 могут тоже дать одинаковый результат (скажем двухзубая вилка попадает в одно и то же число то одним зубом, то другим, второй же при этом попадает в уже вычеркнутое число). Кажется поэтому vc[] нельзя просчитать дальше только по самому себе пока могут быть двухзубые вилки (простые менее половины диаметра).

Если спросить есть ли числа в a[], которые не выбиваются вообще ни одним из допустимых остатков по какому-то модулю, то да, такие числа есть. Все такие числа в a[] легко найти выполнив bitand на весь массив am[] (это маски оставляемых чисел для каждого остатка). Например для паттерна [0,30,60,90,120] по модулю p=7 есть всего два допустимых остатка с масками 0xF7EFBF7DFBEFDF и 0xFBF7DFBEFDF7EF, сделав им bitand получим 0xF3E79F3CF9E7CF - вот каждая единичка (40шт) здесь показывает какое число из a[] не будет вычеркнуто ни одним из двух допустимых остатков по модулю 7.
Для модуля p=11 допустимых остатков 6шт с масками: 0xBFF7FDFF7FDFFB, 0xDFFBFEFFBFEFFD, 0xFBFEFFDFF7FDFF, 0xFDFF7FEFFBFEFF, 0xFF7FDFF7FEFFBF, 0xFFBFEFFBFF7FDF, сделав им общий bitand получим 0x99324CC3324C99 (24 единицы), вот эти 24 числа из a[] никакими допустимыми остатками по модулю 11 не выбиваются.
Сделав bitand(0xF3E79F3CF9E7CF,0x99324CC3324C99)=0x91220C00304489 (14 единиц), вот такие 14 чисел не выбиваются никакими допустимыми остатками по 7 и 11. И так далее.

Но это лишь какие числа точно не будут выбиты. Остальные числа будут выбиты той или иной комбинацией остатков по всем используемым модулям. Но разумеется не целиком все. Потому что например для 19-252 после учёта 3# из 108 чисел остаются лишь 24 никогда не выбиваемых, после ещё и 5# лишь 8, после и 7# лишь 2, а после и 11# никогда не выбиваемых чисел не остаётся вовсе - но ведь чистые комбинации не появляются на 11#! Так что пользы от такой величины (никогда не выбиваемые за несколько шагов числа) не улавливаю.

[Yadryara]

Dmitriy40 в сообщении #1637066 писал(а):

Маска - это просто удобный короткий способ кодирования списка элементов массива a[].

Ещё нужно (возможно так же) закодировать массив v[], то есть паттерн. Но у меня всё руки не дойдут разобраться с этими командами. А Вы в них прекрасно разбираетесь.

Dmitriy40 в сообщении #1637066 писал(а):

В vc[] накапливаем число вариантов расстановки чисел в массиве a[] заданной длины.

Опечатка? Разве Вы их не в ww[] накапливаете?

Dmitriy40 в сообщении #1637066 писал(а):

Если спросить есть ли числа в a[], которые не выбиваются вообще ни одним из допустимых остатков по какому-то модулю, то да, такие числа есть.

Ну вот меня как раз интересовало какие же есть ограничения на $e$. Этой буквой я уже давно обозначаю количество нетронутых кортежей.

Возвращаюсь ещё раз:

vicvolf в сообщении #1634928 писал(а):

Если кортеж при переходе на следующий шаг вычеркивается полностью, то зачем определять, какие элементы в нем вычеркнуты?

Dmitriy40 в сообщении #1634744 писал(а):

Непонятно почему 47# для 9-96 не окейная, ведь a[]=[2,...,94] и 47 в него дважды попасть всё равно не может ... Как и 41# для диаметров 84.

Что происходит пр переходе от $p_i\#$ к $p_{i+1}\#$? Использование старого $vc_i$ для вычисления нового $vc_{i+1}$.

Причём есть различные подходы и отличие в самом начале.

1. Можно умножить $vc_i$ на $p_{i+1}-\#v$.
И затем смотреть, какие грязные числа вычёркиваются (выбиваются).

2. Можно умножить $vc_i$ на $p_{i+1}$.
И затем смотреть, какие чистые и грязные числа выбиваются.

Я использую и 1-й, и 2-й подходы, а Dmitriy40 пока только 1-й.

Дело в том, что в общем количестве кортежей равном $vc_ip_{i+1}$ есть определённое количество чистых $c$ и грязных $g$ чисел. Причём количество таких чисел известно. И при переходе от $p_i\#$ к $p_{i+1}\#$ строго определённое количество этих чисел выбивается. Чистых чисел выбивается столько:

$$c1+cg= vc_i\#v$

, а грязных столько

$$g1+2g2+cg= vc_i(L-\#v)$

[Yadryara]

Видите? В нижнем уравнении для количества грязных присутствует $cg$.

Да, конечно можно вычесть из одного уравнения другое и избавиться от $cg$. Но тогда появится $c1$. Хрен редьки не слаще: другая переменная (а значит и другой массив) с чистыми числами теперь вклинилась.

Или слаще? Может и не нужно $cg[]$ вычислять, а только $c1[]$, который для краткости именовать просто $c[]$. Но и в этом случае вроде бы нужна проверка не по избранным, а по всем остаткам.

Yadryara в сообщении #1636978 писал(а):

Эти 10 остатков повели себя так:

ost     1       2       4       5       6       7       9      10      11     12

46230:  0       1       0       1       0       1       2       1       1      0
26925:  1       0       0       1       1       2       1       0       1      0

Вот здесь, например, надо смотреть не на $2\cdot10=20$ кортежей, а на $2\cdot13=26$.

И это, видимо, позволит вычислить 3-й массив, $c[]$ или $cg[]$. А зачем он нам?

Dmitriy40 в сообщении #1637008 писал(а):

Один шаг не интересен,

Вот именно что один шаг не позволяет решить главную задачу с 19-252. Надо каким-то образом добраться до нужным формул и на каждом шаге вычислять 3 новых массива по 3-м старым. Тогда можно будет идти от $\frac16$ диаметра, хотя так рано стартовать и не нужно.

Но как до них добраться-то? Для начала получить большое количество исходных данных, чтоб было в чём разбираться.

Для массива $vc[]$ у нас данных полным-полно. $g2[]$ научились быстро и просто считать вчера. Остался ещё один массив.

v=[0, 30, 60]

g2 = [0, 0, 0, 0,  0,   0,    0,     0,     0,     0,     0,   20,  48]; \\  7# --> 11#

g2 = [0, 0, 0, 0,  0,   0,    0,     0,     0,    26,   132,  178,  44]; \\ 11# --> 13#

g2 = [0, 0, 0, 0,  0,   0,    0,     6,   156,   608,  1126,  500,  84]; \\ 13# --> 17#

g2 = [0, 0, 0, 0,  0,   2,  112,  1046,  4748,  9110,  7374, 2560, 376]; \\ 17# --> 19#

g2 = [0, 0, 0, 0, 16, 252, 3174, 17246, 48192, 65644, 38108, 8244, 564]; \\ 19# --> 23#

Господа математики! Вы видите как из одной строчки получать другую? Понятно, что нужно при переходе умножать на $p-x$ и делать что-то ещё...

[Dmitriy40]

Yadryara в сообщении #1637074 писал(а):

Опечатка? Разве Вы их не в ww[] накапливаете?

Нет: в vc[] различия только по длине (остальное свёрнуто в сумму), а в ww[] ещё и по содержимому (список всех уникальных комбинаций). Но разумеется vc[k]=vecsum(ww[k][..][1][2]), потому vc[] считается только при выводе на экран, а в процессе счёта достаточно и ww[].

Yadryara в сообщении #1637074 писал(а):

Ещё нужно (возможно так же) закодировать массив v[], то есть паттерн.

Думал над этим: можно удлинить массив a[] до полных 127 (v[#v]/2+1) элементов, прямо всех чётных с 0 по v[#v] (точнее просто не удалять из него v[]). И проверять все остатки 0..p-1, включая и запрещённые. Только смысла в этом не увидел: запрещённые остатки не выбивают числа из a[]. Тогда зачем их обрабатывать и удлинять a[]? Неясно.

Yadryara в сообщении #1637074 писал(а):

Но у меня всё руки не дойдут разобраться с этими командами.

Непонятно с bitand и hammingweight - расскажите логику работы в терминах списка чисел в a[], какие оставались, какие удаляются, какие остаются. Для разности двух массивов (сортированных) есть команда setminus.
Если надо я могу переписать последнюю программу в терминах списков, просто хранить в ww[][][1] не маску, а массив. Будет медленнее, займёт намного больше памяти (раза в три), но работать будет.

Yadryara в сообщении #1637074 писал(а):

Что происходит пр переходе от $p_i\#$ к $p_{i+1}\#$? Использование старого $vc_i$ для вычисления нового $vc_{i+1}$.

Я по прежнему думаю что для неокейных строк невозможно получить $vc_{i+1}$ из $vc_i$ без дополнительной информации какие конкретно варианты загрязнений дали $vc_i$ (т.е. без знания ww[]). Отсюда есть лишь одно исключение: vc[0] (число чистых) можно получить из предыдущего vc[0..1] когда ww[1] уже стало равно всем возможным вариантам и ни одна многозубая вилка (больше одного зуба) не срабатывает ни для одного из ww[2..], в этом случае для них работает Ваша формула для окейных строк. Но уже для получения vc[1] из vc[1..2] так не работает - в ww[2] обычно не все возможные варианты, я привёл примеры выше. Можно ли эту информацию, каких вариантов недостаёт в ww[2..], получить из списка запрещённых остатков - я не знаю, это очень хороший вопрос.

Yadryara в сообщении #1637076 писал(а):

$g2[]$ научились быстро и просто считать вчера. Остался ещё один массив.

Почему бы не сделать по аналогии с g2[]? Вместо if(u==2,g2[l]+=xx[1][2]); сделать if(u==1,c1g1[l]+=xx[1][2]);?

Yadryara в сообщении #1637074 писал(а):

есть определённое количество чистых $c$ и грязных $g$ чисел

Yadryara в сообщении #1637074 писал(а):

$c1+cg= vc_i\#v$

Я не понимаю, здесь в формуле $cg$ это массив, число или произведение двух указанных выше чисел? Вам что, букв мало?

-- 22.04.2024, 14:43 --

Yadryara в сообщении #1637076 писал(а):

Господа математики! Вы видите как из одной строчки получать другую? Понятно, что нужно при переходе умножать на $p-x$ и делать что-то ещё...

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

И скорее всего понадобится ещё и не показанный массив vc[], в котором зависимости аналогичны.

-- 22.04.2024, 14:54 --

Yadryara в сообщении #1637076 писал(а):

Тогда можно будет идти от $\frac16$ диаметра, хотя так рано стартовать и не нужно.

Очень даже нужно: для 19-252 на PARI можно посчитать ww[] (а соответственно вероятно и ваши c1g1[] и g2[]) только для 41# или с большим трудом для 43#, не дальше, как раз 1/6 диаметра. Получится ли посчитать c1g1[] и g2[] для больших простых пока неясно, ww[] точно не удастся (на PARI, на асме можно попробовать 47# или даже 53#, но это писанины кода на месяц).
Мне кажется Вы забываете что я посчитал по 67# только vc[], из которого получить c1g1[] или g2[] по моему невозможно, у Вас они (g2[], про c1g1[] вообще пока непонятно) считаются по ww[], не vc[].

[Yadryara]

Dmitriy40 в сообщении #1637098 писал(а):

Я не понимаю, здесь в формуле $cg$ это массив, число или произведение двух указанных выше чисел?

Элемент массива cg:

Yadryara в сообщении #1636934 писал(а):

Кстати c1g1 я теперь именую просто cg.

$c1_l+cg_l= vc_l\#v$

Где $l$ — длина кортежа. Формулы можно проверить по большой схеме для паттерна 3-36, взяв конкретные числа.

Dmitriy40 в сообщении #1637098 писал(а):

Почему бы не сделать по аналогии с g2[]? Вместо if(u==2,g2[l]+=xx[1][2]); сделать if(u==1,c1g1[l]+=xx[1][2]);?

Ну тут-то у меня полный порядок с обозначениями! Единственное что Вы сделали — заменили 2-ку на 1-цу. Значит, что Вы получите вместо g2 ? Конечно g1 ! Тоже можно проверить по большой схеме.

Говорю же, надо смотреть запрещённые остатки чтобы вычислить cg.

Dmitriy40 в сообщении #1637098 писал(а):

Только смысла в этом не увидел: запрещённые остатки не выбивают числа из a[]. Тогда зачем их обрабатывать и удлинять a[]? Неясно.

Говорю же, надо смотреть запрещённые остатки чтобы вычислить cg.

[Yadryara]

Yadryara в сообщении #1637100 писал(а):

Говорю же, надо смотреть запрещённые остатки чтобы вычислить cg.

Причём только их и надо смотреть. Если удлините a[], думаю достаточно будет пройтись только по запрещённым с той же проверкой: if(u==2,cg[l]+=xx[1][2]);

Dmitriy40 в сообщении #1637098 писал(а):

Я по прежнему думаю что для неокейных строк невозможно получить $vc_{i+1}$ из $vc_i$ без дополнительной информации

Согласен. Вот её и нужно добыть.

Dmitriy40 в сообщении #1637098 писал(а):

Очень даже нужно: для 19-252 на PARI можно посчитать ww[] (а соответственно вероятно и ваши c1g1[] и g2[]) только для 41# или с большим трудом для 43#, не дальше, как раз 1/6 диаметра.

Согласен. Достаточно для 41#. Для 43# необходимости не будет, если только найдутся формулы. Разве что для проверки.

Dmitriy40 в сообщении #1637098 писал(а):

И скорее всего понадобится ещё и не показанный массив vc[], в котором зависимости аналогичны.

Все 3 массива понадобятся, Вы же видели как формула усложнилась. К двум старым слагаемым добавились 5 новых:

vc[i] =

(p-i)*vc[i] + (i-cm+1)*vc[i+1]
+   c1g1[i] -        c1g1[i+1]
+     g2[i] -        2*g2[i+1] + g2[i+2] 

[Dmitriy40]

Yadryara в сообщении #1637103 писал(а):

Dmitriy40 в сообщении #1637098 писал(а):

И скорее всего понадобится ещё и не показанный массив vc[], в котором зависимости аналогичны.

Все 3 массива понадобятся, Вы же видели как формула усложнилась.

Я имел в виду что для вычисления даже только g2[] понадобится и vc[] тоже (хотя как обойтись без ww[] или перебора sum вариантов я не понимаю).
На месте математиков я бы отказался решать столь недоформулированную задачу. И отсылки мол на 29 страницах темы всё есть - не покатят.

-- 22.04.2024, 18:50 --

Yadryara в сообщении #1637100 писал(а):

$c1_l+cg_l= vc_l\#v$
Где $l$ — длина кортежа.

Почему тогда в формуле #v, а не l если это одно и то же?!

[Yadryara]

Dmitriy40 в сообщении #1637110 писал(а):

Я имел в виду что для вычисления даже только g2[] понадобится и vc[] тоже

Я понял. И дополнил.

Dmitriy40 в сообщении #1637110 писал(а):

(хотя как обойтись без ww[] я не понимаю).

Я и не говорил что надо без чего-то обходиться.

Паттерн 3-36. Сработает ли способ, если а[] расширить до предела, то есть до 19-ти, а затем проверить только 3 запрещённых остатка?

Dmitriy40 в сообщении #1637110 писал(а):

Почему тогда в формуле #v, а не l если это одно и то же?!

Это не одно и то же. #v это количество чистых в кортеже, то есть $l_{min}$. A $l$ — величина переменная и гуляет от $l_{min}$ до максимально загрязнённого $l_{max}$.

[Dmitriy40]

Yadryara в сообщении #1637111 писал(а):

Паттерн 3-36. Сработает ли способ, если а[] расширить до предела, то есть до 19-ти, а затем проверить только 3 запрещённых остатка?

Понятия не имею. Даже что конкретно надо посчитать и что должно получиться. Не понимаю что значит "проверить запрещённые остатки".
Возьмите бумажку, напишите все 37 исходных чисел 0..36 в a[] (включая и нечётные!) и попробуйте для 2# получить vc[16]=1 (нумерация с нуля, это чистые) и что там Вам ещё нужно. Потому что я не понимаю как обрабатывать запрещённые остатки, а уже для 2# такой один.

[Yadryara]

Dmitriy40 в сообщении #1637120 писал(а):

Даже что конкретно надо посчитать и что должно получиться.

Получиться должны известные значения cg для трёх p#:

Yadryara в сообщении #1634873 писал(а):

\\vc   = [0,0,0,0,0,0,0,2,12,0,2];                      16          7#
\\c1g1 = [0,0,0,0,0,0,0,2, 6,0,0];                       8
\\  g2 = [0,0,0,0,0,0,0,2, 8,0,2];                      10


\\vc   = [0,0,0,0,0,2,12,60,40,12,2];                  128         11#
\\c1g1 = [0,0,0,0,0,2, 6,38,26,10,2];                   84
\\  g2 = [0,0,0,0,0,0, 2,12,12, 8,2];                   36


\\vc   = [0,0,0,0,6,66,330,548,258,64,8];        \\     1280       13#
\\c1g1 = [0,0,0,0,2, 8, 76,118,114,52,8];         \\     378
\\  g2 = [0,0,0,0,0, 0,  0,  0,  0, 0,0];

Dmitriy40 в сообщении #1637120 писал(а):

Потому что я не понимаю как обрабатывать запрещённые остатки, а уже для 2# такой один.

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

[Dmitriy40]

Yadryara в сообщении #1637122 писал(а):

Возможно ли придумать какую-то инверсию, чтобы запрещённые считать разрешёнными? И наоборот.

Это то легко: в am=...(t+i)%p>0 меняем знак на противоположный (==) и всё. Вот только что в результате получится я не понимаю.
Вот был полный список всех чисел, включая и нечётные. Обработка допустимых остатков по модулю 2 оставляет от него список чётных чисел, причём не равных v[] - т.е. фактически исходный массив a[]. А что будет при обработке запрещённых остатков? Логика подсказывает что останутся как минимум все нечётные числа, плюс все числа из v[] (для 3-36):
0, 1, 3, 5, 7, 9, 11, 13, 15, 17, 18, 19, 21, 23, 25, 27, 29, 31, 33, 35, 36.
Это точно так и должно быть? Ладно, по модулю 3 запрещён только один остаток, нулевой, т.е. в списке останутся только кратные 3 нечётные числа плюс все числа из v[] (они тоже кратные):
0, 3, 9, 15, 18, 21, 27, 33, 36.
По модулю 5 запрещены остатки 0, 2, 4, т.е. из одного списка получится три разных, в которых останутся числа имеющие остаток 0 или 2 или 4 по модулю 5:
0, 15.
27.
9.
По модулю 7 запрещены остатки 0, 3, 6, из трёх списков должны получиться 9 списков:
[0, 15] -> [0], [], [].
[27] -> [], [], [27].
[9] -> [], [], [].
И? Что со всем этим делать-то? Где тут c1g1[] или g2[]?
И кстати я что-то совсем не уверен в правильности всех переходов.

Yadryara в сообщении #1637122 писал(а):

Детально я расписать не могу, трудно понять Вашу прогу.

Так не надо про неё, расскажите просто про списки чисел, вот как я выше.

[Yadryara]

Dmitriy40 в сообщении #1637125 писал(а):

А что будет при обработке запрещённых остатков? Логика подсказывает что останутся как минимум все нечётные числа, плюс все числа из v[] (для 3-36):
0, 1, 3, 5, 7, 9, 11, 13, 15, 17, 18, 19, 21, 23, 25, 27, 29, 31, 33, 35, 36.
Это точно так и должно быть?

Да, нужны числа из v[], но вместе с чётными. Нечётные в топку.

Yadryara в сообщении #1637100 писал(а):

Единственное что Вы сделали — заменили 2-ку на 1-цу. Значит, что Вы получите вместо g2 ? Конечно g1 !

И с нулём тоже работает, так что заменил $e$ на $g0$.

if(u==0,g0[l]+=xx[1][2]);
if(u==1,g1[l]+=xx[1][2]);
if(u==2,g2[l]+=xx[1][2]);

Вот ещё формулы есть:

$c1 _l+ cg _l+ g2 _l+ g1 _l+ g0 _l = vc_l^{old}p$

$g2_{l+2}+ g1_{l+1}+ g0_l = vc_l^{new}$

По этой схеме их уже гораздо легче проверить.

Pattern                                   0, 18, 36
                     vc_7#                                            vc_5#  L

                         0 =  4*0 + 1*0                                      3
                                             
                         0 =  3*0 + 2*0                                      4
            
                         0 =  2*0 + 3*0                                      5
        
                         0 =  1*0 + 4*0          
                                         
                         0 =  0*0 + 5*0                   + 0    

                         2 = -1*0 + 6*0     - 0     - 2*0 + 2      
    c1  cg  g2  g1  g0
                        12 = -2*0 + 7*2 + 0 - 4 + 0 - 2*2 + 6   

3/6  0   0   0   0   0   0 = -3*2 + 8*2 + 4 - 4 + 2 - 2*6           0/7 = 0

3/7  2   4   2   6   0   2 = -4*2       + 4     + 6                14/7 = 2
   
3/8  2   4   6   0   2                                             14/7 = 2
_____________________________________________________________________
     8   4   8   6   2                                             28

[Dmitriy40]

Yadryara в сообщении #1637134 писал(а):

но вместе с чётными. Нечётные в топку.

А почему? То что нас обычно интересуют лишь чётные - не директива бога, а продукт обработки одного разрешённого остатка по модулю 2. Если Вы хотите работать с запрещёнными остатками, то пожалуйста, но по модулю 2 тогда получите нечётные числа вместо чётных. Где-то тут у Вас пробел в логике. Точнее я не понимаю чего Вы хотите.

Yadryara в сообщении #1637134 писал(а):

И с нулём тоже работает, так что заменил $e$ на $g0$.

Ну разумеется работает. Вы же просто считаете на сколько уменьшается загрязнение. Только что с того? Вы понимаете что даже один и тот же грязный вариант с l=10 при уменьшении загрязнения на 2 до l=8 может дать (и реально даст) два разных грязных варианта? И соответственно на следующем шаге они будут давать разное уменьшение загрязнения даже для одного и того же остатка? А вы их в g2[] уже не различаете - и как будете учитывать что на следующем шаге один должен g1[] увеличить, а другой g2[]? Т.е. Вы пытаетесь свернуть всё множество вариантов ww[l] в два-три массива, но простите по моему это невозможно. Даже на два шага, не говоря уж про большее количество. На один шаг да, по ww[] можно понять как будет меняться vc[] на следующем шаге. Ну так мои программы именно это и делают, только первая (на базе ещё Вашей) останавливается на модуле 13#-41# (для разных паттернов) и дальше идёт просто перебор всех вариантов комбинаций разрешённых остатков, а вторая пытается не остановиться и досчитать ww[] до конца (окейной строки).
Т.е. ещё раз, я думаю что предсказать vc[] на два шага в принципе невозможно без информации ww[], по хоть 10 вашим массивам cg[] и gX[], именно потому что каждая добавленная в g2[] (да и остальные gX[]) единица на следующем шаге пойдёт каждая своим путём,, т.е. они не одинаковы, и надо следить за каждой, а не только за их суммой (количеством). А на один шаг достаточно одного массива - просто разности d[]=vc_new[]-vc_old[]*p. И как её рассчитывать лишь по vc_old[] не интересно, проще просто перебрать остатки и получить сразу vc_new[].
Формулы же для окейных строк нарушают это правило непредсказуемости и работают только потому что к тому моменту мы уже перечислили все возможные пути как могут пойти любые грязные варианты и новых не возникает, именно поэтому где сколько убыло, в другом месте (и точно известно в каком) столько же добавится. Но для не окейных строк это нарушается, грязные варианты появляются новые, мало, но появляются. И потому следить нужно не только за общим количеством вариантов (vc[] и ваши массивы), но и за каждым отдельно (ww[]). И по моему это принципиально.