Đầu vào:

• Một mảng chứa ba số nguyên: 0, 1và 2trong bất kỳ thứ tự (ví dụ [2, 0, 1])
• Và một chuỗi có độ dài> = 2 chỉ chứa các chữ cái (cả chữ thường và chữ hoa) và chữ số (nghĩa là a1B2c3)

Đầu ra:

Dựa vào mảng chúng ta sắp xếp và xuất chuỗi.
Cái này hoạt động ra sao?

• Mảng chỉ ra thứ tự ưu tiên của a-z, A-Zvà 0-9, bản thể đầu tiên 0; thứ hai 1; và thứ ba 2.
• Các ký tự riêng lẻ của chuỗi sau đó có thể được sắp xếp dựa trên đó.

Thí dụ:

• Mảng: [2, 0, 1]
• Chuỗi: a1B2c3

Dựa trên mảng, chúng tôi biết ưu tiên đặt hàng của chúng tôi là 0-9a-zA-Z.
Dựa vào đó, chúng ta có thể chuyển đổi và xuất chuỗi : 123acB.

Quy tắc thử thách:

• Đối với mảng, bạn có thể chọn sử dụng đầu vào 0 chỉ mục hoặc 1 chỉ mục, do đó, [3, 1, 2]cũng là đầu vào hợp lệ nếu bạn thích sử dụng mảng 1 chỉ mục.
• Chuỗi (cả đầu vào và đầu ra) chỉ chứa các ký tự hợp lệ : abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.
• Nếu ngôn ngữ của bạn không hỗ trợ mảng (hoặc nếu bạn chọn), bạn có thể tự do sử dụng chuỗi thay vì mảng cho tham số đầu tiên (tức là 012, [0,1,2], vv).

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Các quy tắc chuẩn áp dụng cho câu trả lời của bạn, vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp, các chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn.
• Ngoài ra, xin vui lòng thêm một lời giải thích nếu cần thiết.

Các trường hợp thử nghiệm:

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

Mã số:

