Це виклик копів та грабіжників. Це нитка розбійника. В нитка поліцейського тут .

Поліцейські виберуть будь-яку послідовність із OEIS і напишуть програму p, яка друкує перше ціле число з цієї послідовності. Вони також знайдуть деякі рядки s . Якщо ви десь вставите s в p , ця програма повинна надрукувати друге ціле число з послідовності. Якщо ви вставите s + s в те саме місце в p , ця програма повинна надрукувати третє ціле число з послідовності. s + s + s в тому самому місці буде друкувати четверте, і так далі, і так далі. Ось приклад:

Python 3, послідовність A000027

print(1)

Прихований рядок - два байти .

Рядок є +1, оскільки програма print(1+1)надрукує друге ціле число в A000027, програма print(1+1+1)надрукує третє ціле число тощо.

Копи повинні розкрити послідовність, оригінальну програму p та довжину прихованої рядки s . Грабіжники розтріскують подання, знаходячи будь-який рядок до цієї довжини та місце, де його вставити, щоб створити послідовність. Рядок не повинен відповідати призначеному рішенню, щоб бути дійсним тріском, а також розташуванню, в яке він вставлений.

Якщо ви зламаєте одну з відповідей поліцейських, опублікуйте своє рішення (із виявленим прихованим рядком та місцем розташування) та посиланням на відповідь. Потім прокоментуйте тут відповіді поліцейських із посиланням на вашу тріщину.

Правила

• Ваше рішення повинно працювати для будь-якого числа в послідовності, або принаймні до розумного обмеження, коли воно не вдається через обмеження пам'яті, переповнення цілого / стека тощо.

• Розбійник-переможець - це той користувач, який тріщить більшість матеріалів, і тим самим той, хто першим дійшов до цієї кількості тріщин.

• Виграючий коп - це поліцейський з найкоротшим рядком , який не тріщиться. Tiereaker - найкоротший p . Якщо немає неподілених подань, поліцейський, який мав рішення, що не було розірвано, виграє найдовше.

• Для того, щоб оголосити його безпечним, ваше рішення повинно залишатися нерозкритим протягом 1 тижня, а потім відкрити приховану рядок (і місце для її вставки).

• s може не бути вкладеним, він повинен об'єднатись у кінець. Наприклад, якщо s був 10, кожна ітерація буде йти , 10, 1010, 101010, 10101010...а не10, 1100, 111000, 11110000...

• Усі криптографічні рішення (наприклад, перевірка хешу підрядки) заборонені.

• Якщо s містить будь-які символи, що не належать до ASCII, ви також повинні вказати кодування, яке використовується.

Python 2 , послідовність A138147 від xnor

Оригінал:

print 10

Тріщини:

print "1%s0"%10
      ^^^^^^^

Спробуйте в Інтернеті!

Brain-Flak , A000984 від Nitrodon

({({}<>({}))<>}<>){({}<>)<>}<>

Це лише 30 байт, не впевнений, що мав на увазі Нітродон.

Спробуйте в Інтернеті!

Пояснення

Я спробував багато речей, але ось, що спрацювало. Умови A000984 є центральними елементами трикутника Паскаля.

Тепер я зрозумів, що я можу їх отримати, додавши діагоналі над ними:

Наприклад:

$1+3+6+10 = 20$

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

Отже, ми хочемо, щоб програма, яка бере одну часткову суму, і виробляла наступну. На щастя, є досить акуратний спосіб дістатися від одного з них до іншого. Кожен рядок - дельти наступного ряду. Тобто $n$ й член підряд є різницею між $n$ м і $n-1$ м членами в наступному рядку.

Одна з проблем полягає в тому, що нам не вистачає останнього рядка, щоб обчислити потрібний ряд. Оскільки кожен рядок на один довший, ніж останній, якщо у нас є рядок, ми не можемо отримати останнього члена наступного рядка за допомогою цього методу. Однак тут у нас є ще одна хитрість, останній член кожного ряду дорівнює всім попереднім членам цього ряду!

$1+3+6=10$

І якщо ви знайомі з Brain-Flak, це повинно прилягати до вас як до чогось, що робити буде дуже просто.

Тепер про код:

Для початку робимо розрахунок наступного ряду, де кожен новий член - це сума двох сусідніх старих членів. Це можна зробити за допомогою:

