Ваше завдання - написати програму, яка, задавши число і рядок, розбиває рядок на шматки такого розміру і повертає їх назад.

Правила

Ваша програма отримає додатне ціле число n, а також рядок sдовжиною щонайменше однієї, що складається лише з друкованого ASCII (не враховуючи пробіли). Потім рядок слід розділити на шматки довжини n, якщо довжина струни не ділиться nжодним залишком на кінці, слід вважати її власною частиною. Потім переверніть порядок шматочків і знову складіть їх.

Випробування

n   s           Output

2   abcdefgh    ghefcdab
3   foobarbaz   bazbarfoo
3   abcdefgh    ghdefabc
2   a           a
1   abcdefgh    hgfedcba
2   aaaaaa      aaaaaa
2   baaaab      abaaba
50  abcdefgh    abcdefgh
6   abcdefghi   ghiabcdef

Це код-гольф , тому вам слід націлитись на якомога менше байтів.

Желе , 2 байти

sṚ

Повна програма, яка друкує результат.

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

Як?

sṚ - Main link: string, number                                   e.g. 'abcdefg', 3
s  - split string into chunks of length number (keeping any overflow) ["abc","def","g"]
 Ṛ - reverse the resulting list                                       ["g","def","abc"]
   - implicit print                                                   gdefabc

Python 3 , 35 байт

f=lambda s,n:s and f(s[n:],n)+s[:n]

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

05AB1E , 5 4 3 байти

-1 завдяки Деннісу
-1 завдяки carusocomputing

ôRJ

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

     # Implicit: push input
 ô   # Split in pieces of length b
  RJ # Reverse and join

JavaScript (ES6), 37 байт

n=>F=s=>s&&F(s.slice(n))+s.slice(0,n)

Вводиться за допомогою currying: спочатку число, потім рядок, як f(2)("abcdefgh").

let f =
n=>F=s=>s&&F(s.slice(n))+s.slice(0,n)

let g = (n, s) => console.log(`f(${n})("${s}"): ${f(n)(s)}`)

g(2, "abcdefgh")
g(3, "foobarbaz")
g(3, "abcdefgh")
g(2, "a")
g(1, "abcdefgh")
g(2, "aaaaaa")
g(2, "baaaab")
g(50, "abcdefgh")

Perl 6 ,  28  20 байт

{$^b.comb($^a).reverse.join}

Спробуй це

{[R~] $^b.comb($^a)}

Спробуй це

Розширено:

{  # bare block lambda with placeholder parameters ｢$a｣ and ｢$b｣
  [R[~]] # reduce the following using the reverse meta operator `R`
         # combined with the string concatenation operator

    # `comb` with a number splits the invocant into chunks of that size
    $^b.comb($^a)
}

Bash + coreutils, 22

fold -$1|tac|tr -d \\n

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

Haskell , 32 байти

n#""=""
n#s=n#drop n s++take n s

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

PHP, 53 байти

<?=join(array_reverse(str_split($argv[2],$argv[1])));

Рода , 36 байт

f n{[[_]..[try head n-1]]|reverse|_}

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

Це функція, яка бере один аргумент. Символи рядка повинні бути в потоці.

tryвикористовується для усунення помилок у випадку, якщо headфункція не може прочитати n-1значення.

Пояснення:

f n{[[_]..[try head n-1]]|reverse|_}
f n{                               } /* Function declaration */
                                     /* In a loop: */
      _                              /*   Pull one value */
           try head n-1              /*   Pull n-1 values (or less) */
     [ ]..[            ]             /*   Make an array */
    [                   ]            /*   Push it to the stream */
                         |reverse    /* Reverse all values in the stream */
                                 |_  /* Flat all arrays in the stream */
                                     /* Characters in the stream are printed */

Не так заплутано, як зазвичай. Я думаю, що це досить красиво. :)

CJam , 5 байт

q~/W%

Введення - це число і рядок, укладені у подвійні лапки, розділені пробілом.

Спробуйте в Інтернеті! Або перевірити всі тестові випадки .

Пояснення

q~   e# Read all input and evaluate: pushes a number and a string
/    e# Split string into chunks of that size. Last chunk may be
     e# smaller. Gives an array of strings
W%   e# Reverse the array. Implicitly display

Пакет, 74 байти

@if %2=="" (echo %~3)else set s=%~2&call %0 %1 "%%s:~%1%%" "%%s:~,%1%%%~3"

