입력:

• 배열은 세 개의 정수를 포함 : 0, 1및 2임의의 순서 (예 [2, 0, 1])
• 그리고 길이의 문자열> = 2 만 개 포함 된 알파벳 문자 (낮은 - 대문자 모두)와 숫자 (즉 a1B2c3)

산출:

배열을 기반으로 문자열을 정렬하고 출력합니다.
이것은 어떻게 작동합니까?

• 배열의 순서로 우선 순위를 나타내고 a-z, A-Z그리고 0-9, 상기 제 존재를 0; 두번째 존재 1; 셋째 2.
• 그런 다음 문자열의 개별 문자를 기반으로 주문할 수 있습니다.

예:

• 정렬: [2, 0, 1]
• 끈: a1B2c3

배열을 기준으로 우리는 우선 순위가 0-9a-zA-Z입니다.
이를 기반으로 문자열을 변환하고 출력 할 수 있습니다 123acB.

도전 규칙 :

• 배열의 경우 0 인덱스 또는 1 인덱스 입력을 선택할 수 있으므로 [3, 1, 2]1 인덱스 배열을 사용하려는 경우 유효한 입력이기도합니다.
• 문자열 (입력 및 출력 모두)에는 유효한 문자 만 포함 abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789됩니다.
• 언어는 배열을 지원하지 않는 경우 (당신이 선택하는 경우 또는), 당신은 첫 번째 매개 변수 (예 : 대신 배열의 문자열을 자유롭게 사용할 수 있습니다 012, [0,1,2]등).

일반적인 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하지 마십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙이 답변에 적용 되므로 STDIN / STDOUT, 적절한 매개 변수가있는 기능 / 방법, 전체 프로그램을 사용할 수 있습니다. 당신의 전화.
• 기본 허점 은 금지되어 있습니다.
• 가능하면 코드 테스트 링크를 추가하십시오.
• 또한 필요한 경우 설명을 추가하십시오.

테스트 사례 :

[2, 0, 1]  &  a1B2c3             ->   123acB
[2, 1, 0]  &  aAaA909UuHWw9gh2   ->   02999AAHUWaaghuw
[2, 1, 0]  &  6Bx43              ->   346Bx
[1, 0, 2]  &  jfjf33g            ->   ffgjj33
[0, 2, 1]  &  AbC13              ->   b13AC
[1, 2, 0]  &  Qfl0l              ->   Q0fll
[0, 1, 2]  &  9870abcABC         ->   abcABC0789
[0, 2, 1]  &  test123            ->   estt123
[2, 0, 1]  &  WHAT               ->   AHTW
[2, 0, 1]  &  WhAt               ->   htAW
[1, 0, 2]  &  102BACbac          ->   ABCabc012

05AB1E , 15 14 12 바이트

암호:

