您的任务是编写一个程序，给定一个数字和一个字符串，该程序将字符串拆分为该大小的块并将其反转。

规则

您的程序将收到一个正整数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

这是code-golf，因此您应该针对尽可能少的字节。

果冻，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感谢Dennis
-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)

通过以下方式获取输入：首先输入数字，然后输入字符串，例如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])));

Röda，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个字节，感谢mazzy

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

在线尝试！

Mathematica，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评估中的额外字节！

原版的：

(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字节

@LeakyNun节省了1个字节

^

+`(.* (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+¶

Java，147138字节

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

感谢Kevin Cruijssen，节省了9个字节！

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

在线尝试！

向Grinnz喊话告诉我有关 =~ m/.{1,$n}/g

-M5.010 可以使用 say功能，出于我们的目的功能以较短的名称打印。

-n 将输入的第一行放入 $_，和-l删除尾随的换行符。

然后，使用来获取输入的第二行<>，并将其应用于正则表达式.{1,$_}：介于1到$ _（第一个输入）之间的任意字符。由于默认情况下这是贪婪的，因此它将尝试始终匹配$ _个字符。的1,需要可能的剩余块。

该/g修改使我们每一个输入字符串作为一个列表，然后将其逆转，打印出的正则表达式匹配。在Perl中，say默认情况下，传递列表以将其加入而没有任何定界符。

Dyalog APL扩展，16 15字节

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

在线尝试！

Python，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（“ /：”）的符号形式，我可以提取几个字节。

欧姆，5个字节

σ]QWJ

在线尝试！

说明

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

R，69 60字节

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

在线尝试！

感谢Kirill L.提出的删除建议seq。