To wyzwanie dla gliniarzy i rabusiów . Wątek rabusiów jest tutaj .

Ciekawe pytanie do przemyślenia to:

Jeśli mam ciąg liczb, ile z nich muszę podać, zanim stanie się jasne, o jakiej sekwencji mówię?

Na przykład, jeśli chcę mówić o dodatnich liczbach całkowitych w kolejności od , mógłbym powiedzieć , ale czy to naprawdę wystarczy?$1$$1,2,3, \dots$

Mam jeden sposób na udzielenie odpowiedzi na to pytanie, a bycie golfistą wymaga od golfa. Podano wystarczającą liczbę sekwencji, jeśli najkrótszy kod, który je tworzy, tworzy wszystkie warunki sekwencji. Jeśli myślimy o tym w kategoriach golfa kodu, oznacza to, że dostarczyłeś wystarczającą liczbę przypadków testowych, tak aby najkrótszy kod, który przejdzie przez przypadki testowe, wykonał pożądane zadanie.

Wyzwanie

To wyzwanie jest wyzwaniem dla gliniarzy i rabusiów . W którym policjanci będą prezentować przypadki testowe, a złodzieje będą musieli znaleźć krótszy sposób na sfałszowanie przypadków testowych niż zamierzona sekwencja. Gliniarze przedstawią następujące rzeczy:

• Fragment kodu, który przyjmuje nieujemną liczbę całkowitą jako dane wejściowe i tworzy liczbę całkowitą jako dane wyjściowe. Ten kod określi Twoją sekwencję. Twój kod nie musi obsługiwać 0 jako danych wejściowych, zamiast tego wybierz 1 jako najmniejszą wartość wejściową. Powinno być jasne, czy tak jest w twojej odpowiedzi.

• Wszelkie odpowiednie wymagania dotyczące platformy lub języka, które mogą wpłynąć na wynik, na przykład rozmiar longinta.

• Liczba wraz z pierwszymi członami sekwencji obliczonymi przez kod. Będą one działać jako „przypadki testowe”.$n$$n$

Zachęcamy do wyjaśnienia, co robi twoja sekwencja i połączenia OEIS, jeśli istnieje, jednak to kod definiuje sekwencję, a nie opis.

Rabusie znajdą program w tym samym języku, który jest krótszy niż ten przedstawiony i przejdzie wszystkie przypadki testowe (produkuje takie same dane wyjściowe dla pierwszych danych wejściowych jak kod gliniarza). Kod rabusia musi również różnić się wyjściem z programu policjanta dla pewnej liczby większej niż .$n$$n$

Gliniarze muszą umieć łamać własne odpowiedzi przed ich przesłaniem.

Po tygodniu policjant może ujawnić swój crack i oznaczyć swoją odpowiedź jako Bezpieczną. Odpowiedzi oznaczone jako takie nie mogą być już łamane.

Punktacja

Odpowiedzi gliniarzy zostaną ocenione według liczby bajtów, przy czym im mniej bajtów, tym lepiej. Pęknięte odpowiedzi dają nieskończony wynik.

cQuents , 4 bytes ( Cracked )

"::$

Wypróbuj online!

Oto osiem ( n=8) przypadków:

1 1
2 12
3 123
4 1234
5 12345
6 123456
7 1234567
8 12345678

Objaśnienie kodu:

"      Stringify sequence (join on "", remove it and see what happens)
 ::    Given input n, output all items in the sequence up to and including n
   $   Each item in the sequence equals the index

Sekwencja jest 1,2,3,4,5 ...więc połączona, ""więc staje się 12345 ...i ::oznacza, że ​​drukuje do wejścia.

Python 3 , 66 57 bajtów ( pęknięty )

cracked by xnor
również cracked przez Cat Wizard przed edycją

def f(n):x=n/10-2;return int(x*60-x**3*10+x**5/2-x**7/84)

Wypróbuj online!

Dzień dobry! Oto sekwencja do złamania dla . Daje te pierwsze 40 elementów z indeksowaniem 0, to nie jest sekwencja OEIS$n=40$

[-54, -56, -58, -59, -59, -59, -59, -57, -55, -53, -50, -46, -43, -38, -33, -28, -23, -17, -11, -5, 0, 5, 11, 17, 23, 28, 33, 38, 43, 46, 50, 53, 55, 57, 59, 59, 59, 59, 58, 56]

Python 2 , 44 bajty ( pęknięty )

f=lambda n,i=1,p=1:n and-~f(n-p%i,i+1,p*i*i)

Wypróbuj online!

Liczby pierwsze. Jaka sekwencja może być czystsza? Lub więcej przesadzone ? Twoim celem jest stworzenie pierwszych 50 liczb pierwszych do n=1celu n=50.

