Скручування слів!


34

Скручування слів!

Дано рядок і додатне ціле число. Ви повинні скручувати струну вперед-назад.

Приклад введення / виводу

Вхідні дані

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!  


Це може бути не будь-який пробільний пробіл. Гольф геть дієслово?
Адам

Чи можемо ми повернути список рядків?
Адам

Відповіді:


10

Піт, 19 15

VPc+z*dQQ_W~!ZN

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

Спробуйте тут


6

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

5

Сніговик 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для об'єднання елементів масиву групи по дві, щоб я міг змінити один одного, але я не перевіряю, чи є в останнього елемента очікувані елементи, тому він спробує отримати доступ до неіснуючого елемента, якщо є непарна кількість рядків.)

Недозволений / пояснення:

{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

Пітон 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залишилося менше символів.

Рекурсивне рішення дозволило б врятувати знак (59), за винятком того, що він залишає зворотний новий рядок, що заборонено.

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

4

Haskell , 83 75 байт

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

Простий chunksOf реалізація з функцією "take and drop", застосовуючи парне або непарне число зворотних даних до результату.

Дякуємо @BMO за п’ять байтів та @ ØrjanJohansen за три байти!

Спробуйте в Інтернеті!


2
Використовуючи cycleекономію 5 байт, спробуйте це в Інтернеті!
ბიმო

Зберегти більше три байта шляхом видалення gі заміни nі l: Спробуйте його в Інтернеті!
Ørjan Johansen

3

Застряг , 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

2

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

Як діє зв’язування letвиразу?
xnor

Це letтвердження два в одному, розділене крапкою з комою - зазвичай ви використовуєте нові рядки та відступи, але Haskell також дозволяє писати let a=b; c=d in expr.
Лінн

Я не знав, що це дозволено, виймаючи putStrLn з програми!
Leif Willerts

1
@LeifWillerts, останнім часом тут виникають виклики, як правило, дозволяють вам виконувати введення-виведення через аргументи / результати аргументів або stdin / stdout - тут моє рішення - це функція (%) :: String -> String -> Stringзамість IO ().
Лінн

2

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)

2

Луа, 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)


2

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

2

Свинка, 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" в кінці вводу є фактичне повернення каретки / введення. [[Знову місцева ехо-річ. ]]

Якщо хтось зацікавлений, я можу описати, що відбувається з кодом; але я розумію, що там не так багато любителів свинки ... :-)


2

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

1
Приємно побачити ще одного стропальника PowerShell! param($s,$i)$s+' '*($i-$s.Length%$i)-replace'(.{4})?(.)(.)(.)(.)',"`$1`n`$5`$4`$3`$2`n"-split"`n"|?{$_-ne""}
Простим

