これは警官と強盗の挑戦です。この課題に対する警官のスレッドはこちら

考えるべき興味深い質問は次のとおりです。

番号のシーケンスがある場合、どのシーケンスについて話しているかが明確になる前に、それらの番号をいくつ提供する必要がありますか？

私はから順に、正の整数についての話をしたい場合は例えば$1$、私が言うことができる$1,2,3, \dots$、それは本当に十分でしょうか？

この質問に答える1つの方法があり、コードゴルファーになるには、コードゴルフが関係します。これらの用語を生成する最短コードがシーケンスのすべての用語を生成する場合、シーケンスの十分な用語を提供しました。これをcode-golfの観点から考えると、テストケースを通過する最短のコードが目的のタスクを実行するように、十分なテストケースを提供したことになります。

チャレンジ

この挑戦は警官と強盗の挑戦です。どの警官がテストケースを提示し、強盗は、意図されたシーケンス以外のテストケースをスプーフィングするためのより短い方法を見つける必要があります。警官は次のものを提示します。

• 入力として正の整数を受け取り、出力として整数を生成するコード。このコードは、0個または1個のインデックスを付けることができますが、インデックスが何であるかを明確にする必要があります。このコードはシーケンスを定義します。

• 出力に影響する可能性のある関連するプラットフォームまたは言語の要件（longintのサイズなど）。

• コードによって計算されたシーケンスの最初のn項とともに、数値。これらは「テストケース」として機能します。$n$$n$

強盗は、提示されたものよりも短い同じ言語のプログラムを見つけ、すべてのテストケースに合格します（最初の入力に対して警官のコードと同じ出力を生成します）。強盗のコードは、警官のプログラムからの出力がnよりも大きい数で異なっていなければなりません。$n$$n$

得点

強盗は、発見されたクラックの数でスコアが付けられ、クラックが多いほど良くなります。元のクラックよりも短い有効な回答を見つけることにより、回答を再びクラックすることができます。2回目に答えがクラッキングされた場合、ポイントは最初ではなく2番目のクラッカーに与えられます。

cQuents、Stephenの回答、3バイト

z~$

オンラインでお試しください！

使い方

z     Last item in the sequence
 ~    Concat
  $   Current index

シーケンスのように見えるが同一である必要がありますが、これは与え12345678910用n = 10ながら"::$提供します1234567891。

JavaScript、fəˈnɛtɪkの回答（17バイト）

x=>"11237"[x]||22

まあ、それははるかに低いスコアを取得するためにハードコーディングする簡単だった...すべてのエントリの参照実装とは異なり、0インデックス。これは非常によく知られているJSゴルフトリックを使用します：境界を超える整数でシーケンスにインデックスを付けると、偽の値（）が返されるため、論理OR（$x\ge 6$undefined||） case 22、シーケンスの最後の項だけでなく、後続の項も扱います。

テスト中

let f=x=>"11237"[x]||22

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

または、オンラインでお試しください！

ハスケル、ライコニの答え、15バイト

b n=n*div(n+1)2

オンラインでお試しください！

私は通常、コメントでこのようなことを指摘しますが、警官や強盗はもう少しイライラすると思いました。

これは、BMOの答えからの特別なケースを引いたものですb 42。Laikoniのオリジナルは浮動小数点を経由するので、それは必要ではありませんInteger。正確な算術ではなく、その中に丸め誤差を与えるのに十分な大きさの数値を見つけるだけです。例えば：

a 100000000000000000000000 = 4999999999999999580569600000000000000000000000
b 100000000000000000000000 = 5000000000000000000000000000000000000000000000

Python 2、xnorの答え、43バイト

最初の違いは、場合に発生します。$n = 69$

f=lambda n,p=2:n<1or-~f(n-(~-2**p%p<2),p+1)

オンラインでお試しください！

クレジット

このクラックの功績は、この方法を使用した攻撃の可能性について最初にコメントを投稿した@ Mr.Xcoderと@PoonLeviに与えられます。、44バイトのソリューションを見つけたられます。

どうやって？

理論

亀裂はフェルマーの小さな定理に基づいており、が素数で、aとpが比較的素数の場合、$p$$a$$p$

特に、：$a=2$

したがって、次のような正の整数が存在します。$k$

これは以下につながります：

2 P - 1 = 2 k個のP + 1 2 P - 1 ≡

この最後の式は、2がそれ自体とは比較的素数でなくても、Pythonコードの派生元であり、現在に対して成り立っています。$p=2$$2$

さて、最も重要な部分については、フェルマーの小さな定理の逆は真実ではありません。我々は持っていることのn - 1 ≡ 1ある複合数 nに対して。そのような数は、aを基にする Fermat擬似素数と呼ばれます。基数2へのフェルマー擬似プライムは、Pouletとしても知られています。$a^{n-1}\equiv 1 \pmod n$$n$$a$素数は数とます。