v²žK26ôyèÃ{?

Giải trình:

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.

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến! .

Python 2, 67 66 byte

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

Kiểm tra nó trên Ideone .

JavaScript (ES6), 87 byte

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

Nếu mảng đầu vào đưa ra thứ tự, thay vì ưu tiên của ba phạm vi (điều này chỉ tạo ra sự khác biệt cho [1, 2, 0]và [2, 1, 0]có hiệu ứng được hoán đổi) thì điều này sẽ có hiệu quả trong 80 byte:

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

Tôi đã đọc sai câu hỏi và vẫn nhận được 7 lượt upvote với điều này. Thay vào đó, vui lòng xóa upvote của bạn và đưa chúng cho @CharlieWynn, người đã đưa ra cách khắc phục tốt nhất cho cách tiếp cận của tôi.

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

Thạch , 13 byte

2_ịØWs26¤Ff@€

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

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 byte

s@RSz@L[GrG1`UT

Bộ thử nghiệm.

       [          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

Cảm ơn @FryAmTheEggman cho một byte và @Jakube cho một cái khác!

Javascript es6 77 byte

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

Chơi gôn

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 @

Ung dung:

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 @

Vĩ cầm

APLX , 19 byte

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

⎕a⎕A⎕D chữ số dưới

(... )[a]sắp xếp lại theo mảng một

∊ làm phẳng

(Từ khóa )⍋stheo "bảng chữ cái" đó, đưa ra các chỉ số sắp xếp chuỗi s

s[Sọ ]sử dụng để sắp xếp lại s

Python 2, 121 byte

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 byte

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

Đối với mỗi giá trị trong danh sách đầu tiên, hãy lấy regex thích hợp và áp dụng nó cho chuỗi đầu vào. Kết quả là một danh sách các danh sách các biểu tượng phù hợp với biểu thức chính quy. Sau đó sắp xếp từng cái và nối kết quả vào một danh sách và biến nó thành chuỗi.

Bạn có thể thấy nó trực tuyến tại đây: https://ideone.com/dqAkxg

Võng mạc , 43 39 byte

Số lượng byte giả định mã hóa ISO 8859-1. Các linefeed trailing là đáng kể.

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

Đầu vào dự kiến ​​là thứ tự sắp xếp dưới dạng danh sách dựa trên số 0 mà không có dấu phân cách trên dòng đầu tiên và chuỗi được sắp xếp trên dòng thứ hai, ví dụ:

120
fOo42BaR

Hãy thử trực tuyến!

Giải trình

Tôi sẽ sử dụng ví dụ đầu vào ở trên để hướng dẫn bạn qua mã:

120
fOo42BaR

Giai đoạn 1: Thay thế

2=`.
!$&"

Bản thân regex chỉ là .(khớp với bất kỳ ký tự không phải dòng nào), được bao quanh !...". Tuy nhiên, 2=là một giới hạn nói Retina để áp dụng các thay chỉ đến trận đấu thứ hai của regex. Vì vậy, chúng tôi nhận được điều này:

1!2"0
fOo42BaR

Giai đoạn 2: Chuyển ngữ

T04`¶d`#^@%

Một giai đoạn chuyển ngữ chỉ đơn giản là thay thế từng ký tự. Biểu ¶thị một nguồn cấp dữ liệu và dmở rộng đến 0123456789(mặc dù chúng ta có thể bỏ qua tất cả các chữ số sau 2). Điều đó có nghĩa là, phiên âm này tương ứng với ánh xạ sau:

¶012
#^@%

Ở 04phía trước là hai giới hạn, cùng nhau chỉ ra rằng chỉ có bốn ký tự đầu tiên trong bộ này được phiên âm. Đó là các chữ số trên dòng đầu tiên, cũng như nguồn cấp dữ liệu phân tách hai dòng, vì vậy chúng tôi nhận được điều này:

@!%"^#fOo42BaR

Ở phía trước của chuỗi, bây giờ chúng ta có ba cặp ký tự sau:

@!
%"
^#

Lưu ý rằng các ký tự thứ hai của các cặp chỉ đơn giản là theo thứ tự ASCII bình thường của chúng (và sẽ luôn giống nhau). Chúng ta sẽ sử dụng chúng sau này để sắp xếp các nhóm ký tự trong đầu vào chính theo thứ tự yêu cầu.

Các ký tự đầu tiên thú vị hơn một chút: ý nghĩa của chúng là %trước các chữ số trong bảng ASCII, @đi trước các chữ cái in hoa (nhưng sau các chữ số) và ^đi trước các chữ cái viết thường (nhưng sau các chữ cái viết hoa). Điều này sẽ giúp chúng tôi nhóm các điểm đánh dấu vị trí (tức là ký tự thứ hai trong mỗi cặp) với bộ ký tự phù hợp.

Giai đoạn 3: Sắp xếp

O`\W?.

Đây là một giai đoạn sắp xếp đơn giản. Nó khớp với hai ký tự nếu ký tự đầu tiên không phải là ký tự từ (do đó khớp với cả ba cặp tôi vừa nói) hoặc một ký tự khác (khớp từng ký tự của đầu vào chính) và sắp xếp các chuỗi đó. Điều này có hai mục đích: nó đưa các ký tự trong mỗi nhóm theo đúng thứ tự (và vì việc sắp xếp ổn định, nên thứ tự này sẽ không bị rối trong giai đoạn tiếp theo) và do các %@^điểm đánh dấu, nó chèn các cặp vào đúng vị trí:

%"24@!BOR^#afo

Giai đoạn 4: Sắp xếp

O`.\w+

Giai đoạn này sắp xếp tất cả các trận đấu của .\w+regex, do sự tham lam, khớp với một điểm đánh dấu vị trí (tức là một trong số !"#) cùng với tất cả các ký tự từ sau nó. Đó là, nó sắp xếp ba chuỗi này, có thứ tự chỉ được xác định bởi ký tự đánh dấu:

"24! BOR #afo

Trong khi điều này xáo trộn xung quanh các điểm đánh dấu đó (trong khi để lại ba điểm đánh dấu khác), quan trọng nhất là nó mang các chữ số và chữ cái theo đúng thứ tự:

%!BOR@"24^#afo

Giai đoạn 5: Thay thế

\W

Tất cả những gì còn lại là dọn dẹp một chút, nơi chúng tôi loại bỏ tất cả các điểm đánh dấu bằng cách khớp chúng và thay thế chúng không có gì.

JavaScript (ES6), 65

Lưu ý: thứ tự ASCII 'tự nhiên' là 0-9, AZ, az, trái ngược với OP 0,1,2. Vì thế

• sắp xếp chuỗi thêm ký tự không hợp lệ để phân tách các lần chạy
• chia nó thành 3 segmenents - đánh dấu ký tự không hợp lệ
• nhận từng phân đoạn một theo thứ tự được yêu cầu
• tập hợp lại

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 byte

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

Ví dụ sử dụng: "cD12ab" # [2,0,1]-> "12abcD".

Làm thế nào nó hoạt động:

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

Chỉnh sửa: @Christian Sievers tìm thấy một lỗi. Cảm ơn! Đã sửa cho 1 byte bổ sung.

Stax , 15 byte

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

Chạy và gỡ lỗi trực tuyến

Đệ trình 15 byte này được đóng gói thành một biến thể của bộ ký tự CP437. Biểu diễn ascii tương ứng mất 18 byte:

EVlVd+26/s@:fs{[Io

Khá chắc chắn rằng nó có thể được cắt giảm hơn nữa mặc dù.

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+cũng có thể VLA|(, mà trái quay 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZmười mười elemenet. Toàn bộ mã cũng có thể là VlVd+26/,e@:f,{[Io, đọc ngăn xếp đầu vào hai lần thay vì đọc tất cả chúng ở đầu ngăn xếp chính và sử dụng định dạng đầu vào khác (truyền thống hơn), như thể hiện trong phần này .

APL Dyalog , 22 byte

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

(819⌶⎕A) gấp bảng chữ cái viết hoa thành chữ thường

(Các )⎕A⎕D[a]chữ số trên thấp hơn được sắp xếp lại theo mảng a

∊ làm phẳng

s⍋⍨đối với chuỗi s , hãy lấy các chỉ số sắp xếp s theo "bảng chữ cái" đó

s[Sọ ]sử dụng để sắp xếp lại s

PowerShell v2 +, 107 byte

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

Tôi đang khám phá các thuật toán sử dụng regex, nhưng cho đến nay tất cả chúng dường như dài hơn.

Lấy đầu vào dưới dạng mảng rõ ràng $n(xem ví dụ bên dưới) và chuỗi $sđược truyền ngay lập tức vào mảng char. Sau đó, chúng tôi đang xây dựng ba phần tử của một mảng động mới, mỗi phần tử được gói gọn bằng một -join:
- (($s=$s|sort)|?{$_-ge97})
- ($s|?{$_-in65..96})
-($s|?{$_-lt58})

Việc đầu tiên chúng tôi thực hiện $svà chạy qua Sort-Object. Rất may, vì chúng tôi đã chọn nó như một mảng char, nên nó là phân loại theo trường hợp. Điều đó được lưu lại vào $svà sau đó được dẫn đến Where-Objectmột mệnh đề lớn hơn 97(nghĩa là chữ thường ASCII a-z). Thứ hai là cho A-Zvà thứ ba cho 0-9.

Vì vậy, bây giờ chúng ta có một chuỗi các chuỗi, trong đó mỗi chuỗi được tạo thành một trong ba loại ký tự và được sắp xếp. Chúng tôi cắt nó với [$n]và sau đó -joinkết quả cùng nhau để tạo thành chuỗi đầu ra cuối cùng của chúng tôi. Đó là còn lại trên đường ống và in ấn là ẩn.

Các trường hợp thử nghiệm

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 byte

Chuyển từ câu trả lời @Dennis.

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

Một giải pháp thay thế 58 byte mà tôi thích hơn, lấy cảm hứng từ @Neil và sửa đổi một chút từ câu trả lời của anh ấy.

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

Hãy thử một trong hai phiên bản trực tuyến! (phiên bản nhận xét là giải pháp thay thế)

Mã máy x86 32 bit, 70 byte

Trong hex:

fc31c031c95189e3ac84c0740a34cf0404880c0341ebf189fe9160ac88c2c0e805d788c652ac88c2c0e805d788c658740e6639d076029241aa92aa4e4febdc85c96175d658c3

Quy trình này hy vọng thứ tự sắp xếp lớp ký tự là một chuỗi kết thúc 3-char (0..2) NULL ESIvà chuỗi để sắp xếp EDI. Sắp xếp được thực hiện tại chỗ bằng cách sử dụng phiên bản sắp xếp bong bóng cực kỳ tối ưu (hiệu suất thông minh).

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 byte

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

Hơi ngắn hơn Java ...

Clojure, 77 byte

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

Không hoàn toàn ngắn như cái re-seqdựa trên, và tôi không thể tìm ra cách thể hiện điều đó "(apply str(mapcat sort(map(...)))) " trong không gian ít hơn. group-bytạo ra một bản đồ băm có thể được sử dụng như một hàm, khi được truy vấn với một hàm trong khoảng từ 0 đến 2, nó trả về nhóm tương ứng, điều này sẽ ra lệnh cho ba lớp ký tự khác nhau.

Điều này sẽ nhỏ gọn hơn re-seqgiải pháp nếu có nhiều lớp ký tự để xử lý vì việc này chỉ mất thêm 5 ký tự / nhóm như 57 1,thay vì 8 cho biểu thức như thế nào #"[a-z]".

Con trăn 2, 140 117 101 100 99 byte

Mọi người nói, "Ewww!". Ít nhất là nó có thể đọc được ... ho không thực sự ho

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]

Dùng thử trực tuyến

R , 101 byte

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

Tạo một vectơ với az, AZ và 0-9 theo thứ tự cho trước và sắp xếp lại các ký tự của chuỗi đầu vào để khớp với thứ tự này.

Hãy thử trực tuyến!

J, 40 byte

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

Java 8, 221 212 193 156 byte

Tất nhiên tôi cũng nên cố gắng trả lời thử thách của chính mình. :) (Và như thường lệ trong 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 byte được lưu nhờ @cliffroot .

Giải trình:

Hãy thử nó ở đây.

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