Znajdź program, który drukuje tę sekwencję całkowitą (wątek gliniarzy)


39

To jest wątek gliniarzy. Wątek rabusiów idzie tutaj .

Ostatni wątek był już 4 miesiące temu .

Zadanie gliniarza

  • Zadaniem gliniarza jest napisanie programu / funkcji, która przyjmuje dodatnią (lub nieujemną) liczbę całkowitą i wysyła / zwraca inną liczbę całkowitą.
  • Policjant musi to stwierdzić, jeśli program nie toleruje zera.
  • Policjant zapewni co najmniej 2 przykładowe wejścia / wyjścia.
  • Na przykład, jeśli zdecyduję się napisać sekwencję Fibonacciego , zapisałbym to w mojej odpowiedzi:
a (0) zwraca 0
a (3) zwraca 2
  • Liczba przykładów zależy od uznania policjanta.
  • Jednak sekwencja musi faktycznie istnieć w Encyklopedii liczb całkowitych on-line® , aby nie było dla ciebie generatora liczb pseudolosowych.:(
  • Policjant może ukryć tyle znaków, ile sobie życzy.
  • Na przykład, jeśli mój program to:

function a(n)
    if n>2 then
        return n
    else
        return a(n-1) + a(n-2)
    end
end

  • Potem chowałbym te postacie, jak chcę:

function a(n)
    if ### then
        ########
    else
        ######################
    end
end

Zadanie rabusia

  • jest oczywiście znalezienie oryginalnego kodu źródłowego.
  • Jednak każdy proponowany kod źródłowy, który generuje ten sam zestaw danych wyjściowych, również jest uznawany za ważny, o ile znajduje się również w OEIS.

Wskazówki dla gliniarzy

  • Funkcja wyszukiwania w OEIS działa tylko dla następujących po sobie haseł, więc jeśli chcesz ukryć sekwencję, po prostu zostaw dziurę w dowolnym miejscu.
  • Najwyraźniej nie ma sposobu na ukrycie sekwencji. Pamiętaj o tym, wybierając sekwencję.

Twój wynik to liczba bajtów w kodzie.

Zwycięzcą zostanie zgłoszenie o najniższym wyniku, który nie został złamany w ciągu 7 dni.

Tylko zgłoszenia przesłane w kwietniu 2016 r. Kwalifikują się do wygranej. Zgłoszenia przesłane później są mile widziane, ale nie można wygrać.

Aby ubiegać się o zwycięstwo, musisz ujawnić pełny kod i sekwencję OEIS (po 7 dniach).

Twój post powinien być sformatowany w następujący sposób (NN to liczba znaków):


Lua, 98 bajtów

Wynik:

a(0) returns 0
a(3) returns 2

Kod ( #oznacza nieujawnione znaki):

function a(n)
    if ### then
        ########
    else
        ######################
    end
end

Jeśli kod jest pęknięty, wstaw go [Cracked](link to cracker)w nagłówku. Jeśli przesłanie jest bezpieczne, wstaw „Bezpieczny” w nagłówku i ujawnij pełny kod w swojej odpowiedzi. Tylko odpowiedzi, które ujawniły pełny kod, będą kwalifikować się do wygranej.


2
Wyszukiwanie OEIS może również zawierać spacje _,
fyi

9
Może być za późno na zmianę, ale zezwolenie na sekwencje, które są wielokrotnościami sekwencji OEIS i / lub obejmują tylko co n-ty termin, znacznie poprawiłoby to wyzwanie . piaskownica, podpowiedź, podpowiedź
Nathan Merrill,

6
Czy mogę na przykład wybrać sekwencję Fibonacciego i podać tylko a(1000)? (który jest częścią sekwencji, ale jest zbyt duży, aby można go było przeszukiwać w OEIS)
Sp3000,

2
Powiedziałbym, że wartości muszą być możliwe do przeszukiwania w OEIS, aby można było łatwo zweryfikować, czy wartości są prawidłowe dla wybranej sekwencji.
Mego

3
„Nietolerancja wobec zera” nie ma sensu. Co to miało znaczyć?
feersum

Odpowiedzi:


11

Vim, 36 naciśnięć klawiszy - Bezpiecznie!

i****<esc>:let @q="^*i****$**@***"<cr><n>@qbD

(Uwaga: <n>tam wpisujesz dane wejściowe)

Oto kod niezwiązany z generowaniem liczb:

          :let @q="              "<cr><n>@qbD

Czyli ujawniam 5 z 19 znaków.

<n>jest wejściem. Oto kilka przykładowych wyników:

1@q:    1
2@q:    3
6@q:    18

Odpowiedź

Ten kod drukuje Liczby Lucasa ( A000032 ), które są jak Sekwencja Fibonnaci, tyle że zaczyna się od 2, 1zamiast 1, 1. Oto pierwsze 15 liczb:

2, 1, 3, 4, 7, 11, 18, 29, 47, 76, 123, 199, 322, 521, 843

Oto ujawniony kod:

i2 1 <esc>:let @q="^diwwyw$pb@-<c-v><c-a>"<cr><n>@qbD

Wyjaśnienie:

i2 1 <esc>                          "Insert the starting numbers
          :let @q="....."<cr>       "Define the macro 'Q'

Objaśnienie makra:

^                      "Move to the first non-whitespace character on the line.
 diw                   "(d)elete (i)nner (w)ord. This is different then 'dw' because it doesn't grab the space. 
                      "It also throws people off since 'i' is usually used for inserting text.
    wyw$               "Move to the next number, yank it then move to the end of the line 
        pb             "(p)aste the yanked text and move (b)ack
          @-     <c-a> "@- is the register holding the word we deleted. Increment the current number that many times.
            <c-v>      "Since we're adding <c-a> this from the command line, we need to type it as a literal.

Teraz musimy tylko usunąć drugi numer, ponieważ pierwszy numer to numer Lucas, którego chcemy. Tak robimy

b   "move (b)ack
 D  "(D)elete to the end of the line.

Ponadto, jeśli się nie mylę, jest to pierwsze bezpieczne przesłanie! To trochę fajne.


Myślę, że znam sekwencję. Po prostu nie wiem, jak to zmienić w klawisze Vima.
Nic Hartley,

Czy wyjście to tylko liczba czy cała linia?
ASCIIThenANSI

@ASCIIThenANSI Po trafieniu bDna końcu, wyjście to tylko jedna liczba i dodatkowe spacje.
DJMcMayhem

Mam prawidłową sekwencję!
Nic Hartley,

8

05AB1E , 5 bajtów, bezpieczny

Ostatni na dziś: str. Wynik:

a(0) = 9
a(5) = 4
a(10) = 89

Kod:

___m_

Zaciemnione znaki są oznaczone symbolem _. Wypróbuj online! -połączyć. Wykorzystuje kodowanie CP-1252 .


Rozwiązanie:

žhžm‡

Wyjaśnienie:

žh       # Short for [0-9].
  žm     # Short for [9-0].
    ‡    # Translate.

Wypróbuj online! lub Wypróbuj dla wszystkich przypadków testowych! .


Znam sekwencję, ale nie wiem, jak ją wygenerować w tak niewielu bajtach ...
LegionMammal978

@ LegionMammal978 Tak, myślę, że będzie to najtrudniejsza część tego.
Adnan

Mogę uzyskać w 5 bajtach, g°<¹-ale nie mogę wymyślić żadnego sposobu użycia mtego rozmiaru! D:
81655

@ user81655 Tak, to było alternatywne rozwiązanie :).
Adnan

6

Element , 7 bajtów, pęknięty

Wynik:

a(3) = 111
a(7) = 1111111

#to ukryte znaki i wszystkie można wydrukować w formacie ASCII. Myślę, że ten jest w rzeczywistości dość trudny (mając tylko 5 brakujących postaci).

###,##}

Dla wygody oto strony wiki Try It Online i Esolang .


Mój oryginalny program to:

_'[,$ ` }

Sztuka polega na tym

]i }są funkcjonalnie identyczne (oba tłumaczą na }Perl). Ponadto ,$produkowałem 1dodatkową warstwę zamieszania, chociaż można ,całkowicie zignorować , robiąc to ,1.


