Скручивание слов!

Дана строка и положительное целое число. Вы должны крутить струну, взад и вперед.

Пример ввода / вывода

вход

Programming Puzzles & Code Golf
4

Выход

Prog
mmar
ing 
zzuP
les 
oC &
de G
 flo

вход

Ввод может быть принят через STDIN или аргумент функции. Входные данные будут состоять из строки и положительного целого числа n . Целое число будет определять длину каждой витой линии.

Струна скручена взад-вперед. Ввод HELLO, WORLD!и 5 будет выглядеть так:

Выход

На выходе будет искривленный текст. Это может не быть какой-либо конечный пробел. Если длина входной строки не делится на длину строки, добавьте пробел, пока строка не будет заполнена:

Пример этого:

вход

Hello, World!
5

Вывод (обратите внимание на пробел в самом конце)

Hello
roW ,
ld!  

Пиф, 19 15

VPc+z*dQQ_W~!ZN

Предварительно дополняет строку, а затем переворачивает каждую строку, когда она печатается. Заполнение равно размеру поля, но последняя строка после выделения ввода отбрасывается.

Попробуй здесь

CJam, 19 байтов

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

Пример ввода:

5 "Hello, World!"

Пояснения

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

Снеговик 1.0.1 , 91 байт

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

Или все в одну строку (для эстетики или, более конкретно, для антиэстетики), стоимостью 2 байта:

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

Это слишком коротко, для Снеговика. (Это, вероятно, самое короткое, что он может получить, хотя; я занимался этим в гольф довольно долго.)

Это имеет одно предостережение: оно завершится с ошибкой (но все равно выдаст правильный вывод) в 50% случаев, когда последняя строка не перевернута. (Это потому, что я использую, agчтобы сгруппировать элементы массива в группы по два, чтобы я мог повернуть вспять все остальные, но я не проверяю, имеет ли последний элемент оба ожидаемых элемента, поэтому он попытается получить доступ к несуществующему элементу, если там нечетное количество строк.)

Ungolfed / объяснение:

{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

Принимает nсимволы за один раз из от s, печатая их в направлении, dкоторое чередуется между 1и -1. Для интервала в последней строке sдополняется nпробелами в конце до его нарезки, что влияет на него только тогда, когда в нем осталось меньше nсимволов.

Рекурсивное решение сохранит char (59) за исключением того, что оно оставляет завершающий символ новой строки, что недопустимо.

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

Хаскелл , 83 75 байт

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

Простая chunksOfреализация с взятием и выпуском, применяя четное или нечетное количество обращений к выводу по мере продвижения.

Спасибо @BMO за пять байтов и @ ØrjanJohansen за три байта!

Попробуйте онлайн!

Застрял , 42 41 40 38 байт

Это слишком долго, вероятно, будет пытаться играть в гольф больше!

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

Ввод должен быть как "string"|n.

Объяснение:

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 байт

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

Это довольно долго, господи. Вот оно в действии:

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

Python 2, 109 байт

Пришлось добавить отступы с пробелами, чтобы последняя строка была правильной.

Попробуй здесь

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)

Луа, 91 88 88 84 83 82 байта

Старая версия:

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

Новая версия:

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

O, 60 байтов

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

Моя самая первая программа O, и длинная в этом!

Живая демоверсия.

Perl, 87 байт

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

Старая версия (печатает завершающий символ новой строки):

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

Строка передается как аргумент функции без завершающего символа новой строки. Звоните так:

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

Свинка, 86 байт

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

Хотя это может быть на 2 байта короче, если вы удалите первый ',!' символы в операторе R (читать из STDIN); это добавляет возврат каретки между входом и выходом. Если этого не было, выходные данные являются технически правильными, но первая строка будет добавлена ​​к входной строке.[[Стандартный терминал Mumps, который я использую, не имеет локального эха. ]]   Как он сидит, вот тест:

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 

Также обратите внимание, что на самом деле есть нажатие возврата каретки / ввода между «123» и «6» в конце ввода. [[Местное эхо снова. ]]

Если кому-то интересно, я могу описать, что происходит с кодом; но я понимаю, что там не куча энтузиастов свинки ... :-)

PowerShell, 102 байта

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

Вызывается следующим образом (если сохранено в файл CodeGolf55051.ps1)

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

Предыдущие попытки

(длиннее или недействительно)

PowerShell, 110 байт

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

PowerShell, 111 байт

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

объяснение

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 байт

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 байт

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

