12

Dies ist eine Herausforderung für Bullen und Räuber . Der Thread der Cops zu dieser Herausforderung ist hier

Eine interessante Frage zum Nachdenken ist die folgende:

Wenn ich eine Folge von Zahlen habe, wie viele muss ich angeben, bevor klar ist, über welche Folge ich spreche?

Wenn ich zum Beispiel über die positiven ganzen Zahlen in der Reihenfolge ab sprechen möchte $1$ , könnte ich sagen , aber ist das wirklich genug? $1,2,3, \dots$

Ich habe eine Möglichkeit, diese Frage zu beantworten und ein Code-Golfer zu sein. Es geht um Code-Golf. Sie haben genügend Terme einer Sequenz angegeben, wenn der kürzeste Code, der diese Terme erzeugt, alle Terme der Sequenz erzeugt. Wenn wir dies in Form von Code-Golf betrachten, würde dies bedeuten, dass Sie genügend Testfälle bereitgestellt haben, so dass der kürzeste Code, der die Testfälle besteht, die gewünschte Aufgabe erfüllt.

Herausforderung

Diese Herausforderung ist eine Herausforderung für Polizisten und Räuber . In welchen Cops Testfälle präsentieren und Räuber einen kürzeren Weg finden müssen, um andere Testfälle als die beabsichtigte Sequenz zu fälschen. Cops werden die folgenden Dinge präsentieren:

Ein Teil des Codes, der eine positive Ganzzahl als Eingabe annimmt und eine Ganzzahl als Ausgabe erzeugt. Dieser Code kann entweder null oder eins sein, aber es sollte klar sein, was die Indizierung ist. Dieser Code definiert Ihre Sequenz.
Alle relevanten Plattform- oder Sprachanforderungen, die sich auf die Ausgabe auswirken können, z. B. die Größe von longint.
Eine Zahl , zusammen mit den ersten Begriffen der Sequenz, wie vom Code berechnet. Diese dienen als "Testfälle". $n$ $n$

Räuber werden ein Programm in derselben Sprache finden, das kürzer ist als das vorgestellte und alle Testfälle besteht (erzeugt die gleiche Ausgabe für die ersten Eingaben wie der Code des Polizisten). Der Code des Räubers muss sich auch in der Ausgabe des Cop-Programms für eine Nummer unterscheiden, die größer als . $n$ $n$

Wertung

Räuber werden in der Anzahl der Risse gewertet, die sie finden, wobei mehr Risse besser sind. Eine Antwort kann erneut geknackt werden, indem eine gültige Antwort gefunden wird, die kürzer als der ursprüngliche Riss ist. Wenn eine Antwort ein zweites Mal geknackt wird, wird der Punkt eher dem zweiten als dem ersten Cracker gegeben.

sequence cops-and-robbers

— Post Rock Garf Hunter
quelle

2

Lassen wir uns nicht gegenseitig von Räubern schlagen, weil sie eine Antwort geknackt haben (dh kürzester Riss im Sprachgewinn)

— 29.

@ fəˈnəˈtɛk Hört sich gut an, das habe ich hinzugefügt.

— Post Rock Garf Hunter

6

cQuents , Stephens Antwort , 3 Bytes

z~$

Probieren Sie es online!

Wie es funktioniert

z     Last item in the sequence
 ~    Concat
  $   Current index

Sieht so aus, als ob die Sequenzen identisch sein sollten, aber das gibt 12345678910für eine n = 10Weile "::$gibt 1234567891.

— Bubbler
quelle

5

JavaScript, fəˈnəˈtɪks Antwort (17 Bytes)

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

Nun, es war einfach, eine viel niedrigere Punktzahl hart zu codieren ... Weicht von der Referenzimplementierung für jeden Eintrag , 0-indiziert ab. Dies verwendet einen sehr bekannten JS-Golftick: Indizieren in eine Sequenz mit einer Ganzzahl, die die Grenzen überschreitet, gibt einen falschen Wert ( ) zurück, sodass sie in diesem Fall einfach mit einem logischen ODER ( ) auf einen Standardwert erzwungen werden kann In diesem Fall wird der letzte Term der Sequenz behandelt, aber auch die folgenden. $x\ge 6$ undefined||22

Testen

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

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

Erweitern Sie das Snippet

Alternativ können Sie es auch online versuchen!

— Mr. Xcoder
quelle

4

Haskell , Laikonis Antwort , 15 Bytes

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

Probieren Sie es online!

Normalerweise würde ich so etwas in einem Kommentar erwähnen, aber dann dachte ich, Bullen und Räuber sind ein bisschen härter.

Dies ist nur die Antwort von BMO abzüglich des Sonderfalls für b 42. Da Laikonis Original über Gleitkommazahlen verfährt, ist es nicht erforderlich, eine Zahl zu finden, die groß genug ist, um Rundungsfehler zu liefern, jedoch nicht in exakter IntegerArithmetik. Beispielsweise:

a 100000000000000000000000 = 4999999999999999580569600000000000000000000000
b 100000000000000000000000 = 5000000000000000000000000000000000000000000000

— Ørjan Johansen
quelle

Ich dachte, dass dies möglich sein könnte (daher schrieb ich, dass es für die erforderlichen Begriffe umgeschrieben werden kann), fand aber keinen Wert, für den es funktioniert. Gut gemacht!

— 2.

4

Python 2 , Antwort von xnor , 43 Bytes

Der erste Unterschied tritt für : $n = 69$

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

Probieren Sie es online!

Credits

Ein Großteil des Verdienstes für diesen Riss muss an @ Mr.Xcoder gehen, der zuerst einen Kommentar zu einem möglichen Angriff mit dieser Methode gepostet hat, und an @PoonLevi, der eine 44-Byte-Lösung gefunden hat.

Wie?

Theorie

$p$ $a$ $p$

\begin{matrix} (1) & {ein}^{p - 1} \equiv 1 (\mod p) \end{matrix}

$a^{p-1}\equiv 1 \pmod p\tag{1}$

$a=2$

2^{p - 1} \equiv 1 (\mod p)

$2^{p-1}\equiv 1 \pmod p$

$k$

2^{p - 1} = k p + 1

$2^{p-1}=kp+1$

Was dazu führt:

2^{p} = 2 k p + 2

$2^p=2kp+2$

2^{p} - 1 = 2 k p + 1

$2^p-1=2kp+1$

\begin{matrix} (2) & 2^{p} - 1 \equiv 1 (\mod p) \end{matrix}

$2^p-1\equiv 1 \pmod p\tag{2}$

$p=2$ $2$

$a^{n-1}\equiv 1 \pmod n$ $n$ $a$

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

2^{341 - 1} \equiv 1 (\mod 341)

$2^{341-1}\equiv 1 \pmod{341}$

2^{341} - 1 \equiv 1 (\mod 341)

$2^{341}-1\equiv 1 \pmod{341}$

$341$ $347$

Implementierung

$(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)

Probieren Sie es online!

$p=2$

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

Probieren Sie es online!

Der letzte Trick ist, n<1orstatt zu verwenden n and. Dies ist genauso lang, bewirkt jedoch, dass die letzte Iteration True anstelle von 0 zurückgibt, und fügt daher den fehlenden Offset zu jedem Term hinzu.

— Arnauld
quelle

Herzlichen Glückwunsch an euch alle! Dies ist die Lösung, die ich mir vorgestellt hatte. Ich finde es lustig, dass aus der Herausforderung Motivation "Wenn ich eine Folge von Zahlen habe, wie viele von ihnen muss ich angeben, bevor klar ist, von welcher Folge ich spreche?" Die ersten 50 Primzahlen anscheinend nicht genug sind - Ein Python-Golf-Alien würde annehmen, dass Sie über eine andere Sequenz sprechen.

— Xnor

@ Xnor Ich liebe die Idee eines "Python-Golf-Aliens"

— Dylnan

3

Python 3 , crashoz , 45 Bytes

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

Probieren Sie es online!

x*60-x**3*10+x**5/2-x**7/84 $sin(x)$ $x^7$

— xnor
quelle

3

JavaScript (ES6), Arnauld's Antwort (10 Bytes)

n=>8*n*n|n

Probieren Sie es online!

— ngn
quelle

2

Haskell , Laikonis Antwort , 26 22 Bytes

_{-4 Bytes ohne Infix div, danke an Laikoni !}

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

Probieren Sie es online!

Erläuterung

$0 \leq n \leq 20$ ceiling(realToFrac n/2)div(n+1)2 $n > 20$

b 42=0

— ბიმო
quelle

Ah, daran habe ich nicht gedacht. Ich habe einen anderen Ansatz, der zu einem 20-Byte-Riss führt, falls Sie ein bisschen mehr rätseln möchten. Auch ((n+1)`div`2)-> div(n+1)2.

— Laikoni

@Laikoni: Ja, verrate es noch nicht! Oopsies, ja, es ist schon eine Weile her, seit ich Golf gespielt habe. Ich werde es aktualisieren.

— 30.

2

> <> , Antwort von crashoz 203 Bytes

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





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

Probieren Sie es online!

Ich wollte etwas Kluges damit anfangen, dass ungerade / gerade Zahlen n=20bis auf ein wiederholtes Element in der Mitte gleich waren, aber es war einfacher, jedes Element nur hart zu codieren.

Die Eingabe erfolgt über die -vFlagge. Druckt nichts für Elemente über 34.

— Scherzen
quelle

2

Pascal (FPC) , AlexRacers Antwort , 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.

Probieren Sie es online!

