Sfida

Nella quantità più breve di codice:

1. Calcola la lunghezza del ciclo di permutazione di un mescolamento perfetto su un mazzo di carte di qualsiasi dimensione n (dove n ≥ 2 e n è pari).
2. Stampa una tabella di tutte le lunghezze del ciclo per 2 ≤ n ≤ 1000 ( n pari).

Nota che ci sono due modi di base per definire un shuffle perfetto. C'è il riordino , che mantiene la prima carta in cima e l'ultima in fondo, e c'è il mischiato , che sposta la prima e l'ultima carta di una posizione verso il centro. Puoi scegliere se stai eseguendo un riordino o un rimescolamento; l'algoritmo è quasi identico tra i due.

• mazzo casuale di 10 carte: [1,2,3,4,5,6,7,8,9,10] ↦ [1,6,2,7,3,8,4,9,5, 10].
• mescolata del mazzo da 10 carte: [1,2,3,4,5,6,7,8,9,10] ↦ [6,1,7,2,8,3,9,4,10, 5].

Esempio grafico

Qui, vediamo che uno shuffle su un mazzo da 20 carte ha una durata del ciclo di 18 passi. (Questo è solo a scopo illustrativo; la tua soluzione non è richiesta per generare cicli graficamente.) Il classico mazzo da 52 carte, d'altra parte, ha una durata del ciclo di riordino casuale di soli 8 passaggi (non mostrato).

Un mischiato su un mazzo da 20 carte ha una durata del ciclo di soli 6 passi.

Esempio tabellare di output

Il tuo programma dovrebbe produrre qualcosa di simile a questo, anche se puoi scegliere qualsiasi formato tabulare che ti piace di più. Questo è per un riordino:

2 1
4 2
6 4
8 3
10 6
12 10
14 12
16 4
18 8
20 18
22 6
24 11
26 20
28 18
30 28
32 5
34 10
36 12
38 36
40 12
...many lines omitted...
1000 36

Domande

1. Sembra esserci qualche connessione tra l'ingresso numerico n e il suo conteggio dei cicli, quando n è una potenza di 2?
2. Che ne dici di quando n non è una potenza di 2?
3. Curiosamente, un mazzo da 1000 carte ha un conteggio dei cicli di riordino di solo 36, mentre un mazzo da 500 carte ha un conteggio dei cicli di riordino di 166. Perché potrebbe essere?
4. Qual è il numero più grande che puoi trovare il cui conteggio dei cicli c è notevolmente più piccolo di n , il che significa che il rapporto n / c è massimizzato?

Haskell, 47 46 44 (in ordine casuale)

[[i|i<-[1..],mod(2^i)n<2]!!0|n<-[3,5..1001]]

la realizzazione di base è che questo è l'ordine di 2 nel gruppo moltiplicativo di modulo n+1.

Pyth, 16 byte

mfq1%^2T+3yd)500

Riproduzione casuale utilizzando A002326 .

Pyth, 22 byte

V500,JyhNl{.u.iFc2NJUJ

Provalo online: dimostrazione . Sostituisci 500 con un numero più piccolo, se è troppo lento.

Spiegazione:

V500                     for N in [0, 1, ..., 499]:
      yhN                   (N + 1) * 2
     J                      assign to J
           .u      JUJ      apply the following expression J times
                            to N, starting with N = [0, 1, ..., J - 1],
                            and return all intermediate results:
                c2N            split N into 2 halfs
             .iF               and interleave them
         l{                 remove duplicates and give length
    ,                       make a pair and print

Mathematica, 53 (in ordine casuale)

Grid[{2#,MultiplicativeOrder[2,2#+1]}&/@Range[1,500]]

o, non distanziato antagonisticamente

Grid[{2 #, MultiplicativeOrder[2, 2 # + 1]} & /@ Range[1, 501]]

Produzione:

   2    2
   4    4
   6    3
   8    6
  10   10
  12   12
  14    4
  16    8
  18   18
  20    6
 (* digits, digits, bo bidgits, banana fana, ... *)
  498  166
  500  166
 (* skip a bit, brother ...  *)
  998   36
 1000   60

Ogni voce in entrambe le colonne è centrata orizzontalmente nelle loro colonne, ma non ho gli spazi frazionari  ...  qui per replicarlo.

osservazioni:

• Out-shuffle è in-shuffle su un mazzo più piccolo di due carte. (Nota che la prima e l'ultima carta sono in posizione fissa durante la dimostrazione out-shuffle.) Di conseguenza, le due scelte porteranno a liste di output simili - la seconda colonna verrà spostata di una riga. Per quanto riguarda le "potenze di due" suggerimento, l'in-riordino della potenza di due ponti ha il modello {2^n - 2, n}, {2^n, 2n}. (Combinazioni out-shuffle 2^ncon n.)
• Osservare nell'esempio in ordine casuale che la distanza 2dall'estremità più vicina del mazzo raddoppia ad ogni passo. {2, 4, 8, 15 = -5, -10, -20}. In realtà, questo è vero per ogni carta. Pertanto, abbiamo solo bisogno di sapere quale potere 2è congruente alla 1mod n+1dov'è nil numero di carte. (Si noti che nell'esempio, le carte nell'ultima colonna, colonna -1, sono raddoppiate rispetto alla penultima colonna, -2il che significa che 0è congruente con una carta in più rispetto al mazzo, quindi "mod n+1".) Pertanto, il MultiplicativeOrder [] la funzione è la strada da percorrere (in Mathematica).
• Per impostazione predefinita, si dovrebbe provare TableForm [] invece di Grid [], ma l'output è simile.

C, 86 (o 84)

Il punteggio esclude gli spazi bianchi non necessari, inclusi per chiarezza.

i,j,n;
main(){
  for(;n<1002;printf("%d %d\n",n,j),n+=2)
    for(i=n,j=1;i=i*2%(n+1),i-n;)j++;
}

Questo è un riordino, che, come sottolineato da altri, è solo il riordino esterno con le carte ferme ad entrambe le estremità rimosse.

Come sottolineato da altri, nella mischia, la posizione di ogni carta raddoppia ogni volta, ma questo deve essere preso modulo n+1. Mi piace pensare che la posizione della carta in più sia la posizione zero a sinistra del tavolo (puoi pensare a questo come a tenere entrambe le carte ferme dal riordino). Ovviamente la posizione della carta deve essere sempre positiva, quindi la posizione zero rimane sempre vuota per il caso in ordine casuale.

Il codice si inizializza ial valore di n. Quindi si moltiplica per 2, prende la mod del risultato (n+1)e controlla se iè tornato al suo valore iniziale ( i-nè zero.) Si incrementa jper ogni iterazione, tranne l'ultima (quindi la necessità è inizializzata jsu 1.)

In linea di principio, ipotrebbe essere con qualsiasi valore nell'intervallo 1..n, purché il confronto alla fine abbia verificato se fosse stato inizializzato con lo stesso numero. Il motivo della scelta nera assicurarsi che il programma funzionasse per il caso n==0. il problema era che qualsiasi numero modulo era (0+1)zero, quindi il loop non si chiudeva mai in questo caso se iera stato inizializzato su una costante come 1.

Gli esempi di domande includono il caso equivalente n==2per il riordino casuale, quindi è stato interpretato che questo caso è richiesto. In caso contrario, è n,possibile salvare due byte inizializzando isu 1, lo stesso valore di j.