To wyzwanie dla gliniarzy i rabusiów. To jest nić rabusia. W gwint policjanta jest tutaj .

Policjanci wybiorą dowolną sekwencję z OEIS i napiszą program p, który wypisze pierwszą liczbę całkowitą z tej sekwencji. Będą one również znaleźć kilka ciągów s . Jeśli wstawisz s gdzieś w p , ten program musi wydrukować drugą liczbę całkowitą z sekwencji. Jeśli wstawisz s + s w tej samej lokalizacji w p , ten program musi wydrukować trzecią liczbę całkowitą z sekwencji. s + s + s w tej samej lokalizacji wydrukuje czwartą itd. i tak dalej. Oto przykład:

Python 3, sekwencja A000027

print(1)

Ukryty ciąg ma dwa bajty .

Łańcuch jest taki +1, ponieważ program print(1+1)wypisze drugą liczbę całkowitą w A000027, program print(1+1+1)wypisze trzecią liczbę całkowitą itp.

Policjanci muszą ujawnić sekwencję, oryginalny program p oraz długość ukrytego ciągu s . Rabusie łamią przesłanie, znajdując dowolny ciąg znaków do tej długości i lokalizację, w której można go wstawić w celu utworzenia sekwencji. Ciąg nie musi być zgodny z zamierzonym rozwiązaniem, aby być poprawnym pęknięciem, podobnie jak lokalizacja, w której jest wstawiany.

Jeśli złamiesz jedną z odpowiedzi gliniarzy, opublikuj swoje rozwiązanie (z ujawnionym ukrytym ciągiem i lokalizacją) oraz link do odpowiedzi. Następnie skomentuj odpowiedź gliniarzy, podając link do twojego cracka tutaj.

Zasady

• Twoje rozwiązanie musi działać dla dowolnej liczby w sekwencji lub przynajmniej do rozsądnego limitu, w którym nie powiedzie się z powodu ograniczeń pamięci, przepełnienia liczby całkowitej / stosu itp.

• Zwycięski rabuś to użytkownik, który pęka najwięcej zgłoszeń, a remis jest tym, który pierwszy osiągnął taką liczbę pęknięć.

• Zwycięski gliną jest glina z najkrótszych ciągów s , który nie jest pęknięta. Tiebreaker to najkrótsza p . Jeśli nie ma żadnych niezrackowanych zgłoszeń, policjant, który miał rozwiązanie niesprawdzone dla najdłuższych zwycięstw.

• Aby zostać uznane za bezpieczne, rozwiązanie musi pozostać niezakłócone przez 1 tydzień, a następnie musi zostać ujawniony ukryty ciąg (i lokalizacja, w której należy go wstawić).

• s nie może być zagnieżdżony, musi być konkatenowany od końca do końca. Na przykład, jeśli ów był 10, każda iteracja pójdzie 10, 1010, 101010, 10101010...zamiast10, 1100, 111000, 11110000...

• Wszystkie rozwiązania kryptograficzne (na przykład sprawdzanie skrótu podłańcucha) są zakazane.

• Jeśli s zawiera znaki spoza ASCII, musisz również określić używane kodowanie.

Python 2 , sekwencja A138147 według xnor

Oryginalny:

print 10

Pęknięty:

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

Wypróbuj online!

Brain-Flak , A000984 firmy Nitrodon

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

To tylko 30 bajtów, nie jestem pewien, co Nitrodon miał na myśli.

Wypróbuj online!

Wyjaśnienie

Próbowałem wielu rzeczy, ale oto, co zadziałało. Warunki A000984 są centralnymi elementami trójkąta Pascala.

Teraz zorientowałem się, że mogę je zdobyć, sumując przekątne nad nimi:

Na przykład:

$1+3+6+10 = 20$

A ponieważ ostatnią czynnością w programie Nitrodon jest podsumowanie wszystkiego, wydawało się to dobrym kandydatem (bardziej jak próbowałem wielu rzeczy, ale ten skończył się działaniem).

Chcemy więc programu, który pobiera jedną sumę częściową, a tworzy następną. Na szczęście istnieje całkiem fajny sposób na przejście od jednego do drugiego. Każdy wiersz to delty następnego wiersza. To jest $n$ ty termin z rzędu to różnica między $n$ tym i $n-1$ terminem w następnym rzędzie.

Jedynym problemem jest to, że nie mamy dość ostatniego wiersza, aby obliczyć żądany wiersz. Ponieważ każdy wiersz jest o jeden dłuższy niż ostatni, jeśli mamy wiersz, nie możemy uzyskać ostatniego członka następnego wiersza za pomocą tej metody. Jednak tutaj mamy inną sztuczkę, ostatni członek każdego rzędu jest równy wszystkim poprzednim członkom tego rzędu!