Спасибі @TimmyD; щойно я помітив кілька принципових помилок у моєму сценарії (він не відповідає вимогам / жорстко
кодується

Під час тестування для того, щоб потік туди і назад починався в правильному напрямку, мені потрібно було поміняти підсумковий [$r]індекс на [-not$r]... інакше перший рядок читає протилежне (тобто справа наліво), ніж у наведених прикладах. Інакше дійсно гладке виконання!
AdmBorkBork

1
Крім того, оскільки нам дано, що вхідне число nє позитивним, і ми гарантуємо, що довжина рядка є негативною (за визначенням), це означає, що (($i-$l%$i)%i)еквівалентно ($i-$l%$i)збереженню чотирьох символів.
AdmBorkBork

1
Ну, я якось це набрав, спочатку мав на увазі (-$l)%$i. Не знаю, звідки це взялося. Цікаво, однак, що це не рівнозначно, хоча і має бути. Це, мабуть, вигадка про те, як PowerShell (серед інших мов) реалізує функцію модуля, яка відрізняється, ніж я (будучи математикою) або очікував Wolfram-Alpha. Мабуть, вам потрібно буде дотримуватися більш тривалої версії. Довідкове((y-x%y)%y) ==> ((y%y)-(x%y%y))%y ==> ((0)-(x%y))%y ==> (-x%y)%y ==> (-x)%y
доведення

2

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

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

кілька виправлень після коментарів нижче, дякую Ørjan .

Спробуйте в Інтернеті!

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

Пояснення:

  • дані, два аргументи число та рядок
  • почніть з запуску вбудованого функціонального розділу clojure на рядок, який sз'єднує його в послідовність списків символів, де списки мають довжину n. Останній шматок буде прокладений пробілами по довжині, nвикористовуючи "колекцію колодок", повернуту з(repeat " ") якої повертає нескінченну ледачу послідовність пробілів
  • Потім ми називаємо карту з трьома аргументами:
    • анонімна функція (the #(..) )
    • нескінченна чергування ледачої послідовності функцій, #(or %)яка функціонує як функція ідентичності та зворотний (тобто [#(or %) reverse #(or %) reverse ...]), повернута циклом .
    • зведена лінива послідовність списків, повернених розділом.
  • нарешті анонімна функція #(apply ...) :
    • дзвонить identityабо по reverseчерзі на шматок. Це робиться через (% %2)вираз, який викликає функцію, що надсилається в якості першого аргументу анонімній функції [тобто identityабо reverse], використовуючи другий аргумент [тобто фрагмент] анонімній функції як аргумент виклику.
    • дзвінки (apply str ...)для перетворення списку символів у рядок
  • зовнішня функція повертає ледачу послідовність рядків

один трюк, який ми тут використовуємо, полягає в тому, що багато функцій clojure, як-от, mapприймають довільну кількість колекцій як аргументів, тобто (map f coll1 coll2 coll3 ...)там, де для функції f просто потрібно прийняти стільки аргументів, скільки є колекцій. У цьому випадку ми надсилаємо дві колекції, колекцію змінних посилань функцій та зведений рядок.


1
Це добре, але, здається, не має потрібного пробілу в кінці ld! .
Ørjan Johansen

Ви найбільш правильні. Додана колекція колодок, яка повинна вирішити проблему ... і коштувала мені 8 байт ...
Matias Bjarland

У мене виникає питання щодо правил гольфу: якщо ви використовуєте вбудовану функцію, яка потребує імпорту або подібного твердження (вимагають в clojure, імпорту в java тощо), чи повинен імпорт цієї вбудованої частини бути частиною кількість байтів для гольф-рішення? Я припускаю, що так, але це відчуває прилив, як сіра зона.
Matias Bjarland

Так, імпорт зараховується.
Ørjan Johansen

О, але є інше правило, яке ви порушуєте: Ви не можете приймати введення в заздалегідь визначених змінних, вам потрібно зробити рішення або цілою програмою, або функцією. (Використовуючи або добре, fnабо defnдобре). На зворотній стороні вашій функції дозволено просто повертати результат, а не друкувати.
Ørjan Johansen

2

APL (Dyalog Unicode) , 19 байт

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

Спробуйте в Інтернеті!

Взяв ⊢∘⌽\хитрість із блискучої відповіді ngn на виклик бустрофедонісу .

Зрозумівши, що моє подання перерви на рядки з провідними новими рядками, я додав ще два байти. Нижче наведено старіше представлення.

APL (Dyalog Unicode) , 17 байт

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

Спробуйте в Інтернеті!


2

Пітон 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)]))

Останній рядок виводу неправильний. Виконати його тут.Це чудовий перший пост, і як тільки ви виправте, що я запропоную кілька способів відібрати кілька байтів, перше - ви зможете видалити всі пробіли / вкладки зі своєї відповіді.
mbomb007

ха-ха, ти так прав. виправлення цього коштуватиме дорого, але я на цьому. дякую
bobrobbob


Крім того, ви перемогли мою відповідь досить давно: codegolf.stackexchange.com/a/55082/34718
mbomb007

читаючи поради. ще раз дякую
bobrobbob

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

1

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

1

Джулія, 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)

Безголівки:

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

Це неправильно, коли останній рядок коротший і не скручений, я хотів опублікувати виправлення помилок у своїй відповіді, але, думаю, буде краще, якщо ви можете оновити свій замість: {-1@[l;(&)(til(#)l:y cut x)mod 2;'[neg[y]$;|:]];}(49 байт). Дякую за натхнення! :)
hjk

1

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


1

Пітон 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, але я зробив його код меншим.

Спробуйте тут Спробуйте тут


Привіт AlexN, приємний. Я думаю, що ваш останній рядок у прикладі "Спробуйте тут" невірний. Це має бути виправданим правом. Також я рахую 86 символів? Дивіться мій запис для оновлення.
Віллем

Привіт Віллеме, ти маєш рацію, я виправив код і виявив, що у твоїй помилці : ideone.com/GOmMrE Там має бути праворуч.
Олександр Нігль

1

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

1

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), який повертає вихідний рядок.


1
Вибачте, розміщено трохи занадто швидко. Це виправлено.
DankMemes



0

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

Занадто багато = (


0

Баш, 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).

Гм, я зробив це незалежно від іншої bashвідповіді, яку я бачив лише зараз. У нас фактично та сама логіка. ... насправді відповідь viktorahlström просто дозволить мені поголити ще 9 символів.
Адам Кац

0

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`
`
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.