Rabusie: Ukryty podciąg OEIS

23

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.

DJMcMayhem
źródło

Odpowiedzi:

13

Python 2 , sekwencja A138147 według xnor

Oryginalny:

print 10

Pęknięty:

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

Wypróbuj online!

Hobbs
źródło
3
Masz to! To jest rozwiązanie, o którym myślałem. Uważam za interesujące, że to działa, biorąc pod uwagę %lewicowych współpracowników.
xnor
Tak, ale ciąg formatujący jest ciągiem, a „1% s0”% „1% s0” to „11% s00”, co wciąż robi to, co chcieliśmy zrobić.
hobbs
10

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.

Central elements

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

Na przykład:

1+3+6+10=20

Central sums

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 n1 terminem w następnym rzędzie.

Next row formula

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

Last member formula

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.

Kreator pszenicy
źródło
1
Nawet lepiej niż to, co miałem na myśli. Jedna poprawka do twojego wyjaśnienia: aby przejść od jednej przekątnej do drugiej, dodajesz starą liczbę do nowej liczby (obliczając skumulowane sumy starej przekątnej), nie dodając dwóch starych liczb.
Nitrodon
@Nitrodon Wyjaśnienie naprawione. Gdybym przeczytał swój własny kod, byłbym w stanie zobaczyć, że to źle.
Wheat Wizard
6

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

Oryginalny:

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

Pęknięty:

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

Wypróbuj online!

Alternatywnie:

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

Wypróbuj online!

jimmy23013
źródło
To jest mój ukryty sznurek! ale nie tam go umieszczałem. Dobra robota bez względu na wszystko!
Wheat Wizard
1
@ SriotchilismO'Zaic Więc to musi być oryginał.
jimmy23013
6

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
SamYonnou
źródło
Nie jestem ekspertem od MATL. Myślę, że stałeś się jednym - :) Dla porównania, moim ukrytym łańcuchem był \N17L/k&(zwróć uwagę na dwa różne zastosowania &na środku i na końcu kodu), ale twoje rozwiązanie jest prostsze i bardziej elegancki
Luis Mendo
5

Python 3 - A__

print(100+-1)

Wypróbuj online!

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

Giuseppe
źródło
Pokonaj mnie o 7 sekund. :) Ponadto zasady mówią o znalezieniu dowolnego ciągu o tej długości, więc możesz po prostu to zrobić-1. Uściślę to.
DJMcMayhem
@DJMcMayhem Przeczytałem to po przesłaniu, ale fajniej jest wprowadzić dodatkowe ograniczenia dla tak łatwego crack :-)
Giuseppe
5

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.

Tomsmeding
źródło
1
Fajnie, teraz jest ktoś, kto używa Keg jak ja.
A̲̲
@A__ Jaki był twój oryginalny ciąg 6 znaków? :)
tomsmeding
W rzeczywistości jest bardzo podobny do twojego sznurka; jedyną różnicą jest to, że dodałem :polecenie na początku łańcucha.
Czy to najkrótszy możliwy wstawiony ciąg znaków, jaki można znaleźć?
A̲̲
2
Argh. Znalazłem ten, ale w przeszłości, gdy wyzwanie wynosiło <= 4 bajty.
Khuldraeseth na'Barya
4

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.

Khuldraeseth na'Barya
źródło
4

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 .
Liresol
źródło
Byłem tak zaskoczony odpowiedzią NieDzejkoba (ukryty ciąg 102 bajtów!), Że dołączyłem do StackExchange, aby spróbować go złamać, ale okazuje się, że moje nowe konto nie może komentować postów innych osób, więc nie mogę w pełni przestrzegać zasad ( co jest moją winą)
Liresol
Witamy w CGCC! Skomentowałem dla ciebie odpowiedź gliniarza. Mam nadzieję, że zostaniesz!
Jo King
Dzięki! Tak naprawdę nie próbowałem takich problemów z kodem, ale robienie tego było super.
Liresol
Dobra robota! Kiedy znajdę czas, ujawnię zamierzony ciąg.
NieDzejkob
3

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!