$1+3+6=10$

A jeśli jesteś zaznajomiony z Brain-Flak, który powinien ci wystarczyć jako coś, co będzie naprawdę łatwe do zrobienia.

Teraz kod:

Aby rozpocząć, wykonujemy obliczenie następnego wiersza, w którym każdy nowy członek jest sumą dwóch sąsiadujących starych członków. Można to zrobić za pomocą:

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

Co w zasadzie przesuwa element nad i dodaje (bez usuwania) to, co już było na nim. Jednak wszystko to odwraca, więc następnym razem, gdy otrzymamy wiersz, musimy go odłożyć.

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

Teraz musimy obliczyć ostatniego członka wiersza. Jak powiedziałem wcześniej, jest to bardzo łatwe. Ponieważ mieliśmy pętlę nad wszystkimi elementami wiersza, możemy po prostu pobrać tę sumę i przesunąć ją. Pchamy go przed drugą pętlą, aby wylądował na dole.

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

I to wszystko.

Brain-Flak, A000290 , autor: Sriotchilism O'Zaic

Oryginalny:

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

Pęknięty:

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

Wypróbuj online!

Alternatywnie:

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

Wypróbuj online!

MATL , sekwencja A005206 autorstwa Luisa Mendo

Oryginalny:

voOdoO

Wypróbuj online!

Pęknięty:

voOdoOdNq17L/k
      ^^^^^^^^

Nie jestem ekspertem od MATL-u, ale z tego, co rozumiem, oryginał voOdoOtworzy dwie puste tablice i tablicę [0]na stosie. to [0]jest drukowane bez nawiasów jako pierwszy element sekwencji. Następnie crack / rozwiązanie wykonuje następujące czynności:

• dusuwa elementy ze stosu i (zakładając, że jest to liczba lub tablica wielkości 1) zamienia go w pustą tablicę. Te puste tablice nie są drukowane, ale wpływają na rozmiar stosu
• Nqliczy rozmiar stosu i odejmuje jeden. Jest to n+1termin oceniania funkcji (ponieważ zaczyna się od 2 i zwiększa o jedną każdą iterację z powodu ddodawania do stosu niewidocznych elementów)
• 17L to jest stała Phi = (1+sqrt(5))/2
• /kwykonuje to, floor((n+1)/Phi)co jest jedną z formuł, które obliczają elementy sekwencji. Ta formuła jest wymieniona w OEIS jakoa(n) = floor(sigma*(n+1)) where sigma = (sqrt(5)-1)/2 z wyjątkiem tego, że używamy tożsamości(sqrt(5)-1)/2 = 1/Phi

Python 3 - A__

print(100+-1)

Wypróbuj online!

100 butelek piwa, dodaj, -1aby uzyskać kolejny numer 99itp.

Beczka , sekwencja A000045 , autor: A__

Oryginalny:

0.

Pęknięty:

01":&+.
 ^^^^^

Zauważ, że wyzwaniem było znalezienie podciągu o długości <= 6, ale znaleziony ciąg ma długość 5.

Definicja poleceń dla tych, którzy są zbyt leniwi, aby sprawdzić specyfikację Keg: 0i 1wcisnąć odpowiednią liczbę na stos; "przesuwa górę stosu na spód stosu (rolka); &wkłada stos do góry do rejestru, jeśli jest pusty, w przeciwnym razie opróżnia rejestr na stosie; +dodaje dwie górne wartości stosu.

Inicjał 1"po prostu wstawia 1 na dole stosu. Ta rosnąca lista jedynek odgrywa rolę tylko w pierwszej iteracji, gdzie pozwala nam założyć, że stos zaczyna się 1 0raczej niż po prostu 0. Rzeczywiście program10:&+. , w którym :&+część jest powtarzana, ma dokładnie takie samo zachowanie jak powyższe rozwiązanie, z tym wyjątkiem, że nie ma rosnącej listy 1 na dole.

Ponieważ &jest używany tylko raz w powtarzającej się części i ma naprzemienne zachowanie, zachowanie1":&+ zależy od parzystości iteracji.

Teraz ten program tak naprawdę nie drukuje sekwencji sekwencji Fibonacciego zaczynającej się od 0, 1 od początku; faktycznie drukuje sekwencję Fibonacciego 1, 0 z drugiego miejsca, tj. z 0. (Daje to tę samą sekwencję.) Wiedząc o tym, program można łatwo przeanalizować:

• W pierwszej, trzeciej, ... iteracji, stan zaczyna się [a, b]i kończy jako a+b (&=b).
• W drugiej, czwartej ... iteracji stan zaczyna się [b] (&=a)i kończy jako [b, b+a].

To rzeczywiście oblicza sekwencję zgodnie z wymaganiami.

