Verdrehen von Wörtern!

Gegeben eine Zeichenfolge und eine positive Ganzzahl. Sie müssen die Schnur hin und her drehen.

Beispiel Eingabe / Ausgabe

Eingang

Programming Puzzles & Code Golf
4

Ausgabe

Prog
mmar
ing 
zzuP
les 
oC &
de G
 flo

Eingang

Die Eingabe kann über STDIN oder ein Funktionsargument erfolgen. Die Eingabe besteht aus einer Zeichenfolge und einer positiven Ganzzahl n . Die Ganzzahl bestimmt die Länge jeder verdrillten Linie.

Die Saite ist hin und her gedreht. Eine Eingabe von HELLO, WORLD!und 5 würde folgendermaßen aussehen:

Ausgabe

Die Ausgabe ist der verdrehte Text. Es darf kein nachgestelltes Leerzeichen stehen. Wenn die Länge der Eingabezeichenfolge nicht durch die Zeilenlänge teilbar ist, fügen Sie ein Leerzeichen hinzu, bis die Zeile gefüllt ist:

Ein Beispiel dafür:

Eingang

Hello, World!
5

Ausgabe (Beachten Sie das Leerzeichen ganz am Ende)

Hello
roW ,
ld!  

Pyth, 19 15

VPc+z*dQQ_W~!ZN

Füllt die Zeichenfolge vor und kehrt die Zeilen beim Drucken um. Der Abstand entspricht der Größe des Feldes, die letzte Zeile nach dem Zerlegen der Eingabe wird jedoch verworfen.

Probieren Sie es hier aus

CJam, 19 Bytes

