J'ai demandé à random.org 128 nombres entiers aléatoires entre 0 et 2 ³² - 1. Étant donné que le générateur de nombres aléatoires était si désireux de donner les 64 premiers nombres, ils sont évidemment plus aléatoires que les 64 autres.

Écrivez un programme ou une fonction complète qui retourne un résultat véridique lorsque l'un des 64 entiers suivants est entré:

[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]

Et un résultat de falsey pour les 64 autres numéros:

[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]

Toute entrée autre que l'un de ces 128 nombres est un comportement non défini.

Si votre solution est trouvée par programme, veuillez également partager le code utilisé pour la générer!

Il s'agit de code-golf , donc la solution la plus courte en octets l'emporte.

CJam, 53 52 47 octets

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

Il n'y a pas d'imprimable, mais les deux chaînes peuvent être obtenues par

[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

respectivement. Cela montre également que les points de code sont inférieurs à 256.

Il s'agit d'une réponse en chaîne modulo, où nous appliquons les modules suivants à l'entier d'entrée, dans l'ordre:

[1153 629 512 378 242 136]

Étant donné que cette liste contient des entiers supérieurs à 255, la liste est codée à l'aide de deux caractères chacun. Le décodage est effectué par 2/Dfb, qui divise la chaîne en morceaux de longueur deux et convertit chacun à partir d'un nombre de base 13 (par exemple 88*13 + 9 = 1153). Cependant, il existe deux exceptions au décodage:

• Le dernier chiffre ( 136) n'est pas inclus (voir ci-dessous),
• L'avant-dernier nombre est représenté par un seul caractère, car le nombre ( 242) est inférieur à 256 et la division d'un tableau de longueur impaire en morceaux de taille 2 laissera un tableau de taille 1 à la fin. Merci à @ MartinBüttner pour cette astuce!

Une fois que les modules ont réduit l'entier d'entrée à un nombre relativement petit, nous effectuons une recherche dans une table. Cette table est encodée via la deuxième chaîne, qui est convertie en un 312nombre de base puis décodée en base 2, que nous indexons. Depuis l'indexation des tableaux de CJam, nous pouvons laisser de côté le module final comme mentionné précédemment.

Essayez-le en ligne | Suite de tests

Rétine , 117 octets

([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

Une réponse regex golf, produisant un entier positif pour la vérité et zéro pour la fausse.

Essayez-le en ligne! | Suite de tests - véridique | Suite de tests - falsy | Regex101

JavaScript (ES6) 233

Une fonction anonyme renvoyant 0 as falsyet non nul astruthy

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

Vérification des 3 derniers chiffres de la représentation numérique de la base 36.

La chaîne de vérification est construite de la manière suivante:

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

Tester

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 octets

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

Pour une raison quelconque, il existe un ensemble de modules qui nous permet de distinguer deux ensembles simplement selon que, après application des modules, le résultat est nul ou non. La longue liste de modules a été générée par ce programme:

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]}}
 ]

La première sortie est les modules, les deuxième et troisième sorties sont les deux listes, après avoir appliqué les modules. Les deux longues listes sont les ensembles.

PowerShell, v3 + 194 octets

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

Un peu d'une approche différente, alors j'ai pensé que je le publierais. Cela ne gagnera pas le plus court, mais cela peut donner à quelqu'un d'autre des idées pour raccourcir son code.

Nous prenons toujours l'entier d'entrée $args[0]et lui appliquons des opérations modulo, donc rien de différent là-bas. Dans ce qui précède, nous utilisons l' -inopérateur (d'où l'exigence v3 +), ce qui produira Truedes valeurs qui se trouvent dans le cas de test véridique.

Cependant, j'essaie de trouver des tableaux résultants où nous pouvons tirer parti de la .. fonction de plage pour raccourcir le nombre d'octets, tout en ayant encore des tableaux distincts entre les valeurs true et falsey. Nous pouvons le faire car un comportement autre que l'entrée vérité / falsey n'est pas défini, donc si la plage capture des valeurs en dehors de l'entrée vérité / falsey, peu importe la sortie.

C'est un processus assez manuel jusqu'à présent, car le but est d'essayer de trouver le modulo où l'un des tableaux véridiques ou falsey a un grand écart (s) entre les nombres et l'autre tableau a de grandes quantités de nombres dans cet écart. Je suis surtout allé par intuition et intuition jusqu'à présent, mais je pourrais éventuellement écrire un brute-forcer pour résoudre ce problème. Ce qui précède est le plus court que j'ai trouvé (principalement manuellement) jusqu'à présent.