Вхід:

• Масив , що містить три цілих числа: 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]і т.д.).

Загальні правила:

• Це код-гольф , тому найкоротша відповідь у байтах виграє.
  Не дозволяйте мовам коду-гольфу відштовхувати вас від публікації відповідей з не кодовими гольф-мовами. Спробуйте придумати якомога коротшу відповідь на "будь-яку" мову програмування.
• Стандартні правила діють для вашої відповіді, тому вам дозволяється використовувати 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 оновлень з цим. Не соромтесь видалити свої дані та надіслати їх @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 @

Безголівки:

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

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

Очікується, що вхід буде впорядкованим у порядку списку на основі нуля без розмежувачів у першому рядку, а рядок буде відсортовано у другому рядку, наприклад

120
fOo42BaR

Спробуйте в Інтернеті!

Пояснення

Я буду використовувати приклад вище вводу, щоб провести вас через код:

120
fOo42BaR

Етап 1: Заміна

2=`.
!$&"

Сам регулярний вираз є просто .(відповідає будь-якому персонажу, який не передається), яким оточений !...". Однак, 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! БОР #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 додатковий байт.

Стакс , 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десять елеменетів. Також може бути весь код VlVd+26/,e@:f,{[Io, який читає вхідний стек двічі замість того, щоб прочитати їх на початку до основного стеку та використовує інший (більш традиційний) формат введення, як показано на цьому .

Діалог 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який негайно передається до масиву char. Потім ми будуємо три елементи нового динамічного масиву, кожен з яких інкапсульований -join:
- (($s=$s|sort)|?{$_-ge97})
- ($s|?{$_-in65..96})
-($s|?{$_-lt58})

Перший ми беремо $sі запускаємо його Sort-Object. На щастя, оскільки ми вже представили це як масив char, це сортування залежно від регістру. Це стає повторно збереженим, $sа потім передається в a 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 байт

Подано з відповіді @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]".

Пітон 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());}

-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