(Wiem, że nie powinienem o to pytać, ale) czy jesteś pewien, że to prawda? W szczególności }zamiast ]?
Leaky Nun

@KennyLau }Jest poprawny, a mój program (o ile wiem) działa w każdej wersji elementu.
PhiNotPi


Myślę, że formatowanie jest nieprawidłowe w twoim oryginalnym kodzie?
Rɪᴋᴇʀ

@EasterlyIrk It is. Jeśli wiesz, jak to naprawić, bądź moim gościem.
PhiNotPi


5

JavaScript (ES7), 10 bajtów, pęknięty

Wydajność

f(0) -> 1
f(1) -> -1

Kod

t=>~t##**#

Testuj to w Firefoksie co noc. Kod jest funkcją anonimową. Prawdopodobnie będzie to łatwe, ponieważ ukryte są tylko trzy postacie, ale przynajmniej są krótkie! : P


Mój oryginalny kod to:

t=>~top**t

ale po brutalnym wymuszeniu własnego kodu dla rozwiązania, szybko się zorientowałem

t=>~t.x**t(gdzie xmoże być dowolny znak nazwy zmiennej)

można również użyć. Działa to, ponieważ

w oryginalnej specyfikacji operatora potęgowania ES7 operator miał niższy priorytet niż operatory jednoargumentowe (w przeciwieństwie do konwencjonalnej matematyki i większości innych języków). ~wykonuje bitowe NOT na t.x( undefined) lub top( Object), które rzutuje je na 32-bitową liczbę całkowitą ze znakiem (takie, jak te, które nie można wyemitować 0) przed wykonaniem NOT (tak się 0staje -1). Zagłębiłem się w to, a ostatnio zmieniła się specyfikacja, aby uniemożliwić takie dwuznaczne odniesienia (to nie jest dobre dla przyszłego golfa D:), jednak większość silników ES7 nie zaktualizowała się do najnowszej wersji specyfikacji.


