Ini adalah utas polisi. Utas perampok ada di sini .

Yang terakhir polisi dan perampok benang sudah 4 bulan yang lalu .

Tugas polisi

• Tugas polisi adalah menulis program / fungsi yang mengambil bilangan bulat positif (atau non-negatif) dan mengeluarkan / mengembalikan bilangan bulat lainnya.
• Polisi harus menyatakannya jika program tidak toleran terhadap nol.
• Polisi akan menyediakan setidaknya 2 sampel input / output.
• Misalnya, jika saya memutuskan untuk menulis deret Fibonacci , saya akan menulis ini dalam jawaban saya:

a (0) mengembalikan 0
a (3) mengembalikan 2

• Jumlah contoh tergantung pada kebijaksanaan polisi.
• Namun, urutannya harus benar-benar ada di Ensiklopedia On-Line dari Integer Sequences® , jadi tidak ada pembangkit angka pseudo-acak untuk Anda.:(
• Polisi dapat menyembunyikan karakter sebanyak yang diinginkan.
• Misalnya, jika program saya adalah:

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

• Maka saya akan menyembunyikan karakter ini seperti yang saya inginkan:

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

Tugas perampok

• jelas untuk menemukan kode sumber asli.
• Namun, setiap kode sumber yang diusulkan yang menghasilkan set output yang sama juga dianggap valid, asalkan juga ditemukan di OEIS.

Kiat untuk polisi

• Fungsi pencarian di OEIS hanya berfungsi untuk istilah yang berurutan, jadi jika Anda ingin menyembunyikan urutan Anda, maka tinggalkan lubang di mana saja.
• Tampaknya tidak ada cara untuk menyembunyikan urutannya. Ingatlah hal ini ketika Anda memilih urutannya.

Skor Anda adalah jumlah byte dalam kode Anda.

Pemenang akan menjadi pengajuan dengan skor terendah yang belum di-crack dalam 7 hari.

Hanya kiriman yang diposting pada 2016 April yang memenuhi syarat untuk menang. Kiriman yang dikirim lebih lambat dari ini dipersilahkan, tetapi tidak dapat menang.

Untuk mengklaim kemenangan, Anda perlu mengungkapkan kode lengkap dan urutan OEIS (setelah 7 hari).

Posting Anda harus diformat seperti ini (NN adalah jumlah karakter):

Lua, 98 byte

Keluaran:

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

Kode ( #menandai karakter yang tidak terungkap):

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

Jika kode ini retak, masukkan [Cracked](link to cracker)di header. Jika pengiriman aman, masukkan "Aman" di header dan mengungkapkan kode lengkap dalam jawaban Anda. Hanya jawaban yang telah mengungkapkan kode lengkap yang memenuhi syarat untuk menang.

Vim, 36 penekanan tombol - Aman!

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

(Catatan: <n> adalah tempat Anda mengetik input Anda)

Berikut adalah kode yang tidak terkait dengan pembuatan nomor:

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

Berarti saya mengungkapkan 5 dari 19 karakter.

<n>adalah input. Berikut adalah beberapa contoh keluaran:

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

Menjawab

Kode ini mencetak The Lucas Numbers ( A000032 ), yang sama seperti The Fibonnaci Sequence, kecuali bahwa ia dimulai 2, 1sebagai gantinya 1, 1. Inilah 15 angka pertama:

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

Berikut kode yang terungkap:

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

Penjelasan:

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

Penjelasan makro:

^                      "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.

Sekarang, kita hanya perlu menghapus angka kedua, karena angka pertama adalah nomor lucas yang kita inginkan. Jadi kita lakukan

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

Juga, jika saya tidak salah, ini adalah pengiriman aman pertama! Itu agak keren.

05AB1E , 5 byte, aman

Terakhir untuk hari ini: hlm. Keluaran:

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

Kode:

___m_

Karakter dikaburkan ditandai dengan _. Cobalah online! -link. Menggunakan pengodean CP-1252 .

Larutan:

žhžm‡

Penjelasan:

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

Cobalah online! atau Coba untuk semua kasus uji! .

Elemen , 7 byte, retak

Keluaran:

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

Itu #adalah karakter tersembunyi, dan mereka semua dapat dicetak ASCII. Saya pikir ini sebenarnya cukup sulit (karena hanya memiliki 5 karakter yang hilang).

###,##}

Untuk kenyamanan, inilah halaman wiki Try It Online dan Esolang .

Program asli saya adalah:

_'[,$ ` }

Kuncinya adalah itu

]dan }secara fungsional identik (keduanya diterjemahkan ke }dalam Perl). Juga, saya digunakan ,$untuk menghasilkan 1lapisan kebingungan tambahan, meskipun mungkin untuk mengabaikan ,sepenuhnya dengan melakukan ,1sebaliknya.