{({}<>({}))<>}<>

Що в основному переміщує елемент і додає (без видалення) те, що коли-небудь вже було до нього. Однак це перевертає все, тому наступного разу ми отримуємо рядок, який нам потрібно повернути.

{({}<>({}))<>}<>{({}<>)<>}<>

Тепер нам потрібно обчислити останній член ряду. Як я вже говорив, це дуже просто. Оскільки у нас була петля над усіма елементами рядка, ми можемо просто взяти цю суму і натиснути її. Просуваємо її перед другою петлею, щоб вона закінчилася на дні.

({({}<>({}))<>}<>){({}<>)<>}<>

І це все.

Мозг-Флак, A000290 , шріотчілізм О'Заїк

Оригінал:

((()))({}<>)

Тріщини:

((()))({}([])[]<>)
         ^^^^^^

Спробуйте в Інтернеті!

Як варіант:

((())([])[])({}<>)
     ^^^^^^

Спробуйте в Інтернеті!

MATL , послідовність A005206 від Луїса Мендо

Оригінал:

voOdoO

Спробуйте в Інтернеті!

Тріщини:

voOdoOdNq17L/k
      ^^^^^^^^

Я не експерт MATL, але, наскільки я розумію, оригінал voOdoOстворює два порожніх масиви та масив [0]на стеці. це [0]те, що друкується без дужок як перший елемент послідовності. Тріщина / розчин виконує наступне:

• dзнімає елементи з стека і (припускаючи, що це число або масив розміром 1) перетворює його в порожній масив. Ці порожні масиви не друкуються, але сприяють розміру стека
• Nqпідраховує розмір стека і віднімає один. Це n+1термін при оцінці функції (оскільки вона починається з 2 і збільшується на кожну ітерацію через dдодавання невидимих ​​речей до стеку)
• 17L це константа Phi = (1+sqrt(5))/2
• /kце виконує, floor((n+1)/Phi)що є однією з формул, яка обчислює елементи послідовності. Ця формула вказана на OEIS, оскільки a(n) = floor(sigma*(n+1)) where sigma = (sqrt(5)-1)/2ми використовуємо ідентичність(sqrt(5)-1)/2 = 1/Phi

Пітон 3 - A__

print(100+-1)

Спробуйте в Інтернеті!

100 пляшок пива, додайте, -1щоб отримати наступне число 99тощо.

Кег , послідовність A000045 , автор A__

Оригінал:

0.

Тріщини:

01":&+.
 ^^^^^

Зауважте, що викликом було знайти підрядку довжиною <= 6, але знайдена рядок має довжину 5.

Визначення команд для тих, хто лінивий шукати специфікацію Keg: 0і 1натисніть відповідне число до стеку; "переміщує вершину стека до нижньої частини стека (рулон); &вискакує стек зверху в регістр, якщо він порожній, інакше випирає регістр у стек; +додає два найбільші значення стека.

Початковий 1"просто вставляє 1 у нижній частині стека. Цей зростаючий список "1" відіграє лише важливу роль у першій ітерації, де він дозволяє припустити, що стек починається 1 0не просто, а просто 0. Дійсно, програма10:&+. , де:&+ частина повторюється, має таку саму поведінку, що і рішення вище, за винятком того, що в ній немає списку, що зростає, 1.

Оскільки &використовується лише один раз у повторюваній частині та має чергування поведінки, поведінка 1":&+A залежить від паритету ітерації.

Тепер ця програма насправді не друкує послідовність послідовностей Фібоначчі, починаючи з 0, 1 з самого початку; він фактично друкує послідовність Фібоначчі 1, 0 з другого місця, тобто з 0. (Це призводить до тієї ж послідовності.) Знаючи це, програма легко аналізується:

• У першій, третій, ... ітерації, стан починається як [a, b]і закінчується якa+b (&=b) .
• У другій, четвертій, ... ітерації, стан починається як [b] (&=a)і закінчується як [b, b+a].

Це дійсно обчислює послідовність у міру необхідності.

Java 8+, послідовність A010686 Бенджаміна Уркхарта

()->System.out.println(1^4);
                        ^^

Мозг-Флак, A000578 від шріотчілізму О'Заїка

Оригінал:

