Ihre Aufgabe ist es, ein Programm zu schreiben, das die Zeichenkette anhand einer Zahl und einer Zeichenkette in Stücke dieser Größe aufteilt und sie umkehrt.

Regeln

Ihr Programm erhält eine positive Ganzzahl nsowie eine Zeichenfolge smit mindestens einer Länge, die nur aus druckbarem ASCII (ohne Leerzeichen) besteht. Die Zeichenfolge sollte dann in Abschnitte mit einer Länge aufgeteilt werden n, wenn die Länge der Zeichenfolge nicht durch nReste am Ende teilbar ist, und als eigener Abschnitt betrachtet werden soll. Kehren Sie dann die Reihenfolge der Stücke um und setzen Sie sie wieder zusammen.

Testfälle

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

Dies ist Codegolf , daher sollten Sie so wenig Bytes wie möglich anstreben.

Gelee , 2 Bytes

sṚ

Ein vollständiges Programm, das das Ergebnis druckt.

Probieren Sie es online!

Wie?

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 Bytes

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

Probieren Sie es online!

05AB1E , 5 4 3 Bytes

-1 dank Dennis
-1 dank carusocomputing

ôRJ

Probieren Sie es online!

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

Nimmt die Eingabe durch Curry vor: Nummer zuerst, dann Zeichenfolge, wie 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 Bytes

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

Versuch es

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

Versuch es

Erweitert:

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

Probieren Sie es online aus .

Haskell , 32 Bytes

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

Probieren Sie es online!

PHP, 53 Bytes

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

Röda , 36 Bytes

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

Probieren Sie es online!

Es ist eine Funktion, die ein Argument akzeptiert. Die Zeichen der Zeichenfolge müssen im Stream enthalten sein.

trywird verwendet, um Fehler zu verwerfen, falls die headFunktion keine n-1Werte lesen kann .

Erläuterung:

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

Nicht so verschleiert wie sonst. Ich finde es ziemlich schön. :)

CJam , 5 Bytes

q~/W%

Die Eingabe ist eine Zahl und eine Zeichenfolge in doppelten Anführungszeichen, die durch Leerzeichen getrennt sind.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

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

Batch, 74 Bytes

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

Es ist eher ärgerlich, dass dies eher rekursiv als rekursiv endet.

V , 13-10 Bytes

òÀ|lDÏpòÍî

Probieren Sie es online!

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

In Aktion:

abcdefghijkl

verwandelt sich in

efghijkl
abcd

was wird

ijkl
efgh
abcd

bevor alle Zeilenumbrüche entfernt werden

Brainfuck , 78 Bytes

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

Das erste Byte der Eingabe ist die Blockgröße, angegeben durch den Bytewert. Die restlichen Bytes werden als Zeichenfolge betrachtet.

Probieren Sie es online!

Erweitert und kommentiert

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 Bytes dank mazzy

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

Probieren Sie es online!

Mathematica, 46 Bytes

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

Anonyme Funktion. Nimmt eine Zahl und eine Zeichenfolge als Eingabe und gibt eine Zeichenfolge als Ausgabe zurück. Hier gibt es nicht viel zu sehen.

Javascript - 54 47 46 Bytes

Neu gemacht:

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

Benutzt als

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

Vielen Dank an @ETHproductions für einige RegEx-Verbesserungen. Vielen Dank an @Shaggy für ein zusätzliches Byte in der Auswertung!

Original:

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

Pyth, 5 Bytes

s_c.*

Probieren Sie es online aus .

Erläuterung

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

Retina , 38 Bytes

1 Byte gespart dank @LeakyNun

^

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

(Beachten Sie das Leerzeichen in der zweiten Zeile und das nachfolgende Leerzeichen)

Dieses Programm nimmt die Eingabe in der ersten Zeile als unär und die Eingabe in der zweiten Zeile als unär an.

Probieren Sie es online!

Test Suite! (leicht verändert)

Erläuterung

Der erste Schritt ist das Voranstellen eines Leerzeichens (wird später wichtig).

^
 

Jetzt kehren wir um. Hierbei werden die Bilanzkreise von .NET verwendet. Es ist wichtig zu beachten, dass Gruppen hier als Stapel fungieren, sodass jedes Match im Wesentlichen auf den Stapel geschoben wird. Hier erfassen wir jede Ziffer in der unären Zahl in Gruppe 2. Jedes Mal, wenn ein Zeichen in der Zeichenfolge gefunden wird, wird eine Übereinstimmung aus Gruppe 2 gezogen. Dadurch wird sichergestellt, dass die Anzahl der Zeichen die der unären Zahl nicht überschreitet.

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

Und schließlich entfernen Sie die unäre Nummer und die neue Zeile.

 1+¶

Java, 147 138 Bytes

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

Dank Kevin Cruijssen 9 Bytes gespart!

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

In erweiterter Form:

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

Dies ist eigentlich mein erster Versuch, überhaupt Codegolf zu spielen, daher ist jedes Feedback willkommen!

Perl 5 , 25 Bytes

Verwendet die -lnM5.010Fahnen.

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

Probieren Sie es online!

Grüße Grinnz, dass er mir davon erzählt hat =~ m/.{1,$n}/g

-M5.010ermöglicht die Verwendung der sayFunktion, die für unsere Zwecke mit einem kürzeren Namen gedruckt wird.

-nFügt die erste Eingabezeile in die Zeile ein $_und -lschneidet die nachfolgende neue Zeile ab.

Wir erhalten dann die zweite Eingabezeile mit <>und wenden sie auf den regulären Ausdruck an .{1,$_}: ein beliebiges Zeichen, das zwischen 1 und $ _ (der ersten Eingabe) liegt. Da dies standardmäßig gierig ist, wird versucht, immer mit $ _ -Zeichen übereinzustimmen. Die 1,wird für den eventuell am Ende verbleibenden Brocken benötigt.

Der /gModifikator gibt uns jede Übereinstimmung dieses regulären Ausdrucks in der Eingabezeichenfolge als Liste an, die dann umgekehrt und gedruckt wird. In Perl saywird standardmäßig eine Liste ohne Begrenzer übergeben, um der Liste beizutreten.

Dyalog APL Gesamt , 16 15 Bytes

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

Probieren Sie es online!

Python, 62 Bytes

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

Probieren Sie es online!

Gestapelt , 9 Bytes

#<rev''#`

Probieren Sie es online!

#<Blöcke, revUmkehrungen und ''#`Verknüpfungen durch leere Zeichenfolge. Ziemlich einfach.

QBIC , 24 Bytes

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

Dies nutzt die neue Teilzeichenfolge-Funktion, die ich kürzlich zu QBIC hinzugefügt habe, hervorragend aus:

:;          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 Bytes

s_cF

Nimmt Eingabe als "s",n: Probieren Sie es aus!

Konvex , 2 Bytes

/¥

Probieren Sie es online!

C 69 Bytes

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

Das Ergebnis wird in der Standardausgabe ausgedruckt.

Scala, 57-55 Bytes

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

Danke Jacob! Probieren Sie es hier aus .

Hinweis: Mit der Symbolform foldLeft ("/:") konnte ich noch ein paar Bytes entfernen.

Ohm , 5 Bytes

σ]QWJ

Probieren Sie es online!

Erläuterung

σ]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="")

Probieren Sie es online!

Vielen Dank an Kirill L. für den Vorschlag, ihn zu entfernen seq.