Göreviniz, bir sayı ve bir dize verilen dizeyi bu boyuttaki parçalara bölen ve tersine çeviren bir program yazmaktır.

kurallar

Programınız pozitif bir tamsayı nve sen az biri yalnızca yazdırılabilir ASCII (boşluklar dahil değil) içeren uzunluğa sahip bir dize alır . Daha sonra ipin uzunluğu artıklara bölünmelidir n, eğer ipin uzunluğu nartık herhangi bir kalıntı tarafından bölünemezse , kendi parçası olarak düşünülmelidir. Ardından, parçaların sırasını ters çevirin ve tekrar birleştirin.

Test Kılıfları

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

Bu kod golf , bu yüzden mümkün olduğunca az bayt hedeflemelisiniz.

Jöle , 2 bayt

sṚ

Sonucu basan tam bir program.

Çevrimiçi deneyin!

Nasıl?

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 bayt

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

Çevrimiçi deneyin!

05AB1E , 5 4 3 bayt

-1 sayesinde Dennis
-1 carusocomputing sayesinde

ôRJ

Çevrimiçi deneyin!

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

JavaScript (ES6), 37 bayt

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

Körleyerek girdi alır: önce sayı, sonra string, like 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 bayt

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

Dene

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

Dene

Expanded:

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

Çevrimiçi deneyin .

Haskell , 32 bayt

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

Çevrimiçi deneyin!

PHP, 53 Bayt

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

Röda , 36 bayt

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

Çevrimiçi deneyin!

Bir argüman alan bir işlev. Dizenin karakterleri akışta olmalıdır.

tryheadişlevin n-1değerleri okuyamaması durumunda hataları silmek için kullanılır .

Açıklama:

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

Genelde olduğu kadar şaşkın değil. Bence çok güzel. :)

CJam , 5 bayt

q~/W%

Giriş, boşlukla ayrılmış, çift tırnak içine alınmış bir sayı ve bir dizedir.

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

açıklama

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

Toplu iş, 74 bayt

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

Oldukça can sıkıcı bir şekilde bu özyinelemeli kuyruk özyinelemeden özyinelemeli olur.

V , 13 10 bayt

òÀ|lDÏpòÍî

Çevrimiçi deneyin!

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

Eylemde:

abcdefghijkl

dönüşür

efghijkl
abcd

hangisi olur

ijkl
efgh
abcd

tüm yeni satırlar kaldırılmadan önce

brainfuck , 78 bayt

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

Girişin ilk baytı, bayt değeri ile verilen yığın büyüklüğüdür. Baytların geri kalanı dize olarak kabul edilir.

Çevrimiçi deneyin!

Genişletildi ve yorumlandı

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 bayt

Mazzy sayesinde -7 bayt

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

Çevrimiçi deneyin!

Mathematica, 46 bayt

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

Anonim işlev Girilen sayıyı ve dizgiyi alır ve çıktı olarak dizge döndürür. Burada görülecek çok şey yok.

Javascript - 54 47 46 bayt

remade:

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

Olarak kullanıldı

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

Bazı RegEx bağlantı elemanları için @ETHproductions'e teşekkür ederiz. Değerlendirmede fazladan bir bayt için @Shaggy'ye teşekkür ederiz!

Orijinal:

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

Pyth, 5 bayt

s_c.*

Çevrimiçi deneyin .

açıklama

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

Retina , 38 bayt

@LeakyNun sayesinde 1 bayt kurtarıldı

^

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

(İkinci satırdaki boşluğa ve sondaki boşluğa dikkat edin)

Bu program girdiyi ilk satırdaki unary, ikincisi ise dize olarak alır.

Çevrimiçi deneyin!

Test odası! (biraz değiştirilmiş)

açıklama

İlk adım, bir boşluk hazırlamaktır (daha sonra önem kazanacaktır).

^
 

Şimdi geri döndük. Bu, .NET'in dengeleme gruplarını kullanır. Buradaki grupların yığın olarak hareket ettiğini not etmek önemlidir, bu nedenle her maç esasen yığının üzerine itilir. Burada, tek sayıdaki her basamağı grup 2'ye kaydederiz. Şimdi dizgede bir karakter bulunduğunda, grup 2'den bir eşleşme çıkar. Bu, karakter sayısının tek sayıdaki sayıyı aşmamasını sağlar.

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

Ve nihayet unary numarasını ve yeni satırı kaldırın.

 1+¶

Java, 147 138 Bayt

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 sayesinde 9 bayt kaydedildi!

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

Genişletilmiş biçimde:

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

Bu aslında benim şimdiye kadarki kodlama ilk denemem, bu yüzden herhangi bir geri bildirim bekliyoruz!

Perl 5 , 25 bayt

-lnM5.010Bayrakları kullanır .

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

Çevrimiçi deneyin!

Bana bahsettiği için Grinnz'e bağırıyor =~ m/.{1,$n}/g

-M5.010sayAmaçlarımız için daha kısa bir adla basılan fonksiyonun kullanılmasını sağlar .

-ngiriş satırının ilk satırını yerleştirir $_ve-l arka yeni satır kapalı Chomps.

Sonra ikinci girdi satırını kullanarak elde ederiz <>ve bunu regex'e uygularız .{1,$_}: herhangi bir karakter, 1 ile $ _ (ilk girdi) arasında. Bu, varsayılan olarak açgözlü olduğundan, her zaman $ _ karakteriyle eşleşmeye çalışır. 1,Sonunda olası artık yığın için gereklidir.

/gDeğiştirici bize veren her ardından ters ve yazdırılır listesi olarak girdi dizesindeki bu regex arasında eşleme. Perl’de bir listeyesay varsayılan olarak sınırlayıcı olmadan .

Dyalog APL Genişletilmiş , 16 15 bayt

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

Çevrimiçi deneyin!

Python, 62 bayt

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

Çevrimiçi deneyin!

Yığılmış , 9 bayt

#<rev''#`

Çevrimiçi deneyin!

#<topakları, revters çevirir ve ''#`boş dizeyle katılır. Oldukça basit.

QBIC , 24 bayt

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

Bu, yakın zamanda QBIC’e eklediğim yeni alt işlev işlevini mükemmel şekilde kullanıyor:

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

s_cF

Giriş olarak alır "s",n: Kendiniz deneyin!

Dışbükey , 2 bayt

/¥

Çevrimiçi deneyin!

C, 69 bayt

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

Sonuç standart çıktıya yazdırılır.

Scala, 57 55 bayt

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

Teşekkürler Jacob! Burada dene .

Not: foldLeft ("/:") sembol formunu kullanarak birkaç bayt daha daha çıkarmayı başardım.

Ohm , 5 bayt

σ]QWJ

Çevrimiçi deneyin!

açıklama

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

R , 69 60 bayt

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

Çevrimiçi deneyin!

Öneriniz için Kirill L.'ye teşekkür ederiz seq.