q~1$S*+/W<{(N@Wf%}h

Eingabebeispiel:

5 "Hello, World!"

Erklärungen

q~         e# Input n and the string.
1$S*+      e# Append n spaces to the string.
/W<        e# Split by each n characters, and remove the last chunk.
{          e# While the array of chunks isn't empty:
    (N     e# Extract the first chunk and push a newline.
    @Wf%   e# Reverse every chunk left in the array.
}h

Schneemann 1.0.1 , 91 Bytes

{vg10vg|sB*#.'aGal'NdE'aaAaL|al!*+#5nS" "'aR'!#aCwR|.aC2aG:0aa|sP"
"sP'NdE|1aA.aNsP"
"sP;aE

Oder alles in einer Zeile (für Ästhetik oder genauer gesagt für Antiästhetik) zum Preis von 2 Byte:

{vg10vg|sB*#.'aGal'NdE'aaAaL|al!*+#5nS" "'aR'!#aCwR|.aC2aG:0aa|sP10wRsP'NdE|1aA.aNsP10wRsP;aE

Für Snowman ist das viel zu kurz. (Es ist wahrscheinlich die kürzeste, die es geben kann. Ich habe ziemlich lange daran gearbeitet.)

Dies hat eine Einschränkung: Es wird in 50% der Fälle mit einem Fehler beendet (erzeugt aber immer noch die richtige Ausgabe), wenn die letzte Zeile nicht umgekehrt wird. (Dies liegt daran, dass ich agdie Array-Elemente in Zweiergruppen gruppiere, damit ich alle anderen Elemente umkehren kann. Ich überprüfe jedoch nicht, ob das letzte Element beide erwarteten Elemente enthält. Daher wird versucht, auf ein nicht vorhandenes Element zuzugreifen, wenn Es gibt eine ungerade Anzahl von Zeilen.)

Ungolfed / Erklärung:

{vg10vg|sB*#      // get input, convert second string to number and store
.'aG              // split string into groups of n chars
al'NdE'aaAaL      // take out the last element of the array
|al!*+#5nS" "'aR  // subtract its length from 5, repeat that many spaces
'!#aCwR|.aC       // concat spaces to last el. and that back to the array
2aG               // split in groups of 2, so we can reverse every other string
// for each sub-group in the array of groups...
:
    0aa|sP10wRsP         // print the first element as is
    'NdE|1aA.aNsP10wRsP  // print the second element, reversed
;aE

Python 2, 60

s,n=input()
d=1
while s:print(s+n*' ')[:n][::d];s=s[n:];d=-d

Nimmt nZeichen aus dem von auf einmal sund druckt sie in einer Richtung d, die zwischen 1und wechselt -1. Wird beim Abstand in der letzten Zeile am Ende smit nLeerzeichen aufgefüllt, bevor sie abgeschnitten wird. Dies wirkt sich nur dann aus, wenn weniger als nZeichen übrig sind.

Eine rekursive Lösung würde ein Zeichen (59) speichern, mit der Ausnahme, dass eine nachgestellte Zeile verbleibt, was nicht zulässig ist.

f=lambda s,n,d=1:s and(s+n*' ')[:n][::d]+"\n"+f(s[n:],n,-d) 

Haskell , 83 75 Bytes

(id!)
(f![])_=[]
(f!l)n=f(take n$l++cycle" ")++'\n':((f.reverse)!drop n l)n

Einfache chunksOfImplementierung mit Take-and-Drop, wobei eine gerade oder ungerade Anzahl von Umkehrungen auf die Ausgabe angewendet wird.

Vielen Dank an @BMO für fünf Bytes und @ ØrjanJohansen für drei Bytes!

Probieren Sie es online!

Feststecken , 42 41 40 38 Bytes

Dies ist ein bisschen zu lang, wird wahrscheinlich versuchen, mehr Golf zu spielen!

tg;_lu_@%u;-_0G<*' *+0GKE"];2%;Y_Y?p":

Eingabe sollte so sein "string"|n.

Erläuterung:

tg                 # Take input, place each item on stack, save the int to variable stack                                        
;_l                # Swap the top two items, duplicate the string and obtain length
u_@%               # Rotate to the left, duplicate, rotate right and take mod
u;-                # Rotate left, swap the top two and subtract from each other
_0G<*              # duplicate this value, check if less than stored int and multiply
' *+               # Push space onto stack n times, append to starting string
0GKE               # Split this string into segments, and enumerate
"];2%;Y_Y?p":      # For each segment, determine if should be reversed, and print

Haskell, 108 Bytes

(#)=splitAt
s!n=let(a,t)=n#s;(b,u)=n#t in a:reverse b:(u!n)
s%n=unlines$takeWhile(any(>' '))$(s++cycle" ")!n

Das ist ziemlich lang, Herrgott. Hier ist es in Aktion:

*Main> putStrLn $ "Programming Puzzles & Code Golf" % 4
Prog
mmar
ing
zzuP
les
oC &
de G
 flo

Python 2, 109 Bytes

Musste mit Leerzeichen auffüllen, damit die letzte Zeile korrekt ist.

Probieren Sie es hier aus

I,c=input()
I+=(c-len(I)%c)*" "
L=[]
i=0
while I:s=I[:c];L+=[[s,s[::-1]][i%2]];i+=1;I=I[c:]
print"\n".join(L)

Lua, 91 88 88 84 83 82 Bytes

Alte Version:

a=arg for i=1,#a[1],a[2]do s=a[1]:sub(i,i+a[2]-1)print(d and s:reverse()or s)d=not d end

Neue Version:

arg[1]:gsub((".?"):rep(arg[2]),function(s)print(d and s:reverse()or s)d=not d end)

O, 60 Bytes

z""/rlJ(Q/{n:x;Q({+}dxe{`}{}?p}drQJQ%-{' }dJQ/e{r}{}?Q({o}dp

Mein allererstes O-Programm, und noch dazu ein langes!

Live-Demo.

Perl, 87 Bytes

sub f{$_=@_[0].$"x(@_[1]-1);$a.=(($i++&1?reverse$1:$1).$/)while/(.{@_[1]})/g;chop$a;$a}

Alte Version (druckt eine nachgestellte neue Zeile):

sub f{$_=@_[0].$"x(@_[1]-1);print(($i++&1?reverse$1:$1).$/)while/(.{@_[1]})/g}

Die Zeichenfolge wird als Funktionsargument ohne nachfolgende Newline übergeben. Rufen Sie wie folgt an:

$_=<>;chomp;print f($_,5);

Mumps, 86 Bytes

R I,S,! S P=$L(I),$P(I," ",P)=P F Q=1:S:P S F=$E(I,Q,Q+S-1),P='P W $S('P:F,1:$RE(F)),!

Obwohl es 2 Bytes kürzer sein könnte, wenn Sie das erste ',!' Zeichen in der R-Anweisung (aus STDIN gelesen); das fügt einen Wagenrücklauf zwischen der Eingabe und der Ausgabe hinzu. Wäre dies nicht der Fall, wäre die Ausgabe technisch korrekt, die erste Zeile würde jedoch an die Eingabezeichenfolge angehängt.[[Das von mir verwendete Standard-Mumps-Terminal hat kein lokales Echo. ]]   Wie es sitzt, hier ist der Test:

R I,S,! S P=$L(I),$P(I," ",P)=P F Q=1:S:P S F=$E(I,Q,Q+S-1),P='P W $S('P:F,1:$RE(F)),!
ABCDEFGHIJKLMNOPQRSTUVWXYZ1236
ABCDEF
LKJIHG
MNOPQR
XWVUTS
YZ123 

Beachten Sie auch, dass zwischen '123' und '6' am Ende der Eingabe ein Wagenrücklauf / Eingabe-Tastendruck erfolgt. [[Wieder das lokale Echo. ]]

Wenn jemand interessiert ist, kann ich beschreiben, was mit dem Code los ist. aber mir ist klar, dass es nicht viele Mumps-Enthusiasten gibt ... :-)

PowerShell, 102 Bytes

param($s,$i)$l=$s.Length;$s+' '*($i%$l)-split"(.{$i})"|?{$_}|%{$r=-not$r;@($_,($_[$l..0]-join''))[$r]}

Wird wie folgt aufgerufen (wenn in Datei gespeichert CodeGolf55051.ps1)

.\CodeGolf55051.ps1 -s '1234567890' -i 4

Frühere Versuche

(länger oder ungültig)

PowerShell, 110 Bytes

param($s,$i)$l=$s.Length;$s+' '*(($i-$l%$i)%$i)-split"(.{$i})"|?{$_}|%{$r=-not$r;@($_,($_[$l..0]-join''))[$r]}

PowerShell, 111 Bytes

param($s,$i)$s+' '*(($i-$s.Length%$i)%$i)-split"(.{$i})"|?{$_}|%{$r=-not$r;@($_,($_[$_.length..0]-join''))[$r]}

Erläuterung

param($s,$i)                         #Take input text (s) and column width (i)
$s                                   #take the user entered string
+ ' ' * (($i - $s.Length % $i) % $i) #add the least number of spaces required to make its length divisible by i
-split"(.{$i})"                      #break it into chunks of i characters in length
| ?{$_}                              #skip any blank lines created in the process
| %{                                 #for each line
    $r = -not $r;                    #    toggle a boolean value
    @(                               #    define an array
        $_                           #    index 0 = the string going forwards
        ,($_[$_.length..0] -join '') #    index 1 = the string reversed (by taking each character from the last to the first, then joining them)
    )[$r]                            #    if our boolean value is false take the forward string (index 0), if true take the backwards one (index 1)
}                                    #next

PowerShell, 180 Bytes

param($s,$i)$x="`${0}|{1}|`${2}";$w=$x;1..$i|%{$w=$w-f$_,$x,($i+$_)};$w=$w-replace'\||\${.*}';$r=$w-replace'\$\d+','(.)?';$s+' '*($i-$s.Length%$i)-replace$r,$w-split"(.{$i})"|?{$_}

PowerShell, 196 Bytes

param($s,$i)$x="{0}|{1}|{2}";$w=$x;1..$i|%{$w=$w-f$_,$x,($i+$_)};$w=$w-replace'(\d+)','$$$1'-replace'\||{.*}';$r=$w-replace'\$\d+','(.)?';$s+' '*($i-$s.Length%$i)-replace$r,$w-split"(.{$i})"|?{$_}

Erläuterung

param ($s, $i)                      #Take input text (s) and column width (i)

$x = "{0}|{1}|{2}"                  #Define string format which takes 3 entries and pipe delimits them

$w = $x                             #initialise our replacement regex with this format
1..$i | %{                          #for 1 to the specified column width
    $w = $w -f $_, $x, ($i + $_)    #update the regex 1|{...}|5, 1|2|{...}|6|5, etc
}                                   #resulting in w = 1|2|3|4|{...}|8|7|6|5
$w = $w -replace '(\d+)', '$$$1'    #now prefix the numbers with a dollar (so they're regex replacement variables)
        -replace '\||{.*}'          #and remove the delimiters and superfluous `{...}` left from our middle insertion routine

$r = $w -replace '\$\d+', '(.)?'    #then create the match pattern by replacing the variables with optional single character captures

$s                                  #now take the user entered string
    + ' ' * ($i - $s.Length % $i)   #add the least number of spaces required to make its length divisible by i
    -replace $r, $w                 #perform a replacement using the regex match and replace patterns created above
    -split "(.{$i})"                #then split the string into blocks of length i
    | ?{$_}                         #removing any blank lines created in the process

( {...}In den obigen Kommentaren steht eigentlich {0}|{1}|{2}; ich setze {...}auf bessere Lesbarkeit.

Powershell, 120 Bytes (ungültig)

param($s,$i)$s + ' ' * ($i-$s.Length%$i) -replace '(.{4})?(.)(.)(.)(.)',"`$1`n`$5`$4`$3`$2`n" -split "`n" | ?{$_ -ne ""}

Clojure, 83 Bytes, 87 Bytes , 79 Bytes

(fn[n s](map #(apply str(% %2))(cycle[#(or %)reverse])(partition n n(repeat\ )s))))

Mehrere Korrekturen nach Kommentaren unten, danke Ørjan .

Probieren Sie es online!

Clojure scheint in Code-Golf-Antworten oft leider nicht vorzukommen. Es kann sicherlich nicht mit Golf-Sprachen in Byte-Länge konkurrieren, aber ich denke, die völlige Abwesenheit ist etwas ungerechtfertigt.

Erläuterung:

• in-data, zwei Argumente, eine Zahl und eine Zeichenfolge
• Start von clojure eingebauten Funktion läuft Partition auf Zeichenfolge ses in eine Folge von Zeichenlisten Chunking , wo die Listen Länge haben n. Der letzte Block wird mit Leerzeichen der Länge nach nmit der "Pad-Sammlung" aufgefüllt , die von zurückgegeben wird(repeat " ") der eine unendliche Folge von Leerzeichen zurückgegeben wird
• wir rufen dann map auf mit drei Argumenten auf:
  • eine anonyme Funktion (die #(..) )
  • eine unendliche alternierende faule Folge von Funktionen, #(or %)die wie die Identitätsfunktion und umgekehrt (dh [#(or %) reverse #(or %) reverse ...]) funktionieren, wie sie vom Zyklus zurückgegeben werden .
  • Die zerlegte, faule Folge von Listen, die von der Partition zurückgegeben wurden.
• endlich die anonyme funktion #(apply ...) :
  • ruft entweder identityoder reverseabwechselnd einen Chunk an. Dies erfolgt über den (% %2)Ausdruck, der die als erstes Argument an die anonyme Funktion gesendete Funktion aufruft [dh identityoder reverse], wobei das zweite Argument [dh der Block] an die anonyme Funktion als Argument für den Aufruf verwendet wird.
  • ruft (apply str ...)auf, um die Liste der Zeichen in eine Zeichenfolge umzuwandeln
• Die äußere Funktion gibt eine verzögerte Folge von Zeichenfolgen zurück

Ein Trick, den wir hier anwenden, ist, dass viele Clojure-Funktionen mapeine beliebige Anzahl von Sammlungen als (map f coll1 coll2 coll3 ...)Argumente annehmen , dh, die Funktion f muss nur so viele Argumente akzeptieren, wie es Sammlungen gibt. In diesem Fall senden wir zwei Sammlungen, eine Sammlung alternierender Funktionsreferenzen und die zerlegte Zeichenfolge.

APL (Dyalog Unicode) , 19 Byte

{↑⊢∘⌽\↓↑⍵⊆⍨⌈⍺÷⍨⍳≢⍵}

Probieren Sie es online!

Nahm den ⊢∘⌽\Trick von ngns brillanter Antwort auf die Herausforderung der Boustrophedonise .

Nachdem ich festgestellt habe, dass meine Übermittlung für Zeilen mit führenden Zeilenumbrüchen unterbrochen wird, habe ich zwei weitere Bytes hinzugefügt. Unten ist die ältere Vorlage.

APL (Dyalog Unicode) , 17 Byte

{↑⊢∘⌽\⍵⊆⍨⌈⍺÷⍨⍳≢⍵}

Probieren Sie es online!

Python 3, 110 108 107 103 Bytes

def a(s,n):l=len(s)//n+1;s+=' '*(len(s)-l);print('\n'.join([s[x*n:n*x+n][::(-1)**x]for x in range(l)]))

(auf andere Antworten schauend), mit rjust :95 93 92 90 Bytes

def a(s,n):print('\n'.join([s[x*n:n*x+n][::(-1)**x].rjust(n)for x in range(len(s)//n+1)]))

PHP, 135 Bytes

Nimmt zwei Befehlszeilenargumente wie mit gezeigt an $argv.

<? foreach($a=str_split($s=$argv[1],$n=$argv[2])as$k=>&$v)$v=$k%2?$v:strrev($v);echo implode("\n",$a).str_repeat(' ',$n-strlen($s)%$n);

CoffeeScript, 131 Bytes

Das scheint zu lang.

f=(s,n,r=l=s.length,i=0,z='')->(t=s[i...i+=n].split '';t=t.reverse()if r=!r;z+=t.join('')+(i<l&&'\n'||' '.repeat n-l%n))while i<l;z

Julia, 104 Bytes

f(s,n)=(L=length(s);L+=L÷n;j=0;for i=1:n:L-n+1 x=rpad(s,L)[i:i+n-1];println(j%2<1?x:reverse(x));j+=1end)

Ungolfed:

function f(s::String, n::Int)
    L = length(s) + length(s) ÷ n
    j = 0
    for i = 1:n:L-n+1
        x = rpad(s, L)[i:i+n-1]
        println(j % 2 == 0 ? x : reverse(x))
        j += 1
    end
end

Python 3, 101 Bytes

t,x=eval(input())
print("\n".join([t[c:c+x].ljust(x)[::1-2*(int(c/x)%2)] for c in range(0,len(t),x)]))

Probieren Sie es hier aus

q, 46

{-1@neg[y]$@[a;(&)(til(#)a:y cut x)mod 2;|:];}

.

q){-1@neg[y]$@[a;(&)(til(#)a:y cut x)mod 2;|:];}["Programming Puzzles & Code Golf";4]
Prog
mmar
ing
zzuP
les
oC &
de G
 flo

Q 64 56 Bytes

{c::neg y;-1(til(#)l){$[x mod 2;c$(|:)y;y]}'l:y cut x;}

• {}ist eine Funktion, die als aufgerufen werden sollte {}[x;y].
  • x wird die Zeichenfolge sein.
  • y wird die Länge der resultierenden Linien sein.

Prüfung:

{c::neg y;-1(til(#)l){$[x mod 2;c$(|:)y;y]}'l:y cut x;}["Programming Puzzles & Code Golf";4]
Prog
mmar
ing
zzuP
les
oC &
de G
 flo

edit : Verwendet kürzere Funktionen, inspiriert von der anderen q Antwort von @tmartin

Python 2, 82 75 Bytes

s,n=input()
k=0
while k<=len(s):print s[k:k+n].ljust(n)[::1-2*(k/n%2)];k+=n

Ich konnte @willem nicht kommentieren, aber ich habe seinen Code verkleinert.

Versuchen Sie es hier Versuchen Sie es hier

Perl, 72 Bytes

perl -p0e's/\n(.*)/$"x($1-$-[0]%$1)/e;s/.{$1}/($i++%2?reverse$&:$&)."\n"/ge;chop'

70 Bytes plus 2 Bytes für -p0.

Demo:

$ echo -en 'Hello, World!\n5' | perl -p0e's/\n(.*)/$"x($1-$-[0]%$1)/e;s/.{$1}/($i++%2?reverse$&:$&)."\n"/ge;chop'
Hello
roW ,
ld!  $

Beachten Sie, dass die von STDIN gelesene Eingabe nicht mit einer neuen Zeile enden kann (dies würde 2 zusätzliche Bytes kosten).

Erläuterung:

perl -p0e'  # Read from STDIN, splitting on null bytes,
            # and print $_ automatically at the end

    s/
        \n(.*)  # Replace everything after first newline,
                # capturing wrap length in $1...
     /
        $"x($1-$-[0]%$1)  # ...with spaces until the total length of $_ is
                          # a multiple of $1 (i.e. right-pad with spaces)
     /e;

    s/
        .{$1}  # Replace series of $1 contiguous chars...
     /
        ($i++%2?reverse$&:$&)."\n"  # ...alternately with themselves or in
                                    # reverse, with a trailing newline
     /ge;

    chop'  # Remove final newline

JavaScript ES6, 123 Byte

var t=(s,n)=>{for(var d=1,i=0,o='',l=s.length;i<l;i++){o+=d?s[i]:s[i-i%n+n-1-i%n]||' ';if(i%n==n-1){d=!d;o+='\n'}}return o}

Aufruf mit t(input_string, twist_length), der die Ausgabezeichenfolge zurückgibt.

Perl 5 , 51 Bytes

$_.=$"x(($-=<>)-1);say--$|?$_:~~reverse for/.{$-}/g

Probieren Sie es online!

Rubin, 80

->s,l{s+=' '*(l-s.size%l)
(s.size/l).times{|i|puts [x=s[i*l,l],x.reverse][i%2]}}

Online-Demo: http://ideone.com/w6o8PI

Kaffeeskript, 151 Bytes

f=(s,n)->r="";d=n;i=0;_="\n";u=" ";l=s.length;(d--and(r+=s[i]or u;++i)or(r+=_;r+=s[c]or u for c in[i+n-1..i];i+=d=n;r+=_ if i<l))while i<(l/n+1>>0)*n;r

Zu viel = (

Bash, 83 74

for((i=0;i<${#1};i+=$2));do b=cat;((i/$2%2))&&b=rev;echo ${1:i:$2}|$b;done

Dies wechselt zwischen catund revfür Teilzeichenfolgen des ersten Arguments mit einer Länge des zweiten Arguments.

Zu den verwendeten Sondervariablen gehören

• ${#1}(die Länge der Zeichenfolge $1)
• ((i/$2%2))(Ein arithmetischer Ausdruck, der den Inkrementor $idurch $2das Modulo dividiert und dann verwendet, um ungerade und gerade Werte zu bestimmen, die vorschreiben, ob ein Inkrementor verwendet werden soll oder nicht rev)
• ${1:i:$2}(Teilstring von $1ab Position $imit einer Länge von $2).

JavaScript ES6, 113 Bytes

Nur mein eigener Riss bei meiner eigenen Frage. Es wird Leerzeichen hinzufügen, so dass es teilbar ist n, auf diese Weise wird es einfach geteilt und umgekehrt.

(s,n)=>(s+' '.repeat(n-s.length%n)).match(eval(`/.{1,${n}}/g`)).map((l,i)=>i%2?[...l].reverse().join``:l).join`
`