Nhiệm vụ của bạn là viết một chương trình, cho một số và một chuỗi, chia chuỗi thành các phần có kích thước đó và đảo ngược chúng.

Quy tắc

Chương trình của bạn sẽ nhận được một số nguyên dương n, cũng như một chuỗi scó độ dài ít nhất một chuỗi chỉ bao gồm ASCII có thể in được (không bao gồm khoảng trắng). Chuỗi sau đó nên được chia thành các đoạn có độ dài n, nếu độ dài của chuỗi không chia hết cho nbất kỳ phần còn lại nào ở cuối thì nên được coi là đoạn riêng của nó. Sau đó, đảo ngược thứ tự của các khối và đặt chúng lại với nhau.

Các trường hợp thử nghiệm

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

Đây là môn đánh gôn , vì vậy bạn nên nhắm càng ít byte càng tốt.

Thạch , 2 byte

sṚ

Một chương trình đầy đủ in kết quả.

Hãy thử trực tuyến!

Làm sao?

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 byte

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

Hãy thử trực tuyến!

05AB1E , 5 4 3 byte

-1 nhờ Dennis
-1 nhờ carusocomputing

ôRJ

Hãy thử trực tuyến!

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

JavaScript (ES6), 37 byte

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

Lấy đầu vào bằng cách currying: số đầu tiên, sau đó chuỗi, như 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 byte

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

Thử nó

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

Thử nó

Mở rộng:

{  # 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

Hãy thử trực tuyến .

Haskell , 32 byte

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

Hãy thử trực tuyến!

PHP, 53 byte

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

Röda , 36 byte

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

Hãy thử trực tuyến!

Đây là một hàm có một đối số. Các ký tự của chuỗi phải nằm trong luồng.

tryđược sử dụng để loại bỏ lỗi trong trường hợp headhàm không thể đọc n-1các giá trị.

Giải trình:

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 */

Không bị xáo trộn như thường lệ. Tôi nghĩ nó khá đẹp. :)

CJam , 5 byte

q~/W%

Đầu vào là một số và một chuỗi được đặt trong dấu ngoặc kép, được phân tách bằng khoảng trắng.

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

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

Mẻ, 74 byte

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

Khá khó chịu điều này cuối cùng là đệ quy thay vì đệ quy đuôi.

V , 13 10 byte

òÀ|lDÏpòÍî

Hãy thử trực tuyến!

ò      ò    ' 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

Trong hành động:

abcdefghijkl

trở thành

efghijkl
abcd

trở thành

ijkl
efgh
abcd

trước khi tất cả các dòng mới được gỡ bỏ

Brainfuck , 78 byte

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

Byte đầu tiên của đầu vào là kích thước khối, được cho bởi giá trị byte. Phần còn lại của các byte được coi là chuỗi.

Hãy thử trực tuyến!

Mở rộng và bình luận

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 byte

-7 byte nhờ mazzy

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

Hãy thử trực tuyến!

Toán học, 46 byte

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

Chức năng ẩn danh. Lấy một số và một chuỗi làm đầu vào và trả về một chuỗi làm đầu ra. Không có gì nhiều để xem ở đây.

Javascript - 54 47 46 byte

Làm lại:

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

Được dùng như là

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

Cảm ơn bạn @ETHproductions cho một số nhanh chóng RegEx Cảm ơn bạn @Shaggy cho một byte bổ sung trong eval!

Nguyên:

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

Bình thường, 5 byte

s_c.*

Hãy thử trực tuyến .

Giải trình

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

Võng mạc , 38 byte

Lưu 1 byte nhờ @LeakyNun

^

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

(Lưu ý không gian trên dòng thứ hai và không gian dấu)

Chương trình này lấy đầu vào là unary trên dòng đầu tiên và chuỗi trên thứ hai.

Hãy thử trực tuyến!

Phòng thử nghiệm! (sửa đổi một chút)

Giải trình

Bước đầu tiên là chuẩn bị một không gian (sẽ trở nên quan trọng sau này).

^
 

Bây giờ chúng tôi đảo ngược. Điều này sử dụng các nhóm cân bằng của .NET. Điều quan trọng cần lưu ý là các nhóm ở đây hoạt động như các ngăn xếp, vì vậy mọi trận đấu về cơ bản được đẩy lên ngăn xếp. Ở đây chúng tôi nắm bắt từng chữ số trong số đơn vị vào nhóm 2. Bây giờ mỗi lần tìm thấy một ký tự trong chuỗi, một kết quả khớp được bật từ nhóm 2. Điều này đảm bảo số lượng ký tự không vượt quá số lượng đơn vị.

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

Và cuối cùng loại bỏ số unary và dòng mới.

 1+¶

Java, 147 138 byte

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

Đã tiết kiệm được 9 byte nhờ 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;}

Ở dạng mở rộng:

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

Đây thực sự là lần thử đầu tiên của tôi với codegolf, vì vậy mọi phản hồi đều được chào đón!

Perl 5 , 25 byte

Sử dụng các -lnM5.010cờ.

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

Hãy thử trực tuyến!

Hét lên Grinnz vì đã nói với tôi về =~ m/.{1,$n}/g

-M5.010 cho phép sử dụng say chức năng, với mục đích của chúng tôi là in với tên ngắn hơn.

-n đặt dòng đầu tiên vào $_ và -lloại bỏ dòng mới.

Sau đó, chúng tôi nhận được dòng đầu vào thứ hai bằng cách sử dụng <>và áp dụng nó cho regex .{1,$_}: bất kỳ ký tự nào, từ 1 đến $ _ (đầu vào đầu tiên) lần. Vì mặc định điều này là tham lam, nên nó cố gắng luôn khớp với các ký tự $ _. Điều 1,cần thiết cho phần còn lại có thể có ở cuối.

Công cụ /gsửa đổi cung cấp cho chúng tôi mọi kết quả của biểu thức chính quy đó trong chuỗi đầu vào dưới dạng danh sách, sau đó được đảo ngược và in. Trong Perl, thông qua một danh sách để saytham gia nó mà không có bất kỳ dấu phân cách nào theo mặc định.

Dyalog APL Mở rộng , 16 15 byte

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

Hãy thử trực tuyến!

Python, 62 byte

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

Hãy thử trực tuyến!

Xếp chồng lên nhau , 9 byte

#<rev''#`

Hãy thử trực tuyến!

#<chunk, revđảo ngược và ''#`tham gia bởi chuỗi rỗng. Kha đơn gảin.

QBIC , 24 byte

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

Điều này giúp sử dụng tuyệt vời chức năng chuỗi con mới mà tôi đã thêm gần đây vào 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$

Bình thường, 4 byte

s_cF

Đưa đầu vào là "s",n: Hãy thử nó cho chính mình!

Lồi , 2 byte

/¥

Hãy thử trực tuyến!

C, 69 byte

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

Kết quả được in ra cho đầu ra tiêu chuẩn.

Scala, 57 55 byte

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

Cảm ơn Jacob! Hãy thử nó ở đây .

Lưu ý: Bằng cách sử dụng biểu tượng của FoldLeft ("/:"), tôi có thể lấy thêm một vài byte.

Ồ , 5 byte

σ]QWJ

Hãy thử trực tuyến!

Giải trình

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

R , 69 60 byte

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

Hãy thử trực tuyến!

Cảm ơn Kirill L. đã gợi ý để loại bỏ seq.