Esse número é aleatório?

18

Eu pedi ao random.org 128 números inteiros aleatórios entre 0 e 2 32 - 1. Como o gerador de números aleatórios estava tão ansioso para fornecer os primeiros 64 números primeiro, eles são obviamente mais aleatórios do que os outros 64.

Escreva um programa ou função completa que retorne um resultado verdadeiro quando um dos 64 números inteiros a seguir for inserido:

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

E um resultado falsey para os outros 64 números:

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

Qualquer entrada que não seja um desses 128 números é um comportamento indefinido.

Se sua solução for encontrada programaticamente, compartilhe também o código usado para gerá-la!

Isso é código-golfe , então a solução mais curta em bytes vence.

code-golf number random classification decision-problem lirtosiast
fonte
19
Uma vez que o gerador de números aleatórios deu os primeiros 64 números em primeiro lugar, eles devem ser mais aleatória ಠ ___ ಠ
Luis Mendo
Você pode distinguir os dois conjuntos módulo 834
CalculatorFeline
11
Esses números não são aleatórios.
CalculatorFeline
"Maybe, not enough information."&33 bytes, responde à pergunta.
CalculatorFeline
3
@CatsAreFluffy Na verdade, desde que a entrada não contenha 0 ou 1 e dois elementos não sejam diferentes por 1, você pode separá-los por uma cadeia de módulos. por exemplo, separar [4 20 79]de [8 18 100]pode ser feito com [99 79 20 17 7 4](veja se você consegue identificar o padrão). Claro, a metade inicial da sua resposta pode usar um módulo muito menor do que a entrada, mas a metade traseira consiste em mudar um elemento de cada vez.
Sp3000

Respostas:

11

CJam, 53 52 47 bytes

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

Há imprimíveis, mas as duas seqüências podem ser obtidas por

[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

respectivamente. Isso também mostra que os pontos de código estão abaixo de 256.

Esta é uma resposta em cadeia do módulo, onde aplicamos os seguintes módulos ao número inteiro de entrada, em ordem:

[1153 629 512 378 242 136]

Como essa lista contém números inteiros maiores que 255, a lista é codificada usando dois caracteres cada. A decodificação é feita por 2/Dfb, que divide a cadeia em pedaços de comprimento dois e converte cada um a partir de um número base 13 (por exemplo 88*13 + 9 = 1153). No entanto, existem duas exceções à decodificação:

  • O último número ( 136) não está incluído (veja abaixo),
  • O segundo último número é representado por um único caractere, uma vez que o número ( 242) é menor que 256 e a divisão de uma matriz de tamanho ímpar em pedaços de tamanho 2 deixará uma matriz de tamanho 1 no final. Obrigado a @ MartinBüttner por esta dica!

Depois que os módulos reduziram o número inteiro de entrada para um número relativamente pequeno, realizamos uma pesquisa em uma tabela. Essa tabela é codificada através da segunda string, que é convertida em um 312número base e, em seguida, decodificada na base 2, que indexamos. Como a indexação de array do CJam é finalizada, podemos deixar de fora o módulo final, como mencionado anteriormente.

Experimente online | Suíte de teste

Sp3000
fonte
11
Como vocês inventam os módulos mágicos?
CalculatorFeline
@CatsAreFluffy Apenas um DFS simples com um limite no número de módulos. Minha implementação atual é bastante lenta; portanto, se eu sentir que o programa está travado por um tempo, tento um ponto de partida inicial diferente.
`` Sp3000
O que é um DFS? (Wikipedia não ajuda.)
CalculatorFeline
@CatsAreFluffy Busca pela profundidade inicial
Sp3000 5/16
Ah Eu apenas usei um algoritmo ganancioso.
CalculatorFeline
2

JavaScript (ES6) 233

Uma função anônima retornando 0 como falsye diferente de zero comotruthy

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

Verificando os últimos 3 dígitos na representação numérica na base 36.

A cadeia de verificação é criada para:

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

Teste

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>
Expandir snippet

edc65
fonte
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

Por qualquer motivo, existe um conjunto de módulos que nos permite distinguir dois conjuntos, independentemente de, após a aplicação dos módulos, o resultado ser zero ou não. A longa lista de módulos foi gerada por este programa:

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

A primeira saída são os módulos, a segunda e a terceira saídas são as duas listas, tendo aplicado os módulos. As duas longas listas são os conjuntos.

CalculatorFeline
fonte
2
Provavelmente, você pode compactar uma parte da lista em uma sequência.
Njpipeorgan #
1

PowerShell, v3 + 194 bytes

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

Uma abordagem um pouco diferente, então achei que a publicaria. Não vai ganhar mais, mas pode dar a outra pessoa idéias para encurtar seu código.

Ainda estamos pegando o número inteiro de entrada $args[0]e aplicando operações de módulo a ele, então nada de diferente lá. No exposto, estamos usando o -inoperador (daí o requisito v3 +), para que isso produza Truevalores que estão no caso de teste de verdade.

No entanto, estou tentando encontrar matrizes resultantes nas quais podemos aproveitar a ..função de intervalo para reduzir a contagem de bytes, e ainda assim ter matrizes distintas entre os valores de verdade e falsey. Podemos fazer isso, pois um comportamento diferente da entrada truthy / falsey é indefinido; portanto, se o intervalo capturar valores fora da entrada truthy / falsey, não importa a saída.

Até agora, é um processo bastante manual, pois o objetivo é tentar encontrar o módulo em que uma das matrizes de verdade ou falsey tem grandes intervalos entre números e a outra matriz possui grandes quantidades de números nessa diferença. Eu tenho andado principalmente por intuição e pressentimento até agora, mas posso eventualmente escrever um bruto para resolver isso. A descrição acima é a mais curta que encontrei (principalmente manualmente) até agora.

AdmBorkBork
fonte