Przekręcanie słów!

Podany ciąg i dodatnia liczba całkowita. Musisz przekręcić sznurek, tam iz powrotem.

Przykład wejścia / wyjścia

Wkład

Programming Puzzles & Code Golf
4

Wydajność

Prog
mmar
ing 
zzuP
les 
oC &
de G
 flo

Wkład

Dane wejściowe mogą być pobierane przez STDIN lub argument funkcji. Dane wejściowe będą składać się z łańcucha i dodatniej liczby całkowitej, n . Liczba całkowita określa długość każdej skręconej linii.

Sznurek jest skręcony tam iz powrotem. Dane wejściowe HELLO, WORLD!i 5 wyglądałyby następująco:

Wydajność

Wynikiem będzie skręcony tekst. Może nie zawierać żadnych spacji. Jeśli wejściowa długość ciągu nie jest podzielna przez długość linii, dodaj spację, aż linia zostanie wypełniona:

Przykład tego:

Wkład

Hello, World!
5

Dane wyjściowe (zwróć uwagę na białe znaki na samym końcu)

Hello
roW ,
ld!  

Pyth, 19 15

VPc+z*dQQ_W~!ZN

Wstępnie wypełnia ciąg, a następnie odwraca linię podczas drukowania. Dopełnienie jest równe rozmiarowi pudełka, ale ostatni wiersz po pocięciu wejścia jest odrzucany.

Wypróbuj tutaj

CJam, 19 bajtów

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

Przykład wprowadzania:

5 "Hello, World!"

Objaśnienia

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

Snowman 1.0.1 , 91 bajtów

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

Lub wszystko w jednym wierszu (w przypadku estetyki, a dokładniej antyestetyki), kosztem 2 bajtów:

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

Jest to o wiele za krótko, jak na Bałwana. (Jest to jednak prawdopodobnie najkrótszy możliwy; grałem w golfa dość długo).

Ma to jedno zastrzeżenie: zakończy się z błędem (ale nadal będzie generować prawidłowe wyjście) w 50% przypadków, gdy ostatni wiersz nie zostanie odwrócony. (Jest tak, ponieważ używam agdo grupowania elementów tablicy w grupy po dwie, aby móc odwrócić każdy inny, ale nie sprawdzam, czy ostatni element ma oba oczekiwane elementy, więc spróbuje uzyskać dostęp do nieistniejącego elementu, jeśli liczba linii jest nieparzysta).

Nieskluczone / wyjaśnienie:

{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

Pobiera npostacie od początku s, drukując je w kierunku na dprzemian między 1i -1. Aby wstawić odstępy w ostatnim wierszu, sjest on wypełniany nspacjami na końcu, zanim zostanie pocięty, co wpływa na to tylko wtedy, gdy ma mniej niż nznaków.

Rozwiązanie rekurencyjne uratowałoby znak (59), z tym wyjątkiem, że pozostawia on końcowy znak nowej linii, co jest niedozwolone.

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

Haskell , 83 75 bajtów

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

Prosta chunksOfimplementacja z funkcją „bierz i upuszczaj”, stosując do wyjścia parzystą lub nieparzystą liczbę zwrotów.

Dzięki @BMO za pięć bajtów i @ ØrjanJohansen za trzy bajty!

Wypróbuj online!

Utknął , 42 41 40 38 bajtów

To trochę za długo, prawdopodobnie postaram się więcej zagrać w golfa!

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

Dane wejściowe powinny być jak "string"|n.

Wyjaśnienie:

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 bajtów

(#)=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

To trochę długie, Jezu. Oto jest w akcji:

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

Python 2, 109 bajtów

Musiałem dodać dopełnienie ze spacjami, aby ostatni wiersz był poprawny.

Wypróbuj tutaj

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 bajtów

Stara wersja:

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

Nowa wersja:

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

O, 60 bajtów

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

Mój pierwszy program O, i to długi!

Demo na żywo.

Perl, 87 bajtów

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

Stara wersja (drukuje końcowy znak nowej linii):

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

Ciąg jest przekazywany jako argument funkcji bez końcowego znaku nowej linii. Zadzwoń tak:

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

Świnka, 86 bajtów

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)),!

Chociaż usunięcie pierwszego „,!” Może być o 2 bajty krótsze. znaki w instrukcji R (odczytane ze STDIN); który dodaje znak powrotu karetki między wejściem a wyjściem. Gdyby tego nie było, dane wyjściowe są technicznie poprawne, ale pierwszy wiersz pojawiłby się w łańcuchu wejściowym. [[Standardowy terminal Mumpa, którego używam, nie ma lokalnego echa. ]]   Na miejscu jest 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 

Zauważ również, że faktycznie istnieje klawisz powrotu karetki / Enter pomiędzy „123” a „6” na końcu wejścia. [[Lokalne echo ponownie. ]]

Jeśli ktoś jest zainteresowany, mogę opisać, co się dzieje z kodem; ale zdaję sobie sprawę, że nie ma tam wielu entuzjastów świnki ... :-)

PowerShell, 102 bajty

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

Wywoływany w następujący sposób (jeśli zapisany w pliku CodeGolf55051.ps1)

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

Poprzednie próby

(dłuższy lub nieprawidłowy)

PowerShell, 110 bajtów

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

