Ich habe random.org nach 128 Zufallszahlen zwischen 0 und 2 ³² - 1 gefragt . Da der Zufallszahlengenerator so sehr darauf bedacht war, die ersten 64 Zahlen zuerst zu geben, sind sie offensichtlich zufälliger als die anderen 64.

Schreiben Sie ein vollständiges Programm oder eine vollständige Funktion, die ein wahres Ergebnis zurückgibt, wenn eine der folgenden 64 Ganzzahlen eingegeben wird:

[1386551069, 1721125688, 871749537, 3410748801, 2935589455, 1885865030, 776296760, 614705581, 3841106923, 434616334, 1891651756, 1128215653, 256582433, 310780133, 3971028567, 2349690078, 489992769, 493183796, 3073937100, 3968540100, 777207799, 515453341, 487926468, 2597442171, 950819523, 1881247391, 3676486536, 3852572850, 3498953201, 2544525180, 297297258, 3783570310, 2485456860, 2866433205, 2638825384, 2405115019, 2734986756, 3237895121, 1560255677, 4228599165, 3106247743, 742719206, 2409129909, 3008020402, 328113612, 1081997633, 1583987616, 1029888552, 1375524867, 3913611859, 3488464791, 732377595, 431649729, 2105108903, 1454214821, 997975981, 1764756211, 2921737100, 754705833, 1823274447, 450215579, 976175934, 1991260870, 710069849]

Und ein falsches Ergebnis für die anderen 64 Zahlen:

[28051484, 408224582, 1157838297, 3470985950, 1310525292, 2739928315, 3565721638, 3568607641, 3857889210, 682782262, 2845913801, 2625196544, 1036650602, 3890793110, 4276552453, 2017874229, 3935199786, 1136100076, 2406566087, 496970764, 2945538435, 2830207175, 4028712507, 2557754740, 572724662, 2854602512, 736902285, 3612716287, 2528051536, 3801506272, 164986382, 1757334153, 979200654, 1377646057, 1003603763, 4217274922, 3804763169, 2502416106, 698611315, 3586620445, 2343814657, 3220493083, 3505829324, 4268209107, 1798630324, 1932820146, 2356679271, 1883645842, 2495921085, 2912113431, 1519642783, 924263219, 3506109843, 2916121049, 4060307069, 1470129930, 4014068841, 1755190161, 311339709, 473039620, 2530217749, 1297591604, 3269125607, 2834128510]

Jede andere Eingabe als eine dieser 128 Zahlen ist undefiniertes Verhalten.

Wenn Ihre Lösung programmgesteuert gefunden wird, teilen Sie bitte auch den Code mit, mit dem sie generiert wurde!

Das ist Code-Golf , also gewinnt die kürzeste Lösung in Bytes.

CJam, 53 52 47 Bytes

l~"X    0'ò"2/Dfb+:%"gÇâì6Ô¡÷Ç8nèS¡a"312b2b=

Es gibt nicht druckbare Dateien, aber die beiden Zeichenfolgen erhalten Sie mit

[88 9 48 5 39 5 29 1 242]:c
[8 103 199 226 236 54 212 15 161 247 199 56 110 232 83 161 97]:c

beziehungsweise. Dies zeigt auch, dass die Codepunkte unter 256 liegen.

Dies ist eine Modulo-Kettenantwort, bei der die folgenden Module der Reihe nach auf die Eingabe-Ganzzahl angewendet werden:

[1153 629 512 378 242 136]

Da diese Liste Ganzzahlen größer als 255 enthält, wird die Liste mit jeweils zwei Zeichen codiert. Die Dekodierung erfolgt durch 2/DfbAufteilen der Zeichenfolge in Abschnitte der Länge zwei und Konvertieren von jeweils einer Basiszahl (z 88*13 + 9 = 1153. B. 13 ). Es gibt jedoch zwei Ausnahmen bei der Dekodierung:

• Die letzte Zahl ( 136) ist nicht enthalten (siehe unten),
• Die vorletzte Zahl wird durch ein einzelnes Zeichen dargestellt, da number ( 242) kleiner als 256 ist und die Aufteilung eines Arrays ungerader Länge in Blöcke der Größe 2 am Ende ein Array der Größe 1 hinterlässt. Danke an @ MartinBüttner für diesen Tipp!

Sobald die Module die Eingabe-Ganzzahl auf eine relativ kleine Zahl reduziert haben, führen wir eine Suche aus einer Tabelle durch. Diese Tabelle wird über die zweite Zeichenfolge codiert, die in eine Basisnummer konvertiert und 312dann in Basis 2 decodiert wird, die wir indizieren. Da die Array-Indizierung von CJam abgeschlossen ist, können wir, wie bereits erwähnt, das letzte Modulo weglassen.

