Sandbox Post hier .

Erstellen Sie eine Funktion oder ein Programm, das eine Zeichenfolge "springt".

• Die Eingabe ist ein String in Stdin oder die nächstgelegene Alternative
• Die Eingabe enthält nur druckbare ASCII- und / oder Leerzeichen
• Die Ausgabe erfolgt nach Stdout oder der nächstgelegenen Alternative
• Nachgestellte Zeilenumbrüche und Leerzeichen sind zulässig

Wie man einen String springt

1. Formatieren Sie den String in beliebig viele ASCII-Federspulen
2. Füllen Sie die Spulen mit Leerzeichen bis zur nächsten Spule
3. Lesen Sie die Zeichen ab und folgen Sie der Feder um die Spulen

Dies ist eine ASCII-Federspule:

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

Wo die #s die Zeichen des Strings sind

Hier ist ein Beispiel:

abcdefghijklmnopqrstuvwxyz

wird

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

Wo die .s Leerzeichen für Sichtbarkeit ersetzen.

Dann wird die Zeichenfolge zurückgelesen, wobei die ASCII-Feder nach unten um die Schleifen herum verläuft gund uzweimal auf und und trifft :

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

... geben:

abgjklmhfedcginopuxyz vtsrquw (mit einem Leerzeichen)

Testfälle

(Zitate hinzugefügt, um nachgestellte Leerzeichen hervorzuheben - bitte in Bezug auf E / A ignorieren)

I: "abcdefghijklmnopqrstuvwxyz"
O: "abgjklmhfedcginopuxyz vtsrquw "

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

I: ""
O: ""

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

I: " "
O: "               "

Beachten Sie, dass die Ausgangslänge immer ein Vielfaches von 15 ist, der Länge einer Federspule

Dies ist Code-Golf , daher gewinnt die kürzeste Antwort in Bytes.

Gelee , 26 Bytes

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

TryItOnline!

Wie?

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

Danke für die Kommentarhilfe!

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

Hexadezimaler String, der schamlos aus @ETHproductions gestohlen wurde.

Netzhaut , 71 Bytes

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

Probieren Sie es online aus!

Das Permutieren von Strings ist in Retina nicht gerade prägnant ...

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

Vielen Dank an ETHProductions für eine 10B-Ersparnis!

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

Beispiel

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

Ausgabe

abgjklmhfedcginopuxyz vtsrquw 

Perl 6 , 61 Bytes

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

Wie es funktioniert

Die Grundstruktur ist folgende:

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

Der Ausdruck, der zum Indizieren in jedes 14-stellige Segment verwendet wird "abgjklmhfedcgin".ords X- 97, lautet wie folgt:

1. Nehmen Sie die fest codierte Zeichenfolge abgjklmhfedcgin.
2. Holen Sie sich seine Codepunkte : 97 98 103 106 107 108 109 104 102 101 100 99 103 105 110.
3. Subtrahieren Sie 97 von jeder Zahl : 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//" "}

Probieren Sie es online aus!

Wie es funktioniert

Die Grundstruktur ist folgende:

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

Gleiche Indizes wie oben, aber da wir .flattrotzdem aufrufen , können wir einen verschachtelten (aber 1 Byte kürzeren) Ausdruck für sie verwenden : 0,1,6,9..12,7,5...2,6,8,13.

(Sieht trivial aus, stützt sich aber tatsächlich auf eine Analyse-Besonderheit von Rakudo Perl 6, die wahrscheinlich ein Fehler ist . Um sie zu schreiben, ohne diesen Fehler auszunutzen, müsste man Parens um das hinzufügen 5...2.)

Befunge-93, 97 Bytes

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

Probieren Sie es online aus!

Dies ist eine Aufschlüsselung des Quellcodes, wobei die verschiedenen Komponenten hervorgehoben sind.

Die Hauptschleife beginnt mit der Ausführung von rechts nach links und wird auf der rechten Seite des Spielfelds ausgeführt. Hier lesen wir das erste Zeichen aus stdin und beenden es, wenn es sich um eine EOF handelt.
Im nächsten Abschnitt wird sichergestellt, dass alle EOF-Zeichen mithilfe der Formel in Leerzeichen konvertiert werden c = c + 31*!(c+1). Dies gilt zwar nicht für die erste Iteration, kann jedoch bei nachfolgenden Durchläufen auftreten.
Eine Kopie des Zeichens wird im temporären Speicher gespeichert, und anschließend wird in der Tabelle in Zeile 4 ( ) nach dem aktuellen Index gesucht, um festzustellen, ob das Zeichen ausgegeben werden soll oder nicht.
Wenn das Zeichen ausgegeben werden muss, nehmen wir den linken Zweig. Hier wird ein Swap durchgeführt, um den nächsten Swap aufzuheben, und dann wird eine Null gedrückt, um den Zweig nach rechts zu zwingen.
Wenn das Zeichen nicht ausgegeben wurde, tauschen wir es im Stapel unter dem Indexzähler aus (dies ist der Austausch, der im linken Zweig abgebrochen wird). In beiden Fällen speichern wir das Zeichen beim aktuellen Indexversatz im Speicher, erhöhen den Index und prüfen, ob er größer als 13 ist.
Wenn nicht, lesen wir das nächste Zeichen aus stdin und wiederholen die innere Schleife.
Wenn dies der Fall ist, haben wir einen Satz von 14 Zeichen fertiggestellt, von denen 7 ausgegeben wurden ( abgjklm) und 7 auf dem Stapel verbleiben ( cdefhin). Wir lassen die letzten beiden, Ausgang die restlichen 5 ( hfedc) und dann abrufen und geben die Sonderfälle g, iund naus dem Speicher.
Und das bringt uns zurück zum Anfang der Hauptschleife, wo wir den Vorgang für die nächsten 14 Zeichen erneut wiederholen.

Mathematica, 77 72 Bytes

Vielen Dank an JungHwan Min für das Speichern von 5 Bytes!

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

Unbenannte Funktion, die eine Liste von Zeichen als Eingabe verwendet und eine Liste von Zeichen zurückgibt. Partition[#,14,14,{1,1}," "]teilt die Eingabe in Unterlisten der Länge 14 auf und füllt sie bei Bedarf mit Leerzeichen auf. LetterNumber@"abgjklmhfedcgin"ausgewertet mit {1,2,7,10,11,12,13,8,6,5,4,3,7,9,14}, was die Reihenfolge angibt, in der jede Unterliste der Länge 14 aufgenommen werden soll (wobei das 7. Element entsprechend wiederholt wird). Nehmen Sie [[;;,...]]dann die Elemente aller Unterlisten der Länge 14 in dieser Reihenfolge und Join@@fügen Sie die Antworten zusammen.

Vorherige Einreichung:

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

Probieren Sie es online aus!

Als Bonus ist die Zeichenfolge Tq>]zQ|1/X;:L$oein gültiges CJam-Programm, das die eindeutigen Zeichen sortiert auf Standardeingabe druckt. Probieren Sie es online aus! (+ Erklärung)

PHP, 94 Bytes

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

teilt das Befehlszeilenargument in 14-Byte-Blöcke auf und durchläuft die Übersetzungszeichenfolge als Index für die Unterzeichenfolge. Laufen Sie mit php -nr '<code>' <string>.

Ich war froh herauszufinden, dass ??auch die leere Zeichenfolge (für einen "ungültigen" Index) als null akzeptiert wird.

Ruby, 83 Bytes

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

Die erste Idee war die Verwendung von Hex-Zahlen, aber ord-48 speichert ein weiteres Byte (gestohlen aus der Antwort von throx).