Questa sfida è ispirata da questa simpatica risposta di TidB.

Nella risposta di TidB, ogni otto caratteri è nell'ordine corretto: gnilwoB edoC( Code Bowlingindietro). Le altre stringhe sono comunque in uno strano ordine casuale.

La tua sfida è risolvere questo problema.

Prendi ncome input una stringa (non vuota) e un numero intero positivo . La stringa conterrà caratteri ASCII nell'intervallo: 32-126 (spazio alla tilde).

È necessario ordinare la stringa in ordine crescente (vista da sinistra, in base al valore del codice ASCII), ma saltare ogni ncarattere a partire dalla fine della stringa. Ad esempio, prendiamo la stringa abcdABC123come input e n=4poi otterremo:

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 altro esempio:

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 stringa di input può essere acquisita in un formato opzionale (stringa, elenco di caratteri, elenco di stringhe di singoli caratteri ...). L'intero di input può anche essere preso in un formato opzionale.

Casi test:

Il formato sarà n=__, seguito dalla stringa di input sulla riga successiva. L'output è sulla riga sottostante.

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(

Gli input sono una stringa racchiusa tra virgolette singole e un numero. I simboli a virgoletta singola nella stringa devono essere salvati duplicando (come in MATLAB e Octave).

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Considerare input 'abcdABC123'e 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 basato su 1 significa che mod([1 2 3 4 5], 3)dà [1 2 3 1 2]invece del solito (basato su 0) [1 2 0 1 2]. Questo è necessario qui per gestire n=1adeguatamente il caso .

PHP, 101 byte

gli indici di stringa negativi (PHP 7.1) risparmiano 21 byte - e possibilmente il giorno:

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

Corri con php -nr '<code>' '<string>' <N>.

abbattersi

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
    ;

Ottava , 65 54 byte

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

Provalo online!

Utilizza l'indicizzazione logica per creare una matrice di caratteri "fissi" e "ordinati". Spiegazione:

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

Il modo in cui ho creato lrichiede che ssia diverso da zero, che ritengo sia un requisito ragionevole, come molte lingue usano \0come delimitatore di fine stringa.

Python 2, 191 byte

Sì, sono sicuro che questa sia una soluzione terribile.

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]

Provalo online

Non mi preoccuperò di spiegarlo. È andato tutto bene finché non ho capito che doveva essere indicizzato dalla fine. Adesso è un mostro. A questo punto, sono solo felice che funzioni.

JavaScript (ES6), 100 93 byte

Accetta input nella sintassi del 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)

Formattato e commentato

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

Casi 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 byte

88 byte di codice + -F -plflag.

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

Provalo online!

Secondo me è troppo lungo, ma non è poi così brutto ... Sto ancora cercando di continuare a giocare a golf.

Gelatina , 14  13 byte

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

Programma completo che stampa la stringa su STD out *.

Provalo online!

Come?

Ṛ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

Non posso fare a meno di pensare che esiste un modo per utilizzare il fatto che Ḣmodifica il suo input

* per una funzione si vorrebbe appiattire l'output in un unico elenco con F.
Ad esempio un input di "abcdABC123", 4produce:
[[['1'],['b']],[['2','A','C'],['B']],[['a','c',',d'],['3']]]
piuttosto che:
['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

Prende un normale elenco Python come input (non ero sicuro se prendere un array sarebbe stato considerato kosher); restituisce un array NumPy contenente il risultato.

Funziona mascherando gli indici rilevanti e ordinando il resto.

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]

Crea un elenco di tutti i caratteri da ordinare, li ordina e li unisce per la stampa, evitando in parte l'inversione tramite indicizzazione negativa.

Rubino, 64 byte

Usa regex per afferrare tutti i caratteri irrilevanti, sia per la sostituzione che per l'ordinamento.

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

Provalo online