Kod jest generatorem twierdzenia Wilsona skopiowanym dokładnie z tej wskazówki .

Różne wartości dla sekwencji alternatywnej nie wynikają z ograniczeń maszyny, takich jak przelewy i precyzja. Brak bibliotek stron trzecich.

Cracked przez Arnaulda, @PoonLevi i Mr. Xcodera.

Wolfram Language (Mathematica) , 39 34 bajtów (Bezpieczny)

Check[{1,9,7}[[#]],18+Boole[#>9]]&

Wypróbuj online!

Wygląda na proste, rozwiązanie powinno być trudne.

$n = 99$

{1, 9, 7, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19}

Powyższa lista jest równa:

Join[{1, 9, 7}, Table[18, 6], Table[19, 90]]

Oto szablon do sprawdzenia rozwiązania: Wypróbuj online!

Zamierzone pęknięcie

Problem polega na tym, że wynik wzrasta o 1, gdy liczba cyfr wzrasta o 1, z wyjątkiem pierwszych trzech wyrazów; zamierzone rozwiązanie ma coś wspólnego z konwersją ciągów znaków.

Dlatego czytając dokumentację dotyczącą konwersji między wyrażeniami i ciągiem , można znaleźć funkcję SpokenString.

Rozwiązaniem jest po prostu długość wyrażenia mówionego x^ndla różnych danych wejściowych:StringLength@SpokenString[x^#]&

Haskell , 29 bajtów (Pęknięty: 1 , 2 )

a n=n*ceiling(realToFrac n/2)

Wypróbuj online!

$a(n)=n\lceil \frac{n}{2} \rceil$

$0 \leq n \leq 20$map a [0..20]

[0,1,2,6,8,15,18,28,32,45,50,66,72,91,98,120,128,153,162,190,200]

Zamierzone rozwiązanie (20 bajtów)

b n=sum$n<$show(3^n)

$n=23$$a(23) = 276$$b(23) = 253$

$b(n) = n\ len(3^n) = n \lceil log_{10}(1+3^n)\rceil$$0$$22$

_źródło

JavaScript (ES6), 12 bajtów ( pęknięty )

Ten jest raczej łatwy.

n=>n*(8*n+1)

Wypróbuj online!

To jest A139275 :

$0\le n<9$

I zgodnie z zasadami wyzwania musi się różnić.

Malbolge, 10 bajtów

ub&;$9]J6

Zauważ, że kod kończy się bajtem 0x14 (kontrola urządzenia 4).

Wypróbuj online!

Sekwencja 0 do indeksowania to crack [9, 19, 29].

> <> , 276 bajtów ( pęknięty )

1$1-:?!v$:      1[0$          >:?!va2[$:{:@%:{$-{,]v
       >$n; v              <  ^   >~{]02.1+1+ffr+1r<
 :}[r]{  [01>:{*@@+$a*l2=?!^~]+ff+9+1g"3"=?v"3"ff+9+1pf0.
 :}[l01-$>    $:0(?v$@$:@@:@)?v@@1-$}v     >"2"ff+9+1p00.
>.       ^-1l v!?} <  .4a}$@@$<   .4a<
^26{]r0[}:{]~{<

Wypróbuj online! Zadzwoń do tego, -v naby uzyskać n-ty element (1-indeksowany)

1$1-:?!;$::n84*o1[0$          >:?!va2[$:{:@%:{$-{,]v
            v              <  ^   >~{]02.1+1+ffr+1r<
 :}[r]{  [01>:{*@@+$a*l2=?!^~]+ff+9+1g"3"=?v"3"ff+9+1pf0.
 :}[l01-$>    $:0(?v$@$:@@:@)?v@@1-$}v     >"2"ff+9+1p00.
>.       ^-1l v!?} <  .4a}$@@$<   .4a<
^26{]r0[}:{]~{<

Wypróbuj online! Zadzwoń z, -v naby uzyskać listę elementów n-1, zaczynając od 1

Internetowy tłumacz ryb

Długi i skomplikowany, to OEIS A004000 .

Niech a (n) = k, utwórz m poprzez odwrócenie cyfr k, dodaj m do k Następnie posortuj cyfry sumy w porządku rosnącym, aby uzyskać (n + 1).

Przykład: 668 -> 668 + 866 = 1534 -> 1345.

$n = 34$

1 2 4 8 16 77 145 668 1345 6677 13444 55778 133345 666677 1333444 5567777 12333445 66666677 133333444 556667777 1233334444 5566667777 12333334444 55666667777 123333334444 556666667777 1233333334444 5566666667777 12333333334444 55666666667777 123333333334444 556666666667777 1233333333334444 5566666666667777

Galaretka , 6 bajtów , Bezpiecznie!

<4+ạ2ȯ

Definiuje to sekwencję o indeksie zerowym , w której:

$a(0)\cdots a(15)$1,1,1,2,2,3,4,5,6,7,8,9,10,11,12,13

Wypróbuj online! ( tutaj jest wersja z jedną wartością)

Obecnie nie ma tego w OEIS (chociaż A34138 będzie działać jako crack, jeśli będzie wystarczająco krótki)

Zamierzone pęknięcie

$16$$n$
$17^{\text{th}}$$107004539285280$$15$$14=a(16)$

!ÆsDL

JavaScript, 26 bajtów ( pęknięty )

let f=x=>x>1?f(x-1)*f(x-2)+1:1

for (x of [0,1,2,3,4,5,6,7]) {
  console.log(x + ' -> ' + f(x))
}

OEIS A007660

Wyjście to pierwsze 6 elementów z indeksowaniem 0 (1,1,2,3,7,22)

(nieco przesunięty w stosunku do tego, co ma na liście OEIS)

Wystarczy stworzyć prostą do rozwiązania odpowiedź, aby rozpocząć

Wypróbuj online!

JavaScript, 16 bajtów ( pęknięty )

g=
x=>Math.exp(x)|0

tmp=[0,1,2,3,4]
console.log(tmp.map(g).join(','))

$\lfloor e^n\rfloor$

Wymagane dane wejściowe do dopasowania wynoszą 0,1,2,3,4.

Wypróbuj online!

APL (Dyalog Unicode) , 17 15 bajtów

⌈∊∘1 5+.633*5-⊢

Wypróbuj online!

Pierwsze 13 warunków (oparte na 1) to:

2 1 1 1 2 2 3 4 7 10 16 25 39

Wskazówka: w zamierzonym rozwiązaniu wykorzystywana jest jedna z najmniej używanych wbudowanych funkcji.

Łuska , 5 bajtów ( pęknięty przez Jonathana Allan )

$16$

←d+16

Wypróbuj online!

$0 \leq n < 23$

Wyjaśnienie

←d+16  -- example input:  23
  +16  -- add 16:         39
 d     -- digits:         [3,9]
←      -- extract first:  3

Rozwiązanie

LdΣ

JavaScript, 25 bajtów ( pęknięty 21 bajtów)

f=
x=>[7,11,12,13,13][x]||14

for(i=0;i<15;i++)
  console.log(i+"->"+f(i))

Sekwencja 7,11,12,13,13, a następnie nieskończone 14s.

Zamierzone rozwiązanie 22 bajty:

x = Math.atan (x + 1) * 10 | 0

Wypróbuj online!

JavaScript, 22 bajtów ( pęknięty )

f=
x=>(3-(5/63)**.5)**x|1

for(y=0;y<16;y++)
  console.log(y +"->"+f(y))

Jest to indeksowane 0 i wymagana jest dokładność do wartości wejściowej 15. Nie można go znaleźć w OEIS

Moje rozwiązanie 20 bajtów

x => 163 ** (32 * x / 163) | 1

Wypróbuj online!

> <> , 42 bajty, pęknięty

i3%0v
642 .
840
789
159
a 1
v<<
n
l
?
\/
;

Wypróbuj online!

Sekwencja do złamania (indeksowana 0): 101786, 5844, 19902(nie w OEIS).

Zamierzone rozwiązanie , w celach informacyjnych.

Perl 6 , 53 bajtów

{(1,2,2,{$!=++$;prepend(@,2-$!%2 xx$_).pop}...*)[$_]}

Wypróbuj online!

Anonimowy blok kodu, który zwraca zindeksowaną sekwencję Kolakoski ( OEIS A000002 ). Wymagane są rozwiązania, aby dopasować pierwsze 130 elementów, aby dla niektórych n > 129różniły się od sekwencji Kolakoskiego.

Pascal (FPC) , 86 bajtów ( pęknięty )

var n:word;begin read(n);write(n div 2+n div 4+n div 8+n div 16+n div 32+n div 64)end.

Wypróbuj online!

$n=120$

0   0   1   1   3   3   4   4   7   7   8   8  10  10  11  11  15  15  16  16  18  18  19  19  22  22  23  23  25  25  26  26  31  31  32  32  34  34  35  35  38  38  39  39  41  41  42  42  46  46  47  47  49  49  50  50  53  53  54  54  56  56  57  57  63  63  64  64  66  66  67  67  70  70  71  71  73  73  74  74  78  78  79  79  81  81  82  82  85  85  86  86  88  88  89  89  94  94  95  95  97  97  98  98 101 101 102 102 104 104 105 105 109 109 110 110 112 112 113 113 116

var n,i,s:word;begin read(n);i:=2;repeat s:=s+n div i;i:=i*2until i>n;write(s)end.

ale r_64 uczynił to jeszcze lepszym !