Versuchen Sie es online | Testsuite

Netzhaut , 117 Bytes

([023]3|[067]0|[1289]1|5[5689]|67|96|88|77|65|05)$|^(8|4[358]|7[147]|51|37|30)|865|349|2.{5}5|761|74[348]|728|811|990

Eine Regex-Golf-Antwort, die eine positive Ganzzahl für Wahrheit und eine Null für Falschheit ausgibt.

Probieren Sie es online! | Testsuite - wahrheitsgemäß | Testsuite - falsch | Regex101

JavaScript (ES6) 233

Eine anonyme Funktion, die 0 als falsyund ungleich Null als zurückgibttruthy

x=>~"lnhp2wm8x6m9vbjmrqqew9v192jc3ynu4krpg9t3hhx930gu8u9n1w51ol509djycdyh077fd1fnrzv6008ipkh0704161jayscm0l6p4ymj9acbv5ozhjzxo3j1t20j9beam30yptco033c9s3a8jwnre63r29sfbvc5371ulvyrwyqx3kfokbu66mpy9eh" // newline added for readability
.search((x.toString(36)).slice(-3))

Überprüfung der letzten 3 Ziffern in der Zahlendarstellung in Basis 36.

Die Prüfzeichenfolge ist folgendermaßen aufgebaut:

a=[1386551069, 1721125688, ... ]
H=x=>(x.toString(36)).slice(-3)
Q=a.map(x=>H(x)).join('')

Prüfung

f=x=>~"lnhp2wm8x6m9vbjmrqqew9v192jc3ynu4krpg9t3hhx930gu8u9n1w51ol509djycdyh077fd1fnrzv6008ipkh0704161jayscm0l6p4ymj9acbv5ozhjzxo3j1t20j9beam30yptco033c9s3a8jwnre63r29sfbvc5371ulvyrwyqx3kfokbu66mpy9eh"
.search((x.toString(36)).slice(-3))

a=[1386551069, 1721125688, 871749537, 3410748801, 2935589455, 1885865030, 776296760, 614705581, 3841106923, 434616334, 1891651756, 1128215653, 256582433, 310780133, 3971028567, 2349690078, 489992769, 493183796, 3073937100, 3968540100, 777207799, 515453341, 487926468, 2597442171, 950819523, 1881247391, 3676486536, 3852572850, 3498953201, 2544525180, 297297258, 3783570310, 2485456860, 2866433205, 2638825384, 2405115019, 2734986756, 3237895121, 1560255677, 4228599165, 3106247743, 742719206, 2409129909, 3008020402, 328113612, 1081997633, 1583987616, 1029888552, 1375524867, 3913611859, 3488464791, 732377595, 431649729, 2105108903, 1454214821, 997975981, 1764756211, 2921737100, 754705833, 1823274447, 450215579, 976175934, 1991260870, 710069849]
b=[28051484, 408224582, 1157838297, 3470985950, 1310525292, 2739928315, 3565721638, 3568607641, 3857889210, 682782262, 2845913801, 2625196544, 1036650602, 3890793110, 4276552453, 2017874229, 3935199786, 1136100076, 2406566087, 496970764, 2945538435, 2830207175, 4028712507, 2557754740, 572724662, 2854602512, 736902285, 3612716287, 2528051536, 3801506272, 164986382, 1757334153, 979200654, 1377646057, 1003603763, 4217274922, 3804763169, 2502416106, 698611315, 3586620445, 2343814657, 3220493083, 3505829324, 4268209107, 1798630324, 1932820146, 2356679271, 1883645842, 2495921085, 2912113431, 1519642783, 924263219, 3506109843, 2916121049, 4060307069, 1470129930, 4014068841, 1755190161, 311339709, 473039620, 2530217749, 1297591604, 3269125607, 2834128510]

A.textContent=a.map(x=>f(x))
B.textContent=b.map(x=>f(x))

<table>
  <tr><th>first 64 - truthy</th></tr><tr><td id=A></td></tr>
  <tr><th>other 64 - falsy</th></tr><tr><td id=B></td></tr>
</table>  

Mathematica, 218 217 Bytes

