Ce challenge est inspiré de cette très belle réponse de TidB.

Dans la réponse de TidB, tous les huit caractères sont dans le bon ordre: gnilwoB edoC(en Code Bowlingarrière). Les autres cordes sont cependant dans un étrange ordre aléatoire.

Votre défi est de résoudre ce problème.

Prenez une chaîne (non vide) et un entier positif nen entrée. La chaîne contiendra des caractères ASCII dans la plage: 32-126 (espace pour tilde).

Vous devez trier la chaîne dans l' ordre croissant (vu de gauche, en fonction de la valeur du code ASCII), mais ignorer chaque ncaractère sur th, en commençant par la fin de la chaîne. À titre d'exemple, prenons la chaîne abcdABC123en entrée n=4, puis nous obtiendrons:

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)

Un autre exemple:

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)

La chaîne d'entrée peut être prise dans un format optionnel (chaîne, liste de caractères, liste de chaînes de caractères uniques ...). L'entier d'entrée peut également être pris dans un format facultatif.

Cas de test:

Le format sera n=__, suivi de la chaîne d'entrée sur la ligne suivante. La sortie est sur la ligne ci-dessous.

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 octets

ttfiX\qgP)S5M(

Les entrées sont une chaîne entre guillemets simples et un nombre. Les symboles de guillemets simples dans la chaîne doivent être échappés par duplication (comme dans MATLAB et Octave).

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

Considérez les entrées 'abcdABC123'et 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 à base 1 signifie que mod([1 2 3 4 5], 3)donne [1 2 3 1 2]au lieu de l'habituel (à base 0) [1 2 0 1 2]. Cela est nécessaire ici pour gérer l'affaire de n=1manière adéquate.

PHP, 101 octets

les index de chaîne négatifs (PHP 7.1) économisent 21 octets - et éventuellement le jour:

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

Courez avec php -nr '<code>' '<string>' <N>.

panne

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 octets

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

Essayez-le en ligne!

Utilise l'indexation logique pour créer un tableau de caractères «fixes» et «triés». Explication:

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

La façon dont j'ai créé lexige que ce ssoit différent de zéro, ce qui, je pense, est une exigence raisonnable, car de nombreuses langues utilisent \0comme délimiteur de fin de chaîne.

Python 2, 191 octets

Ouais, je suis sûr que c'est une terrible solution.

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]

Essayez-le en ligne

Je ne vais pas m'embêter à l'expliquer. Tout allait bien jusqu'à ce que je réalise qu'il doit être indexé depuis la fin. Maintenant c'est un monstre. À ce stade, je suis juste content que cela fonctionne.

JavaScript (ES6), 100 93 octets

Prend une entrée dans la syntaxe de 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)

Formaté et commenté

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

Cas de test

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 octets

88 octets de code + -F -pldrapeaux.

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

Essayez-le en ligne!

C'est beaucoup trop long à mon avis, mais déjà pas si moche que ça ... J'essaye quand même de continuer à jouer au golf.

Gelée , 14  13 octets

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

Programme complet qui imprime la chaîne en sortie STD *.

Essayez-le en ligne!

Comment?

Ṛ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

Je ne peux pas m'empêcher de penser qu'il existe un moyen d'utiliser le fait que Ḣmodifie son entrée

* pour une fonction, on voudrait aplatir la sortie en une seule liste avec F.
Par exemple, une entrée de "abcdABC123", 4donne:
[[['1'],['b']],[['2','A','C'],['B']],[['a','c',',d'],['3']]]
plutôt que:
['1','b','2','A','C','B','a','c',',d','3']

Python + numpy , 115 114 bytes

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

Prend une liste Python régulière en entrée (je ne savais pas si prendre un tableau serait considéré comme casher); renvoie un tableau NumPy contenant le résultat.

Fonctionne en masquant les indices pertinents et en triant le reste.

Python 2, 119 113 octets

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]

Construit une liste de tous les caractères à trier, les trie et les fusionne pour l'impression, tout en évitant une partie de l'inversion via une indexation négative.

Ruby, 64 octets

Utilise l'expression régulière pour saisir tous les caractères non pertinents, à la fois pour le remplacement et pour le tri.

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

Essayez-le en ligne