((())<>)

Спробуйте в Інтернеті!

Тріщини:

((())(({})([][][]){})<>)
    ^^^^^^^^^^^^^^^^

Спробуйте в Інтернеті!

Пірет , послідовність A083420 , М.Л.Аврентьєв

fold({(b,e):(2 * b) + 1},1,[list: 0,0,])
                                  ^^^^

Ви можете запустити його тут, але я не зрозумів, як пов’язати код. Вам доведеться скопіювати та вставити.

Надана функція ігнорує свій другий аргумент. Він подвоює свою першу і додає одну, яка генерує необхідну 2^n - 1послідовність, необхідну тут - все, що мені потрібно зробити, - це сказати, скільки разів виконати цю операцію, виконану шляхом зміни довжини складеного списку. На щастя, Пірет не скаржиться на цю кінцеву кому.

Python 3 , послідовність A268575 від NieDzejkob

Оригінал:

from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW")
print(len(W))

Зламаний (100 байт):

from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW");A=-1,1,0;*X,=F(lambda a:(S(a,x)for x in product(A,A)),W);W={p for p in X if 2<X.count(p)<4+({p}<W)}
print(len(W))

Спробуйте в Інтернеті!

З того, що я можу зібрати, оригінальний код - це визначення визначень, щоб зробити прихований рядок якомога скороченим, а потім визначити початковий зразок гри життя. Потім прихований рядок еквівалентний написанню ітерації гри Життя Конвея в 102 байтах.

Для цілей цього тріщини S- це функція, яка підсумовує елементи в своїх аргументах (які є ітерабельними) і Fзастосовує функцію, що повертає ітерабельний елемент до кожного елемента списку і розбиває всі результати разом.

• ;A=-1,1,0;закінчує попереднє твердження і скорочує кортеж (-1,1,0) символом A, який використовується таким чином, product(A,A)що дає всі сусіди відносно даної комірки, а також саму клітинку.
• *X,=F(lambda a:(S(a,x)for x in product(A,A)),W);створює новий список, що Xмістить усіх сусідів комірок Wі самих комірок W, додаючи відносні позиції сусідів до кожної комірки та розбиваючи їх разом до списку.
• W={p for p in X if 2<X.count(p)<4+({p}<W)}проходить цей список Xі визначає, чи Xналежить кожна комірка в наборі комірок при наступній ітерації. Це було взято майже дослівно з цієї гри в гольф гри .

Haskell, A014675 від Khuldraeseth na'Barya

Оригінальний код

main=print$uncurry(!!)([2],0)

З підрядком

main=print$uncurry(!!)                                   ([2],0)
                      $(\(a,n)->(a>>= \e->2:[1|e>1],n+1))

Спробуйте в Інтернеті!

Настільний калькулятор, A006125 , автор A__

Оригінал:

1n

Тріщини:

1 2lx1+dsx^*n
 ^^^^^^^^^^^

Спробуйте в Інтернеті!

Безпосередня реалізація.

cQuents , послідовність A003617 by Stephen

=10#2:pZ
  ^

Спробуйте в Інтернеті!

Почніть з найнижчого n + 1-значного числа, з якого слід n нулів. В #2вказує , що тільки другий член послідовності, яка є визначення послідовності застосовується один раз до насіння, будуть надруковані; це визначення послідовності просто знаходить і повертає наступний прайм.

Python 3 - аґтовер

from sympy import isprime, primerange
from itertools import count
r=1
r+=1
while isprime(r-2)or r&1<1and r>3:r+=1
print(r)

Спробуйте в Інтернеті!

MATL , послідовність A000796 від Луїса Мендо

Оригінал:

'pi'td1_&:_1)Y$J)

Спробуйте в Інтернеті!

Тріщини:

'pi'td1_&:|SQ_1)Y$J)
          ^^^

Оригінальний автор підступно створив масив, [-7:-1]а потім вилучив і заперечив перший елемент його отримання 7. Потім він використав це для отримання округлої 7-ї цифри pi (що є 3) і подав її як першу цифру pi. Додавання |SQробить оригінальний масив усім позитивним, сортує його та додає один до всього. Це означає, що після всього, а не отримання індексу, 7він отримує індекс -2після однієї програми, -3після двох додатків тощо. Це -важливо, оскільки воно вказує на Y$функцію не округляти цифри.

