Ist diese Zahl zufällig?

18

Ich habe random.org nach 128 Zufallszahlen zwischen 0 und 2 32 - 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.

code-golf number random classification decision-problem Lirtosiast
quelle
19
Da der Zufallsgenerator die ersten 64 Zahlen zuerst gab, müssen sie zufälliger sein be ___ ಠ
Luis Mendo
Sie können die beiden Sätze unterscheiden modulo 834
CalculatorFeline
1
Diese Zahlen sind nicht zufällig.
CalculatorFeline
"Maybe, not enough information."&33 Bytes, beantwortet die Frage.
CalculatorFeline
3
@CatsAreFluffy Solange die Eingabe keine 0 oder 1 enthält und sich keine zwei Elemente um 1 unterscheiden, können Sie sie durch eine Modulo-Kette trennen. Das Trennen [4 20 79]von [8 18 100]kann zB durch erfolgen [99 79 20 17 7 4](sehen Sie, ob Sie das Muster erkennen können). Sicher, die erste Hälfte Ihrer Antwort verwendet möglicherweise ein viel kleineres Modulo als die Eingabe, aber die hintere Hälfte besteht darin, jeweils ein Element zu verschieben.
Sp3000

Antworten:

11

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

Sp3000
quelle
1
Wie kommen die Leute auf die magischen Module?
CalculatorFeline
@CatsAreFluffy Nur eine einfache DFS mit einer Begrenzung der Anzahl der Module. Meine derzeitige Implementierung ist ziemlich langsam. Wenn ich das Gefühl habe, dass das Programm für eine Weile hängen bleibt, versuche ich, einen anderen Ausgangspunkt zu finden.
Sp3000
Was ist eine DFS? (Wikipedia hilft nicht.)
CalculatorFeline
@CatsAreFluffy Tiefe-erste Suche
Sp3000
Ah. Ich habe gerade einen gierigen Algorithmus verwendet.
CalculatorFeline
2

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>
Erweitern Sie das Snippet

edc65
quelle
1

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.

CalculatorFeline
quelle
2
Sie können wahrscheinlich einen Teil der Liste in eine Zeichenfolge komprimieren.
njpipeorgan
1

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.

AdmBorkBork
quelle