Sandbox publica aquí .

Cree una función o programa que "Springify" una cadena.

• La entrada será una cadena en Stdin, o la alternativa más cercana
• La entrada solo contendrá ASCII y / o espacios imprimibles
• La salida será a Stdout, o la alternativa más cercana
• Las líneas y espacios finales son aceptables

Cómo hacer saltar una cuerda

1. Formatee la cadena en tantas bobinas de resorte ASCII como sea necesario
2. Rellene las bobinas con espacios, hasta la bobina más cercana
3. Lea los personajes, siguiendo la primavera alrededor de las bobinas.

Esta es una bobina de resorte ASCII:

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

Donde los #s son los personajes de la cadena

Aquí hay un ejemplo:

abcdefghijklmnopqrstuvwxyz

se convierte

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

Donde los .s reemplazan espacios para visibilidad.

Luego, la cadena se vuelve a leer, siguiendo el resorte ASCII hacia abajo, alrededor de los bucles, presionando gy udos veces:

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

... dando:

abgjklmhfedcginopuxyz vtsrquw (con un espacio final)

Casos de prueba

(citas agregadas para resaltar los espacios finales - ignore en términos de IO)

I: "abcdefghijklmnopqrstuvwxyz"
O: "abgjklmhfedcginopuxyz vtsrquw "

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

I: ""
O: ""

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

I: " "
O: "               "

Tenga en cuenta que la longitud de salida es siempre un múltiplo de 15, la longitud de una bobina de resorte

Este es el código de golf , por lo que gana la respuesta más corta en bytes.

Jalea , 26 bytes

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

TryItOnline!

¿Cómo?

“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')

Gracias por el comentario ayuda!

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>

Cadena hexadecimal robada descaradamente de @ETHproductions.

Retina , 71 bytes

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

Pruébalo en línea!

Permutar cuerdas no es exactamente conciso en Retina ...

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

¡Gracias a ETHProductions por un ahorro de 10B!

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

Ejemplo

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

Salida

abgjklmhfedcginopuxyz vtsrquw 

Perl 6 , 61 bytes

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

Cómo funciona

La estructura básica es 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.

La expresión utilizada para indexar en cada segmento de 14 caracteres es la "abgjklmhfedcgin".ords X- 97siguiente:

1. Toma la cuerda codificada abgjklmhfedcgin.
2. Obtener sus puntos de código: 97 98 103 106 107 108 109 104 102 101 100 99 103 105 110.
3. Restar 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//" "}

Pruébalo en línea!

Cómo funciona

La estructura básica es 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.

Mismos índices que el anterior, pero ya que estamos llamando .flattodos modos, podemos utilizar una expresión anidada (1 byte, pero más corto) para ellos: 0,1,6,9..12,7,5...2,6,8,13.

(Parece trivial, pero en realidad se basa en una peculiaridad de análisis de Rakudo Perl 6 que probablemente sea un error . Para escribirlo sin explotar ese error, uno tendría que agregar parens alrededor del 5...2.)

Befunge-93, 97 bytes

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

Pruébalo en línea!

Este es un desglose del código fuente con las diversas partes componentes resaltadas.

El bucle principal comienza a ejecutarse de derecha a izquierda, envolviendo el lado derecho del campo de juego. Aquí es donde leemos el primer carácter de stdin y terminamos si es un EOF.
La siguiente sección se asegura de que los caracteres EOF se conviertan en espacios utilizando la fórmula c = c + 31*!(c+1). Aunque esto no se aplicará en la primera iteración, puede ocurrir en pases posteriores.
Se guarda una copia del carácter en la memoria temporal, y luego se realiza una búsqueda del índice actual en la tabla en la línea cuatro ( ) para determinar si el carácter se debe generar o no.
Si el carácter necesita ser sacado, tomamos la rama izquierda. Aquí se realiza un intercambio para cancelar el intercambio que ocurrirá a continuación, y luego se empuja un cero para forzar la rama hacia la derecha.
Si el personaje no salió, lo cambiamos por la pila debajo del contador de índice (este es el intercambio que se cancela en la rama izquierda). Y en ambos casos guardamos el carácter en la memoria en el desplazamiento del índice actual, incrementamos el índice y verificamos si es mayor que 13.
Si no, leemos el siguiente carácter de stdin y repetimos el ciclo interno.
Si es así, habremos terminado un conjunto de 14 caracteres, 7 de los cuales salieron ( abgjklm) y 7 restantes en la pila ( cdefhin). Dejamos a los dos últimos, salida de los restantes 5 ( hfedc), y luego recuperar y salida de los casos especiales g, iy nde la memoria.
Y eso nos lleva de vuelta al inicio del ciclo principal, donde repetimos el proceso nuevamente para los siguientes 14 caracteres.

Mathematica, 77 72 bytes

¡Gracias a JungHwan Min por guardar 5 bytes!

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

Función sin nombre que toma una lista de caracteres como entrada y devuelve una lista de caracteres. Partition[#,14,14,{1,1}," "]divide la entrada en sublistas de longitud 14, rellenando con espacios si es necesario. LetterNumber@"abgjklmhfedcgin"evalúa a {1,2,7,10,11,12,13,8,6,5,4,3,7,9,14}, lo que indica el orden en el que se debe incluir cada sublista de longitud 14 (repitiendo el séptimo elemento adecuadamente). Luego [[;;,...]]toma los elementos de todas las sublistas de longitud 14 en ese orden y Join@@une las respuestas.

Presentación previa:

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

Pruébalo en línea!

Como Tq>]zQ|1/X;:L$obeneficio adicional, la cadena es un programa CJam válido que imprime los caracteres únicos en la entrada estándar, ordenados. Pruébalo en línea! (+ explicación)

PHP, 94 bytes

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

divide el argumento de la línea de comandos en fragmentos de 14 bytes y recorre la cadena de traducción como índice para la subcadena. Corre con php -nr '<code>' <string>.

Me alegró descubrir que ??también acepta la cadena vacía (para un índice "no válido") como nula.

Ruby, 83 bytes

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

La primera idea fue usar números hexadecimales, pero ord-48 guarda otro byte (robado de la respuesta de throx).