Bu zorluk, TidB'nin bu çok güzel cevabından ilham alıyor.

TidB'nin cevabında her sekiz karakter doğru sırada: gnilwoB edoC( Code Bowlinggeriye). Diğer dizeleri ancak edilir garip, rasgele sırada idi.

Buradaki zorluk, bunu düzeltmek.

(Boş olmayan) bir dize ve ngiriş olarak pozitif bir tamsayı alın . Dize, aralıktaki ASCII karakterlerini içerecektir: 32-126 (tilde boşluk).

Dizeyi artan sırada (ASCII kod değerini temel alarak soldan görüldüğü gibi) sıralamanız gerekir , ancak ndizgenin sonundan başlayarak her karakteri atlayın . Örnek olarak, dizeyi abcdABC123girdi olarak alalım ve n=4sonra şunu alalım:

abcdABC123   <- Input string. (n=4)
_b___B___3   <- These will not be sorted (every 4th starting from the end)
1_2AC_acd_   <- The remaining characters, sorted
1b2ACBacd3   <- The final string (the output)

Başka bir örnek:

9876543210   <- Input string (n=2)
_8_6_4_2_0   <- These will not be sorted
1_3_5_7_9_   <- The remaining characters, sorted
1836547290   <- The final string (the output)

Giriş dizisi isteğe bağlı bir biçimde alınabilir (dize, karakter listesi, tek karakterli dizelerin listesi ...). Giriş tamsayı isteğe bağlı bir formatta da alınabilir.

Test durumları:

Format n=__, bir sonraki satırdaki giriş dizgisi olacaktır. Çıktı aşağıdaki satırda.

n=1   (All elements will stay in place)
nafgaksa1252#"%#
nafgaksa1252#"%#    

