Przekręcanie słów!


34

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:

WITAJ ŚWIECIE!

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!  


Może nie zawierać żadnych spacji. Grałeś w golfa bez czasownika?
Adám

Czy możemy zwrócić listę linii?
Adám

Odpowiedzi:


10

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


6

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

5

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

5

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) 

4

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!


2
Korzystając z cyclezapisanych 5 bajtów, spróbuj online!
maja18

Zaoszczędź jeszcze trzy bajty, usuwając gi wymieniając ni l: Wypróbuj online!
Ørjan Johansen

3

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

2

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

Jak działa wiązanie letwyrażenia?
xnor

Jest to letinstrukcja dwa w jednym oddzielona średnikiem - zwykle używasz znaków nowej linii i wcięć, ale Haskell pozwala także na pisanie let a=b; c=d in expr.
Lynn,

Nie wiedziałem, że było to dozwolone, usuwając putStrLn z programu!
Leif Willerts,

1
@LeifWillerts, ostatnio wyzwania tutaj pozwalają na wykonywanie operacji we / wy za pomocą argumentów / wyników funkcji lub stdin / stdout - tutaj moje rozwiązanie jest funkcją (%) :: String -> String -> Stringzamiast IO ().
Lynn,

2

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)

2

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)


2

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

2

Ś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 ... :-)


2

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

1
Wspaniale jest zobaczyć kolejnego procera PowerShell! Łatwym początkiem jest pozbycie się gnoju w pobliżu każdego miejsca, param($s,$i)$s+' '*($i-$s.Length%$i)-replace'(.{4})?(.)(.)(.)(.)',"`$1`n`$5`$4`$3`$2`n"-split"`n"|?{$_-ne""}które doprowadzi cię do 108.
AdmBorkBork

Dzięki @TimmyD; Właśnie zauważyłem kilka podstawowych błędów w moim skrypcie (nie spełnia wymagań / jest na stałe ustawiony tylko na 4 ... teraz naprawia)
JohnLBevan

Podczas testowania, aby uzyskać przepływ tam iz powrotem, aby rozpocząć w prawidłowym kierunku, musiałem zamienić [$r]indeks końcowy na [-not$r]... w przeciwnym razie pierwsza linia odczytuje odwrotność (tj. Od prawej do lewej) niż w podanych przykładach. W przeciwnym razie naprawdę szybkie wykonanie!
AdmBorkBork,

1
Ponadto, ponieważ otrzymaliśmy informację, że liczba wejściowa njest dodatnia, i mamy gwarancję, że długość łańcucha nie jest ujemna (z definicji), co oznacza, że (($i-$l%$i)%i)jest to równoważne z ($i-$l%$i)zapisaniem czterech znaków.
AdmBorkBork,

1
Ups, jakoś to napisałem, pierwotnie miałem na myśli (-$l)%$i. Nie wiem skąd to się wzięło. Interesujące jest jednak to, że nie jest to równoważne, chociaż powinno być. To najwyraźniej dziwactwo tego, jak PowerShell (między innymi językami) implementuje funkcję modulo, która różni się od tego, czego oczekiwałem ja (jako matematyka) lub Wolfram-Alpha. Najwyraźniej będziesz musiał trzymać się dłuższej wersji. Referencyjny dowód ->((y-x%y)%y) ==> ((y%y)-(x%y%y))%y ==> ((0)-(x%y))%y ==> (-x%y)%y ==> (-x)%y
AdmBorkBork

2

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.


1
To miłe, ale nie wydaje się, aby zawierało wymagane białe znaki na końcu ld! .
Ørjan Johansen

Jesteś najbardziej poprawny. Dodano kolekcję padów, która powinna rozwiązać problem ... i kosztować mnie 8 bajtów ...
Matias Bjarland

Mam pytanie dotyczące zasad gry w golfa: jeśli używasz wbudowanej funkcji, która wymagałaby importu lub podobnego oświadczenia (wymaga w clojure, importu w Javie itp.), Czy importowanie tej wbudowanej musi być częścią liczba bajtów rozwiązania golfowego? Zakładam, że tak, ale czuje się trochę jak szary obszar.
Matias Bjarland

Tak, import jest liczony.
Ørjan Johansen

Och, ale jest inna zasada, którą łamiesz: nie możesz przyjmować danych wejściowych w predefiniowanych zmiennych, musisz wprowadzić rozwiązanie jako cały program lub funkcję. (Użycie jednej fnlub defnjest w porządku.) Z drugiej strony twoja funkcja może po prostu zwrócić wynik, zamiast go wydrukować.
Ørjan Johansen


2

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

Ostatni wiersz wyniku jest nieprawidłowy. Uruchom tutaj. To świetny pierwszy post, a kiedy to naprawisz, zasugeruję kilka sposobów na oderwanie niektórych bajtów, po pierwsze, że możesz usunąć wszystkie spacje / tabulatory z odpowiedzi.
mbomb007

haha, masz rację. naprawienie tego będzie kosztować dużo, ale jestem na tym. dzięki
bobrobbob


Poza tym dość dawno pobiłeś moją odpowiedź: codegolf.stackexchange.com/a/55082/34718
mbomb007

czytając wskazówki. jeszcze raz dziękuję
bobrobbob

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

1

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

1

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


1

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

Jest to niepoprawne, gdy ostatni wiersz jest krótszy i nie jest przekręcony, chciałem opublikować poprawkę błędu w mojej odpowiedzi, ale myślę, że lepiej będzie, jeśli możesz zaktualizować swój: {-1@[l;(&)(til(#)l:y cut x)mod 2;'[neg[y]$;|:]];}(49 bajtów). Dzięki za inspirację! :)
hjk

1

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


1

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


Cześć AlexN, miło. Myślę, że twój ostatni wiersz w przykładzie „Spróbuj tutaj” jest nieprawidłowy. Powinno to być uzasadnione. Też liczę 86 znaków? Zobacz mój wpis dotyczący aktualizacji.
Willem,

Cześć Willem, masz rację, poprawiłem kod i stwierdziłem, że masz błąd: ideone.com/GOmMrE Powinien być po prawej stronie.
Alexander Nigl,

1

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

1

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.


1
Przepraszamy, opublikowałem trochę za szybko. Jest naprawione.
DankMemes,



0

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


0

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

Hm, zrobiłem to niezależnie od drugiej bashodpowiedzi, którą dopiero co widziałem. Mamy efektywnie tę samą logikę. ... właściwie odpowiedź viktorahlström pozwoliła mi zgolić kolejne 9 znaków.
Adam Katz

0

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`
`
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.