To wyzwanie jest zainspirowany tym bardzo ładnym Odpowiedź TidB.

W odpowiedzi TidB co osiem znaków ma prawidłową kolejność: gnilwoB edoC( Code Bowlingwstecz). Pozostałe ciągi jednak są były w dziwny, losowej kolejności.

Twoim wyzwaniem jest to naprawić.

nJako dane wejściowe weź (niepusty) ciąg znaków i dodatnią liczbę całkowitą . Ciąg będzie zawierał znaki ASCII z zakresu: 32-126 (spacja do znaku tyldy).

Musisz posortować ciąg w porządku rosnącym (patrząc od lewej, w oparciu o wartość kodu ASCII), ale pomiń każdy nznak, zaczynając od końca łańcucha. Jako przykład weźmy ciąg abcdABC123jako dane wejściowe, a n=4następnie otrzymamy:

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)

Inny przykład:

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)

Ciąg wejściowy może być przyjęty w dowolnym formacie (ciąg, lista znaków, lista ciągów pojedynczych znaków ...). Wejściową liczbę całkowitą można również przyjąć w opcjonalnym formacie.

Przypadki testowe:

Format będzie n=__poprzedzony ciągiem wejściowym w następnym wierszu. Dane wyjściowe znajdują się w wierszu poniżej.

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 bajtów

ttfiX\qgP)S5M(

Dane wejściowe są ciągiem zamkniętym pojedynczymi cudzysłowami i liczbą. Symbole pojedynczych cudzysłowów w ciągu powinny być poprzedzane przez duplikowanie (jak w MATLAB i Octave).

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie

Rozważ dane wejściowe 'abcdABC123'i 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

Moduł oparty na 1 oznacza, że mod([1 2 3 4 5], 3)daje [1 2 3 1 2]zamiast zwykłego (oparty na 0) [1 2 0 1 2]. Jest to potrzebne tutaj, aby odpowiednio obsłużyć sprawę n=1.

PHP, 101 bajtów

indeksy ciągu ujemnego (PHP 7.1) oszczędzają 21 bajtów - i być może dzień:

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

Uruchom z php -nr '<code>' '<string>' <N>.

awaria

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
    ;

Oktawa , 65 54 bajtów

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

Wypróbuj online!

Wykorzystuje logiczne indeksowanie, aby utworzyć tablicę znaków „ustalonych” i „posortowanych”. Wyjaśnienie:

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

Sposób, który utworzyłem l, sjest niezerowy, co moim zdaniem jest rozsądnym wymogiem, ponieważ wiele języków używa \0jako ogranicznika końca łańcucha.

Python 2, 191 bajtów

Tak, jestem pewien, że to okropne rozwiązanie.

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]

Wypróbuj online

Nie zamierzam zawracać sobie głowy wyjaśnianiem tego. Było w porządku, dopóki nie zdałem sobie sprawy, że musi być indeksowany od końca. Teraz to potwór. W tym momencie cieszę się, że to działa.

JavaScript (ES6), 100 93 bajtów

Pobiera dane wejściowe w składni curry (s)(n).

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

Sformatowane i skomentowane

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

Przypadki testowe

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 bajtów

88 bajtów kodu + -F -plflagi.

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

Wypróbuj online!

Moim zdaniem jest to zbyt długo, ale już nie takie brzydkie ... W każdym razie nadal próbuję grać w golfa.

Galaretka , 14  13 bajtów

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

Pełny program, który wypisuje ciąg do STD *.

Wypróbuj online!

W jaki sposób?

Ṛ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

Nie mogę przestać myśleć, że istnieje sposób na wykorzystanie faktu, który Ḣmodyfikuje jego dane wejściowe

* dla funkcji chciałbyś spłaszczyć dane wyjściowe do pojedynczej listy za pomocą F.
Na przykład wartość wejściowa "abcdABC123", 4daje:
[[['1'],['b']],[['2','A','C'],['B']],[['a','c',',d'],['3']]]
zamiast:
['1','b','2','A','C','B','a','c',',d','3']

Python + NumPy , 115 114 bajtów

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

Pobiera na wejściu zwykłą listę Pythona (nie był pewien, czy przyjęcie tablicy byłoby uważane za koszerne); zwraca tablicę NumPy zawierającą wynik.

Działa poprzez maskowanie odpowiednich wskaźników i sortowanie pozostałych.

Python 2, 119 113 bajtów

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]

Tworzy listę wszystkich znaków do posortowania, sortuje je i łączy w celu wydrukowania, unikając przy tym odwracania poprzez ujemne indeksowanie.

Rubinowy, 64 bajty

Używa wyrażenia regularnego, aby pobrać wszystkie nieistotne znaki, zarówno w celu zamiany, jak i sortowania.

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

Wypróbuj online