Jolf , 5 byte, retak

Keluaran:

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

Semua itu penting, dan saya telah menunjukkan 1 dari 5.

####x

Kode asli:

mPm$x
mP     cube
  m$   catalan number
    x  input

Cobalah online!

JavaScript (ES7), 10 byte, Retak

Keluaran

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

Kode

t=>~t##**#

Uji di Firefox setiap malam. Kode ini adalah fungsi anonim. Ini mungkin akan mudah karena hanya ada tiga karakter yang disembunyikan, tetapi setidaknya singkat! : P

Kode asli saya adalah:

t=>~top**t

tetapi setelah memaksa kode saya sendiri untuk solusi, saya segera menyadari

t=>~t.x**t(di mana xdapat berupa karakter nama variabel)

bisa juga digunakan. Ini berhasil karena

dalam spec operator eksponensial ES7 asli, operator memiliki prioritas lebih rendah daripada operator unary (tidak seperti matematika konvensional dan sebagian besar bahasa lainnya). ~melakukan bitwise NOT pada t.x( undefined) atau top( Object) yang melemparkannya ke integer bertanda 32-bit (uncastable seperti ini menjadi 0) sebelum melakukan NOT (jadi 0menjadi -1). Saya melihat lebih jauh ke dalam ini, dan baru-baru ini, spek telah berubah untuk melarang referensi ambigu seperti ini (tidak baik untuk golf D masa depan), namun sebagian besar mesin ES7 belum memperbarui ke versi terbaru dari spesifikasi.

05AB1E, 4 byte ( Retak )

Output sampel:

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

Dan untuk kodenya:

###^