Fold[Mod,#,{834,551,418,266,228,216,215,209,205,199,198,195,178,171,166,162,154,151,146,144,139,137,122,120,117,114,110,106,101,98,95,88,84,67,63,61,60,57,55,51,45,44,43,41,40,35,34,30,27,26,25,23,20,14,13,11,10,9}]<1

Aus irgendeinem Grund gibt es eine Menge von Modulen, die es uns ermöglicht, zwei Mengen nur danach zu unterscheiden, ob das Ergebnis nach dem Anwenden der Module Null ist oder nicht. Die lange Liste der Module wurde von diesem Programm generiert:

Block[{data1, data2, n, mods}, 
 data1 = {1386551069, 1721125688, 871749537, 3410748801, 2935589455, 
   1885865030, 776296760, 614705581, 3841106923, 434616334, 
   1891651756, 1128215653, 256582433, 310780133, 3971028567, 
   2349690078, 489992769, 493183796, 3073937100, 3968540100, 
   777207799, 515453341, 487926468, 2597442171, 950819523, 1881247391,
    3676486536, 3852572850, 3498953201, 2544525180, 297297258, 
   3783570310, 2485456860, 2866433205, 2638825384, 2405115019, 
   2734986756, 3237895121, 1560255677, 4228599165, 3106247743, 
   742719206, 2409129909, 3008020402, 328113612, 1081997633, 
   1583987616, 1029888552, 1375524867, 3913611859, 3488464791, 
   732377595, 431649729, 2105108903, 1454214821, 997975981, 
   1764756211, 2921737100, 754705833, 1823274447, 450215579, 
   976175934, 1991260870, 710069849};
 data2 = {28051484, 408224582, 1157838297, 3470985950, 1310525292, 
   2739928315, 3565721638, 3568607641, 3857889210, 682782262, 
   2845913801, 2625196544, 1036650602, 3890793110, 4276552453, 
   2017874229, 3935199786, 1136100076, 2406566087, 496970764, 
   2945538435, 2830207175, 4028712507, 2557754740, 572724662, 
   2854602512, 736902285, 3612716287, 2528051536, 3801506272, 
   164986382, 1757334153, 979200654, 1377646057, 1003603763, 
   4217274922, 3804763169, 2502416106, 698611315, 3586620445, 
   2343814657, 3220493083, 3505829324, 4268209107, 1798630324, 
   1932820146, 2356679271, 1883645842, 2495921085, 2912113431, 
   1519642783, 924263219, 3506109843, 2916121049, 4060307069, 
   1470129930, 4014068841, 1755190161, 311339709, 473039620, 
   2530217749, 1297591604, 3269125607, 2834128510};
 n = 1;
 mods = {};
 While[Intersection[Mod[data1, n], Mod[data2, n]] != {}, n++];
 FixedPoint[
  (mods = Append[mods, n]; data1 = Mod[data1, n]; 
    data2 = Mod[data2, n]; n = 1;
    While[Intersection[Mod[data1, n], Mod[data2, n]] != {}, n++]; 
    n) &
  , n];
 {mods, {Fold[Mod, data1, mods], Fold[Mod, data2, mods]}}
 ]

Die erste Ausgabe sind die Module, die zweite und die dritte Ausgabe sind die beiden Listen, auf die die Module angewendet wurden. Die zwei langen Listen sind die Mengen.

PowerShell, Version 3 + 194 Byte

$args[0]%834%653-in(40..45+4,8,12,51,60,64,69,76,84,86,93,97,103,117+137..149+160,162,178+195..209+215..227+255,263+300..329+354,361,386,398,417,443,444+469..506+516,519,535,565,581,586,606,618)

Ein bisschen anders, also dachte ich, ich würde es posten. Es wird nicht das kürzeste gewinnen, aber es kann jemand anderem Ideen geben, um seinen Code zu verkürzen.

Wir nehmen immer noch die Eingabe-Ganzzahl $args[0]und wenden Modulo-Operationen darauf an, also ist da nichts anderes. Im obigen Beispiel verwenden wir den -inOperator (daher v3 + -Anforderung), sodass dieser Truefür Werte ausgegeben wird , die dem Wahrheitstest entsprechen.

Ich versuche jedoch, resultierende Arrays zu finden, bei denen wir die ..Range-Funktion nutzen können, um die Byte-Anzahl zu verkürzen, und dennoch unterschiedliche Arrays zwischen den Wahrheits- und Falsey-Werten haben. Dies ist möglich, da ein anderes Verhalten als die Eingabe truthy / falsey undefiniert ist. Wenn der Bereich also Werte außerhalb der Eingabe truthy / falsey erfasst, spielt dies keine Rolle für die Ausgabe.

Bisher ist es ein ziemlich manueller Prozess, da das Ziel darin besteht, das Modulo zu finden, bei dem eines der wahrheitsgemäßen oder falschen Arrays große Lücken zwischen Zahlen aufweist und das andere Array große Mengen von Zahlen in dieser Lücke aufweist. Ich bin bisher meistens nach Intuition und Bauchgefühl vorgegangen, aber vielleicht schreibe ich irgendwann einen Brute-Forcer, um dieses Problem zu lösen. Das obige ist das kürzeste, das ich (größtenteils manuell) bisher gefunden habe.