Java 8+, sekwencja A010686 autorstwa Benjamina Urquharta

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

Brain-Flak, A000578 autorstwa Sriotchilism O'Zaic

Oryginalny:

((())<>)

Wypróbuj online!

Pęknięty:

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

Wypróbuj online!

Pyret , sekwencja A083420 , autor: MLavrentyev

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

Możesz go uruchomić tutaj, ale nie wymyśliłem, jak połączyć z kodem. Będziesz musiał skopiować i wkleić.

Podana funkcja ignoruje swój drugi argument. Podwaja swój pierwszy i dodaje jeden, który wygeneruje potrzebną 2^n - 1sekwencję potrzebną tutaj - wszystko, co muszę zrobić, to powiedzieć mu, ile razy wykonać tę operację, dokonaną przez zmianę długości złożonej listy. Na szczęście Pyret nie narzeka na ten przecinek.

Python 3 , sekwencja A268575 według NieDzejkob

Oryginalny:

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))

Pęknięty (100 bajtów):

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))

Wypróbuj online!

Z tego, co mogę zebrać, oryginalny kod konfiguruje definicje, aby ukryty ciąg był jak najkrócej skrócony, a następnie definiuje początkowy wzorzec Gry w Życie. Ukryty ciąg jest następnie równoważny zapisaniu iteracji Gry Życia Conwaya w 102 bajtach.

Na potrzeby tego pęknięcia Sjest funkcją, która sumuje elementy w argumentach (które są iterowalne) i Fstosuje funkcję zwracającą iterowalność do każdego elementu listy i niszczy wszystkie wyniki razem.

• ;A=-1,1,0;kończy poprzednią instrukcję i skraca krotkę (-1,1,0) literą A, która jest używana jako product(A,A)dająca wszystkich sąsiadów względem danej komórki, a także samej komórki.
• *X,=F(lambda a:(S(a,x)for x in product(A,A)),W);tworzy nową listę Xobejmującą wszystkich sąsiadów komórek Wi Wsame komórki przez dodanie względnych pozycji sąsiadów do każdej komórki i rozbicie ich razem na listę.
• W={p for p in X if 2<X.count(p)<4+({p}<W)}przechodzi przez tę listę Xi określa, czy każda komórka Xnależy do zestawu komórek w następnej iteracji. Zostało to niemal dosłownie zaczerpnięte z gry w golfa Game of Life .

Haskell, A014675 , autor : Khuldraeseth na'Barya

Oryginalny kod

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

Z podciągiem

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

Wypróbuj online!

Kalkulator biurkowy, A006125 , autor: A__

Oryginalny:

1n

Pęknięty:

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

Wypróbuj online!

Prosta implementacja.

cQuents , sekwencja A003617 autorstwa Stephena

=10#2:pZ
  ^

Wypróbuj online!

Rozpocznij od najniższej liczby n + 1-cyfrowej, jednej po której następuje n zer. W #2określa, że tylko drugie określenie sekwencji, która jest określenie sekwencji podawano raz na nasiona będą drukowane; ta definicja sekwencji po prostu wyszukuje i zwraca następną liczbę pierwszą.

Python 3 - agtoever

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)

Wypróbuj online!

MATL , sekwencja A000796 autorstwa Luisa Mendo

Oryginalny:

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

Wypróbuj online!

Pęknięty:

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

Oryginalny autor podstępnie utworzył tablicę, [-7:-1]a następnie wyodrębnił i zanegował pierwszy jej element 7. Następnie użył tego, aby uzyskać zaokrągloną 7-tą cyfrę pi (która jest 3) i przedstawił ją jako pierwszą cyfrę pi. Dodanie |SQpowoduje, że pierwotna tablica jest dodatnia, sortuje ją i dodaje jeden do wszystkiego. Oznacza to, że po wszystkim zamiast uzyskać indeks 7, otrzymuje indeks -2po jednej aplikacji, -3po dwóch aplikacjach i tak dalej. Jest -to ważne, ponieważ mówi Y$funkcji, aby nie zaokrąglać cyfr.

Forth (gforth) , A000042 , autor: NieDzejkob

.( 1)1 .
^^^^^

Wypróbuj online!

Trywialny 1-bajter po prostu rozszerza literał. Problem polega na tym, że przepełnia 64 bity już od dziewiętnastej cyfry. Łatwym rozwiązaniem jest wielokrotne drukowanie pojedynczej cyfry, prawda? Tak, ale to nie jest takie proste. Chociaż zaznaczenie 1 .na końcu rzeczywiście wydrukuje dodatkowe wymagane cyfry, zostaną one oddzielone spacjami. To nie zadziała.

