Desafio

Escreva uma função ou programa que aceite uma linha de entrada, execute uma aleatória muito específica e estranhamente familiar em seus caracteres e produz o resultado.

O embaralhamento necessário pode ser descrito usando o seguinte algoritmo:

1. Rotule cada caractere na entrada com um índice baseado em 1.
2. Escreva o número do caractere 1 como saída.
3. Começando com o caractere número 2, escreva todos os outros caracteres na saída em ordem, excluindo o próprio caractere 2. Em outras palavras, escreva os caracteres 4, 6, 8, 10 e assim por diante como saída.
4. Começando com o próximo número de caractere n ainda não gravado como saída, escreva cada enésimo caractere na saída, excluindo o próprio caractere n e excluindo qualquer outro caractere (por etiqueta numérica) que você já tenha gravado na saída.
5. Repita a etapa 4, enquanto continuar adicionando novos caracteres à saída.
6. Escreva os caracteres restantes na saída, em ordem.

Exemplo

1. Rotule os caracteres.

  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. Escreva o primeiro caractere a ser impresso:

 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. Escreva todos os outros caracteres começando com 2, excluindo 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 S   C    Y A   K '   S    B E   A L   T Y     C   O R   N E   R
O OA 'EUYCRE

4. O próximo caractere ainda não escrito é o número de caractere 3; escreva cada terceiro caractere começando com 3, mas excluindo o próprio caractere 3 e qualquer caractere já escrito.

 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. Repita a etapa 4 usando o próximo caractere, o caractere 5.

4. O próximo caractere ainda não escrito é o número 5; escreva cada quinto caractere começando com 5, mas excluindo o próprio caractere 5 e qualquer caractere já escrito. (Isso equivale apenas ao caractere 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. O próximo caractere é 7; mas 14, 21 já foram escritos, portanto, nenhum caractere seria gerado se repetirmos a etapa 4. Assim, terminamos com 5.

6. Escreva os caracteres restantes em ordem.

 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                  

Regras

A entrada e a saída podem ser via entrada / saída padrão, seqüências de caracteres ou matrizes de caracteres.

Se ler como entrada padrão, você pode, por sua conveniência, assumir que há uma nova linha à direita ou que toda a entrada contém a linha. Os caracteres de nova linha não participam do shuffle.

Da mesma forma, para sua conveniência, sua saída pode ter uma nova linha à direita ou não.

As brechas padrão não são permitidas.

Esta é uma competição de código de golfe. O menor código em bytes vence.

Casos de teste

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 bytes

JÆfṂ$ÞÆPÞị

TryItOnline

Como?

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 bytes

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

Função sem nome, recebendo uma lista de caracteres como entrada e retornando uma lista de caracteres.

FactorInteger[#][[1,1]]produz o menor fator primo de #(e retorna 1se for #igual 1). Portanto, FactorInteger[#][[1,1]]PrimeQ@#produz uma expressão estranha: #o menor fator primo de [] Falsese #não for primo e # Truese #for primo (esses são produtos não avaliados de um número e um booleano).

Range@Length@#produz uma lista dos números até o comprimento da entrada. Em seguida, SortByclassifica esses números pela função engraçada descrita acima. O Mathematica é realmente sensível a tipos de várias maneiras, mas as combina alegremente de outras maneiras: as expressões do formulário [número] Falsesão classificadas em ordem alfabética antes das expressões do formulário [número] True, enquanto os vínculos são quebrados ao classificar os números numericamente. Isso produz exatamente a permutação que queremos aqui e #[[...]]permuta os caracteres da entrada de acordo.

C, 164 bytes

Isso recebe a entrada como o primeiro parâmetro de comando e imprime de volta ao stdout. À medida que processamos cada personagem, limpamos, permitindo o passe final.

#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);}