nimi
źródło
To by wystarczyło! Miałem flip take[1,2]zamiast tej wewnętrznej lambda. W przeciwnym razie identyczne.
Khuldraeseth na'Barya
1
@ Khuldraesethna'Barya: (`take`[2,1])jest nawet o jeden bajt krótszy
nimi
To kłuje. Być może mógłbym mieć ten bezpieczny na dłużej, gdybym to zrozumiał. (`take`)napotkałem błąd kompilacji, więc pomyślałem, (`take`[2,1])że też. :(
Khuldraeseth na'Barya
2

Kalkulator biurkowy, A006125 , autor: A__

Oryginalny:

1n

Pęknięty:

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

Wypróbuj online!

Prosta implementacja.

jimmy23013
źródło
Mój oryginalny ciąg jest Sa2Lad1-*2/^na wypadek, gdyby ktoś mnie o to zapytał.
A̲̲
2

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ą.

Khuldraeseth na'Barya
źródło
2

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!

NieDzejkob
źródło
2
Powodem, dla którego pytałem o hipotezę Goldbacha, jest to, że takie rozwiązanie nie jest poprawne, jeśli w serii jest parzysty wpis oprócz 2. Myślę, że to działa, jeśli nie możesz założyć hipotezy, ale używa tego samego podstawowego pomysł (nie krępuj się zostawić to jako crack, chcę po prostu być pedantyczny).
FryAmTheEggman
Niezłe rozwiązanie. Krótszy niż mój. Opublikuję moje jutro (CET). Nie mam teraz pod ręką mojego kodu. Moje rozwiązanie korzysta z wyrażenia generatora i nie opiera się na przypuszczeniu Gb, ale wciąż pozostaje to dobrą odpowiedzią (i moim zdaniem kwalifikującą).
agtoever
1
@FryAmTheEggman Tak, sekcja „formuła” OEIS nie wspomniała, że ​​zależy to od przypuszczenia ... brb z dowodem;)
NieDzejkob
2

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.

SamYonnou
źródło
Mój dokładnie ukryty ciąg! Dobra robota!
Luis Mendo,
2

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.

Khuldraeseth na'Barya
źródło
Good job! That's exactly my string.
NieDzejkob
2

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.
Khuldraeseth na'Barya
źródło
2

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 .

Kritixi Lithos
źródło
Ahh, summing odd numbers, I didn't think about that. Nicely done :) I took the phrase square numbers much more literally with ÄÎé*<CR>
DJMcMayhem
@DJMcMayhem I thought similarly at first, but messed something up/got 6 bytes, so tried this other approach inspired by the brainflak wiki's square number construction via summing odd numbers.
Kritixi Lithos
2

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.

Nitrodon
źródło
1
The following also works: \v / v>-----)
SamYonnou
Great job, you two. @SamYonnou was closer to the intended solution. Additionally, I'm glad that the thought process was similar to the intended one, despite leading towards a different solution!
Alion
2

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.

Fatalize
źródło
1
Very nicely done. I never even thought of the 9001b1 issue, it actually just turned out that although b will fail if the list of digits is empty, it won't fail if you never actually have a list, because single-digit numbers behead to 0, including 0 itself.
Unrelated String
1
@UnrelatedString In short: b is weird
Fatalize
2

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

Unrelated String
źródło
I tested it up to n=11 and it worked fine
Unrelated String
...it's only supposed to be one number. If you insert s somewhere into p, this program must print the second integer from the sequence. If you insert s + s into the same location in p, this program must print the third integer from the sequence. Note the behavior of the example print(1).
Unrelated String
Ah rip, understandable
Unrelated String
1
Don't think this is super trivial, it's still pretty cool!
Expired Data
1
Use ++ to map override
Expired Data
2

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.

Khuldraeseth na'Barya
źródło