การป้อนข้อมูล:

• อาร์เรย์สามจำนวนเต็ม: 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 ดัชนี
• สตริง (ทั้ง input และ output) 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``

หากอินพุตอาร์เรย์ให้คำสั่งแทนที่ลำดับที่มาก่อนของช่วงสามช่วง (สิ่งนี้สร้างความแตกต่าง[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 ด้วยสิ่งนี้ อย่าลังเลที่จะลบ 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อีกอัน!

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 @

Ungolfed:

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]สั่งซื้อใหม่ตามอาร์เรย์

∊ เรียบ

(... )⍋sตามที่ "ตัวอักษร" ให้ดัชนีที่จะจัดเรียงสตริง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))))

สำหรับแต่ละค่าในรายการแรกรับ regex ที่เหมาะสมและใช้กับสตริงอินพุต ผลลัพธ์คือรายการของสัญลักษณ์ที่ตรงกับ regex จากนั้นเรียงลำดับแต่ละรายการแล้วเชื่อมผลลัพธ์เป็นหนึ่งรายการแล้วแปลงเป็นสตริง

คุณสามารถดูออนไลน์ได้ที่นี่: https://ideone.com/dqAkxg

เรติน่า43 43ไบต์

จำนวนไบต์ถือว่าการเข้ารหัส ISO 8859-1 ตัวป้อนบรรทัดต่อท้ายมีความสำคัญ

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

คาดว่าอินพุตเป็นลำดับการจัดเรียงเป็นรายการ zero-based โดยไม่มีตัวคั่นในบรรทัดแรกและสตริงที่จะเรียงลำดับในบรรทัดที่สองเช่น

120
fOo42BaR

ลองออนไลน์!

คำอธิบาย

ฉันจะใช้ตัวอย่างอินพุตด้านบนเพื่อนำคุณผ่านรหัส:

120
fOo42BaR

ด่าน 1: การเปลี่ยนตัว

2=`.
!$&"

regex ตัวเองเป็นเพียง.(ตรงกับตัวอักษรที่ไม่เลื่อนบรรทัด) !..."ซึ่งถูกล้อมรอบด้วย อย่างไรก็ตาม2=นี่เป็นข้อ จำกัด ที่บอกให้ Retina ใช้การทดแทนกับคู่ที่สองของ regex เท่านั้น ดังนั้นเราจึงได้สิ่งนี้:

1!2"0
fOo42BaR

ด่าน 2: การทับศัพท์

T04`¶d`#^@%

ขั้นตอนการถอดเสียงเป็นการทดแทนตัวละครแบบตัวอักษร The ¶แสดงถึงตัวป้อนบรรทัดและdขยายเป็น0123456789(แม้ว่าเราสามารถละเว้นตัวเลขทั้งหมดหลังจาก2) นั่นหมายถึงการทับศัพท์นี้สอดคล้องกับการทำแผนที่ดังต่อไปนี้:

¶012
#^@%

04ที่ด้านหน้ามีสองข้อ จำกัด ซึ่งร่วมกันแสดงให้เห็นว่ามีเพียงสี่ตัวแรกจากชุดนี้ควรได้รับการทับศัพท์ นั่นเป็นตัวเลขในบรรทัดแรกเช่นเดียวกับ linefeed ที่แยกสองบรรทัดดังนั้นเราจึงได้สิ่งนี้:

@!%"^#fOo42BaR

ที่ด้านหน้าของสตริงตอนนี้เรามีตัวละครเหล่านี้สามคู่:

@!
%"
^#

โปรดทราบว่าอักขระที่สองของคู่นั้นเป็นไปตามลำดับ ASCII ปกติ (และจะเหมือนกันเสมอ) เราจะใช้สิ่งเหล่านี้ในภายหลังเพื่อจัดเรียงกลุ่มของอักขระในอินพุตหลักลงในลำดับที่ต้องการ

อักขระตัวแรกน่าสนใจมากกว่านี้เล็กน้อย: ความสำคัญของพวกเขาคือ%ตัวเลขที่มาก่อนตัวเลขในตาราง ASCII @มาก่อนตัวอักษรตัวพิมพ์ใหญ่ (แต่หลังตัวเลข) และ^มาก่อนตัวอักษรตัวพิมพ์เล็ก (แต่หลังจากตัวอักษรตัวพิมพ์ใหญ่) สิ่งนี้จะช่วยให้เราจัดกลุ่มเครื่องหมายตำแหน่ง (เช่นอักขระที่สองในแต่ละคู่) ด้วยชุดอักขระที่เหมาะสม

ด่าน 3: เรียงลำดับ

O`\W?.