n=214  (The last character will stay in place. All other are sorted. 
&/lpfAVD
&/AVflpD  

n=8
g7L9T E^n I{><#ki XSj!uhl y= N+|wA}Y~Gm&o?'cZPD2Ba,RFJs% V5U.W;1e  0_zM/d$bH`@vKoQ 43Oq*C
g       n !#$%&'i*+,./01l234579;w<=>?@ADoEFGHIJKBLMNOPQR STUVWXYeZ^_`abcdhjkmqsuovyz{|}~C

MATL , 15 14 bayt

ttfiX\qgP)S5M(

Girişler, tek tırnak içine alınmış bir dize ve bir sayıdır. İpteki tekli alıntı sembolleri, çoğaltılarak çıkarılmalıdır (MATLAB ve Octave'deki gibi).

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

açıklama

Girdileri düşünün 'abcdABC123've 4.

tt     % Implicitly input string. Duplicate twice
       % STACK: 'abcdABC123', 'abcdABC123', 'abcdABC123'
f      % Find: indices of nonzero elements: gives [1 2 ... n] where n is input length
       % STACK: 'abcdABC123', 'abcdABC123', [1 2 3 4 5 6 7 8 9 10]
i      % Input n
       % STACK: 'abcdABC123', 'abcdABC123', [1 2 3 4 5 6 7 8 9 10], 4
X\     % 1-based modulo
       % STACK: 'abcdABC123', 'abcdABC123', [1 2 3 4 1 2 3 4 1 2 3 4]
qg     % Subtract 1, convert to logical: gives true (1) for 1, false (0) otherwise
       % STACK: 'abcdABC123', 'abcdABC123', [0 1 1 1 0 1 1 1 0 1]
P      % Flip
       % STACK: 'abcdABC123', 'abcdABC123', [1 0 1 1 1 0 1 1 1 0]
)      % Use as logical index into the string
       % STACK: 'abcdABC123', 'acdAC12'
S      % Sort
       % STACK: 'abcdABC123', '12ACacd'
5M     % Push logical index again
       % STACK: 'abcdABC123', '12ACacd', [1 0 1 1 1 0 1 1 1 0]
(      % Write into original string as specified by the index. Implicitly display
       % STACK: 1b2ACBacd3

1 tabanlı modülo normal yerine mod([1 2 3 4 5], 3)verir [1 2 3 1 2](0 tabanlı) [1 2 0 1 2]. Davayı n=1yeterince ele almak için burada buna ihtiyaç var .

PHP, 101 bayt

negatif dize dizinleri (PHP 7.1) 21 bayttan tasarruf eder - ve muhtemelen günü:

for([,$s,$n]=$argv;a&$c=$s[$i-=1];)$i%$n+1?$a[]=$c:0;for(sort($a);++$i;)echo$i%$n+1?$a[+$k++]:$s[$i];

İle koş php -nr '<code>' '<string>' <N>.

Yıkmak

for([,$s,$n]=$argv;     # import command line arguments to $s and $n
    a&$c=$s[$i-=1];)    # loop backward through string
    $i%$n+1?$a[]=$c:0;      # if index is not n-th, copy character to array
for(sort($a);           # sort array
    ++$i;)              # loop forward through string:
    echo$i%$n+1             # if index is not n-th
        ?$a[+$k++]              # print character from array
        :$s[$i]                 # else print character from string
    ;

Octave , 65 54 bayt

function s=f(s,n)
l=~~s;l(end:-n:1)=0;s(l)=sort(s(l));

Çevrimiçi deneyin!

Bir 'sabit' ve 'sıralı' karakter dizisi yapmak için mantıksal indeksleme kullanır. Açıklama:

function s=f(s,n) % Create a function, taking a string `s` and the number `n`; the output is also named `s`.
l=~~s;             % Create logical array with the same size of the input string 
                  %    [equivalent to much more verbose true(size(s))].
l(end:-n:1)=0;    % Set the 'fixed' character positions. MATLAB/Octave automatically produces
                  %    the correct result even if n is larger than the string length.
s(l)=sort(s(l)) % Select the elements from `s` where `l` is true. Sort, and store in the corresponding positions in `s`.

Oluşturduğum yolu lgerektirir sben birçok dil kullandıkça, makul bir gereklilik olduğunu düşünüyorum, hangi sıfırdan farklı olan \0bir sonu dize sınırlayıcı olarak.

Python 2, 191 bayt

Evet, bunun korkunç bir çözüm olduğuna eminim.

n,s=input()
s=s[::-1]
R=range(len(s)/n+1)
J=''.join
k=s[::n]
t=J(sorted(J(s[i*n+1:i*n+n]for i in R)))
n-=1
print J(j[::-1]for i in zip(k,[t[::-1][i*n:i*n+n][::-1]for i in R])for j in i)[::-1]

Çevrimiçi deneyin

Bunu açıklamaya zahmet etmeyeceğim. Sonundan indekslenmesi gerektiğini fark edene kadar sorun yoktu. Şimdi bu bir canavar. Bu noktada, işe yaramasına sevindim.

JavaScript (ES6), 100 93 bayt

Körleme sözdiziminde girdi alır (s)(n).

s=>n=>s.replace(/./g,(c,i)=>(F=_=>(s.length-++i)%n)()?[...s].filter(F,i=0).sort()[j++]:c,j=0)

Biçimlendi ve yorumlandı

s => n => s.replace(        // given a string s and an integer n
  /./g,                     // for each character c of s
  (c, i) => (               // at position i:
    F = _ =>                //   F = function that tests whether the
      (s.length - ++i) % n  //       character at position i is non-static
  )()                       //   call F() on the current position
  ?                         //   if the current character is non-static:
    [...s].filter(F, i = 0) //     get the list of non-static characters
      F, i = 0              //     by filtering all characters in s with F()
    )                       //
    .sort()[j++]            //     sort them and pick the next occurrence
  :                         //   else:
    c,                      //     let c unchanged
  j = 0                     //   initialize j = non-static character pointer
)                           //

Test durumları

let f =

s=>n=>s.replace(/./g,(c,i)=>(F=_=>(s.length-++i)%n)()?[...s].filter(F,i=0).sort()[j++]:c,j=0)

console.log(f("abcdABC123")(4))
console.log(f('nafgaksa1252#"%#')(1))
console.log(f('&/lpfAVD')(214))
console.log(f("g7L9T E^n I{><#ki XSj!uhl y= N+|wA}Y~Gm&o?'cZPD2Ba,RFJs% V5U.W;1e  0_zM/d$bH`@vKoQ 43Oq*C")(8))

Perl 5 , 94 bayt

88 bayt kodu + -F -plbayrakları.

$_=join"",(map{(--$i%$n?"":$F[$#F-$i--]),$_}sort grep$i++%$n,reverse@F),chop if($n=<>)>1

Çevrimiçi deneyin!

Bence çok uzun, ama zaten o kadar çirkin değil ... Ben yine de daha fazla golf oynamaya çalışıyorum.

Jöle , 14  13 bayt

FṢṁ
ṚsṚµḢ€ż@Ç

Dizeyi STD çıkışına basan tam program *.

Çevrimiçi deneyin!

Nasıl?

ṚsṚµḢ€ż@Ç - Main link: string s, non-negative number n
Ṛ         - reverse s
 s        - split into chunks of size n
  Ṛ       - reverse the resulting list
   µ      - monadic chain separation (call that list x)
    Ḣ€    - head €ach - yield a list of the first entries of each of x and modify x
        Ç - call the last link (1) as a monad - get the sorted and re-split list
      ż@  - zip together (with reversed @rguments)

FṢṁ - link 1, sort and reshape like self: list of lists
F   - flatten into a single list
 Ṣ  - sort
  ṁ - mould the result like the input

Yardım edemem amaḢ girişini değiştiren gerçeği kullanmanın bir yolu olduğunu düşünüyorum

* Bir işlev için biri çıktıyı tek bir liste halinde düzleştirmek ister F.
Örneğin bir giriş için "abcdABC123", 4: verimleri
[[['1'],['b']],[['2','A','C'],['B']],[['a','c',',d'],['3']]]
yerine:
['1','b','2','A','C','B','a','c',',d','3']

Python + NumPy , 115 114 bayt

from numpy import *
def f(x,n):l=len(x);x=array(x);m=[1<2]*l;m[-1::-n]=[1>2]*len(m[0::n]);x[m]=sort(x[m]);return x

Giriş olarak düzenli bir Python listesi alır (dizi almanın koşer olarak kabul edilip edilmeyeceğinden emin değildi); sonucu içeren bir NumPy dizisi döndürür.

İlgili endeksleri maskeleyerek ve diğerlerini sıralayarak çalışır.

Python 2, 119 113 bayt

n,l=input()
i=range(len(l))
print"".join(sorted(l[~a]for a in i if a%n)[-a+a/n]if a%n else l[~a]for a in i)[::-1]

Sıralanacak tüm karakterlerin bir listesini oluşturur, bunları sıralar ve negatif indeksleme yoluyla tersten çevirmekten kaçınırken bunları yazdırmak için birleştirir.

Ruby, 64 bayt

Regex'i hem değiştirme hem de sıralama için alakasız karakterleri almak için kullanır.

->i,s,j=-1{s.gsub(r=/.(?!(?=.{#{i}})*$)/){s.scan(r).sort[j+=1]}}

Çevrimiçi deneyin