Sandbox postar aqui .

Crie uma função ou programa que "Springifica" uma seqüência de caracteres.

• A entrada será uma String em Stdin, ou a alternativa mais próxima
• A entrada conterá apenas ASCII e / ou espaços imprimíveis
• A saída será para Stdout, ou a alternativa mais próxima
• Novas linhas e espaços à direita são aceitáveis

Como springify uma String

1. Formate o String em quantas bobinas de mola ASCII forem necessárias
2. Preencher as bobinas com espaços, até a bobina mais próxima
3. Leia os caracteres, seguindo a mola ao redor das bobinas

Esta é uma bobina de mola ASCII:

#
# ####
 #    #
# ####
#

Onde #s são os caracteres da String

Aqui está um exemplo:

abcdefghijklmnopqrstuvwxyz

torna-se

a
b cdef
 g    h
i jklm
n
o
p qrst
 u    v
w xyz.
.

Onde eles .substituem espaços para visibilidade.

Em seguida, a string é lida novamente, seguindo a mola ASCII para baixo, ao redor dos loops, pressionando a tecla ge uduas vezes:

1| a  <-3
 V b cdef
    g    h
4| i jklm
 V n  2->
  ...

... dando:

abgjklmhfedcginopuxyz vtsrquw (com um espaço à direita)

Casos de teste

(cotações adicionadas para destacar espaços à direita - ignore em termos de IO)

I: "abcdefghijklmnopqrstuvwxyz"
O: "abgjklmhfedcginopuxyz vtsrquw "

I: "!@#"
O: "!@         #   "

I: ""
O: ""

I: "12345 67890"
O: "12690  7 54368 "

I: " "
O: "               "

Observe que o comprimento de saída é sempre um múltiplo de 15, o comprimento de uma bobina de mola

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

Geléia , 26 bytes

“4ṘƝ;þ¦Ɱ’b®¤ị
;⁶x14©¤s®ṖÇ€

TryItOnline!

Quão?

“4ṘƝ;þ¦Ɱ’b®¤ị - Link 1, output for a single coil: char array
           ¤  - nilad followed by link(s) as a nilad
“4ṘƝ;þ¦Ɱ’     - base 250 number, 13140239220751650
          ®   - retrieve from register (14 from main link)
         b    - convert to base, [1,2,7,10,11,12,13,8,6,5,4,3,7,9,0]
            ị - index into the char array

;⁶x14©¤s®ṖÇ€ - Main link: theString
      ¤      - nilad followed by link(s) as a nilad
 ⁶           - a space character
  x          - repeated
   14©       - place 14 into the register and yield 14
;            - concatenate theString with the 14 spaces
       s     - split into chunks of length
        ®    -     retrieve from register (14)
         Ṗ   - pop last entry from the result (removes the space only last entry of 14 chars or less)
          Ç€ - call the last link (1) as a monad for €ach
             - implicit print

Python 2, 104 102 98 bytes

f=lambda t:''.join((t+' '*13)[ord(x)-97+y*14]for y in range(len(t)/14+1)for x in'abgjklmhfedcgin')

Obrigado pelo comentário ajuda!

https://tio.run/#2VDVy

Original:

t=raw_input()+' '*13
print''.join(t[ord(x)-97+y*14]for y in range(len(t)/14)for x in'abgjklmhfedcgin')

JavaScript (ES6), 79 bytes

f=
s=>s.replace(/.{1,14}/g,s=>'0169abc7543268d'.replace(/./g,c=>s['0x'+c-0]||' '))

<input oninput=o.textContent=f(this.value)><pre id=o>

Sequência hexadecimal roubada descaradamente de @ETHproductions.

Retina , 71 bytes