1
@insertusernamehere Wydaje się, że zawiera niedozwolone wyrażenie. Działa to jednak w Firefoksie co noc. Myślę, że implementują specyfikację ES7 inaczej.
user81655

Właśnie dostałem Firefoksa co noc i muszę narzekać, że to tam nie działa . 32-bitowe okna stąd
Conor O'Brien,

Zakładając, że **jest to równoważne Math.pow, przeprowadziłem niektóre własne testy, a nawet uruchomiłem brutalną siłę. Trudno to złamać!
Conor O'Brien

@ CᴏɴᴏʀO'Bʀɪᴇɴ Mój Firefox co wieczór jest aktualny od wczoraj. Używam OS X, ale jestem pewien, że będzie działał również w systemie Windows. Traceur z włączonymi odpowiednimi opcjami ES7 transpiluje go również poprawnie.
user81655 13.04.16

@ CᴏɴᴏʀO'Bʀɪᴇɴ Właśnie wypróbowałem to w 32-bitowym systemie Windows z linku i działa również. Dziwię się, że twoje brutalne poszukiwanie siły nie mogło go złamać. Właśnie zdałem sobie sprawę, że jest na to wiele rozwiązań! D:
81655

4

05AB1E, 4 bajty ( pęknięty )

Przykładowe dane wyjściowe:

a(5) = 51
a(8) = 257

A dla kodu:

###^

