당신의 임무는 숫자와 문자열이 주어지면 문자열을 그 크기의 덩어리로 나누고 뒤집는 프로그램을 작성하는 것입니다.

규칙

프로그램은 양의 정수 와 인쇄 가능한 ASCII (공백 제외)로 구성된 길이가 하나 이상인 n문자열 s을받습니다. 문자열 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

파이썬 3 , 35 바이트

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

온라인으로 사용해보십시오!

05AB1E , 5 4 3 바이트

Dennis
-1 덕분에 carusocomputing 덕분에 -1

ôRJ

온라인으로 사용해보십시오!

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

자바 스크립트 (ES6), 37 바이트

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

currying : number first를 입력 한 다음 string을 입력하여 입력합니다 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")

펄 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)
}

배쉬 + coreutils, 22

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

온라인으로 사용해보십시오 .

하스켈 , 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|_}

온라인으로 사용해보십시오!

하나의 인수를 취하는 함수입니다. 문자열의 문자는 스트림에 있어야합니다.

tryhead함수가 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

모든 줄 바꿈이 제거되기 전에

brainfuck , 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 바이트

mazzy 덕분에 -7 바이트

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

온라인으로 사용해보십시오!

수학, 46 바이트

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

익명의 기능. 숫자와 문자열을 입력으로 받아서 문자열을 출력으로 반환합니다. 여기서 볼 것이 많지 않습니다.

자바 스크립트 -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));

RegEx 빠른 처리를 위해 @ETHproductions에 감사드립니다. 평가판에서 여분의 바이트를 @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+¶

자바, 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;
}

이것은 실제로 코드 골프를 시도한 첫 번째 시도이므로 모든 의견을 환영합니다!

펄 5 , 25 바이트

-lnM5.010플래그를 사용합니다 .

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

온라인으로 사용해보십시오!

Grinnz에게 소리를 지르며 =~ m/.{1,$n}/g

-M5.010say우리의 목적을 위해 더 짧은 이름으로 인쇄되는 기능을 사용할 수 있습니다 .

-n둔다 입력에 첫 행 $_및 -l후행 개행 오프 chomps.

그런 다음을 사용하여 두 번째 입력 행을 가져 와서 <>정규 표현식에 적용합니다 .{1,$_}. 1에서 $ _ (첫 번째 입력) 시간 사이의 모든 문자. 기본적으로 욕심이 많으므로 항상 $ _ 문자와 일치 시키려고합니다. 은 1,끝 가능한 남은 청크 필요합니다.

/g수정은 우리에게주는 모든 후 반전 인쇄 목록으로 입력 문자열이 정규식의 일치. Perl에서는 say기본적으로 구분 기호없이 목록을 조인 하여 목록을 전달합니다 .

Dyalog APL 확장 , 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);}

결과는 표준 출력으로 인쇄됩니다.

스칼라, 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.