Votre tâche consiste à écrire un programme qui, à partir d’un nombre et d’une chaîne, divise la chaîne en morceaux de cette taille et les inverse.

Règles

Votre programme recevra un entier positif n, ainsi qu'une chaîne sd'au moins une longueur composée uniquement d'ASCII imprimable (sans les espaces). La chaîne doit ensuite être divisée en morceaux de longueur n. Si la longueur de la chaîne n'est divisible par naucun reste à la fin, elle doit être considérée comme son propre morceau. Ensuite, inversez l’ordre des morceaux et remettez-les ensemble.

Cas de test

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

C'est du code-golf , vous devriez donc viser le moins d'octets possible.

Gelée , 2 octets

sṚ

Un programme complet qui imprime le résultat.

Essayez-le en ligne!

Comment?

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 octets

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

Essayez-le en ligne!

05AB1E , 5 4 3 octets

-1 grâce à Dennis
-1 grâce à carusocomputing

ôRJ

Essayez-le en ligne!

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

JavaScript (ES6), 37 octets

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

Prend les entrées en currying: nombre d’abord, puis chaîne, comme 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 octets

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

L'essayer

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

L'essayer

Étendu:

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

Essayez-le en ligne .

Haskell , 32 octets

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

Essayez-le en ligne!

PHP, 53 octets

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

Röda , 36 octets

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

Essayez-le en ligne!

C'est une fonction qui prend un argument. Les caractères de la chaîne doivent être dans le flux.

tryest utilisé pour supprimer les erreurs dans le cas où la headfonction ne peut pas liren-1 valeurs.

Explication:

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

Pas aussi obscurci que d'habitude. Je pense que c'est assez beau. :)

CJam , 5 octets

q~/W%

L'entrée est un nombre et une chaîne entre guillemets, séparés par des espaces.

Essayez-le en ligne!Ou vérifiez tous les cas de test .

Explication

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

Lot, 74 octets

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

Plutôt ennuyeux, cela finit par être récursif plutôt que final.

V , 13 à 10 octets

òÀ|lDÏpòÍî

Essayez-le en ligne!

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

En action:

abcdefghijkl

se transforme en

efghijkl
abcd

qui devient

ijkl
efgh
abcd

avant que toutes les nouvelles lignes soient supprimées

brainfuck , 78 octets

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

Le premier octet de l'entrée est la taille du bloc, donnée par la valeur d'octet. Le reste des octets est considéré comme la chaîne.

Essayez-le en ligne!

Développé et commenté

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 octets

-7 octets grâce à mazzy

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

Essayez-le en ligne!

Mathematica, 46 octets

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

Fonction anonyme. Prend un nombre et une chaîne en entrée et retourne une chaîne en sortie. Pas grand chose à voir ici.

Javascript - 54 47 46 octets

Refait:

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

Utilisé comme

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

Merci à @ETHproductions pour quelques quick Reg RegEx Merci à @Shaggy pour un octet supplémentaire dans l'eval!

Original:

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

Pyth, 5 octets

s_c.*

Essayez-le en ligne .

Explication

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

Retina , 38 octets

1 octet enregistré grâce à @LeakyNun

^

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

(Notez l'espace sur la deuxième ligne et l'espace de fin)

Ce programme prend en entrée unaire sur la première ligne et la chaîne sur la seconde.

Essayez-le en ligne!

Suite de tests! (légèrement modifié)

Explication

La première étape consiste à prévoir un espace (qui deviendra important par la suite).

^
 

Maintenant nous inversons. Ceci utilise les groupes d'équilibrage .NET. Il est important de noter que les groupes ici agissent comme des piles, de sorte que chaque match est essentiellement poussé sur la pile. Ici, nous capturons chaque chiffre du nombre unaire dans le groupe 2. Maintenant, chaque fois qu'un caractère de la chaîne est trouvé, une correspondance est extraite du groupe 2. Cela garantit que le nombre de caractères ne dépasse pas celui du nombre unaire.

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

Et enfin, supprimez le nombre unaire et la nouvelle ligne.

 1+¶

Java, 147 138 octets

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 octets sauvés grâce à 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;}

Sous forme développée:

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

C’est en fait mon premier essai de codegolf, alors tout commentaire est le bienvenu!

Perl 5 , 25 octets

Utilise les -lnM5.010drapeaux.

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

Essayez-le en ligne!

Shoutout to Grinnz pour m'avoir parlé de =~ m/.{1,$n}/g

-M5.010active l'utilisation de la sayfonction qui, pour nous, est une impression avec un nom plus court.

-nmet la première ligne d'entrée dans $_, et-l écrase la nouvelle ligne.

Nous obtenons ensuite la deuxième ligne d’entrée en utilisant <>, et nous l’appliquons à la regex .{1,$_}: n’importe quel caractère, compris entre 1 et $ _ (la première entrée) fois. Comme cela est gourmand par défaut, il essaie de toujours faire correspondre les caractères $ _. Le 1,est nécessaire pour le reste de morceau possible à la fin.

Le /gmodificateur nous donne chaque correspondance de cette expression rationnelle dans la chaîne d'entrée sous forme de liste, qui est ensuite inversée et imprimée. En Perl, passer une liste à la sayjoindre sans aucun délimiteur par défaut.

Dyalog APL Extended , 16 à 15 octets

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

Essayez-le en ligne!

Python, 62 octets

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

Essayez-le en ligne!

Empilés , 9 octets

#<rev''#`

Essayez-le en ligne!

#<morceaux, revinverse et se ''#`joint par chaîne vide. Assez facile.

QBIC , 24 octets

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

Cela fait un excellent usage de la nouvelle fonction de sous-chaîne que j'ai récemment ajoutée à 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 octets

s_cF

Takes input as "s",n: Try it for yourself!

Convex, 2 bytes

/¥

Try it 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);}

Result is printed out to the standard output.

Scala, 57 55 bytes

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

Thanks Jacob! Try it here.

Note: By using the symbol form of foldLeft ("/:"), I was able to take off a couple more bytes.

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.