Now, according to Wikipedia, ".( (dot-paren) is an immediate word that parses a parenthesis-delimited string and displays it." Fortunately, that displaying has no other weird characters, so using .( to print a single 1 should suffice. And it does. No space is needed after the close-paren, so these five characters (there's a space after the open-paren) can be repeated to our hearts' content. To demonstrate, I've included in TIO an example that would have overflowed a 64-bit int several times over. Works like a charm.

Unefunge-98 (PyFunge), sequence A000108, by NieDzejkob

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

Try it online!

Repeated six times

Two bytes to spare of the nineteen allowed! What appears to be a space there is actually a 0x01 Start Of Header character.

Explanation:

This challenge is all about generating a(n) from a(n-1) and perhaps n. OEIS provides the explicit formula a(n) = (2n)!/(n!(n+1)!), which is easily enough converted to a(n) = a(n-1) * (4n-6) / n. Now to implement this in Funge.

I must be inserting code between the 1 and the .. That's half the puzzle done already. All that remains is what code to insert? Funge is notably lacking in stack manipulation tools, so the bottom of the stack is off-limits; I need to track both n and a(n) without growing the stack. And how better to do that than with Funge space?

That 0x01 character is my counter n. I keep a(n) on the stack, as it must be on the stack after my bit finishes executing.

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 by tsh

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

Try it online!

V, A000290, by DJMcMayhem

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

yields the squares from 1.

Try it online!

The base é* inserts * and Ø. counts the number of non-newline characters in the entire buffer. The insertion Ä duplicates the top line to its own line, on which 2é* inserts **. Concatenations of the insertions yield successive odd numbers with the largest at the top. The final Ø. in effect sums the first n odd numbers, hence yielding the n-th square .

AsciiDots, sequence A019523 by Alion

\+++/
//\/\

Once!

Twice!

Ten times!

While trying to figure out how the code/language works, I learned that the first two lines of the existing code does all the work of outputting the Fibonacci sequence infinitely. The code terminates when any dot hits the &, so I merely needed to add further delay in the remaining lines to allow for the appropriate number of entries to output.

After some trial, error, and observation, I discovered that the correct delay interval is 16 time units per number. Fitting enough characters in a single row seemed infeasible, so I would need to put the delay in 2 rows, leaving 10 characters for the actual delay. In order for the pattern to match up with itself, both rows had to have 5 characters, and since the middle three characters in a row can be traversed twice, this gives 16 time units as desired.

The requirement to match this up to the & in the eighth column seemed to make this impossible, until I realized that I could start with a newline in the interior of the third row. This makes the penultimate row the right length, and removes the now-redundant end of the third line.

Brachylog, sequence A114018 by Unrelated String

Original program:

≜ṗ↔ṗb&w

String to insert:

≜ṗ↔ṗẹbb&w
    ^^

Try it online!

Explanation

Here is first the explanation of the original program (knowing that the sequence used is "least n-digit prime whose digit reversal is also prime")

≜         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

As you can see, the program is fairly straightforward except for one thing: there is a completely useless b - behead predicate call, that removes the first element of the reverse of our number, with which we don't do anything.

This is a definite clue as to how we can find the string. The idea is that, since we want to increase the length of the number by 1 digit each time we add the string, we need a string that "evaluates" the length of that number somehow, using that useless b.

The solution is to use ẹb: first, ẹ - elements will transform the number into a list of digits; then, b - behead will remove its first element. The trick is that b will fail if the list of digits is empty. So everytime we append a b, we will increase the length of the required number by 1 (because it will fail until the assigned value of ? is high enough to contain sufficiently many digits so that the last b is applied on a list of one digit).

Re-appyling ẹ each time has no effect because it's already a list of digits. We only need it once at the beginning because if we behead a number like 9001 instead of the list of its digits, we will get 001 = 1 which loses information about the number of digits.

VDM-SL, A000312, by Expired Data

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

Since VDM-SL's let-expressions can re-bind variables which are already bound in an enclosing scope, x**x can be evaluated arbitrarily deeply nested in scopes in which x is one more than in the previous scope, while the original x is still less than the cardinality of m(1).

Haskell, A083318 by xnor

f=length     [2]
        $show

Try it online!

Haskell, A000045 (Fibonacci), by Rin's Fourier transform

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

Try it online!

23 bytes exactly.

This one was fun and a bit tricky. The reversed 0 and 1 threw me off for a little bit before I realized that wasn't an issue. The lack of $ in the original had me trying sketchy stuff like $...$id (one byte too long) before it dawned on me that I could just wrap it all in parentheses. All in all, a nice little puzzle.

H.PWiz points out that pattern matching could have saved me at least five bytes: $(\[x,y]->[y,x+y]). That darn pointfree challenge has me thinking pointfree everywhere.