PowerShell, 111 bajtów

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

Wyjaśnienie

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 bajtów

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 bajtów

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})"|?{$_}

Wyjaśnienie

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

( {...}w powyższych komentarzach jest tak naprawdę {0}|{1}|{2}; postawiam {...}na lepszą czytelność.

PowerShell, 120 bajtów (nieprawidłowy)

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

Clojure, 83 bajty, 87 bajtów , 79 bajtów

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

kilka poprawek po komentarzach poniżej, dziękuję Ørjan .

Wypróbuj online!

Clojure wydaje się często niestety nieobecny w odpowiedziach na golfa z kodem. Z pewnością nie może konkurować długością bajtów z językami golfowymi, ale myślę, że całkowita nieobecność jest nieco nieuzasadniona.

Wyjaśnienie:

• w danych, dwa argumenty liczba i ciąg
• zacznij od uruchomienia wbudowanej funkcji clojure partycja na łańcuch, sdzieląc go na sekwencję list znaków, których listy mają długość n. Ostatnia porcja zostanie wypełniona spacjami na długość nza pomocą zwróconej „kolekcji padów”, z (repeat " ")której zwraca nieskończoną leniwą sekwencję spacji
• wywołujemy mapę z trzema argumentami:
  • anonimowa funkcja (the #(..))
  • nieskończona naprzemienna leniwa sekwencja funkcji, #(or %)która działa jak funkcja tożsamości i odwrotna (tj. [#(or %) reverse #(or %) reverse ...]) zwracana przez cykl .
  • podzielona na leniwe sekwencje list zwracanych przez partycję.
• wreszcie anonimowa funkcja #(apply ...) :
  • wzywa zarówno identitylub reversenaprzemiennie na fragmencie. Odbywa się to za pomocą (% %2)wyrażenia, które wywołuje funkcję wysłaną jako pierwszy argument do funkcji anonimowej [tj. identityLub reverse] przy użyciu drugiego argumentu [tj. Porcji] do funkcji anonimowej jako argumentu wywołania.
  • wywołań, (apply str ...)aby przekonwertować listę znaków na ciąg znaków
• funkcja zewnętrzna zwraca leniwą sekwencję ciągów

jedną sztuczką, której tu używamy, jest to, że wiele funkcji clojure, takich jak mapprzyjmowanie dowolnej liczby zbiorów jako argumentów, tj. (map f coll1 coll2 coll3 ...)gdy funkcja f musi zaakceptować tyle argumentów, ile jest zbiorów. W tym przypadku wysyłamy dwie kolekcje, kolekcję naprzemiennych odwołań do funkcji i podzielony ciąg.

APL (Dyalog Unicode) , 19 bajtów

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

Wypróbuj online!

Wziął ⊢∘⌽\ sztuczkę z genialnej odpowiedzi NNG na wyzwanie boustrophedonise .

Po uświadomieniu sobie, że moje przesyłanie zrywa z liniami z wiodącymi nowymi liniami, dodałem jeszcze dwa bajty. Poniżej znajduje się starsze zgłoszenie.

APL (Dyalog Unicode) , 17 bajtów

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

Wypróbuj online!

Python 3, 110 108 107 103 bajty

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

(patrząc na inne odpowiedzi), z rjust:95 93 92 90 bajtów

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 bajtów

Pobiera dwa argumenty wiersza polecenia, jak pokazano za pomocą $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 bajtów

To wydaje się za długie.

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 bajty

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)

Nie golfowany:

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 bajtów

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

Wypróbuj tutaj

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 bajtów

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

• {}to funkcja, którą należy wywołać jako {}[x;y].
  • x będzie ciąg.
  • y będzie długością wynikowych linii.

Test:

{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

edycja : Użyto krótszych funkcji inspirowanych inną q odpowiedzią @tmartin

Python 2, 82 75 bajtów

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

Nie mogłem skomentować @willem, ale zmniejszyłem jego kod.

Spróbuj tutaj Spróbuj tutaj

Perl, 72 bajty

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

70 bajtów plus 2 bajty dla -p0.

Próbny:

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

Zauważ, że dane wejściowe odczytane ze STDIN nie mogą kończyć się nową linią (to kosztuje 2 dodatkowe bajty).

Wyjaśnienie:

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 bajty

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}

Wywołaj za pomocą t(input_string, twist_length), która zwraca ciąg wyjściowy.

Perl 5 , 51 bajtów

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

Wypróbuj online!

Ruby, 80

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

Demo online: http://ideone.com/w6o8PI

Coffeescript, 151 bajtów

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

Za dużo = (

Bash, 83 74

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

Dzieje się to naprzemiennie między cati revdla podciągów pierwszego argumentu o długości drugiego argumentu.

Zastosowane specjalne zmienne obejmują

• ${#1}(długość łańcucha $1)
• ((i/$2%2))(wyrażenia arytmetycznego podzielenie incrementor $iprzez $2czym przy jego modulo aby określić kurs vs parzysty, co podyktowane czy po użyciu rev)
• ${1:i:$2}(substring $1rozpoczynania od pozycji $io długości $2).

JavaScript ES6, 113 bajtów

Tylko mój trzask na własne pytanie. Dodają spacje, dzięki czemu można je podzielić n, w ten sposób po prostu dzielą się i cofają.

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