Forth (gforth) , A000042 , автор NieDzejkob

.( 1)1 .
^^^^^

Спробуйте в Інтернеті!

Тривіальний 1-байт - це просто розширення прямого. Проблема полягає в тому, що переповнюється 64 біта вже на дев'яту цифру. Просте виправлення полягає в тому, щоб надрукувати однозначну цифру повторно, правда? Так, але це не так просто. Хоча торцювання 1 .до кінця дійсно надрукує необхідні нам додаткові цифри, вони будуть розділені пробілами. Це не спрацює.

Тепер, згідно з Вікіпедією, " .((dot-paren) - це негайне слово, яке розбирає обмежений в дужках рядок і відображає його". На щастя, у зображенні немає інших дивних символів, тому використання .(для друку одного 1 має бути достатньо. І це робить. Після закритого батьків не потрібно місця, тому ці п’ять символів (є пробіл після відкритих батьків) можуть бути повторені змістом нашого серця. Щоб продемонструвати, я включив у TIO приклад, який би кілька разів переповнював 64-бітний int. Працює як шарм.

Unefunge-98 (PyFunge) , послідовність A000108 , автор NieDzejkob

1# 2g1+:2p4*6-*2g/.@
 ^^^^^^^^^^^^^^^^^

Спробуйте в Інтернеті!

Повторювали шість разів

Дозволено два байти з дев'ятнадцяти! Пробілом, що представляється, є насправді символ 0x01 Start Of Header.

Пояснення:

Ця проблема все про генерацію a(n)від a(n-1)і , можливо n. OEIS пропонує чітку формулу a(n) = (2n)!/(n!(n+1)!), в яку досить легко перетворитисьa(n) = a(n-1) * (4n-6) / n . Тепер застосувати це у Funge.

Я повинен вставляти код між 1і .. Це вже половина головоломки. Залишилося лише який код вставити? Funge помітно бракує інструментів для маніпулювання стеком, тому нижня частина стека є поза межами; Мені потрібно відстежувати і те, nі a(n)не зростаючи стек. І як краще це зробити, ніж з простором Funge?

Цей символ 0x01 - мій лічильник n. Я тримаюсь a(n)на стеці, як це має бути на стеці після того, як мій біт закінчує виконання.

1# 2g1+:2p4*6-*2g/.@
1                       Push 1. This is a(0).
 #                        Skip the next instruction. Without this, I believe the instruction pointer will reverse direction upon encountering 0x01.
   2g                     Push the third character in the source, which starts out as 1.
     1+                   Increment it...
       :                  ...copy it...
        2p                ...and put it back. One copy remains atop the stack.
          4*6-            Multiply by four. Subtract six.
              *           Multiply by a(n), leaving the result alone on the stack.
               2g         Push n again...
                 /        ...and divide our intermediate result by it. Ta-da!
                          At this point, the stack is the same as at the start of the indented block, except the one item has been advanced one place in the sequence.
                          The source of the program has changed; the third character holds the number of times this indented block has run.
                  .@    Print and terminate.

Python 3 , A008574 від tsh

print(1*2+2)
       ^^^^

Спробуйте в Інтернеті!

V, A000290 , автор DJMcMayhem

é*Ä2é*Ø.
  ^^^^

виходить квадрати з 1.

Спробуйте в Інтернеті!

База é*вставляє *та Ø.підраховує кількість символів, які не є новими рядками, у всьому буфері. Вставка Äдублює верхню лінію до власної лінії, на якій 2é*вставляється **. Сполучення вставок дають послідовні непарні числа з найбільшою вгорі. Фінальний Ø.по суті підсумовує перші n непарних чисел, отже, виходить n-й квадрат.

AsciiDots , послідовність A019523 від Alion

\ +++ /
// \ / \

Раз!

Двічі!

Десять разів!

Намагаючись розібратися, як працює код / ​​мова, я дізнався, що перші два рядки існуючого коду виконують всю роботу з виведення послідовності Фібоначчі нескінченно. Код припиняється, коли будь-яка точка потрапляє на &, тому мені просто потрібно було додати подальше затримку в решти рядків, щоб забезпечити виведення відповідної кількості записів.

Після деяких проб, помилок та спостережень я виявив, що правильний інтервал затримки - 16 одиниць часу на число. Вміст достатньої кількості символів в одному ряду видався нездійсненним, тому мені потрібно було б поставити затримку в 2 ряди, залишивши 10 символів для фактичної затримки. Для того, щоб візерунок відповідав собі, обидва ряди повинні були мати 5 символів, а оскільки середні три символи підряд можна пройти двічі, це дає 16 одиниць часу за бажанням.

Вимога, що відповідає цьому до &восьмої колонки, здавалося, зробила це неможливим, поки я не зрозумів, що можу почати з нового рядка в інтер'єрі третього ряду. Це робить передостанній ряд правильної довжини та видаляє тепер зайвий кінець третього рядка.

Брахілог , послідовність A114018 від непов'язаної струни

Оригінальна програма:

≜ṗ↔ṗb&w

Рядок для вставки:

≜ṗ↔ṗẹbb&w
    ^^

Спробуйте в Інтернеті!

Пояснення

Ось спочатку пояснення вихідної програми (знаючи, що використовувана послідовність є "найменше n-розрядним простим числом, чисте перевернення цифр також є простим")

≜         Assign an integer value to a variable named ? 
            (try 0, then 1, then -1, then 2, etc.)
 ṗ        ? must be prime
  ↔ṗ      The reverse of ? must be prime
    b     Remove the first element of ?
     &    Ignore that we removed that element
      w   Write ? to STDOUT

Як бачите, програма є досить простою, за винятком однієї речі: є абсолютно марний b - beheadвиклик предикатів, який видаляє перший елемент зворотного нашої кількості, з яким ми нічого не робимо.

Це певна підказка щодо того, як ми можемо знайти рядок. Ідея полягає в тому, що, оскільки ми хочемо збільшувати довжину числа на 1 цифру щоразу, коли ми додаємо рядок, нам потрібна рядок, який якось "оцінює" довжину цього числа, використовуючи цю марну b.

Рішення полягає у використанні ẹb: по-перше, ẹ - elementsперетворить число у список цифр; тоді b - beheadвидалить перший елемент. Хитрість полягає в тому, що bне вдасться, якщо список цифр порожній. Тож щоразу, коли ми додаємо,, bми збільшимо довжину необхідного числа на 1 (тому що воно буде невдалим, поки призначене значення не ?буде достатньо високим, щоб містити достатньо багато цифр, щоб остання bзастосовувалася у списку однієї цифри).

Повторне подання заявки ẹкожного разу не має ефекту, оскільки це вже список цифр. Нам він потрібен лише один раз на початку, тому що якщо ми обезголовимо число на зразок 9001списку його цифр, то отримаємо, 001 = 1що втрачає інформацію про кількість цифр.

VDM-SL , A000312 , За даними , що втратили чинність

let m={1|->{0}}in hd reverse[let x=x+1 in x**x|x in set m(1)&x<card m(1)]
                             ^^^^^^^^^^^^^

Оскільки -вираження VDM-SL letможуть повторно зв'язувати змінні, які вже пов'язані у x**xвкладеній області, їх можна оцінювати довільно глибоко вкладеними в області, в якихx на один більше, ніж у попередній області, в той час як оригінал xвсе ще менший, ніж простота m(1).

Haskell, A083318 від xnor

f=length     [2]
        $show

Спробуйте в Інтернеті!

Хаскелл , A000045 (Фібоначчі) , шляхом трансформації Фур'є Ріна

f = head $(flip(:)<*>sum.take 2)[0, 1]
         ^^^^^^^^^^^^^^^^^^^^^^^

Спробуйте в Інтернеті!

23 байти рівно.

Цей був веселий і трохи хитрий. Зворотні 0 і 1 трохи відкинули мене, перш ніж я зрозумів, що це не проблема. Відсутність $оригіналу змусила мене спробувати схематичні речі на кшталт $...$id(один байт занадто довгий), перш ніж воно зрозуміло мені, що я можу просто загорнути все це в дужки. Загалом, приємна маленька загадка.

H.PWiz вказує, що відповідність шаблону могла врятувати мене щонайменше на п'ять байт:$(\[x,y]->[y,x+y]) . Цей проклятий безпроблемний виклик змушує мене думати безглуздо.