Це завдання натхненний цим дуже хороший відповідь по TidB.

У відповіді TidB кожен восьмий символ у правильному порядку: gnilwoB edoC( Code Bowlingназад). Решта рядків , однак будуть були в дивному, випадковому порядку.

Ваше завдання - це виправити.

Візьміть (не порожній) рядок і додатне ціле число nяк вхід. Рядок буде містити символи ASCII в діапазоні: 32-126 (пробіл до нахилу).

Ви повинні сортувати рядок у порядку зростання (видно зліва на основі значення коду ASCII), але пропустити кожен nсимвол, починаючи з кінця рядка. Як приклад, візьмемо рядок abcdABC123як вхідний, і n=4тоді ми отримаємо:

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)

Ще один приклад:

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)

Рядок введення можна приймати у необов'язковому форматі (рядок, список символів, список одиночних символьних рядків ...). Ціле число введення також можна приймати у необов'язковому форматі.

Тестові приклади:

Формат буде n=__з наступним рядком введення в наступному рядку. Вихід знаходиться на рядку нижче.

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 байт

ttfiX\qgP)S5M(

Вхідні дані - це рядок, укладений в одиничні лапки та число. Символи з однією цитатою у рядку слід уникати шляхом дублювання (як у MATLAB та Octave).

Спробуйте в Інтернеті! Або перевірити всі тестові випадки .

Пояснення

Розглянемо вхідні дані 'abcdABC123'та 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, який mod([1 2 3 4 5], 3)дає [1 2 3 1 2]замість звичайного (на основі 0) [1 2 0 1 2]. Це потрібно тут, щоб n=1адекватно вирішити справу .

PHP, 101 байт

Індекс негативних рядків (PHP 7.1) економить 21 байт - можливо, і день:

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

Бігайте з php -nr '<code>' '<string>' <N>.

зламатися

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
    ;

Октава , 65 54 байти

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

Спробуйте в Інтернеті!

Використовує логічну індексацію для створення масиву "фіксованих" та "відсортованих" символів. Пояснення:

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

Спосіб, який я створив, lвимагає, щоб sце було ненульовим рівнем, що, на мою думку, є розумною вимогою, оскільки багато мов використовують \0як роздільник кінця рядка.

Пітон 2, 191 байт

Так, я впевнений, це жахливе рішення.

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]

Спробуйте в Інтернеті

Я не збираюся заважати пояснювати це. Це було добре, поки я не зрозумів, що його потрібно індексувати з кінця. Тепер це чудовисько. На даний момент я просто радий, що це працює.

JavaScript (ES6), 100 93 байт

Здійснює введення в синтаксис 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)

Відформатовано та прокоментовано

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

Тестові кейси

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 байти

88 байт коду + -F -plпрапори.

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

Спробуйте в Інтернеті!

На мій погляд, це занадто довго, але вже не таке потворне ... Я все одно намагаюся ще більше пограти в гольф.

Желе , 14  13 байт

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

Повна програма, яка друкує рядок до STD *.

Спробуйте в Інтернеті!

Як?

Ṛ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

Я не можу допомогти, але думаю, що є спосіб використовувати той факт, що Ḣзмінює його вхід

* для функції хотілося б вирівняти вихід в єдиний список F.
Наприклад, вхід "abcdABC123", 4урожай:
[[['1'],['b']],[['2','A','C'],['B']],[['a','c',',d'],['3']]]
а не:
['1','b','2','A','C','B','a','c',',d','3']

Python + NumPy , 115 114 байт

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

Приймає звичайний список Python як вхідний (не був впевнений, чи вважатиметься прийняття масиву кошерним); повертає масив NumPy, що містить результат.

Працює шляхом маскування відповідних показників та сортування решти.

Пітон 2, 119 113 байт

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]

Створює список усіх символів, які слід сортувати, сортує їх та об’єднує для друку, уникаючи деяких реверсів за допомогою негативного індексування.

Рубін, 64 байти

Використовує регулярний вираз, щоб схопити всі неактуальні символи, як для заміни, так і для сортування.

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

Спробуйте в Інтернеті