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

Ostatni wątek gliniarzy i rabusiów 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.

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.

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

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

Wynik:

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

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

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

Wynik:

a(2) = 8
a(10) = 4738245926336

Wszystko to jest kluczowe i pokazałem 1 z 5.

####x

Oryginalny kod:

mPm$x
mP     cube
  m$   catalan number
    x  input

Wypróbuj online!

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.

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

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

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

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.

05AB1E , 3 bajty, pęknięty

Wynik:

a(9) = 165
a(10) = 220

Ukryty kod:

##O

Wypróbuj online, może się przydać.

Sześciokąt , 7 bajtów, pęknięty

Wynik:

a(1) = 2
a(2) = 4

Ukryty kod:

?#####@

Lub alternatywnie:

 ? #
# # #
 # @

Wypróbuj online, może się przydać.

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

• To pełny program, a nie funkcja.
• Czyta dane wejściowe z wiersza poleceń (oczywiście).
• Nie zawiera tagu otwierającego PHP .

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.

Jolf, 11 bajtów, Cracked , A011551

c*______x__

c*mf^+91x~P

Oryginalny kod:

c*^c"10"x~P

Przykłady:

0 -> 1

12 -> 1618033988749

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

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

Oktawa, 34 bajty, pęknięty

@(m)(m###m#####m##)&isprime(#)####

Wyjścia:

ans(1) = 0
ans(6) = 5
ans(7) = 10
ans(8) = 15

Sekwencja zaczyna się ans(1)w OEIS.

C, pęknięty 71 bajtów

############
#####
main(){
 scanf("%d",##);
 ###6#;
 printf("%d",##);
}

Wynik:

a(1) = 0   a(2) = 0   a(5) = 1
a(6) = 1   a(7) = 1   a(9) = 2

Działa to z gcc i jest pełnym programem. Przyjmuje 0 jako dane wejściowe.

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

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

05AB1E , 5 bajtów, pęknięty

Wynik:

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

Zaciemniony kod:

_____

Wypróbuj online! -połączyć.

05AB1E , 4 bajty, pęknięty

Cóż, myślę, że jestem uzależniony od CnR ... zaciemniony kod ( _wskazuje na dziką kartę):

____

Sekwencja:

a(1) = 2
a(4) = 6720

Sekwencja w OEIS zaczyna się od (1) = 2.

Wypróbuj online! -połączyć

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

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.

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.

05AB1E, 1 bajt, pęknięty

_

_ oznacza ukryty kod.

f(1) == 1
f(18) == 6

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@^^`

Pyth , 18 bajtów

# oznacza nie objawione znaki.

L?Jtb##5#m##S#2 #y

Wyjścia (zaczyna się od 1):

1 -> 2
2 -> 3
3 -> 5
4 -> 7

Tłumacz online

05AB1E , 5 bajtów, pęknięty

Mam nadzieję, że to zgłoszenie nie jest tak łatwe jak moje inne: str. Wyjścia:

a(0) = 0
a(1) = 1
a(2) = 6
a(3) = 24
a(4) = 80
a(5) = 240

Zaciemniony kod:

####O

Zawiera jednak niektóre znaki spoza ASCII, wykorzystuje kodowanie CP-1252 .

Wypróbuj online! może się przydać: str.

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

Pyke , 6 bajtów, pęknięty

###X#s

Wynik:

a(2) = 8
a(8) = 80
a(10) = 120

To nie działa z N <1

Oryginalne rozwiązanie:

hSmX$s