Швидше дратівливо це в кінцевому підсумку стає рекурсивним, а не рекурсивним хвостом.

V , 13 10 байт

òÀ|lDÏpòÍî

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

ò      ò    ' Recursively
 À|         ' Go to the "nth" column
   l        ' Move one character right (breaks loop when no more chunks)
    D       ' Delete from here to the end of the line
     Ï      ' Add a line above the current line (now contains one chunk)
      p     ' Paste the remainder of the line that was deleted
        Íî  ' Remove all newlines

Дія:

abcdefghijkl

перетворюється на

efghijkl
abcd

що стає

ijkl
efgh
abcd

перш ніж всі нові рядки будуть видалені

мозковий ебать , 78 байт

,<<<+[[>]>+>[[>],<[<]>+>-]<-[->>[>]>>+<<<[<]<]>>]<<<<[[<]>[-[+.[-]]+>]<[<]<<<]

Перший байт вводу - це розмір блоку, заданий значенням байта. Решта байтів вважаються рядком.

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

Розширено та прокоментовано

Read the chunk size byte
This cell will become a counter cell
,

Move left a few cells an increment; 
this is to make the starting position 
line up with the relative positioning
needed to fit in with the loop
<<<+

While the current cell is nonzero:
[

 Move right to the first zero cell
 [>]

 Move right once and increment and then move right to the counter cell
 The increment is required because of "move to zero cell" loops
 >+>

 This loop will store one chunk of the input in consecutive memory cells
 [
  [>]   Move right until a zero cell is hit
  ,     Store 1 byte of input there
  <[<]  Move back left until a zero cell (other than the current one) is hit
  >+>-  Increment the temporary cell by 1 and decrement the counter
 ] (end loop once the counter hits zero)

 Decrement the temp cell (because we needed to have 1 there initially to make the cell location work)
 <-

 Move the temp cell to three cells after the end of the chunk
 This is the new counter cell for the next chunk
 [->>[>]>>+<<<[<]<]

 Move two cells right from where the temp cell was
 This is the first cell of the chunk; if it's 0
 then the input is finished and the loop should end
 >>
]

Due to the way the counter is kept track of the tape head
will always be four cells to the right of the last input cell
when the loops breaks
<<<<

Now the chunks are printed one by one
At the start of an iteration the tape head is at the end of a chunk
[
 Locate the start of the last chunk
 [<]>

 Print the chunk:
 [
  Print the byte held in the current cell if it isn't 1
  This is necessary because we left a stray 1 in a cell at
  the start which shouldn't be printed
  -[+.[-]]+

  Move to the next cell
  >
 ]

 Move to just left of the chunk
 <[<]

 Move three cells over to the end of the next chunk
 <<<
]

PowerShell, 56 49 байт

-7 байт завдяки маззі

param($n,$s)$s-split"(.{$n})"-ne''|%{$r=$_+$r};$r

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

Математика, 46 байт

