入力：

• 3つの整数を含む配列：0、1および2任意の順序（つまり[2, 0, 1]）
• そして、アルファベット文字（小文字と大文字の両方）と数字（つまりa1B2c3）のみを含む長さ2以上の文字列

出力：

配列に基づいて、文字列を並べ替えて出力します。
これはどのように作動しますか？

• アレイは、の順の優先順位を示しa-z、A-Zそして0-9、第一ビーイング0。第二の存在1; そして3番目の存在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エンコードを使用します。オンラインでお試しください！。

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

入力配列が3つの範囲の優先順位ではなく順序を与えた場合（これは違いが[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つの賛成票を得ました。アップボートを削除して、代わりに@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

1バイトは@FryAmTheEggmanに、もう1 バイトは@Jakubeに感謝します！

Javascript 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、199の 191バイト

ゴルフ：

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を並べ替える

Python 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],[]))

Clojure、74バイト

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

最初のリストの各値について、適切な正規表現を取得し、入力文字列に適用します。結果は、正規表現に一致するシンボルのリストのリストです。次に、それぞれを並べ替えて結果を1つのリストに連結し、文字列に変換します。

ここでオンラインで見ることができます：https : //ideone.com/dqAkxg

網膜、43 39バイト

バイトカウントはISO 8859-1エンコードを前提としています。後続の改行は重要です。

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

入力は、最初の行に区切り文字のないゼロベースのリストとしてのソート順であり、2番目の行にソートされる文字列であることが期待されます。

120
fOo42BaR

オンラインでお試しください！

説明

上記の入力例を使用して、コードを説明します。

120
fOo42BaR

ステージ1：置換

2=`.
!$&"

正規表現自体は.（改行以外の文字に一致する）だけで、で囲まれてい!..."ます。ただし、これ2=は正規表現の2番目の一致にのみ置換を適用するようRetinaに指示する制限です。したがって、これを取得します。

1!2"0
fOo42BaR

ステージ2：文字変換

T04`¶d`#^@%

音訳ステージは、単に文字ごとの置換を行います。¶改行と表しdに展開する0123456789（私たちは後にすべての桁を無視することができますが2）。つまり、この音訳は次のマッピングに対応します。

¶012
#^@%

04フロントでは、一緒になって、このセットから最初の4つの文字が音訳されるべきであることを示す2つの限界です。それはたまたま最初の行の数字であり、2行を区切る改行なので、次のようになります。

@!%"^#fOo42BaR

文字列の先頭に、これらの文字の3つのペアがあります。

@!
%"
^#

ペアの2番目の文字は単純に通常のASCII順であることに注意してください（常に同じです）。これらを後で使用して、メイン入力の文字のグループを必要な順序に並べ替えます。

最初の文字はもう少しおもしろいです。その重要性は%、ASCIIテーブルの数字の@前、大文字の前（数字の後）にあることです。^小文字の前（大文字の後）です。これは、位置マーカー（各ペアの2番目の文字）を正しい文字セットとグループ化するのに役立ちます。

ステージ3：並べ替え

O`\W?.

これは単純なソート段階です。最初の文字が単語文字でない場合は2文字に一致し（これにより、先ほど説明した3つのペアすべてに一致します）、そうでなければ単一の文字（メイン入力の各文字に個別に一致します）に一致し、それらの文字列を並べ替えます。これには2つの目的があります。各グループ内の文字を正しい順序で並べます（並べ替えは安定しているため、この順序は次の段階で混乱しません）。また、%@^マーカーのため、ペアを正しい位置：

%"24@!BOR^#afo

ステージ4：並べ替え

O`.\w+

この段階では、.\w+貪欲さにより、1つの位置マーカー（つまりの1つ!"#）とその後のすべての単語文字が一致する正規表現のすべての一致が並べ替えられます。つまり、次の3つの文字列を並べ替えます。これらの文字列の順序は、マーカー文字によってのみ決定されます。

「24！BOR #afo

これはそれらのマーカーをシャッフルします（他の3つのマーカーはそのままにします）が、最も重要なことは、数字と文字を正しい順序に並べることです。

%!BOR@"24^#afo

ステージ5：置換

\W

残っているのは少しクリーンアップするだけです。マーカーを一致させて何も置き換えないことで、すべてのマーカーを削除します。

JavaScript（ES6）、65

注：「自然な」ASCII順序は0〜9、A〜Z、a〜zであり、OP 0、1、2の反対です。そう

• 無効な文字を追加して文字列を実行し、実行を分ける
• 3つのセグメントに分割します-無効な文字がそれぞれマークします
• 要求された順序でセグメントを1つずつ取得します
• 再組み立て

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+')'))
})

Haskell、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バイト追加されました。

スタックス、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|(、左に0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ10個の要素を回転させることもできます。コード全体をにすることもできますVlVd+26/,e@:f,{[Io。これは、メインスタックの先頭ですべてを読み込む代わりに、入力スタックを2回読み込み、これに示すように、異なる（より伝統的な）入力形式を使用します。

Dyalog APL、22 バイト

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

(819⌶⎕A) 大文字のアルファベットを小文字に折ります

(… )⎕A⎕D[a]配列aに従って並べ替えられた下位の上位桁

∊ 平らにする

s⍋⍨文字列sに対して、その「アルファベット」に従ってsをソートするインデックスを取得します

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。ありがたいことに、すでにchar-arrayとしてキャストしているので、大文字と小文字を区別する並べ替えです。それは再保存され$s、Where-Objectより大きい句97（つまり、ASCII小文字a-z）でにパイプされます。2番目はA-Z、3番目は0-9です。

これで、文字列の配列ができました。各文字列は3つの文字タイプのいずれかで構成され、ソートされています。それをスライスして[$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バイト

@Dennisの回答から移植。

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

Emacs Lisp、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))))))))

Javaより少し短い...

Clojure、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のインゲジャーで照会すると、対応するグループを返します。これにより、3つの異なるクラスの文字が並べられます。

これは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'&,

Java 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