Wann $0\le n\le 120$ Die Ausgänge sind identisch, aber wann $n=128$ die obigen Code-Ausgaben $127$ , während AlexRacer den Code ausgibt $126$ .

Dies scheint eine späte Antwort zu sein, aber trotzdem danke @AlexRacer für ein gutes Puzzle!

— r_64
quelle

1

Wow, das ist noch kürzer als das, was ich hatte. Willkommen bei PPCG!

— AlexRacer

1

JavaScript, fəˈnəˈtɪks Antwort (12 Bytes)

Dies funktioniert für die angegebenen Werte, schlägt jedoch für viele andere Werte fehl (z. B. $x=6$ ) aufgrund von Präzisionsfehlern.

x=>2.72**x|0

Testen

g=
x=>2.72**x|0

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

Erweitern Sie das Snippet

Alternativ können Sie es auch online versuchen!

— Mr. Xcoder
quelle

1

JavaScript, fəˈnəˈtɪks Antwort (17 Bytes)

Sie können im TIO-Link oder im Stack-Snippet-Ergebnis sehen, dass es bei Einträgen über fehlschlägt $15$ .

x=>2.7182819**x|1

Wenn Genauigkeit nur für erforderlich wäre $n\le 14$ (Der Erste $15$ Werte), x=>Math.exp(x)|1würde dann auch für 16 Bytes funktionieren.

Testen

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(","))

Erweitern Sie das Snippet

Alternativ können Sie es auch online versuchen!

— Mr. Xcoder
quelle

1

Schale , die BMOs 5-Byte mit 3 knackt 2 Byte

-1 dank BMO ( LdΣ-> LΣda, wenn man sich ein Tnum, Lführt „von String - Darstellung Länge“)

LΣ

Probieren Sie es online!

Die digitale Länge der Dreieckszahlen * stimmt überein $a(0)\cdots a(23)$ dann unterscheidet sich bei $a(24)$
... wenn die LΣErträge $3$ während ←d+16ergibt $4$ .

_{* Wo $T(0)=0$ hat eine digitale Länge von $1$ (nicht $0$ )}

— Jonathan Allan
quelle

Herzlichen Glückwunsch, das war meine genaue Lösung! Allerdings habe ich gerade bemerkt, dass für TNum s Lund Ld äquivalent sind, sparen Sie ein Byte;)

— ბიმო

Ah, ich habe im Wiki nach "digit" gesucht, um die digitale Länge zu finden, aber ich habe diese LÜberschreibungen nicht als "Länge der Zeichenfolgendarstellung" für erkannt Tnum.

— Jonathan Allan

(Beachten Sie, dass sie nur für nicht negative ganze Zahlen gleichwertig sind - gut genug dafür.)

— Jonathan Allan

1

> <> , Antwort von Aiden F. Pierce , 36 Bytes

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

Probieren Sie es online!

Eine andere Lösung mit jedem Wert, der pro Zeile fest codiert ist. Da die ursprüngliche Antwort auch größtenteils hart codiert war, fühle ich mich nicht zu schuldig.

— Scherzen
quelle

0

JavaScript, f answernəˈtɪks Antwort , 23 Bytes

Kehrt zurück $0$ zum $n\ge 14$ .

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

Probieren Sie es online!

Wie?

Der Ausdruck wird `${73211e9}`zu der Zeichenfolge erweitert "73211000000000"und stellt eine Nachschlagetabelle mit 14 Werten bereit, die von 14 subtrahiert werden, was die erwartete Sequenz ergibt.

Zum $n\ge 14$ , Das Ergebnis ist:

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

21 Bytes

Rückgabe NaNfür $n\ge 14$ , die als gültige Ausgabe angesehen werden können oder nicht.

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

Probieren Sie es online!

— Arnauld
quelle

Hardcodierung der Bullen und Räuber (Robbers)

Herausforderung

Wertung

cQuents , Stephens Antwort , 3 Bytes

Wie es funktioniert

JavaScript, fəˈnəˈtɪks Antwort (17 Bytes)

Testen

Haskell , Laikonis Antwort , 15 Bytes

Python 2 , Antwort von xnor , 43 Bytes

Credits

Wie?

Theorie

Implementierung

Python 3 , crashoz , 45 Bytes

JavaScript (ES6), Arnauld's Antwort (10 Bytes)

Haskell , Laikonis Antwort , 26 22 Bytes

Erläuterung

> <> , Antwort von crashoz 203 Bytes

Pascal (FPC) , AlexRacers Antwort , 80 Bytes

JavaScript, fəˈnəˈtɪks Antwort (12 Bytes)

Testen

JavaScript, fəˈnəˈtɪks Antwort (17 Bytes)

Testen

Schale , die BMOs 5-Byte mit 3 knackt 2 Byte

> <> , Antwort von Aiden F. Pierce , 36 Bytes

JavaScript, f answernəˈtɪks Antwort , 23 Bytes

Wie?

21 Bytes