""<>Reverse@Partition[Characters@#2,#,#,1,{}]&

Анонімна функція. Бере число та рядок як вхідні дані та повертає рядок як вихід. Тут не багато чого побачити.

Javascript - 54 47 46 байт

Перероблено:

(s,n)=>s.match(eval(`/.{1,${n}}/g`)).reverse()

Використовується як

f=(s,n)=>s.match(eval(`/.{1,${n}}/g`)).reverse()
alert(f("abcdefgh",2));

Дякуємо @ETHproductions за деяке поскорення RegEx Дякую @Shaggy за додатковий байт в eval!

Оригінал:

(s,n)=>s.match(new RegExp('.{1,'+n+'}','g')).reverse()

Pyth, 5 байт

s_c.*

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

Пояснення

   .*  splat implicit input
  c    split into chunks length n
 _     reverse
s      join

Сітківка , 38 байт

1 байт збережено завдяки @LeakyNun

^

+`(.* (1)+¶)((?<-2>.)+)
$3$1
 1+¶

(Зверніть увагу на пробіл у другому рядку та пробіл)

Ця програма приймає введення як уніар у першому рядку, а рядок у другому.

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

Тестовий сюїт! (трохи змінено)

Пояснення

Перший крок - передбачити пробіл (стане важливим згодом).

^
 

Тепер ми реверсуємо. Для цього використовуються балансуючі групи .NET. Важливо зазначити, що групи тут виступають як стеки, тому кожен матч по суті висувається на стек. Тут ми фіксуємо кожну цифру унарного числа в групу 2. Тепер кожен раз, коли знайдений символ у рядку, збіг вискакує з групи 2. Це забезпечує, що кількість символів не перевищує кількість унарного числа.

+`(.* (1)+¶)                       Capture the unary number in group 2
             ((?<-2>.)+)           Balancing group for substrings
$3$1                               Reverse

І нарешті видаліть одинарне число та новий рядок.

 1+¶

Ява, 147 138 байт

String r(String s,int n){String r="";int l=s.length();for(int i=l/n*n;i>=0;i-=n)if(!(i>=l))r+=(i+n)>=l?s.substring(i):s.substring(i,i+n);return r;}

Збережено 9 байт завдяки Kevin Cruijssen!

String r(String s,int n){String r="";int l=s.length(),i=l/n*n;for(;i>=0;i-=n)if(i<l)r+=i+n>=l?s.substring(i):s.substring(i,i+n);return r;}

У розгорнутому вигляді:

String r(String s,int n){
    String r="";
    int l=s.length(),i=l/n*n;
    for(;i>=0;i-=n)
        if(i<l)
            r+=i+n>=l?s.substring(i):s.substring(i,i+n);
    return r;
}

Це насправді моя перша спроба кодогольфу коли-небудь, тому будь-який відгук вітається!

Perl 5 , 25 байт

Використовує -lnM5.010прапори.

say reverse<>=~/.{1,$_}/g

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

Кричати Грінцу за те, що він розповів про мене =~ m/.{1,$n}/g

-M5.010дозволяє використовувати sayфункцію, яка для наших цілей друкується із скороченою назвою.

-nставить перший рядок вводу в $_, і-l відключає кінцевий новий рядок.

Потім ми отримуємо другий рядок введення за допомогою <>та застосовуємо його до регулярного вираження .{1,$_}: будь-який символ, від 1 до $ _ (перший вхід) разів. Оскільки це за замовчуванням жадібне, воно намагається завжди відповідати символам $ _. 1,Необхідно для можливого залишкового шматка в кінці.

/gМодифікатор дає нам кожен матч , що регулярний вираз в рядку введення у вигляді списку, який потім обернено і надрукованій. У Perl, передаючи список, sayприєднується до нього без обмежувача за замовчуванням.

Dyalog APL Extended , 16 15 байт

{∊⌽⍵⊂⍨(≢⍵)⍴=⍳⍺}

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

Пітон, 62 байти

lambda n,s:''.join([s[i:i+n]for i in range(0,len(s),n)][::-1])

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

Складені , 9 байт

#<rev''#`

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

#<скидає, revобертає назад і ''#`з'єднує порожній рядок. Досить просто.

QBIC , 24 байти

:;[1,_lA|,a|Z=_sA,b,a|+Z

Це чудово використовує нову функцію підрядки, яку я нещодавно додав до QBIC:

:;          Read in the cmd line params a (number) and A$ (text)
[1,_lA|,a|  Set up a FOR loop: FOR b = 1; b <= A$.length; b += a
Z=          Modify Z$; Z$ is autoprinted at the end of QBIC code
_sA,b,a|    SUBSTRING: _s is the function followed by the string 
               to take from, the starting pos and the # of chars
+Z          Take chunks from further into A$, put them before Z$

Pyth, 4 байти

s_cF

Вважається як "s",n: Спробуйте самі!

Опукла , 2 байти

/¥

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

C, 69 байт

i;f(s,n)char*s;{i=strlen(s);for(i-=i%n;printf("%.*s",n,s+i),i;i-=n);}

Результат роздруковується на стандартний вихід.

Scala, 57 55 байт

(n:Int,s:String)=>(""/:s.grouped(n).toSeq.reverse)(_+_)

Дякую Якобу! Спробуйте тут .

Примітка. Використовуючи форму символу foldLeft ("/:"), я зміг зняти ще пару байтів.

Ohm, 5 bytes

σ]QWJ

Try it online!

Explanation

σ]QWJ
σ         # Split input1 into input2 pieces
 ]        # Flatten array
  Q       # Reverses stack
   W      # Wraps stack to array
    J     # Joins stack
          # Implicit print

R, 69 60 bytes

function(s,n)cat(substring(s,(x=nchar(s):0*n)+1,x+n),sep="")

Try it online!

Thanks to Kirill L. for the suggestion to remove seq.