Thách thức này được lấy cảm hứng từ đây câu trả lời rất thoải mái bởi TidB.

Trong câu trả lời của TidB, cứ tám ký tự theo đúng thứ tự: gnilwoB edoC( Code Bowlingngược). Tuy nhiên các dây khác đang ở trong một, thứ tự ngẫu nhiên kỳ lạ.

Thách thức của bạn là khắc phục điều này.

Lấy một chuỗi (không trống) và một số nguyên dương nlàm đầu vào. Chuỗi sẽ chứa các ký tự ASCII trong phạm vi: 32-126 (khoảng trắng đến dấu ngã).

Bạn phải sắp xếp chuỗi theo thứ tự tăng dần (nhìn từ bên trái, dựa trên giá trị mã ASCII), nhưng bỏ qua mọi nký tự thứ, bắt đầu từ cuối chuỗi. Ví dụ: chúng ta hãy lấy chuỗi abcdABC123làm đầu vào, và n=4sau đó chúng ta sẽ nhận được:

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)

Một vi dụ khac:

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)

Chuỗi đầu vào có thể được lấy theo định dạng tùy chọn (chuỗi, danh sách các ký tự, danh sách các chuỗi ký tự đơn ...). Số nguyên đầu vào cũng có thể được thực hiện trên một định dạng tùy chọn.

Các trường hợp thử nghiệm:

Định dạng sẽ là n=__, theo sau là chuỗi đầu vào trên dòng tiếp theo. Đầu ra là trên dòng dưới đây.

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 byte

ttfiX\qgP)S5M(

Đầu vào là một chuỗi được bao trong các dấu ngoặc đơn và một số. Các ký hiệu trích dẫn đơn trong chuỗi phải được thoát bằng cách nhân đôi (như trong MATLAB và Octave).

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

Xem xét đầu vào 'abcdABC123'và 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

Modulo dựa trên 1 có nghĩa là mod([1 2 3 4 5], 3)cho [1 2 3 1 2]thay vì thông thường (dựa trên 0) [1 2 0 1 2]. Điều này là cần thiết ở đây để xử lý trường hợp n=1đầy đủ.

PHP, 101 byte

chỉ mục chuỗi âm (PHP 7.1) lưu 21 byte - và có thể cả ngày:

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

Chạy với php -nr '<code>' '<string>' <N>.

phá vỡ

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 byte

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

Hãy thử trực tuyến!

Sử dụng lập chỉ mục logic để tạo một mảng các ký tự 'cố định' và 'được sắp xếp'. Giải trình:

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`.

Cách tôi tạo lyêu cầu đó slà khác không, mà tôi nghĩ là một yêu cầu hợp lý, vì nhiều ngôn ngữ sử dụng \0như một dấu phân cách cuối chuỗi.

Python 2, 191 byte

Vâng, tôi chắc chắn đây là một giải pháp khủng khiếp.

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]

Dùng thử trực tuyến

Tôi sẽ không bận tâm giải thích nó. Mọi chuyện vẫn ổn cho đến khi tôi nhận ra rằng nó cần được lập chỉ mục từ cuối. Bây giờ nó là một con quái vật. Tại thời điểm này, tôi chỉ vui mừng vì nó hoạt động.

JavaScript (ES6), 100 93 byte

Đưa đầu vào theo cú pháp currying (s)(n).

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

Định dạng và nhận xét

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

Các trường hợp thử nghiệm

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 byte

88 byte mã + -F -plcờ.

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

Hãy thử trực tuyến!

Theo tôi thì nó khá dài, nhưng nó không đến nỗi xấu xí ... dù sao tôi vẫn đang cố gắng chơi golf.

Thạch , 14  13 byte

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

Chương trình đầy đủ in chuỗi ra STD *.

Hãy thử trực tuyến!

Làm sao?

Ṛ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

Tôi không thể không nghĩ có một cách để sử dụng thực tế là Ḣsửa đổi đầu vào của nó

* đối với một chức năng người ta muốn làm phẳng đầu ra thành một danh sách duy nhất với F.
Ví dụ: đầu vào của "abcdABC123", 4sản lượng:
[[['1'],['b']],[['2','A','C'],['B']],[['a','c',',d'],['3']]]
thay vì:
['1','b','2','A','C','B','a','c',',d','3']

Python + NumPy , 115 114 byte

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

Lấy danh sách Python thông thường làm đầu vào (không chắc chắn việc lấy một mảng có được coi là Kosher hay không); trả về một mảng NumPy chứa kết quả.

Hoạt động bằng cách che dấu các chỉ số liên quan và sắp xếp phần còn lại.

Python 2, 119 113 byte

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]

Xây dựng một danh sách tất cả các ký tự sẽ được sắp xếp, sắp xếp chúng và hợp nhất chúng để in, đồng thời tránh một số đảo ngược thông qua lập chỉ mục tiêu cực.

Ruby, 64 byte

Sử dụng regex để lấy tất cả các ký tự không liên quan, cả để thay thế và sắp xếp.

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

Dùng thử trực tuyến