Post sandbox qui .

Creare una funzione o un programma che "Springify" una stringa.

• L'input sarà una stringa in Stdin o l'alternativa più vicina
• L'input conterrà solo ASCII e / o spazi stampabili
• L'output sarà su Stdout o l'alternativa più vicina
• Newline e spazi finali sono accettabili

Come far scattare una stringa

1. Formatta la stringa in tutte le bobine a molla ASCII necessarie
2. Riempi le bobine con spazi, fino alla bobina più vicina
3. Leggi i personaggi, seguendo la molla attorno alle bobine

Questa è una molla elicoidale ASCII:

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

Dove #sono i caratteri della stringa

Ecco un esempio:

abcdefghijklmnopqrstuvwxyz

diventa

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

Dove la .s sostituisce gli spazi per la visibilità.

Quindi, la stringa viene letta di nuovo, seguendo la molla ASCII verso il basso, attorno agli anelli, colpendo il ge udue volte:

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

...dando:

abgjklmhfedcginopuxyz vtsrquw (con uno spazio finale)

Casi test

(citazioni aggiunte per evidenziare gli spazi finali - si prega di ignorare in termini di IO)

I: "abcdefghijklmnopqrstuvwxyz"
O: "abgjklmhfedcginopuxyz vtsrquw "

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

I: ""
O: ""

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

I: " "
O: "               "

Si noti che la lunghezza di uscita è sempre un multiplo di 15, la lunghezza di una molla elicoidale

Questo è code-golf , quindi vince la risposta più breve in byte.

Gelatina , 26 byte

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

TryItOnline!

Come?

“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 byte

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

Grazie per l'aiuto commento!

https://tio.run/#2VDVy

Originale:

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 byte

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>

Stringa esadecimale rubata senza vergogna da @ETHproductions.

Retina , 71 byte

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

Provalo online!

Permutare stringhe non è esattamente conciso in Retina ...

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

Grazie a ETHProductions per un risparmio di 10 B!

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

Esempio

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

Produzione

abgjklmhfedcginopuxyz vtsrquw 

Perl 6 , 61 byte

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

Come funziona

La struttura di base è questa:

{                                  }  # 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.

L'espressione utilizzata per indicizzare in ogni segmento di 14 caratteri è "abgjklmhfedcgin".ords X- 97, che funziona come segue:

1. Prendi la stringa codificata abgjklmhfedcgin.
2. Ottenere le sue codepoints: 97 98 103 106 107 108 109 104 102 101 100 99 103 105 110.
3. Sottrarre 97 da ogni numero: 0 1 6 9 10 11 12 7 5 4 3 2 6 8 13.

Perl 6 , 64 byte

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

Provalo online!

Come funziona

La struttura di base è questa:

{                                    }  # 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.

Stessi indici come sopra, ma dal momento che stiamo chiamando .flatin ogni caso, siamo in grado di utilizzare una (1 byte, ma più breve) espressione nidificato per loro: 0,1,6,9..12,7,5...2,6,8,13.

(Sembra banale, ma in realtà si basa su una particolarità di analisi di Rakudo Perl 6 che è probabilmente un bug . Per scriverlo senza sfruttare quel bug, si dovrebbero aggiungere parentesi attorno al 5...2.)

Befunge-93, 97 byte

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

Provalo online!

Questa è una suddivisione del codice sorgente con le varie parti componenti evidenziate.

Il loop principale inizia eseguendo da destra a sinistra, avvolgendosi sul lato destro del campo di gioco. Qui è dove leggiamo il primo personaggio di stdin e terminiamo se si tratta di un EOF.
La sezione successiva si assicura che tutti i caratteri EOF vengano convertiti in spazi usando la formula c = c + 31*!(c+1). Sebbene ciò non si applichi alla prima iterazione, può verificarsi nei passaggi successivi.
Una copia del personaggio viene salvata nella memoria temporanea, quindi una ricerca dell'indice corrente viene eseguita sulla tabella alla riga quattro ( ) per determinare se il carattere deve essere emesso o meno.
Se il personaggio deve essere emesso, prendiamo il ramo sinistro. Uno swap viene eseguito qui per annullare lo swap che si verificherà successivamente, quindi viene premuto uno zero per forzare il ramo a destra.
Se il personaggio non è stato emesso, lo scambiamo nello stack sotto il contatore dell'indice (questo è lo swap che viene annullato nel ramo sinistro). E in entrambi i casi salviamo il carattere in memoria con l'offset dell'indice corrente, incrementiamo l'indice e controlliamo se è maggiore di 13. In
caso contrario, leggiamo il carattere successivo da stdin e ripetiamo il ciclo interno.
In tal caso, avremo terminato un set di 14 caratteri, 7 dei quali sono stati emessi ( abgjklm) e 7 rimanenti nello stack ( cdefhin). Lasciamo cadere gli ultimi due, in uscita il restante 5 ( hfedc), e quindi recuperare e di uscita dei casi particolari g, ie ndalla memoria.
E questo ci riporta all'inizio del ciclo principale, dove ripetiamo nuovamente il processo per i prossimi 14 caratteri.

Mathematica, 77 72 byte

Grazie a JungHwan Min per aver salvato 5 byte!

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

Funzione senza nome che prende un elenco di caratteri come input e restituisce un elenco di caratteri. Partition[#,14,14,{1,1}," "]suddivide l'input in elenchi secondari di lunghezza 14, riempiendo di spazi se necessario. LetterNumber@"abgjklmhfedcgin"valuta {1,2,7,10,11,12,13,8,6,5,4,3,7,9,14}, che indica l'ordine in cui inserire ciascuna sublist di lunghezza 14 (ripetendo il 7 ° elemento in modo appropriato). Quindi [[;;,...]]prende gli elementi di tutte le liste di lunghezza 14 in quell'ordine e Join@@unisce le risposte.

Presentazione precedente:

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

Python 3 , 86 byte

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

Provalo online!

Come bonus, la stringa Tq>]zQ|1/X;:L$oè un programma CJam valido che stampa i caratteri univoci su input standard, ordinati. Provalo online! (+ spiegazione)

PHP, 94 byte

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

divide l'argomento della riga di comando in blocchi di 14 byte e scorre la stringa di traduzione come indice per la sottostringa. Corri con php -nr '<code>' <string>.

Mi ha fatto piacere scoprire che ??accetta anche la stringa vuota (per un indice "non valido") come null.

Rubino, 83 byte

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

La prima idea era di usare numeri esadecimali, ma ord-48 salva un altro byte (rubato dalla risposta di throx).