이 도전은 영감 이 TidB에 의해 아주 좋은 대답.

TidB의 답변에서 8 문자마다 올바른 순서로 gnilwoB edoC( Code Bowling뒤로) 있습니다. 다른 문자열은 그러나 되어 이상한, 임의의 순서로했다.

당신의 도전은이 문제를 해결하는 것입니다.

비어 있지 않은 문자열과 양의 정수 n를 입력으로 사용하십시오. 문자열은 32-126 (공백에서 물결표까지) 범위의 ASCII 문자를 포함합니다.

문자열을 오름차순으로 정렬해야 하지만 (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 기반 모듈러스 는 일반적인 (0 기반) 대신에 mod([1 2 3 4 5], 3)제공 [1 2 3 1 2]합니다 [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이 아닌 \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]

온라인으로 사용해보십시오

나는 그것을 설명하는 것을 귀찮게하지 않을 것입니다. 끝에서 색인을 생성해야한다는 것을 알기 전까지는 괜찮 았습니다. 이제 괴물입니다. 이 시점에서 나는 그것이 작동하는 것이 기쁘다.

자바 스크립트 (ES6), 100 93 바이트

카레 구문으로 입력을 (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))

펄 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']

파이썬 + 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

일반 파이썬 목록을 입력으로 취합니다 (배열을 취하는 것이 코셔로 간주되는지 확실하지 않았습니다). 결과가 포함 된 NumPy 배열을 반환합니다.

관련 인덱스를 숨기고 나머지를 정렬하여 작동합니다.

파이썬 2, 119113 바이트

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

온라인으로 사용해보십시오