นี่คือขั้นตอนการเรียงลำดับที่เรียบง่าย มันจับคู่อักขระสองตัวถ้าตัวแรกไม่ใช่ตัวอักษรคำ (ดังนั้นจึงจับคู่ทั้งสามคู่ที่ฉันเพิ่งพูดถึง) หรือตัวอักษรเดี่ยวอื่น ๆ (จับคู่อักขระแต่ละตัวของอินพุตหลักเป็นรายบุคคล) และเรียงลำดับสตริงเหล่านั้น นี่มีวัตถุประสงค์สองประการ: มันนำตัวละครในแต่ละกลุ่มในลำดับที่ถูกต้อง (และเนื่องจากการเรียงลำดับมีความเสถียรลำดับนี้จะไม่ถูกทำให้ยุ่งเหยิงในขั้นตอนต่อไป) และเนื่องจาก%@^เครื่องหมายมันแทรกคู่ใน ตำแหน่งที่ถูกต้อง:

%"24@!BOR^#afo

ด่านที่ 4: เรียงลำดับ

O`.\w+

ขั้นตอนนี้จะเรียงลำดับการแข่งขันทั้งหมดของ.\w+regex ซึ่งเนื่องจากความโลภตรงกับเครื่องหมายตำแหน่งหนึ่ง (เช่นหนึ่งของ!"#) พร้อมกับตัวอักษรคำทั้งหมดหลังจากนั้น นั่นคือมันเรียงลำดับสามสตริงเหล่านี้ซึ่งคำสั่งซื้อจะถูกกำหนดโดยตัวทำเครื่องหมาย:

"24! BOR #afo

ขณะที่สิ่งนี้วนรอบเครื่องหมายเหล่านั้น (ในขณะที่ปล่อยเครื่องหมายอีกสามตัวไว้) สิ่งสำคัญที่สุดคือนำตัวเลขและตัวอักษรตามลำดับที่ถูกต้อง:

%!BOR@"24^#afo

ด่านที่ 5: การเปลี่ยนตัว

\W

สิ่งที่เหลืออยู่คือการทำความสะอาดเพียงเล็กน้อยที่เราลบเครื่องหมายทั้งหมดโดยการจับคู่พวกมันและแทนที่พวกมันโดยไม่ทำอะไรเลย

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

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 ไบต์เพิ่มเติม

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]ที่ต่ำกว่าตัวเลขบนจัดลำดับใหม่ตามอาร์เรย์

∊ เรียบ

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]

ฉันสำรวจอัลกอริทึมโดยใช้ regex แต่จนถึงตอนนี้พวกเขาทั้งหมดดูเหมือนอีกต่อไป

รับอินพุตเป็นอาร์เรย์ที่ชัดเจน$n(ดูตัวอย่างด้านล่าง) และสตริง$sที่ถูกส่งไปยัง char-array ทันที จากนั้นเราจะสร้างองค์ประกอบสามแบบของอาเรย์แบบไดนามิกใหม่ซึ่งแต่ละองค์ประกอบจะมี-join:
- (($s=$s|sort)|?{$_-ge97})
- ($s|?{$_-in65..96})
-($s|?{$_-lt58})

เป็นครั้งแรกที่เราใช้และเรียกใช้ผ่าน$s Sort-Objectโชคดีที่เราได้ใช้มันเป็น char-array อยู่แล้วการเรียงลำดับแบบตรงตามตัวพิมพ์ใหญ่ - เล็ก ที่ได้รับการบันทึกใหม่อีกครั้ง$sแล้วส่งไปยัง a Where-Objectด้วยประโยคที่มากกว่า97(เช่น ASCII ตัวพิมพ์เล็กa-z) ประการที่สองคือสำหรับและคนที่สามสำหรับA-Z0-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

Ruby, 56 ไบต์

ส่งจาก @Dennis คำตอบ

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

โซลูชันสำรองขนาด 58 ไบต์ที่ฉันชอบดีกว่าได้แรงบันดาลใจจาก @Neil และปรับเปลี่ยนเล็กน้อยจากคำตอบของเขา

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

ลองเวอร์ชันออนไลน์! (เวอร์ชั่นที่ใส่ความเห็นเป็นทางออกอื่น)

รหัสเครื่อง 32 บิต x86, 70 ไบต์

ในรูปหกเหลี่ยม:

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สร้างแฮชแผนที่ซึ่งสามารถใช้เป็นฟังก์ชั่นเมื่อสอบถามกับ ingeger ระหว่าง 0 และ 2 มันจะส่งกลับกลุ่มที่สอดคล้องกันนี้สั่งให้ตัวละครที่แตกต่างกันสามชั้น

นี้จะเป็นขนาดกะทัดรัดมากขึ้นกว่าre-seqการแก้ปัญหาถ้ามีมากขึ้นชั้นเรียนตัวอักษรที่จะจับเช่นนี้ใช้เวลาเพียง 5 ตัวอักษรพิเศษ / กลุ่มเช่น57 1,แทนที่จะ 8 #"[a-z]"สำหรับการแสดงออกเช่น

Python 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());}

-28 ไบต์บันทึกขอบคุณที่@cliffroot

คำอธิบาย:

ลองที่นี่

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