Ujawniłem ostatni. Powinno to być dość łatwe, miałem trudności ze znalezieniem sekwencji :(

Wszystkie ukryte postacie można wydrukować.



4

MATL , 5 bajtów, pęknięty

Ukryte postacie są oznaczone symbolem %.

%5%*%

Wynik:

a(1) = 3
a(2) = 6
a(4) = 12

Dane wejściowe 0są prawidłowe.


Oryginalny kod:

35B*s

to jest,

35    % push number 35
B     % convert to binary: array [1 0 0 0 1 1]
*     % multiply element-wise by implicit input n: gives [n 0 0 0 n n]
s     % sum of array: gives 3*n

2
Hmmm, pięć w kodzie jest bardzo denerwujące!
Adnan

Technicznie może to być brutalnie wymuszone przez program ... ale tego nie zrobię.
Leaky Nun


4

SWIFT, 55 bajtów, pęknięty

func M(n:Int)->Int{
return(n*****) ?M(**n****):n***;
}

* oznacza ukrytą postać

Wynik:

M(30) -> 91
M(60) -> 91
M(90) -> 91
M(120)-> 110
M(150)-> 140

Funkcja akceptuje 0



4

Rubinowy, 46 bajtów, bezpieczny

Edytuj, aby dodać zastrzeżenie / przeprosiny: Ta sekwencja zaczyna się od f [0], podczas gdy pozycja OEIS zaczyna się od f [1]. Wartości są takie same.

Kod zaciemniony ( #dowolny znak):

->####or x##1###(#..##0#);x*=3;end;#.###ect:+}

Zadzwoń jak

->####or x##1###(#..##0#);x*=3;end;#.###ect:+}[3] (returns 39)

Wynik:

f[0] = 0
f[1] = 3
f[2] = 12
f[3] = 39
f[4] = 120
f[5] = 363
f[6] = 1092
f[7] = 3279
f[8] = 9840
f[9] = 29523

Rozwiązanie:

f=->*x{for x[-1]in(0..x[0]);x*=3;end;x.inject:+}

Sekwencja:

http://oeis.org/A029858

Wyjaśnienie:

Drobną sztuczką jest to, że deklarujemy parametr jako *xzamiast x. Oznacza to, że jeśli przejdziesz 2, na początku xustawione jest [2]... Głównym sztuczka wykorzystuje dziwaczne i sprawiedliwie niejasne, Ruby składni, gdzie można ustawić iteracyjnej w pętli for do każdego ważnego lewej stronie wyrażenia przypisania, zamiast zmiennej iteracyjnej podobnego i. Tak więc pętla przechodzi od 0 do (w tym przykładzie) 2, przypisując każdą liczbę do x[-1], co oznacza, że ​​zastępuje ostatnią wartość x. Następnie ciało pętli x*=3dodatkowo mutuje x, łącząc je ze sobą 3 razy. Więc najpierw x staje [0], wtedy [0,0,0]. W następnej pętli staje się [0,0,1]wtedy [0,0,1,0,0,1,0,0,1]. Wreszcie przechodzimy w 2 i staje się [0,0,1,0,0,1,0,0,2], a następnie[0, 0, 1, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 1, 0, 0, 2]. Następnie sumujemy wynik za pomocą injectmetody, która zmniejsza tablicę, stosując kolejno +(przekazaną metodę) do każdego elementu po kolei. Jeśli weźmiemy pod uwagę, jak każda iteracja zmienia sumę, zobaczymy, że skutecznie dodajemy 1 (poprzez nadpisanie ostatniego elementu elementem wyższym o jeden), a następnie mnożymy przez 3. Ponieważ 3*(n+1) = 3*n + 3implementuje to relację powtarzalności Alexandre Wajnberga dla sekwencji, jak opisano na strona.


Naprawdę podoba mi się twój gliniarz, szczególnie ten. Dobra robota.
Nie, że Charles



3

PHP, 41 bajtów, pęknięty

Tak, wreszcie kolejne wyzwanie dla gliniarzy i rabusiów. Mam nadzieję, że nie ułatwiłem.

Wydajność

a(5)   = 0
a(15)  = 1
a(35)  = 0
a(36)  = 1
a(45)  = 1

Źródło

____________________$argv[1]____________;
####################        ############

Notatki


Pęknięty

Oczywiście zrobiłem to łatwo i podałem za mało przykładów. Sekwencja, którą miałem na myśli, to A010054 :

a (n) = 1, jeśli n jest liczbą trójkątną, w innym przypadku 0.

Oto mój oryginalny kod źródłowy:

echo(int)($r=sqrt(8*$argv[1]+1))==$r?1:0;

Sprawdza, czy dane wejściowe są liczbą trójkątną i 1czy 0odpowiednio.




3

MATL, 9 bajtów, pęknięty

Kod:

3#2###*##

Wynik:

a(1)  = 3
a(2)  = 6
a(4)  = 12
a(12) = 37

a(0) jest ważny.


Pęknięty

Oryginalna sekwencja: A059563

Oryginalny kod:

3L2^Ze*sk
3L          % Push [1 -1j] from the clipboard
  2^        % square
    Ze      % exp
      *     % times input
       s    % sum
        k   % floor


3

Java, 479 bajtów, Pęknięty

Wyjścia:

a(10) = 81
a(20) = 35890

(Dane wejściowe są dostarczane za pomocą argumentów wiersza poleceń)

Kod ( #oznacza ukryte znaki):

import java.util.*;
public class A{

    public static int#########
    public boolean###########

    static A a = new A();

    public static void main(String[] args){
        int input = Integer.parseInt(args[0]);

        LinkedList<Integer> l = new LinkedList<>();
        l.add(1);
        l.add(0);
        l.add(0);

        for(int ix = 0; ################if(##>##{
            ###########d#
            #######+##p##########+##########(#######
        }

        System.out.println(#########################
            ###(A.#############(#5#####)));
    }
}

Program zaczyna się od indeksu 0.

(Zauważ, że SE zamienia wszystkie \twcięcia na 4 spacje, dzięki czemu bajt ma w sumie 569. Kliknij tutaj, aby zobaczyć program z \twcięciami zamiast wcięć.)

Oryginalny kod:

import java.util.*;
public class A{
    public static interface B{
    public boolean C(int i);} 

    static A a = new A();

    public static void main(String[] args){
        int input = Integer.parseInt(args[0]);

        LinkedList<Integer> l = new LinkedList<>();
        l.add(1);
        l.add(0);
        l.add(0);

        for(int ix = 0; ix<input; ix++)cif(i->  {
            return l.add(
            l.pop()+l.peekFirst()+l.peekLast());});{    
        }

        System.out.println(l.get(1));}static boolean 
            cif(A.B b5){return (b5.C((0)));
    }
}

(Ten sam kod, ale sformatowany normalnie):

import java.util.*;

public class A {
    public static interface B { //functional interface for lambda expression
        public boolean C(int i); //void would have given it away
    }

    static A a = new A(); //distraction

    public static void main(String[] args) {
        int input = Integer.parseInt(args[0]);//Input

        LinkedList<Integer> l = new LinkedList<>();
        l.add(1);//Set up list
        l.add(0);
        l.add(0);

        for (int ix = 0; ix < input; ix++)
            cif(i -> { //Fake if statement is really a lambda expression
                return l.add(l.pop() + l.peekFirst() + l.peekLast());
            });
        { //Distraction
        }

        System.out.println(l.get(1));//Output
    }

    static boolean cif(A.B b5) { //Used to pass in lambda expression.
                  //The A. and b5 were both distractions
        return (b5.C((0)));
    }
}

Hm, jak dojść do liczby bajtów 488? Naliczyłem 545 od ido }? I proszę podać tolerancję 0.
Wampir

Nie są twoje przykłady a(9)i a(19)lub a(8)i a(18), zgodnie z którą wersją nim na OEIS wziąłeś?
Wampir

@ BjörnKautler Po powrocie do domu opublikuję link do licznika bajtów. Co rozumiesz przez tolerancję 0? Pierwsza wartość to (1) = 0
Daniel M.

Z PO: „Zadaniem gliniarza jest napisanie programu / funkcji, która przyjmuje dodatnią (lub nieujemną) liczbę całkowitą i wysyła / zwraca inną liczbę całkowitą. Policjant musi to podać, jeśli program nie toleruje zera”. Sądzę więc, że przyjmujesz wartość 1 jako 0, co tłumaczy także zmianę pozycji zgodnie z sekwencją OEIS.
Wampir

@ BjörnKautler OK, dziękuję. Program nie ulega awarii, jeśli wprowadzono 0, ale sekwencja zaczyna się od indeksu 1, więc myślę, że nie toleruje zera.
Daniel M.



3

Pyth, 70 bajtów, Cracked

DhbI|qb"#"qb"#"R!1Iqb"#"#####+""s####2###;##lY+Q1Ih+""Z#####)=Z+Z1;@YQ

# są ukrytymi postaciami

Został złamany, więc oto wersja n bez ukrytych znaków:

DhbI|qb"4"qb"0"R!1Iqb"1"R!0Rh+""sm^sd2cb1;W<lY+Q1Ih+""Z=Y+YZ)=Z+Z1;@YQ

Przykładowe wyniki:

a(2) -> 10
a(4) -> 19

Powodzenia w znalezieniu tego w OEIS, osobiście nie udało mi się go znaleźć na podstawie tych przykładów (nawet jeśli sekwencja jest dość łatwa do wykrycia).



3

Ruby, 38 bajtów, pęknięty

Kod zaciemniony ( #może być dowolnym znakiem):

->#{(s=#########).sum==#3333&&eval(s)}

Wynik:

Mnoży wartość wejściową przez 10 (A008592). Działa dla dowolnej liczby całkowitej, w tym 0. np

->#{(s=#########).sum==#3333&&eval(s)}[3]  => 30
->#{(s=#########).sum==#3333&&eval(s)}[10] => 100




3

Lua, 45 bajtów, pęknięty

Mała wskazówka:

a(0) will make the program crash :)

Wydajność

a(1)=>0
a(2)=>1

Kod

Używa #do ukrywania kodu :).

a=function(n)#####n###### and #or ########end

Korzystałem z OEIS A007814 z następującym kodem:

a=function(n)return n%2>0 and 0or 1+a(n/2)end


@KennyLau Dobra robota, dodałem OEIS, o którym myślałem, i zamierzony kod, powinienem dodać co najmniej jedno wyjście, aby temu zapobiec: p
Katenkyo 14.04.16

3

Pyke , 15 bajtów, BEZPIECZNY

Wydajność

a(2) = 21
a(15) = 17

Ujawniony kod:

#R#D######+##)#

Rozwiązanie:

OEIS A038822
wR}DSR_Q*L+#P)l
Użyłem tutaj kilku czerwonych śledzi, używając wR}do wygenerowania liczby 100 i ujawnienia postaci, Rktóra zwykle służy do obracania stosu. Użyłem również #P)lzamiast prostszego mPsdo policzenia liczby liczb pierwszych w sekwencji.