Saya mengungkapkan yang terakhir. Seharusnya cukup mudah, aku kesulitan menemukan urutan :(

Semua karakter tersembunyi dapat dicetak.

MATL , 5 byte, retak

Karakter tersembunyi ditunjukkan oleh %.

%5%*%

Keluaran:

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

Masukan 0valid.

Kode asli:

35B*s

itu adalah,

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 byte, Retak

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

* menandai karakter yang tersembunyi

Keluaran:

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

Fungsi menerima 0

Ruby, 46 byte, aman

Edit untuk menambahkan penafian / permintaan maaf: Urutan ini dimulai dengan f [0], sedangkan entri OEIS dimulai dengan f [1]. Nilai-nilainya sama.

Kode yang dikaburkan ( #adalah karakter apa saja):

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

Sebut seperti

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

Keluaran:

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

Larutan:

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

Urutan:

http://oeis.org/A029858

Penjelasan:

Trik kecil di sini adalah kita mendeklarasikan parameter sebagai *xganti x. Ini berarti bahwa jika Anda lewat 2, xdiatur ke [2]... pada awalnya. The besar trik mengeksploitasi aneh, dan adil jelas, sintaks Ruby di mana Anda dapat mengatur iterator dalam untuk loop untuk setiap sisi kiri valid dari sebuah ekspresi tugas, bukan variabel iterator seperti i. Jadi ini loop dari 0 ke (dalam contoh ini) 2, menugaskan masing-masing nomor x[-1], yang berarti menimpa nilai terakhir x. Kemudian loop body x*=3, selanjutnya bermutasi x dengan menggabungkannya sendiri 3 kali. Jadi pertama x menjadi [0], lalu metode, yang mengurangi array dengan menerapkan[0,0,0] . Pada loop berikutnya menjadi [0,0,1], lalu . Kami kemudian menjumlahkan hasilnya menggunakan[0,0,1,0,0,1,0,0,1] . Akhirnya kita lulus 2 dan menjadi [0,0,1,0,0,1,0,0,2], lalu[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]inject+ (metode yang diteruskan) ke setiap elemen secara bergantian. Jika kita mempertimbangkan bagaimana setiap iterasi mengubah jumlah, kita melihat bahwa kita secara efektif menambahkan 1 (dengan menimpa elemen terakhir dengan elemen yang lebih tinggi), lalu kalikan dengan 3. Karena 3*(n+1) = 3*n + 3, ini mengimplementasikan relasi pengulangan Alexandre Wajnberg untuk urutan seperti yang dijelaskan pada halaman.

05AB1E , 3 byte, retak

Keluaran:

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

Kode tersembunyi:

##O

Cobalah secara online mungkin berguna.

Hexagony , 7 byte, retak

Keluaran:

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

Kode tersembunyi:

?#####@

Atau sebagai alternatif:

 ? #
# # #
 # @

Cobalah secara online mungkin berguna.

PHP, 41 byte, sudah di- crack

Ya, akhirnya tantangan Polisi dan Perampok lainnya. Semoga saya tidak membuatnya menjadi mudah.

Keluaran

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

Sumber

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

Catatan

• Ini adalah program lengkap, bukan fungsi.
• Membaca input dari baris perintah (jelas).
• Tidak mengandung tag pembuka PHP .

Retak

Saya jelas membuatnya mudah dan memberikan contoh yang tidak cukup. Urutan yang saya pikirkan adalah A010054 :

a (n) = 1 jika n adalah angka segitiga selain 0.

Ini kode sumber asli saya:

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

Ini menguji apakah input adalah angka segitiga dan output 1atau 0sesuai.

Jolf, 11 byte, Retak , A011551

c*______x__

c*mf^+91x~P

Kode asli:

c*^c"10"x~P

Contoh:

0 -> 1

12 -> 1618033988749

MATL, 9 byte, Retak

Kode:

3#2###*##

Keluaran:

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

a(0) adalah benar.

Retak

Urutan asli: A059563

Kode asli:

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

Java, 479 byte, Cracked

Output:

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

(Input diberikan melalui argumen baris perintah)

Kode ( #menandai karakter tersembunyi):

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 dimulai pada indeks 0.

(Perhatikan bahwa SE mengganti semua \tindentasi dengan 4 spasi, sehingga total byte menjadi 569. Klik di sini untuk melihat program dengan\t indents instead of space indents.)

Kode asli:

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

(Kode yang sama, tetapi diformat secara normal):

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

Octave, 34 bytes, cracked

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

Outputs:

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

The sequence starts at ans(1) in OEIS.

C, 71 bytes cracked

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

Output:

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

This works with gcc, and is a full program. It accepts 0 as input.

Pyth, 70 bytes, Cracked

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

# are the hidden characters

Has been cracked, so here is the versionn without hidden chars :

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

Sample outputs :

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

Good luck to find this on OEIS, I personally failed to find it from those examples (even tho the sequence is quite easy to spot.)

Ruby, 38 bytes, cracked

Obfuscated code (# can be any character):

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

Output:

Multiplies the input by 10 (A008592). Works for any integer, including 0. e.g.

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

05AB1E, 5 bytes, cracked

Output:

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

Obfuscated code:

_____

Try it online!-link.

05AB1E, 4 bytes, cracked

Well then, I think I'm addicted to CnR's... Obfuscated code (_ indicates a wild card):

____

Sequence:

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

The sequence in OEIS starts at a(1) = 2.

Try it online!-link

Lua, 45 Bytes, Cracked

A small hint:

a(0) will make the program crash :)

Output

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

Code

Uses # to hide the code :).

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

I was using the OEIS A007814, with the following code:

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

Pyke, 15 bytes, SAFE

Output

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

Revealed code:

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

Solution:

OEIS A038822
wR}DSR_Q*L+#P)l
I used a couple of red herrings here by using wR} to generate the number 100 and revealing the character R which is normally used to rotate the stack. I also used #P)l instead of the more simple mPs to count the number of primes in the sequence.

C, 82 bytes, safe

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

Works with gcc, and it is a full program, which reads its input from stdin and prints its output to stdout. Here the sequence is A004526, floor(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

Solution:

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

This works only on little endian machines, and only if the size of char is 1 byte.
And only if the byte higher than the highest order byte of a has value 0. I think this is true for gcc since by default uninitialized global variables go into the bss segment, and initialized global variables go into the data segment (see https://stackoverflow.com/questions/8721475/if-a-global-variable-is-initialized-to-0-will-it-go-to-bss).
So only a goes into bss (the only other global variable b is initialized and thus goes into the data segment). If a is not at the end of bss, then the byte higher than the highest order byte of a is also in bss and thus has value 0.

05AB1E, 1 byte, Cracked

_

_ denotes hidden code.

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

Element, 10 bytes, cracked

Output:

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

There's probably only a few ways to compute this sequence in Element. I found a 9-char solution, but I figured this 10-char solution is actually more difficult. The # are hidden characters.

#_####@^#`

For convenience, here's the Try It Online and Esolang wiki pages.

The original was

2_3:~2@^^`

Pyth, 18 bytes

# marks unrevealed characters.

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

Outputs (starts from 1):

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

Online interpreter

05AB1E, 5 bytes, cracked

I hope that this submission isn't as easy as my other ones :p. Outputs:

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

Obfuscated code:

####O

Contains some non-ASCII characters though, uses CP-1252 encoding.

Try it online! might come in handy :p.

Jolf, 11 bytes, Cracked.

Output:

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

And the partially hidden code:

####xd###x#

Hint:

When I looked through the sequences in order, I didn't go very far before finding this one.

The cracked version isn't quite the same as my original code. I'm not currently at my computer, so I don't have it exactly, but it was something like this:

l fzxd!m%xH

(The only part I'm unsure about is the !m. It's whatever checks if a variable is zero.)

Pyke, 6 bytes, Cracked

###X#s

Output:

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

This doesn't work with N<1

Original solution:

hSmX$s