$
13$* 
M!`.{14}|$
(.)(.)(.)(.)(.)(.)(.)(....)(.)¶
$5$8$6$4$3$2$1$5$7$9

Experimente online!

Permutar strings não é exatamente conciso na Retina ...

JavaScript (ES7), 144 143 141 114 114 104 103 bytes

Graças a ETHProductions por uma economia de 10B!

a=>[...b=a+' '.repeat(15-a.length%15)].map((_,c)=>b['0x'+'0169abc7543268d'[c%15]-0+(c/15|0)*14]).join``

Exemplo

f=a=>[...b=a+' '.repeat(15-a.length%15)].map((_,c)=>b['0x'+'0169abc7543268d'[c%15]-0+(c/15|0)*14]).join``
f('abcdefghijklmnopqrstuvwxyz')

Resultado

abgjklmhfedcginopuxyz vtsrquw 

Perl 6 , 61 bytes

{S:g/(.)**1..14/{[~] $0["abgjklmhfedcgin".ords X-97]X//" "}/}

Como funciona

A estrutura básica é esta:

{                                  }  # A lambda.
 S:g/(.)**1..14/{                }/   # Regex-replace segments of 1-14 characters, with:
                     $0               #   The single-char submatches captured by the parens.
                       [  ]           #   Index them using certain indices (see below).
                           X//" "}    #   Replace each undefined element with a space.
                 [~]                  #   Concatenate the characters.

A expressão usada para indexar em cada segmento de 14 caracteres é "abgjklmhfedcgin".ords X- 97, que funciona da seguinte maneira:

1. Pegue a string codificada abgjklmhfedcgin.
2. Obter seus codepoints: 97 98 103 106 107 108 109 104 102 101 100 99 103 105 110.
3. Subtrair 97 de cada número: 0 1 6 9 10 11 12 7 5 4 3 2 6 8 13.

Perl 6 , 64 bytes

{[~] .comb(14)».comb»[0,1,6,9..12,7,5...2,6,8,13].flat X//" "}

Experimente online!

Como funciona

A estrutura básica é esta:

{                                    }  # A lambda.
     .comb(14)                          # Split the argument into substrings of <= 14 chars.
              ».comb                    # Split each substring into a list of characters.
                    »[  ]               # Index each list using the same indices (see below).
                         .flat          # Flatten the resulting nested list.
                               X//" "   # Replace each undefined element with a space.
 [~]                                    # Concatenate the list to get a string again.

Mesmos índices que acima, mas uma vez que estamos chamando .flatde qualquer maneira, podemos usar uma expressão aninhada (mas 1 byte mais curto) para eles: 0,1,6,9..12,7,5...2,6,8,13.

(Parece trivial, mas na verdade se baseia em uma peculiaridade de análise do Rakudo Perl 6 que provavelmente é um bug . Para escrevê-lo sem explorar esse bug, seria necessário adicionar parênteses ao redor do 5...2.)

Befunge-93, 97 bytes

<>0>v%2g3\p89:-1+*"!"!:+1<_@#`0:~
,^\,_\:98g\9p1+:76+`#v_:~^
^,,g96g98g9+67,,,,,$$_
==    =  ====

Experimente online!

Este é um detalhamento do código-fonte com as várias partes do componente destacadas.

O loop principal inicia a execução da direita para a esquerda, envolvendo o lado direito do campo de jogo. É aqui que lemos o primeiro caractere de stdin e terminamos se for um EOF.
A próxima seção garante que quaisquer caracteres EOF sejam convertidos em espaços usando a fórmula c = c + 31*!(c+1). Embora isso não se aplique na primeira iteração, pode ocorrer nas passagens subsequentes.
Uma cópia do caractere é salva na memória temporária e, em seguida, é executada uma pesquisa no índice atual na tabela da linha quatro ( ) para determinar se o caractere deve ser produzido ou não.
Se o caractere precisar ser produzido, pegamos o ramo esquerdo. Uma troca é realizada aqui para cancelar a troca que ocorrerá a seguir e, em seguida, um zero é pressionado para forçar a ramificação da direita.
Se o caractere não foi emitido, nós o trocamos pela pilha abaixo do contador do índice (este é o swap que é cancelado no ramo esquerdo). Nos dois casos, salvamos o caractere na memória no deslocamento atual do índice, incrementamos o índice e verificamos se ele é maior que 13.
Caso contrário, lemos o próximo caractere do stdin e repetimos o loop interno.
Se for, teremos terminado um conjunto de 14 caracteres, 7 sendo produzidos ( abgjklm) e 7 restantes na pilha ( cdefhin). Nós deixamos cair os dois últimos, de saída os restantes 5 ( hfedc), e depois recuperar e saída casos especiais g, ie nda memória.
E isso nos leva de volta ao início do loop principal, onde repetimos o processo novamente para os próximos 14 caracteres.

Mathematica, 77 72 bytes

Obrigado a JungHwan Min por salvar 5 bytes!

Join@@Partition[#,14,14,{1,1}," "][[;;,LetterNumber@"abgjklmhfedcgin"]]&

Função sem nome, recebendo uma lista de caracteres como entrada e retornando uma lista de caracteres. Partition[#,14,14,{1,1}," "]divide a entrada em sublistas de comprimento 14, preenchendo espaços se necessário. LetterNumber@"abgjklmhfedcgin"é avaliado como {1,2,7,10,11,12,13,8,6,5,4,3,7,9,14}, o que indica a ordem em que cada sub-lista de tamanho 14 está em (repetindo o sétimo elemento adequadamente). Em seguida, [[;;,...]]pega os elementos de todo o comprimento 14 sublista nessa ordem e Join@@junta as respostas.

Submissão anterior:

Join@@Partition[#,14,14,{1,1}," "][[All,83224017339955102~IntegerDigits~16]]&

Python 3 , 86 bytes

lambda s:''.join(t[i%14]for t in zip(*[iter(s+' '*13)]*14)for i in b'Tq>]zQ|1/X;:L$o')

Experimente online!

Como bônus, a sequência Tq>]zQ|1/X;:L$oé um programa CJam válido que imprime os caracteres exclusivos na entrada padrão, classificados. Experimente online! (+ explicação)

PHP, 94 bytes

foreach(str_split($argv[1],14)as$s)for($i=0;$c=abgjklmhfedcgin[$i++];)echo$s[ord($c)-97]??" ";

divide o argumento da linha de comandos em pedaços de 14 bytes e percorre a cadeia de conversão como índice da sub-cadeia. Corra com php -nr '<code>' <string>.

Fiquei feliz em descobrir que ??também aceita a string vazia (para um índice "inválido") como nula.

Ruby, 83 bytes

->s{v="";(s+" "*13).scan(/.{14}/){|y|"0169:;<7543268=".chars{|o|v+=y[o.ord-48]}};v}

A primeira idéia foi usar números hexadecimais, mas o ord-48 salva outro byte (roubado da resposta da throx).