v²žK26ôyèÃ{?

설명:

v             # For each in the input array.
  žK          #   Push a-zA-Z0-9.
    26ô       #   Split into pieces of 26.
       yè     #   Get the element-th element of the array.
 ²       Ã    #   Keep the characters of that element from the second input.
          {?  #   Sort pop and print without a newline.

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오! .

파이썬 2, 67 66 바이트

lambda s,k:`sorted(s,key=lambda c:`k.index(3-ord(c)/32)`+c)`[2::5]

Ideone에서 테스트하십시오 .

JavaScript (ES6), 87 바이트

(a,s)=>a.map(n=>[...s].sort().join``.replace([/[^a-z]/g,/[^A-Z]/g,/\D/g][n],``)).join``

입력 어레이 세 범위의 순서보다는 우선, (이에만 차이가 준 경우 [1, 2, 0]와 [2, 1, 0]다음이 80 바이트 일 것이다 그의 효과를 교체된다)

(a,s,o=c=>a[(c<'a')+(c<'A')])=>[...s].sort((a,b)=>o(a)-o(b)||(a>b)-(a<b)).join``

나는 그 질문을 잘못 읽었고 여전히 이것으로 7 개의 공감대를 얻었다. upvotes를 제거하고 대신 @CharlieWynn에게 알려주십시오. 대신 내 접근 방식을 가장 잘 교정했습니다.

(a,s)=>a.map(n=>s.replace([/[^a-z]/g,/[^A-Z]/g,/\D/g][n],``)).join``

젤리 , 13 바이트

2_ịØWs26¤Ff@€

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

2_ịØWs26¤Ff@€  Main link. Arguments: k (permutation of [0, 1, 2]), s (string)

2_             Subtract the integers in k from 2, mapping [0, 1, 2] -> [2, 1, 0].
        ¤      Combine the three links to the left into a niladic chain.
   ØW          Yield the string following string.
               'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_'
     s26       Split it into chunks of 26 chars, i.e., ['A...Z', 'a...z', '0...9'].
  ị            Retrieve the chunks from the right result at the indices of the
               left result. The indices of the chunks are modular and 1-based;
               1 retrieves 'A...Z', 2 retrieves 'a...z', and 3 retrieves '0...9'.
         F     Flatten the resulting array of strings.
          f@€  Filter (swapped, each); for each character in the constructed
               string, select all occurrences of that character from s.

Pyth, 17 16 15 바이트

s@RSz@L[GrG1`UT

테스트 스위트.

       [          array literal containing...
        G           the alphabet (lowercase)
         rG1        the alphabet, converted to uppercase
            `UT     inspect-range-10, generating the range [0,10) and
                      stringifying it, resulting in a string that contains no
                      letters and all numbers (so equivalent to '0123456789' for
                      filtering)
                    this creates ['ab...z', 'AB...Z', '01...9']

     @L           map over first (implicit) input (the ordering array) and take
                   the nth element in this array for each item
                   this gives us ['01...9', 'ab...z', 'AB...Z']

   Sz             take another line of input as a string and sort it, and then...
 @R               map over intersection: filter the line of input over presence
                    in each element in the new array
                    this results in ['123', 'ac', 'B']

s                 concatenate all and implicitly output

바이트에 대해서는 @FryAmTheEggman 과 다른 것에 대해서는 @Jakube 에게 감사합니다 !

자바 스크립트 es6 77 바이트

(a,s)=>a.map(o=>s.match([/[a-z]?/g,/[A-Z]?/g,/\d?/g][o]).sort().join``).join``

//test
f=(a,s)=>a.map(o=>(s.match([/[a-z]/g,/[A-Z]/g,/\d/g][o])||[]).sort().join``).join``


f([2, 0, 1], "a1B2c3")             == "123acB" &&
f([2, 1, 0], "aAaA909UuHWw9gh2")   == "02999AAHUWaaghuw" &&
f([2, 1, 0], "6Bx43")              == "346Bx" &&
f([1, 0, 2], "jfjf33g")            == "ffgjj33" &&
f([0, 2, 1], "AbC13")              == "b13AC" &&
f([1, 2, 0], "Qfl0l")              == "Q0fll" &&
f([0, 1, 2], "9870abcABC")         == "abcABC0789" &&
f([0, 2, 1], "test123")            == "estt123" &&
f([2, 0, 1], "WHAT")               == "AHTW" &&
f([2, 0, 1], "WhAt")               == "htAW" &&
f([1, 0, 2], "102BACbac")          == "ABCabc012"

TSQL, 199191 바이트

골프 :

DECLARE @i varchar(99)='abA7B34',@s char(3)='213'

,@ varchar(99)=''SELECT @+=n FROM(SELECT top 99n FROM(SELECT top 99substring(@i,row_number()over(order by 1/0),1)n FROM sys.messages)c ORDER BY CHARINDEX(CHAR(ascii(n)/32+48),@s),n)d SELECT @

언 골프 드 :

DECLARE @i varchar(99)='abA7B34'
-- 1 numbers, 2 upper case, 3 lower case
DECLARE @s char(3)='213'


,@ varchar(99)=''
SELECT @+=n
FROM
  (
    SELECT top 99 n 
    FROM
      (
         SELECT top 99substring(@i, row_number()over(order by 1/0), 1)n
         FROM sys.messages
      )c
    ORDER BY CHARINDEX(CHAR(ascii(n)/32+48),@s),n
  )d

SELECT @

깡깡이

APLX , 19 바이트

s[(∊(⎕a⎕A⎕D)[a])⍋s]

⎕a⎕A⎕D 낮은 자리수

(… )[a]배열 a 에 따라 재정렬

∊ 반음 낮추다

(… )⍋s"알파벳"에 따르면 문자열 s를 정렬하는 인덱스를 제공하십시오

s[…를 ]사용하여 s 를 재정렬하십시오

파이썬 2, 121 바이트

lambda a,s:"".join(sum([[sorted(filter(eval(u),s))for u in["str.islower","str.isupper","str.isdigit"]][i]for i in a],[]))

클로저, 74 바이트

#(apply str(mapcat sort(for[i %](re-seq([#"[a-z]"#"[A-Z]"#"[0-9]"]i)%2))))

첫 번째 목록의 각 값에 대해 적절한 정규식을 가져 와서 입력 문자열에 적용하십시오. 결과는 정규식과 일치하는 기호 목록의 목록입니다. 그런 다음 각각을 정렬하고 결과를 하나의 목록으로 연결하고 문자열로 변환하십시오.

https://ideone.com/dqAkxg에서 온라인으로 볼 수 있습니다.

망막 , 43 39 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다. 후행 줄 바꿈이 중요합니다.

2=`.
!$&"
T04`¶d`#^@%
O`\W?.
O`.\w+
\W

입력은 첫 번째 줄에 구분 기호가없는 0부터 시작하는 목록의 정렬 순서이고 두 번째 줄에 정렬 될 문자열입니다. 예 :

120
fOo42BaR

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

설명

위의 입력 예제를 사용하여 코드를 안내합니다.

120
fOo42BaR

1 단계 : 대체

2=`.
!$&"

정규 표현식 자체는 .(줄 바꿈되지 않은 모든 문자와 일치)로 둘러싸여 있습니다 !...". 그러나 이는 Retina에게 정규식의 두 번째 일치에만 대체를 적용하도록 지시 2=하는 한계 입니다. 그래서 우리는 이것을 얻습니다.

1!2"0
fOo42BaR

2 단계 : 음역

T04`¶d`#^@%

음역 단계는 단순히 문자 별 대체를 수행합니다. 는 ¶라인 피드와 표현 d으로 확장을 0123456789(우리는 모든 숫자 후를 무시할 수 있지만 2). 즉,이 음역은 다음 매핑에 해당합니다.

¶012
#^@%

04앞에 함께 세트에서 첫 번째 네 문자는 음역해야 함을 표시이 개 제한됩니다. 첫 번째 줄의 숫자와 두 줄을 구분하는 줄 바꿈이 발생하므로 다음과 같이됩니다.

@!%"^#fOo42BaR

문자열 앞에는 다음 세 쌍의 문자가 있습니다.

@!
%"
^#

쌍의 두 번째 문자는 단순히 일반적인 ASCII 순서이며 항상 동일합니다. 나중에 이들을 사용하여 기본 입력의 문자 그룹을 필요한 순서로 정렬합니다.

첫 번째 문자는 조금 더 흥미 롭습니다. %ASCII 테이블에서 숫자 앞에 오는 것이 중요 합니다.@ 대문자 앞에오고 (숫자 뒤에) 소문자 앞에옵니다 (그러나 대문자 뒤에 ^옵니다). 이를 통해 위치 표시 자 (즉, 각 쌍의 두 번째 문자)를 올바른 문자 세트로 그룹화 할 수 있습니다.

3 단계 : 정렬

O`\W?.

이것은 간단한 정렬 단계입니다. 첫 번째 문자가 단어 문자 (따라서 방금 이야기 한 세 쌍 모두 일치) 또는 그렇지 않으면 단일 문자 (주 입력의 각 문자와 개별적으로 일치)가 아닌 경우 두 문자를 일치시키고 해당 문자열을 정렬합니다. 이것은 두 가지 목적이 있습니다 : 각 그룹 내 에서 문자를 올바른 순서로 가져옵니다 (정렬이 안정적이기 때문에이 순서는 다음 단계에서 엉망이되지 않습니다). 그리고 %@^마커 로 인해 쌍을 올바른 위치 :

%"24@!BOR^#afo

4 단계 : 정렬

O`.\w+

이 단계는 .\w+탐욕으로 인해 하나의 위치 마커 (예 : 중 하나 !"#)와 그 뒤에 나오는 모든 단어 문자를 일치시키는 정규식 의 모든 일치 항목을 정렬 합니다. 즉,이 세 문자열을 정렬합니다. 순서는 마커 문자만으로 결정됩니다.

"24! BOR #afo

다른 마커 3 개는 그대로두고 마커 주위를 뒤섞 으면서 가장 중요한 것은 숫자와 문자를 올바른 순서로 가져 오는 것입니다.

%!BOR@"24^#afo

5 단계 : 교체

\W

남은 것은 약간의 정리로, 모든 마커를 일치시키고 아무것도 교체하지 않고 제거합니다.

자바 스크립트 (ES6), 65

참고 : '자연'ASCII 순서는 0-9, AZ, az이며 OP 0,1,2와 반대입니다. 그래서

• 잘못된 문자를 추가하여 문자열을 정렬하여 실행을 분리하십시오.
• 3 개의 세그먼트로 분할-유효하지 않은 문자는 각각 표시
• 요청한 순서대로 세그먼트를 하나씩 가져옵니다.
• 재 조립

s=>w=>w.map(w=>[...'^@'+s].sort().join``.split(/\W/)[2-w]).join``

F=s=>w=>w.map(w=>[...'^@'+s].sort().join``.split(/\W/)[2-w]).join``

;[['201','a1B2c3','123acB']
,['210','aAaA909UuHWw9gh2','02999AAHUWaaghuw']
,['210','6Bx43','346Bx']
,['102','jfjf33g','ffgjj33']
,['021','AbC13','b13AC']
,['120','Qfl0l','Q0fll']
,['012','9870abcABC','abcABC0789']
,['021','test123','estt123']
,['201','WHAT','AHTW']
,['201','WhAt','htAW']
,['102','102BACbac','ABCabc012']]
.forEach(t=>{
  var w=t[0],s=t[1],k=t[2], r=F(s)([...w])
  console.log(w,s,r,(r==k?'OK':'KO (expected '+k+')'))
})

하스켈, 62 63 바이트

a#b=[c|i<-b,c<-[' '..],d<-a,d==c,div(fromEnum c)16==[6,4,3]!!i]

사용 예 : "cD12ab" # [2,0,1]-> "12abcD".

작동 방식 :

i<-b                                  -- loop i through the input array
   [c|   c<-[' '..]]                  -- loop through all chars c
       d<-a                           -- loop through all chars d in the input string
       d==c                           -- and keep those that are in the input string
       div(fromEnum c)16==[6,4,3]!!i  -- and where the the ascii value divided by
                                      -- 16 equals the number from [6,4,3] indexed
                                      -- by the current i

편집 : @Christian Sievers는 버그를 발견했습니다. 감사! 1 바이트 추가로 수정되었습니다.

Stax , 15 바이트

┐°!'àÉgYg8∟╗`╖ë

온라인으로 실행 및 디버깅

이 15 바이트 제출은 CP437 문자 세트의 변형으로 압축 됩니다. 해당 ASCII 표현은 18 바이트를 사용합니다.

EVlVd+26/s@:fs{[Io

그래도 더 잘릴 수 있습니다.

E                   Put the two inputs on main stack
 Vl                 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
   Vd               "0123456789"
     +              Concatenate
      26/           Partition to blocks of size 26 (array `a`)
         s@         Index array `a` with the input index array
           :fs      Flatten to get a string `s`
              {[Io  Order the input string
                        Using the char array `s` as the key
                    Implicit output

VlVd+또한 될 수 VLA|(가 회전 남아있는0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ 열 elemenets에 의해. 전체 코드는 또한 VlVd+26/,e@:f,{[Io, 입력 스택을 처음부터 메인 스택으로 읽는 대신 입력 스택을 두 번 읽고이 그림과 같이 다른 (보다 전통적인) 입력 형식을 사용 합니다 .

Dyalog APL , 22 바이트

s[s⍋⍨∊(819⌶⎕A)⎕A⎕D[a]]

(819⌶⎕A) 대문자 알파벳을 소문자로 접으십시오

(…)⎕A⎕D[a] 배열 a 에 따라 순서가 낮은 하위 숫자

∊ 반음 낮추다

s⍋⍨string s의 경우 s를 정렬하는 인덱스를 가져옵니다. "alphabet"에 따라

s[…를 ]사용하여 s 를 재정렬하십시오

PowerShell v2 +, 107 바이트

param($n,[char[]]$s)-join(-join(($s=$s|sort)|?{$_-ge97}),-join($s|?{$_-in65..96}),-join($s|?{$_-lt58}))[$n]

정규식을 사용하여 알고리즘을 탐색하고 있지만 지금까지는 더 길어 보입니다.

입력을 명시 적 배열 $n(아래 예 참조) 및 $s즉시 문자 배열로 캐스트되는 문자열 로 가져옵니다. 우리는 다음 새로운 동적 배열의 세 가지 요소를 구성하고, 이들 각각은 캡슐화 -join:
- (($s=$s|sort)|?{$_-ge97})
-($s|?{$_-in65..96})
-($s|?{$_-lt58})

우리가 처음으로 $s그것을 통해 실행합니다 Sort-Object. 고맙게도, 우리는 이미 그것을 문자 배열로 캐스트 했으므로 대소 문자를 구분합니다. 다시 저장 $s한 다음 Where-Object보다 큰 절 97(예 : ASCII 소문자 a-z) 을 사용하여 파이프로 파이프합니다 . 두 번째는에 대한 A-Z것이고 세 번째는에 대한 것 0-9입니다.

따라서 우리는 이제 문자열 배열을 가지는데, 각 문자열은 세 가지 문자 유형 중 하나로 구성되고 정렬됩니다. 우리는 그것을 슬라이스 [$n]한 다음-join 함께 결과가 우리의 최종 출력 문자열을 형성한다. 그것은 파이프 라인에 남아 있고 인쇄는 암시 적입니다.

테스트 사례

PS C:\Tools\Scripts\golfing> $test = (@(2,0,1),'a1B2c3'), (@(2,1,0),'aAaA909UuHWw9gh2'), (@(2,1,0),'6Bx43'), (@(1,0,2),'jfjf33g'), (@(0,2,1),'AbC13'), (@(1,2,0),'Qfl0l'), (@(0,1,2),'9870abcABC'), (@(0,2,1),'test123'), (@(2,0,1),'WHAT'), (@(2,0,1),'WhAt'), (@(1,0,2),'102BACbac')

PS C:\Tools\Scripts\golfing> $test |%{"($($_[0]-join',')) & $($_[1])".PadRight(28)+" -> " + (.\post-determined-array-sorting.ps1 $_[0] $_[1])}
(2,0,1) & a1B2c3             -> 123acB
(2,1,0) & aAaA909UuHWw9gh2   -> 02999AAHUWaaghuw
(2,1,0) & 6Bx43              -> 346Bx
(1,0,2) & jfjf33g            -> ffgjj33
(0,2,1) & AbC13              -> b13AC
(1,2,0) & Qfl0l              -> Q0fll
(0,1,2) & 9870abcABC         -> abcABC0789
(0,2,1) & test123            -> estt123
(2,0,1) & WHAT               -> AHTW
(2,0,1) & WhAt               -> htAW
(1,0,2) & 102BACbac          -> ABCabc012

루비, 56 바이트

@ 데니스 답변에서 포팅.

->a,s{s.chars.sort_by{|c|a.index(3-c.ord/32).to_s+c}*''}

@Neil에서 영감을 얻었고 그의 대답에서 약간 수정 된 더 나은 대체 58 바이트 솔루션.

->a,s{a.map{|i|s.scan([/[a-z]/,/[A-Z]/,/\d/][i]).sort}*''}

두 버전 중 하나를 온라인으로 사용해보십시오! (설명은 대체 솔루션입니다)

32 비트 x86 머신 코드, 70 바이트

16 진수로 :

fc31c031c95189e3ac84c0740a34cf0404880c0341ebf189fe9160ac88c2c0e805d788c652ac88c2c0e805d788c658740e6639d076029241aa92aa4e4febdc85c96175d658c3

이 절차에서는 문자 클래스 정렬 순서가 3 자 (0..2) NULL로 끝나는 문자열 ESI이고 정렬 할 문자열 이 될 것으로 예상합니다 EDI. 정렬은 매우 부적합한 (성능 측면에서) 버블 정렬 버전을 사용하여 제자리에서 수행됩니다.

0:  fc                  cld
1:  31 c0               xor eax, eax
3:  31 c9               xor ecx, ecx
5:  51                  push ecx        ;Allocate 4 bytes on the stack
6:  89 e3               mov ebx, esp    ;char EBX[4]
_loop0:                                 ;Parsing class order string
8:  ac                  lodsb
9:  84 c0               test al,al      ;Break on NULL
b:  74 0a               jz _break0
d:  34 cf               xor al, 0xCF    ;AL=~atoi(AL)
f:  04 04               add al, 4       ;'0'->3, '1'->2, '2'->1
11: 88 0c 03            mov [ebx+eax], cl    ;EBX[AL]=CL
14: 41                  inc ecx
15: eb f1               jmp _loop0
_break0:
17: 89 fe               mov esi,edi
19: 91                  xchg eax,ecx    ;ECX=0
_bsort:
1a: 60                  pusha
_cx2b:
1b: ac                  lodsb           ;Get the first char to compare
1c: 88 c2               mov dl,al       ;Save to DL
1e: c0 e8 05            shr al,5        ;Char class: [0-9]->1, [A-Z]->2, [a-z]->3
21: d7                  xlat            ;AL=EBX[AL] - priority for the char class 
22: 88 c6               mov dh,al       ;... goes to DH
24: 52                  push edx        ;First "comparable char" in DX goes to the stack
25: ac                  lodsb           ;Get the second char to compare
26: 88 c2               mov dl,al       ;\
28: c0 e8 05            shr al,5        ; > Same as the above
2b: d7                  xlat            ;/
2c: 88 c6               mov dh, al      ;Second "comparable char" in DX
2e: 58                  pop eax         ;The first one goes to AX
2f: 74 0e               jz _endpass     ;ZF is set by the last 'shr', and only on AL==0
31: 66 39 d0            cmp ax,dx       ;Upper halves of 32-bit regs may contain trash
34: 76 02               jbe _sorted
36: 92                  xchg eax,edx    ;Now AX<=DX
37: 41                  inc ecx         ;Swap counter
_sorted:
38: aa                  stosb           ;Store AL in-place
39: 92                  xchg eax,edx    ;AL=DL
3a: aa                  stosb           ;Store the second char
3b: 4e                  dec esi         ;Move pointers...
3c: 4f                  dec edi         ;...back one byte
3d: eb dc               jmp _cx2b       ;Repeat with the next two chars
_endpass:
3f: 85 c9               test ecx,ecx    ;Full pass completed, checking # of swaps made
41: 61                  popa            ;Restores ECX(0), ESI, EDI. Doesn't affect flags
42: 75 d6               jnz _bsort      ;If there were changes, repeat
_end:
44: 58                  pop eax         ;Deallocate EBX[]
45: c3                  ret

이맥스 리스프, 183 바이트

(lambda(s p)(let(l u n)(apply'concat(mapcar(lambda(l)(sort l'<))(dolist(e(string-to-list s)(mapcar(lambda(i)(nth i(list l u n)))p))(push e(cond((< ?` e)l)((< ?@ e)u)((< ?/ e)n))))))))

자바보다 약간 짧은 ...

클로저, 77 바이트

#(apply str(mapcat sort(map(group-by(fn[v](condp <(int v)90 0,57 1,2))%2)%)))

re-seq근거한 것만 큼 ​​짧지 는 않지만 (apply str(mapcat sort(map(...)))), 적은 공간에서 " " 를 표현하는 방법을 알 수 없었습니다 .group-by함수로 사용할 수있는 해시 맵을 생성합니다. 0에서 2 사이의 정수로 쿼리하면 해당 그룹이 반환됩니다. 그러면 세 가지 다른 클래스의 문자가 정렬됩니다.

re-seq처리 할 문자 클래스가 더 많으면 57 1,식과 같은 식에 8 개 대신 5 개 문자 / 그룹 만 추가하면 되므로 솔루션 보다 더 간결합니다 #"[a-z]".

파이썬 (2), 140 (117) 101 (100) 99 바이트

모두 "Ewww!"라고 말합니다. 적어도 읽을 수 있습니다 ... 기침 실제로 기침하지 않습니다

lambda l,s:`sorted(s,key=lambda c:[[c<'a',c<'A'or'Z'<c,c>'9'][l[i]]for i in 0,1,2]+[ord(c)])`[2::5]

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

R , 101 바이트

function(a,s,o=unlist(list(letters,LETTERS,0:9)[a]))cat(o[sort(match(strsplit(s,'')[[1]],o))],sep='')

주어진 순서로 az, AZ 및 0-9를 가진 벡터를 생성하고이 순서와 일치하도록 입력 문자열의 문자를 재정렬합니다.

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

J, 40 바이트

;@:{[:(<@/:~@}./.~2-64 96 I.3&u:)'aA0'&,

자바 (8) 221 212 193 156 바이트

물론 내 자신의 도전에도 대답하려고 노력해야합니다. :) (그리고 Java에서 평소와 같이)

a->i->{for(byte c[],j=0;j<3;System.out.print(new String(c)))java.util.Arrays.sort(c=i.replaceAll("[^a-z];[^A-Z];[^0-9]".split(";")[a[j++]],"").getBytes());}

@cliffroot 덕분에 -28 바이트가 절약 되었습니다 .

설명:

여기에서 시도하십시오.

a->i->{          // Method with integer-array and String parameters and no return-type
  for(byte c[],  //  Temp byte-array
      j=0;j<3;   //  Loop from 0 to 3 (exclusive)
      System.out.print(new String(c)))
                 //    After every iteration: print the byte-array as String
    java.util.Arrays.sort(
                 //   Sort the byte-array
      c=         //    After we've replaced the byte-array with
        i.replaceAll("[^a-z];[^A-Z];[^0-9]".split(";")[a[j++]],"").getBytes());}
                 //    all bytes of the uppercase letters, lowercase letters, or digits,
                 //    depending on the next number in the input-array