$2$$n = 341=11\times 31$

これは、アルゴリズムがを返すことを意味します$341$$347$。

実装

$(2)$

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

<2==1$1$$2^1-1\equiv 0 \pmod 1$

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

オンラインでお試しください！

で始まることによって $p=2$、1回の反復回数が少ないため、期待される用語が1減ります。

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

オンラインでお試しください！

最後のトリックは、のn<1or代わりに使用することですn and。これは同じ長さですが、最後の反復で0ではなくTrueが返されるため、不足しているオフセットが各項に追加されます。

Python 3、crashoz、45バイト

lambda n:int(60*math.sin(n/10-2))
import math

オンラインでお試しください！

式x*60-x**3*10+x**5/2-x**7/84は、次のテイラー級数です。$sin(x)$ 以下 $x^7$ 60を掛けたターム。これは使用される入力に対して十分正確ですが、値が高い場合は、切り捨てられたタームがより適切になるにつれて2つが発散します。

JavaScript（ES6）、Arnouldの回答（10バイト）

n=>8*n*n|n

オンラインでお試しください！

ハスケル、ライコニの答え、26 22バイト

_{Laikoniのdivおかげで、インフィックスを使用しないことで-4バイト！}

b 42=0;b n=n*div(n+1)2

オンラインでお試しください！

説明

にとって $0 \leq n \leq 20$ the term ceiling(realToFrac n/2) can be rewritten as div(n+1)2 which gives us enough bytes to pattern match on an $n > 20$ that leads to a crack within 28 bytes:

b 42=0

> <>、crashozの回答 203バイト

:l2-$g:0=?;n:





M
-
B
"
BM
",
7M
!"
BBM
!",
7CM
!"-
BBBM
!!",
7BBMM
!!,,
7BBBMM
!!,,
7BBBMM
!!!,,
7BBBBMM
!!!,,
7BBBBMM
!!!!,,
7BBBBBMM
!!!!,,
7BBBBBMM
!!!!!,,
7BBBBBBMM

オンラインでお試しください！

上記の奇数/偶数n=20は、中央の要素が繰り返されることを除いて同じであるという事実を巧みに使いますが、すべての要素をハードコーディングする方が簡単でした。

入力は-vフラグ経由です。34を超える要素には何も出力しません。

Pascal (FPC), AlexRacer's answer, 80 bytes

var n,m:word;begin read(n);while n<>0 do begin n:=n div 2;m:=m+n;end;write(m)end.

Try it online!

When $0\le n\le 120$ the outputs are identical, but when $n=128$ the above code outputs $127$, while AlexRacer's code outputs $126$.

This seems a late answer, but anyway thanks @AlexRacer for a good puzzle!

JavaScript, fəˈnɛtɪk's answer (12 bytes)

This works for the given values but fails for many other values (e.g. $x=6$) due to precision errors.

x=>2.72**x|0

Testing

g=
x=>2.72**x|0

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

Alternatively, Try it online!

JavaScript, fəˈnɛtɪk's answer (17 bytes)

You can see in the TIO link or in the Stack Snippet result that it fails for entries higher than $15$.

x=>2.7182819**x|1

If accuracy would only be required for $n\le 14$ (the first $15$ values), then x=>Math.exp(x)|1 would work as well for 16 bytes.

Testing

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

tmp=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21]
console.log(tmp.map(f).join(","))
console.log(tmp.map(g).join(","))

Alternatively, Try it online!

Husk, cracking BMO's 5 byter with  3  2 bytes

-1 thanks to BMO (LdΣ -> LΣ since, when given a Tnum, L performs "length of string representation")

LΣ

Try it online!

The digital length of the triangular numbers* matches $a(0)\cdots a(23)$ then differs at $a(24)$
...when LΣ yields $3$ while ←d+16 yields $4$.

_{* Where $T(0)=0$ has a digital length of $1$ (not $0$)}

><>, Aiden F. Pierce's answer, 36 bytes

v101786
i5844
419902
%
>l{:}g:0=?;o:

Try it online!

Another solution with each value hardcoded per line. Since the original answer was also mostly hard-coded, I don't feel too guilty about this.

JavaScript, fəˈnɛtɪk's answer, 23 bytes

Returns $0$ for $n\ge 14$.

x=>14-`${73211e9}`[x]|0

Try it online!

How?

The expression `${73211e9}` expands to the string "73211000000000", providing a lookup table of 14 values that are subtracted from 14, which gives the expected sequence.

For $n\ge 14$, the result is:

(14 - undefined) | 0
=== NaN | 0
=== 0

21 bytes

Returns NaN for $n\ge 14$, which may or may not be considered a valid output.

x=>14-`${73211e9}`[x]

Try it online!