Sfida

Scrivi una funzione o un programma che accetta una riga di input, esegue uno shuffle molto specifico e stranamente familiare sui suoi caratteri e genera il risultato.

Il mescolamento richiesto può essere descritto usando il seguente algoritmo:

1. Etichetta ciascun carattere nell'input con un indice basato su 1.
2. Scrivi il carattere numero 1 come output.
3. A partire dal carattere numero 2, scrivi ogni altro carattere nell'output in ordine, escluso il carattere 2 stesso. In altre parole, scrivi i caratteri 4, 6, 8, 10 e così via come output.
4. A partire dal numero di carattere successivo n non ancora scritto come output, scrivere ogni ennesimo carattere sull'output, escludendo il carattere n stesso ed escludendo qualsiasi altro carattere (mediante etichetta numerica) che potrebbe essere già stato scritto nell'output.
5. Ripetere il passaggio 4 finché continua ad aggiungere nuovi caratteri all'output.
6. Scrivi i caratteri rimanenti per l'output, in ordine.

Esempio

1. Etichetta i personaggi.

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
  OLDDOCYAK 'SBEAUTYCORNER

2. Scrivi il primo carattere da emettere:

 1   2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
  O   LDDOCYAK 'SBEAUTYCORNER
O

3. Scrivi ogni altro carattere che inizia con 2, escluso 2.

 1   2 3 4   5 6   7 8   9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 
 O   LD    D O   C    Y A   K '   S    B E   A U   T Y     C   O R   N E   R
O OA 'EUYCRE

4. Il prossimo personaggio non ancora scritto è il numero 3; scrivi ogni 3 ° carattere che inizia con 3, ma escluso il carattere 3 stesso e qualsiasi carattere già scritto.

 1   2 3 4   5 6   7 8   9  10 11 12 13 14  15  16 17 18 19 20  21  22 23 24 25 26  27
  O   LD    D O   C Y A   K '   S B E   A U   T Y C   O R   N E R 
OOA «EUYCRE YB R             

5. Ripetere il passaggio 4 utilizzando il carattere successivo, il carattere 5.

4. Il prossimo carattere non ancora scritto è il numero 5; scrivi ogni 5 caratteri che iniziano con 5, ma escluso il carattere 5 stesso e qualsiasi carattere già scritto. (Ciò equivale a solo il personaggio 25).

 1   2 3 4   5 6   7 8  9  10 11 12 13 14  15  16 17 18 19 20  21  22 23 24  25  26  27
  O   LD    D O   C Y A   K '   S B E   A U   T Y C   O R N E R 
OOA «EUYCREYB R N               

5. Il personaggio successivo è 7; ma 14, 21 sono già stati scritti, quindi non verranno più emessi caratteri se ripetiamo il passaggio 4. Quindi, abbiamo finito con 5.

6. Scrivi i caratteri rimanenti in ordine.

 1   2 3 4   5 6   7 8  9  10 11 12 13 14  15  16 17 18 19 20  21  22 23 24  25  26  27
  O   LD   D O   C Y A   K '   S B E   A U   T Y C   O R N E R 
OOA «EUYCREYB RN LDDCKSATO                  

Regole

L'input e l'output possono avvenire tramite input / output standard, stringhe o matrici di caratteri.

Se la lettura come input standard si può presumere, a vostro piacimento, che ci sia una nuova riga finale o che l'intero input contenga la riga. I personaggi di Newline non partecipano allo shuffle.

Allo stesso modo, a vostro piacimento, il vostro output potrebbe avere una nuova riga finale oppure no.

Le scappatoie standard non sono ammesse.

Questa è una competizione di codice golf. Vince il codice più piccolo in byte.

Casi test

123456789ABCDEF -> 1468ACE9F2357BD

OLD DOC YAK'S BEAUTY CORNER -> O O A' EUYCREYB RNLDDCKSATO

Blue boxes use a 2600hz tone to convince telephone switches that use in-band signalling that the caller is actually a telephone operator.
->
Bebxsuea20h oet ovnetlpoesice htuei-adsgaln httecle satal  eehn prtre 0ncce ha nng aiuapootnt ihyon atallu o s 6z oi ehwstsnbilt lr clee.

Gelatina , 10 byte

JÆfṂ$ÞÆPÞị

TryItOnline

Come?

JÆfṂ$ÞÆPÞị - Main link: theString
J          - range(length), the 1-based indexes of theString
     Þ     - sort these by
    $      -     last two links as a monad
 Æf        -         prime factorization array (e.g. 20 -> [2,2,5])
   Ṃ       -         minimum
        Þ  - sort these by
      ÆP   - isPrime, i.e. move all the primes to the right
         ị - index into theString

Mathematica, 61 byte

#[[SortBy[Range@Length@#,FactorInteger[#][[1,1]]PrimeQ@#&]]]&

Funzione senza nome che prende un elenco di caratteri come input e restituisce un elenco di caratteri.

FactorInteger[#][[1,1]]produce il più piccolo fattore primo di #(e restituisce 1se #uguale a 1). Quindi FactorInteger[#][[1,1]]PrimeQ@#produce una strana espressione: [ #il più piccolo fattore primo] Falsese #non è primo e # Truese #è primo (questi sono prodotti non valutati di un numero e un valore booleano).

Range@Length@#produce un elenco di numeri fino alla lunghezza dell'input. Quindi SortByordina quei numeri in base alla divertente funzione descritta sopra. Mathematica è veramente sensibile al tipo in molti modi, ma li mescola allegramente in altri modi: le espressioni della forma [numero] Falsesono ordinate alfabeticamente prima delle espressioni della forma [numero] True, mentre i legami vengono spezzati ordinando i numeri numericamente. Ciò produce esattamente la permutazione che desideriamo qui e #[[...]]permuta i caratteri dell'input di conseguenza.

C, 164 byte

Questo prende l'input come primo parametro di comando e stampa su stdout. Mentre elaboriamo ogni personaggio, lo eliminiamo, consentendo il passaggio finale.

#define p putchar
main(c,s,i,j,t)char**s,*t;{c=strlen(t=s[1]);p(*t);for(;j++<c;)if(t[j])for(i=2*j+1;i<=c;i+=j+1)!t[i]?:p(t[i]),t[i]=0;for(j=0;j++<c;)!*++t?:p(*t);}