Входные данные:

• Массив , содержащий три целых числа: 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 . Попробуйте онлайн! ,

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 голосов с этим. Не стесняйтесь удалять свои возражения и вместо этого отдавайте их @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.

Пиф, 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 байт

Golfed:

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[... ]использование , что для изменения порядка с

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

Для каждого значения в первом списке получает соответствующее регулярное выражение и применяет его к входной строке. Результатом является список списков символов, которые соответствуют регулярному выражению. Затем отсортируйте каждый и объедините результат в один список и преобразуйте его в строку.

Вы можете увидеть это онлайн здесь: https://ideone.com/dqAkxg

Сетчатка , 43 39 байт

Количество байтов предполагает кодировку ISO 8859-1. Конечный перевод строки значителен.

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

Ожидается, что входные данные будут иметь порядок сортировки в виде списка с нулями без разделителей в первой строке и строки, которая должна быть отсортирована во второй строке, например

120
fOo42BaR

Попробуйте онлайн!

объяснение

Я буду использовать приведенный выше пример ввода, чтобы провести вас по коду:

120
fOo42BaR

Этап 1: Замена

2=`.
!$&"

Само регулярное выражение просто .(соответствует любому символу, не являющемуся переводом строки), которое окружено !...". Однако 2=это предел, указывающий Retina применять замену только ко второму совпадению регулярного выражения. Итак, мы получаем это:

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 дополнительный байт.

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

Дьялог АПЛ , 22 байта

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

(819⌶⎕A) сложите прописные буквы в строчные

(...)⎕A⎕D[a] Нижние верхние цифры переупорядочены в соответствии с массивом а

∊ расплющить

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. К счастью, поскольку мы уже представили его как массив символов, сортировка чувствительна к регистру. Это повторно сохраняется в $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) строки 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 вводит соответствующую группу, упорядочивает три различных класса символов.

Это было бы более компактно, чем re-seqрешение, если бы было больше классов символов для обработки, так как для этого требуется только 5 дополнительных символов на группу 57 1,вместо 8 для выражения типа #"[a-z]".

Python 2, 140 117 101 100 99 байт

Все говорят: «Фу!». По крайней мере, это читабельно ... кашель не совсем кашель

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