Myślałem, że to ta sekwencja, tyle że zaczyna się od n = 0, a nie n = 1, jak już powiedziałeś.
Emigna,

3

C, 82 bajty, bezpieczne

####=############
main(i){scanf("%d",##);
for(i=1;i++/4<#;)##=2;
printf("%d",##);}

Działa z gcc i jest to pełny program, który odczytuje dane wejściowe ze standardowego wejścia i wypisuje dane wyjściowe na standardowe wyjście. Tutaj sekwencja to A004526, piętro (n / 2) .

a(0) = 0    a(1) = 0    a(2) = 1
a(3) = 1    a(4) = 2    a(5) = 2
a(6) = 3    a(7) = 3    a(8) = 4

Rozwiązanie:

a;*b=(char*)&a+1;
main(i){scanf("%d",&a);
for(i=1;i++/4<2;)a*=2;
printf("%d",*b);}

Działa to tylko na małych komputerach Endian i tylko wtedy, gdy rozmiar charwynosi 1 bajt.
I tylko jeśli bajt wyższy niż bajt najwyższego rzędu ama wartość 0. Myślę, że dotyczy to gcc, ponieważ domyślnie niezainicjowane zmienne globalne przechodzą do segmentu bss, a zainicjowane zmienne globalne przechodzą do segmentu danych (patrz https: // stackoverflow.com/questions/8721475/if-a-global-variable-is-initialized-to-0-will-it-go-to-bss ).
Więc aidzie tylko do bss ( binicjowana jest tylko inna zmienna globalna, a zatem przechodzi do segmentu danych). Jeśli anie znajduje się na końcu bss, to bajt wyższy niż bajt najwyższego rzędu arównież jest w bss, a zatem ma wartość 0.


Spróbuj teraz wywoływać funkcje :)
mIllIbyte

1
Nie sądzę, żebyś musiał określić sekwencję ...
FliiFe 11.04.16

@FliiFe - Naprawiono :)
mIllIbyte 11.04.16


2

Element , 10 bajtów, pęknięty

Wynik:

a(3) = 6561
a(4) = 4294967296

Prawdopodobnie istnieje tylko kilka sposobów na obliczenie tej sekwencji w elemencie. Znalazłem rozwiązanie 9-znakowe, ale pomyślałem, że to 10-znakowe rozwiązanie jest w rzeczywistości trudniejsze. Są #to ukryte postacie.

#_####@^#`

Dla wygody oto strony wiki Try It Online i Esolang .


Oryginał był

2_3:~2@^^`

Pokaż jeszcze jeden bajt.
Leaky Nun

@KennyLau Myślałem, że to 1 na 5? Ma 10 bajtów, a ja wyświetlam 3.
PhiNotPi

Wejścia i wyjścia się nie liczą, więc masz 8 bajtów i pokazałeś 1.
Leaky Nun

@KennyLau gotowe.
PhiNotPi




2

Jolf , 11 bajtów, pęknięty .

Wynik:

a(10) = 4
a(20) = 6
a(30) = 8

I częściowo ukryty kod:

####xd###x#

Wskazówka:

Kiedy przeglądałem sekwencje w kolejności, nie znalazłem się daleko przed znalezieniem tej.

Pęknięta wersja nie jest dokładnie taka sama jak mój oryginalny kod. Obecnie nie jestem przy komputerze, więc nie mam go dokładnie, ale było coś takiego:

l fzxd!m%xH

(Jedyne, czego nie jestem pewien, to !m. To wszystko sprawdza, czy zmienna ma wartość zero.)


Znalazłem sekwencję ... Szkoda, że ​​nie znam Jolfa ani javascript bardzo dobrze :(
Blue

@muddyfish, To samo tutaj ...
LegionMammal978

Cóż, chyba nadszedł czas, aby mistrz to zrobił ... prawda?
Conor O'Brien

@ CᴏɴᴏʀO'Bʀɪᴇɴ Jeśli wszyscy inni są zakłopotani - i wygląda na to, że są - nie krępuj się.
Nic Hartley,


Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.