Il tuo compito è quello di scrivere un programma che, dato un numero e una stringa, divide la stringa in blocchi di quella dimensione e li inverte.

Regole

Il tuo programma riceverà un numero intero positivo n, oltre a una stringa sdi lunghezza almeno una composta solo da ASCII stampabile (escluso lo spazio bianco). La stringa dovrebbe quindi essere suddivisa in blocchi di lunghezza n, se la lunghezza della stringa non è divisibile per neventuali avanzi alla fine dovrebbe essere considerata la sua parte. Quindi, invertire l'ordine dei blocchi e rimetterli insieme.

Casi 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

Questo è code-golf , quindi dovresti puntare al minor numero di byte possibile.

Gelatina , 2 byte

sṚ

Un programma completo che stampa il risultato.

Provalo online!

Come?

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]

Provalo online!

05AB1E , 5 4 3 byte

-1 grazie a Dennis
-1 grazie al carusocomputing

ôRJ

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

Prende l'input dal curry: numero prima, quindi stringa, come 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}

Provalo

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

Provalo

Allargato:

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

Provalo online .

Haskell , 32 byte

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

Provalo online!

PHP, 53 byte

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

Röda , 36 byte

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

Provalo online!

È una funzione che accetta un argomento. I caratteri della stringa devono essere nello stream.

tryviene utilizzato per eliminare gli errori nel caso in cui la headfunzione non sia in grado di leggere i n-1valori.

Spiegazione:

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

Non così offuscato come al solito. Penso che sia abbastanza bello. :)

CJam , 5 byte

q~/W%

L'input è un numero e una stringa racchiusi tra virgolette doppie, separati da spazi bianchi.

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

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

Lotto, 74 byte

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

Piuttosto fastidioso questo finisce per essere ricorsivo piuttosto che ricorsivo di coda.

V , 13 10 byte

òÀ|lDÏpòÍî

Provalo 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 azione:

abcdefghijkl

diventa

efghijkl
abcd

che diventa

ijkl
efgh
abcd

prima che tutte le nuove righe vengano rimosse

Brainfuck , 78 byte

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

Il primo byte dell'ingresso è la dimensione del blocco, data dal valore del byte. Il resto dei byte è considerato la stringa.

Provalo online!

Ampliato e commentato

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 grazie a mazzy

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

Provalo online!

Mathematica, 46 byte

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

Funzione anonima. Accetta un numero e una stringa come input e restituisce una stringa come output. Non c'è molto da vedere qui.

Javascript - 54 47 46 byte

rifatto:

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

Usato come

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

Grazie a @ETHproductions per alcune accelerazioni di RegEx Grazie a @Shaggy per un byte extra in valutazione!

Originale:

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

Pyth, 5 byte

s_c.*

Provalo online .

Spiegazione

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

Retina , 38 byte

1 byte salvato grazie a @LeakyNun

^

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

(Nota lo spazio sulla seconda riga e lo spazio finale)

Questo programma accetta l'input come unario sulla prima riga e la stringa sulla seconda.

Provalo online!

Test Suite! (leggermente modificato)

Spiegazione

Il primo passo è anteporre uno spazio (diventerà importante in seguito).

^
 

Adesso facciamo il contrario. Questo utilizza i gruppi di bilanciamento di .NET. È importante notare che i gruppi qui agiscono come pile, quindi ogni partita viene essenzialmente messa in pila. Qui catturiamo ogni cifra nel numero unario nel gruppo 2. Ora ogni volta che viene trovato un carattere nella stringa, viene spuntata una corrispondenza dal gruppo 2. Questo assicura che il numero di caratteri non superi quello del numero unario.

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

E infine rimuovere il numero unario e la nuova riga.

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

Salvataggio di 9 byte grazie a 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;}

In forma estesa:

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

Questo è in realtà il mio primo tentativo di codegolf di sempre, quindi qualsiasi feedback è il benvenuto!

Perl 5 , 25 byte

Usa le -lnM5.010bandiere.

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

Provalo online!

Shoutout a Grinnz per avermene parlato =~ m/.{1,$n}/g

-M5.010 consente l'uso di say funzione, che per i nostri scopi è la stampa con un nome più breve.

-ninserisce la prima riga di input in $_, e-l cancella la nuova riga finale.

Otteniamo quindi la seconda riga di input usando <>e la applichiamo alla regex.{1,$_} : qualsiasi carattere, tra 1 e $ _ (il primo input) volte. Dal momento che questo è avido per impostazione predefinita, cerca di abbinare sempre $ _ caratteri. Il1, è necessario per l'eventuale porzione rimanente alla fine.

Il /gmodificatore ci fornisce ogni corrispondenza di quella regex nella stringa di input come un elenco, che viene quindi invertito e stampato. In Perl, passare un elenco per sayunirlo senza delimitatore per impostazione predefinita.

Dyalog APL esteso , 16 15 byte

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

Provalo online!

Python, 62 byte

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

Provalo online!

Impilato , 9 byte

#<rev''#`

Provalo online!

#<blocchi, revinverte e ''#`unisce a stringa vuota. Abbastanza semplice.

QBIC , 24 byte

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

Questo fa un uso eccellente della nuova funzione di sottostringa che ho recentemente aggiunto a 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 byte

s_cF

Accetta input come "s",n: Provalo tu stesso!

Convesso , 2 byte

/¥

Provalo online!

C, 69 byte

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

Il risultato viene stampato sull'output standard.

Scala, 57 55 byte

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

Grazie Jacob! Provalo qui .

Nota: utilizzando la forma del simbolo di foldLeft ("/:"), sono stato in grado di rimuovere un altro paio di byte.

Ohm , 5 byte

σ]QWJ

Provalo online!

Spiegazione

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

Provalo online!

Grazie a Kirill L. per il suggerimento di rimuovere seq.