объяснение

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

( {...}в приведенных выше комментариях на самом деле {0}|{1}|{2}; я положил {...}для улучшения читаемости.

Powershell, 120 байт (недействительно)

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

Clojure, 83 байта, 87 байтов , 79 байтов

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

несколько исправлений после комментариев ниже, спасибо rrjan .

Попробуйте онлайн!

Кажется, что Clojure часто отсутствует в кодах ответов. Конечно, он не может конкурировать по длине в байтах с языками игры в гольф, но я думаю, что полное отсутствие несколько неоправданно.

Объяснение:

• в данных, два аргумента число и строка
• начните с запуска встроенной функции clojure для разбиения строки sна последовательность, разделяющую ее на последовательность списков символов, длина которых у списков есть n. Последний кусок будет дополнен пробелами по длине, nиспользуя (repeat " ")возвращаемую «коллекцию площадок», которая возвращает бесконечную ленивую последовательность пробелов
• Затем мы вызываем map с тремя аргументами:
  • анонимная функция ( #(..))
  • бесконечная чередующаяся ленивая последовательность функций, #(or %)которая функционирует как функция тождества и обратная (то есть [#(or %) reverse #(or %) reverse ...]), возвращаемая циклом .
  • ленивая последовательность списков, возвращаемых разделом.
• наконец анонимная функция #(apply ...) :
  • вызывает либо identityили reverseчередующимся на куске. Это делается с помощью (% %2)выражения, которое вызывает функцию, отправляемую в качестве первого аргумента анонимной функции [т.е. identityили reverse], используя второй аргумент [т.е. кусок] анонимной функции в качестве аргумента вызова.
  • призывает (apply str ...)преобразовать список символов в строку
• внешняя функция возвращает ленивую последовательность строк

Здесь мы используем один трюк, заключающийся в том, что многие закрывающие функции, например, mapпринимают произвольное количество коллекций в качестве аргументов, т. е. (map f coll1 coll2 coll3 ...)когда функции f нужно просто принять столько аргументов, сколько существует коллекций. В этом случае мы отправляем две коллекции: коллекцию чередующихся ссылок на функции и упорядоченную строку.

APL (Dyalog Unicode) , 19 байт

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

Попробуйте онлайн!

Взял ⊢∘⌽\трюк из блестящего ответа СПП, чтобы на boustrophedonise вызов .

После осознания того, что моя передача прерывается для строк с ведущими символами новой строки, я добавил еще два байта. Ниже старое представление.

APL (Dyalog Unicode) , 17 байт

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

Попробуйте онлайн!

Python 3, 110 108 107 103 байта

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

(глядя на другие ответы), с rjust :95 93 92 90 байт

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 байт

Принимает два аргумента командной строки, как показано с $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 байт

Это кажется слишком длинным.

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

Юлия, 104 байта

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 байт

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

Попробуй здесь

д, 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 байт

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

• {}это функция, которая должна быть вызвана как {}[x;y].
  • x будет строка
  • y будет длина результирующих строк.

Тест:

{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

редактировать : использовали более короткие функции, вдохновленные другим ответом q от @tmartin

Python 2, 82 75 байт

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

Я не мог комментировать @willem, но я сделал его код меньше.

Попробуйте здесь Попробуйте здесь

Perl, 72 байта

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

70 байтов плюс 2 байта для -p0 .

Демо-версия:

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

Обратите внимание, что чтение ввода из STDIN не может заканчиваться символом новой строки (это будет стоить 2 дополнительных байта).

Объяснение:

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 байта

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}

Вызов с t(input_string, twist_length), который возвращает строку вывода.

Perl 5 , 51 байт

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

Попробуйте онлайн!

Руби, 80

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

Демо онлайн: http://ideone.com/w6o8PI

Coffeescript, 151 байт

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

Слишком много = (

Баш, 83 74

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

Это чередуется между catиrev для подстрок первого аргумента с длиной второго аргумента.

Используемые специальные переменные включают

• ${#1}(длина строки $1)
• ((i/$2%2))(арифметическое выражение, делающее инкрементатор $iна $2и затем принимающее его по модулю для определения нечетного и четного, которое диктовало, использовать или нет rev)
• ${1:i:$2}(подстрока $1начала в позиции $iс длиной $2).

JavaScript ES6, 113 байт

Просто моя собственная трещина на мой собственный вопрос. Это добавит пробелы, так что это делится на n, таким образом, это просто расщепление и обращение.

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