Вызов

Напечатайте следующие символы:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890

Проблема в том, что вы не можете использовать ни один из них в своем коде.

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

правила

• Вы не можете использовать символы из набора, упомянутого выше
• Вы можете использовать любые другие символы
• Без обмана
• Стандартные лазейки запрещены
• Это код-гольф , самый короткий ответ выигрывает.

Разъяснения

• Если ваш язык использует другую кодировку, вы не можете использовать кодовые точки в этой кодировке, которые соответствуют буквенно-цифровым символам.
• Возвращение строки из функции считается допустимой формой вывода.
• Вы можете вернуть массив символов.

V , 8 7 байт

1 байт сохранен благодаря @DJMcMayhem, поместив все это в одно выражение регулярного выражения

¬/{Ó×ü_

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

Выходы:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Примечание: ×это не x или X, то0xd7

HexDump:

00000000: ac2f 7bd3 d7fc 5f                        ./{..._

объяснение

¬/{            " inserts every character in the range / to {

Теперь вывод выглядит так:

/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{

Мы должны удалить все не алфавитно-цифровые символы и _(поскольку они не включены в \W), так что давайте сделаем это с помощью регулярных выражений

Ó×ü_           " removes every character that is non-alphanumeric or an underscore _ 
               " vim equivalent of :s/\W\|_//g

Октава , 52 46 40 байт

['['-('"':'+'),'{'-(_='!':':'),_+'@','']

Это оценивает

9876543210ZYXWVUTSRQPONMLKJIHGFEDCBAabcdefghijklmnopqrstuvwxyz

объяснение

Здесь мы используем тот факт, что символы неявно преобразуются в целые числа, когда применяются арифметические операции, такие как +-или функция диапазона :. При объединении с пустой строкой ( [...,'']) числа снова преобразуются в символы.

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

брейкфук , 77 76 75 72 байта

++++++++[>+>++++++>++++>-<<<<-]>++[>.+<-]>>[>+>++>+++<<<-]>++[>+.>+.<<-]

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

Как это устроено

Переводчик начинается с ленты из 0 ячеек.

++++++++

Это устанавливает первую ячейку на 8 , оставляя ленту в следующем состоянии.

   8
   ^

[>+>++++++>++++>-<<<<-]

При этом увеличивается вторая ячейка один раз, третья ячейка 6 раз, четвертая ячейка 4 раза, уменьшается пятая ячейка один раз, затем возвращается к началу ленты и уменьшается первая ячейка. После 8 итераций лента выглядит следующим образом.

  0   8  48  32  -8
  ^

>++

Мы переходим ко второй ячейке и увеличиваем ее вдвое, готовясь к печати цифр.

  0  10  48  32  -8
      ^

[>.+<-]

Это печатает третью ячейку, увеличивает ее, затем возвращается ко второй ячейке и уменьшает ее. После 10 итераций мы напечатали, 0123456789и лента выглядит следующим образом.

  0   0  58  32  -8
      ^

>>

Время подготовить ленту для писем! Мы начинаем с продвижения двух клеток.

  0   0  58  32  -8   0   0
              ^

[>+>++>+++<<<-]

Это увеличивает пятую ячейку один раз, шестую - дважды, седьмую - трижды, затем возвращается к четвертой ячейке и уменьшает ее. После 32 итераций лента выглядит следующим образом.

  0   0  58   0  24  64  96
              ^

>++

В качестве последнего шага перед печатью букв мы переходим к пятой ячейке и увеличиваем ее вдвое.

  0   0  58   0  26  64  96
                  ^

[>+.>+.<<-]

Наконец, мы переходим к шестой ячейке, чтобы увеличить и распечатать ее, проделать то же самое для седьмой ячейки, затем вернуться к пятой ячейке и уменьшить ее. После 26 итераций мы напечатали Aa...Zz.

Рубин, 42 байта

->{[*?/...?:,*?@...?[,*?`...?{]-[?/,?@,?`]}

Функция, которая возвращает массив символов. Программа, которая выводит только символы, составляет 49 байт:

$><<([*?/...?:,*?@...?[,*?`...?{]-[?/,?@,?`])*''

При этом просто используются символы ascii с обеих сторон соответствующих диапазонов для определения диапазона. Например, ?/...?:означает символы между косой чертой и двоеточием, исключая конец. Чтобы избавиться от начала, мы вычитаем массив, содержащий три начальных символа.

6502 машинного языка, 74 70 68 байтов

Шестнадцатеричный дамп (6502 программы обычно не перемещаемы; код здесь хранится, начиная с местоположения $ 0603):

0600:          a9 24 0a 8d 20 06 8d 21 06 8d 23 06 8d 
0610: 25 06 09 20 8d 1a 06 8d 1c 06 ea aa ea a8 a9 00 
0620: ea ea 98 ea 8a ea a2 ff a9 7b a0 60 20 3a 06 a9 
0630: 5b a0 40 20 3a 06 a9 3a a0 2f 85 80 c8 e8 98 95 
0640: 00 c8 c4 80 d0 f7 60

Вы можете видеть, что здесь не используется ни один из запрещенных байтов: от 41 до 5 долларов, от 61 до 7 долларов или от 30 до 39 долларов.

Это функция без аргументов, которая при вызове возвращает указатель на массив символов «abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789» в верхней части стека в соответствии со стандартными соглашениями о вызовах 6502.

В порядке объяснения, вот разборка:

Адрес Hexdump Разборка
-------------------------------
$ 0603 a9 24 LDA # $ 24
0605 долл. США ASL A
$ 0606 8d 20 06 STA $ 0620
$ 0609 8d 21 06 STA $ 0621
$ 060c 8d 23 06 STA $ 0623
$ 060f 8d 25 06 STA $ 0625
$ 0612 09 20 ORA # $ 20
$ 0614 8d 1a 06 STA $ 061a
$ 0617 8d 1c 06 STA $ 061c
061 долл. США 
НАЛОГ НА 061 млрд. Долл. США 
061 долл. США 
$ 061d a8 TAY 
$ 061e a9 00 LDA # $ 00
0620 долларов США 
0621 долл. США 
$ 0622 98 TYA 
0623 доллара США 
0624 долл. США TXA 
0625 долл. США 
$ 0626 a2 ff LDX # $ ff
$ 0628 a9 7b LDA # $ 7b
062a a0 60 LDY # 60 $
$ 062c 20 3a 06 JSR $ 063a
$ 062f a9 5b LDA # $ 5b
$ 0631 a0 40 LDY # $ 40
$ 0633 20 3a 06 JSR $ 063a
$ 0636 a9 3a LDA # $ 3a
$ 0638 a0 2f LDY # $ 2f
063a 85 80 STA $ 80
$ 063c C8 INY 
$ 063d e8 INX 
$ 063e 98 TYA 
$ 063f 95 00 STA $ 00, X
$ 0641 C8 INY 
$ 0642 c4 80 CPY $ 80
$ 0644 d0 f7 BNE $ 063d
0646 60 РТС

Код машинного языка является самоизменяющимся. Для манипулирования стеком мне нужно было использовать PHA и PLA, чтобы сдвинуть и вытолкнуть аккумулятор, но в этих инструкциях есть коды операций $ 48 и $ 68, которые запрещены (это коды ASCII для букв «H» и «h»). Итак, для PHA я беру число $ 24, делаю арифметическое смещение влево (ASL) и сохраняю полученные $ 48 в четырех местах кода, где он должен быть выполнен. Затем для PLA я использую побитовое ИЛИ на $ 48 в аккумуляторе, чтобы вычислить $ 68, и сохраняю его в двух местах кода, где это необходимо.

Было несколько инструкций, кроме PHA и PLA, которые я также не мог использовать, потому что их коды операций совпадали с буквами или цифрами ASCII, но я нашел прямые обходные пути для этих других.

Нужный символьный массив вычисляется и сохраняется, начиная с местоположения 0 (на самом деле не имеет значения, где он хранится, так как нам просто нужно быть уверенным, что указатель на него возвращается на вершину стека).

Вы можете попробовать это на 6502 ассемблере и эмуляторе Ника Моргана . Вот скриншот; поле монитора внизу показывает строку вывода (в местах от $ 00 до $ 3D) после запуска программы.

Haskell , 75 72 63 58 56 байт

__=[__|[_',ä]<-["/:","@[","`{"],__<-[_'..],_'<__,__<ä]

Попробуйте онлайн! Позвони с __. Выход:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Спасибо xnor, который предложил __и в _'качестве двухбайтовых имен переменных вместо (!)или похожих, сэкономив 9 байтов. Особенно мне нравится, как _'ломается подсветка синтаксиса. И еще раз спасибо xnor за обобщение диапазонов, сохранив еще 4 байта.
Изменить: Я обнаружил, что символы Unicode допускается в качестве идентификаторов в Haskell, так например ä, ö... может также использоваться в качестве двух идентификаторов байтов. Поскольку в программе остался один трехбайтовый идентификатор, я заменил его ä, сохранив еще 2 байта.

Объяснение:

__и _'являются допустимыми именами переменных. Из спецификации языка :

Идентификатор состоит из буквы, за которой следуют ноль или более букв, цифр, подчеркиваний и одинарных кавычек. [...] Подчеркивание, _рассматривается как строчная буква, и может встречаться везде, где это возможно. Однако _сам по себе является зарезервированным идентификатором, используемым в качестве шаблонов в шаблонах.

Таким образом, код эквивалентен

s = [x|[a,b]<-["/:", "@[", "`{"], x<-[a..], a<x, x<b]

В списке понимание aстановится неизбежно '/'и bк ':'( "/:"эквивалентно ['/',':'], так что соответствующий шаблон успешно). Затем диапазон [a..]строит строку из всех символов, более равных '/':

"/0123456789:;<=>?@ABCDE ... \1114110\1114111"

xЗатем для каждого символа в этой строке проверяется, есть ли '/'<xи x<':', что приводит к появлению символов 0123456789. Тогда aи bсвязаны @ и [, уступая символы ABCDEFGHIJKLMNOPQRSTUVWXYZи так далее.

Perl (5,10 или 5,12), 30 29 байт

Эта программа состоит в основном из непечатаемых символов, поэтому вот hexdump:

00000000: 5f 3d 7e 7e 22 d7 c0 84 8c 9e 86 df 9e d1 d1 85 _=~~"...........
00000010: d3 be d1 d1 a5 d3 cf d1 d1 c6 82 d6 22          ............"

Эта программа очень проста: мы regexing ( =~) подчеркивание ( _; спасибо @Dennis за указание, что это работает) против регулярного выражения. Регулярное выражение указывается как выражение, а не буквально; в частности, мы берем побитовое дополнение ( ~) строки. Обращая побитовое дополнение, чтобы получить базовую строку, мы получаем следующее выполняемое регулярное выражение:

(?{say a..z,A..Z,0..9})

В версиях Perl 5.10 и 5.12 (?{…})синтаксис представлял собой экспериментальный синтаксис, позволяющий регулярным выражениям запускать произвольный код во время выполнения. В этом случае мы используем его для запуска простой Perl-программы для вывода желаемого результата. (Версии ранее 5.10 не могут быть использованы, потому что они не имеют say.)

Современные версии Perl (?{…})по умолчанию отключены по соображениям безопасности, но если у вас есть такая версия Perl, вы можете отключить проверку (и, следовательно, запустить эту программу) через -Mre=evalаргумент командной строки (вместе со стандартом, -M5.010который определяет версию). языка для реализации, и который не считается против byountount).

На самом деле 8 5 4 байта

'>┘▀

Как это устроено:

 '>    Pushes > onto the stack as a string
           STACK: [>]
    ┘  Converts the top item of the stack to it's ordinal
           STACK: [62]
     ▀ Push all digits from base n(top item of the stack)
           STACK: [012...xyz]

Печать неявно в конце программы.

Редактировать 1: Заменено размещение алфавита в нижнем / верхнем регистре, а затем в диапазоне чисел (10) с получением только печатаемых символов базы 62.

Изменить 2: изменил ">" на '> благодаря Mego :) сохранил 1 байт.

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

PHP, 69 байт

<?=~"ÏÎÍÌËÊÉÈÇƾ½¼»º¹¸·¶µ´³²±°¯®­¬«ª©¨§¦¥žœ›š™˜—–•”“’‘ŽŒ‹Š‰ˆ‡†…";

Код стилизован под Windows-1252 здесь. Ниже приведен обратимый xxd hexdump.

00000000: 3c 3f 3d 7e 22 cf ce cd cc cb ca c9 c8 c7 c6 be  <?=~"...........
00000010: bd bc bb ba b9 b8 b7 b6 b5 b4 b3 b2 b1 b0 af ae  ................
00000020: ad ac ab aa a9 a8 a7 a6 a5 9e 9d 9c 9b 9a 99 98  ................
00000030: 97 96 95 94 93 92 91 90 8f 8e 8d 8c 8b 8a 89 88  ................
00000040: 87 86 85 22 3b                                   ...";

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

Java (OpenJDK 9) , 277 байт

Да, Java, ты хорошо это читаешь!

$->""+($='='+'=')+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+($='-'+'-')+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+($='_'-'&')+--$+--$+--$+--$+--$+--$+--$+--$+--$

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

Это печатает диапазоны, но в обратном порядке, так как порядок не имеет значения.

zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

Я играл на отсутствии правила «без ввода», чтобы неявно определить, charчто необходимо для того, чтобы все это работало. Если это обман, пожалуйста, так и скажи.

Ungolfed & тестирование

public class PCG105781 {
  interface X { String apply(char x); }

  public static void main(String[] args) {
    X x = $
        -> "" // Force the result as a String.
        // The line below appends "zyxwvutsrqponmlkjihgfedcba"
        // '=' + '=' is 122 as int. $=122 casts 122 as a char, 'z'
        + ($ = '=' + '=') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
        // The line below appends "ZYXWVUTSRQPONMLKJIHGFEDCBA"
        // '-' + '-' is 90 as int. $=90 casts 90 as a char, 'Z'
        + ($ = '-' + '-') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
        // The line below appends "9876543210"
        // '_' - '&' is 57 as int. $=57 casts 57 as a char, '9'
        + ($ = '_' - '&') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
      ;

    System.out.println(x.apply('_'));
  }
}

Brainfuck, 89 85 байт

Поскольку мозговой трафик в любом случае игнорирует буквенно-цифровые символы, это просто проблема с постоянным выводом ... (Редактировать: См. Решение Денниса для версии, которая на 10 байт короче)

+[-[--<]>>--]++++++++++[<+.>-]<++++++++>+[-[---<]>>-]<-<<+++++[>+++++<-]>+[>.+<<<.+>>-]

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

Этот код является хорошим примером основных подсчитанных циклов в brainfuck:

+[-[--<]>>--]   Create value 47: char just before '0'
++++++++++      Set adjacent cell to 10: to be used as a counter

[               While the counter is not 0:
 <+.              Increment and print the char
    >-            Decrement the counter
       ]        (End loop: Exits when all digits have been printed)


<++++++++>           The char is now at '9' so add 8 to make it 'A'
+[-[---<]>>-]<-      In another cell create lowercase 'a'
<<+++++[>+++++<-]>+  Create 26: the number of times to loop

[                While the counter is not 0:
 >.+               Print and increment the lowercase char
    <<<.+          Print and increment the uppercase char
         >>-       Decrement the counter
            ]    (End loop: Exits when all letters have been printed)

Обратите внимание, что для создания чисел используются сочетания клавиш, что означает, что интерпретатору необходимо иметь 8-разрядные ячейки переноса (например, ту, с которой я связан).

JavaScript (ES6), 983 байта

Оказывается, в ES6 есть много символов, которые вы можете использовать в именах переменных JavaScript ! Прекрасно работает после того, как вы исчерпали шесть имен байтов по 1-2 байта с помощью $и _.

_=~[]
$={}
Á=++_
À=![]+""
Â=À[_]
Ã=++_
Ä=À[_]
Å=++_
Æ=($+"")[_]
Ç=(_[_]+"")[_]
È=++_
É=(!""+"")[_]
Ë=++_
Ì=++_
Ê=($+"")[_]
Í=++_
µ=++_
Î=++_
Ï=++_
_="\\"
Ð=$.$
È_=(!""+"")[Ã]
Å_=$+""
Ñ=Å_[Ã]
Ò=(Ð+"")[Ã]
__=Å_[Í]
Ó=(!""+"")[Å]
$_=Å_[Ì]+Ñ+Ò+(!$+"")[È]+__+È_+Ó+Å_[Ì]+__+Ñ+È_
$$=È_+(!""+"")[È]+__+Ó+È_+Ò
$=Á[$_][$_]
$($($$+"\""+Ê+Ñ+_+Ã+Ì+Í+_+Ã+Í+È+Ñ+À[Å]+É+"."+À[Å]+Ñ+_+Ã+Ë+µ+"('"+Ä+Æ+Ê+Ç+É+Â+_+Ã+Ë+µ+_+Ã+Ì+Á+_+Ã+Ì+Ã+_+Ã+Ì+Å+_+Ã+Ì+È+À[Å]+_+Ã+Ì+Ì+_+Ã+Ì+Í+Ñ+_+Ã+Í+Á+_+Ã+Í+Ã+_+Ã+Í+Å+_+Ã+Í+È+__+Ó+_+Ã+Í+Í+_+Ã+Í+µ+_+Ã+µ+Á+_+Ã+µ+Ã+_+Ã+µ+Å+_+Ã+Á+Ã+_+Ã+Á+Å+_+Ã+Á+È+_+Ã+Á+Ë+_+Ã+Á+Ì+_+Ã+Á+Í+_+Ã+Á+µ+_+Ã+Ã+Á+_+Ã+Ã+Ã+_+Ã+Ã+Å+_+Ã+Ã+È+_+Ã+Ã+Ë+_+Ã+Ã+Ì+_+Ã+Ã+Í+_+Ã+Ã+µ+_+Ã+Å+Á+_+Ã+Å+Ã+_+Ã+Å+Å+_+Ã+Å+È+_+Ã+Å+Ë+_+Ã+Å+Ì+_+Ã+Å+Í+_+Ã+Å+µ+_+Ã+È+Á+_+Ã+È+Ã+_+Ã+È+Å+Ã+Å+È+Ë+Ì+Í+µ+Î+Ï+Á+"')\"")())()

JavaScript, 1223 байта

Это был мой ответ, прежде чем я узнал об этом.

_=~[]
$={}
___=++_
____=![]+""
$$$$=____[_]
__$=++_
$_$_=____[_]
_$_=++_
$_$$=($+"")[_]
$$_$=(_[_]+"")[_]
_$$=++_
$$$_=(!""+"")[_]
$__=++_
$_$=++_
$$__=($+"")[_]
$$_=++_
$$$=++_
$___=++_
$__$=++_
_="\\"
_$_$=$.$
_$$_=(!""+"")[__$]
_$__=$+""
_$=_$__[__$]
__$_=(_$_$+"")[__$]
__=_$__[$$_]
___$=(!""+"")[_$_]
$_=_$__[$_$]+_$+__$_+(!$+"")[_$$]+__+_$$_+___$+_$__[$_$]+__+_$+_$$_
$$=_$$_+(!""+"")[_$$]+__+___$+_$$_+__$_
$=___[$_][$_]
$($($$+"\""+$$__+_$+_+__$+$_$+$$_+_+__$+$$_+_$$+_$+____[_$_]+$$$_+"."+____[_$_]+_$+_+__$+$__+$$$+"('"+$_$_+$_$$+$$__+$$_$+$$$_+$$$$+_+__$+$__+$$$+_+__$+$_$+___+_+__$+$_$+__$+_+__$+$_$+_$_+_+__$+$_$+_$$+____[_$_]+_+__$+$_$+$_$+_+__$+$_$+$$_+_$+_+__$+$$_+___+_+__$+$$_+__$+_+__$+$$_+_$_+_+__$+$$_+_$$+__+___$+_+__$+$$_+$$_+_+__$+$$_+$$$+_+__$+$$$+___+_+__$+$$$+__$+_+__$+$$$+_$_+_+__$+___+__$+_+__$+___+_$_+_+__$+___+_$$+_+__$+___+$__+_+__$+___+$_$+_+__$+___+$$_+_+__$+___+$$$+_+__$+__$+___+_+__$+__$+__$+_+__$+__$+_$_+_+__$+__$+_$$+_+__$+__$+$__+_+__$+__$+$_$+_+__$+__$+$$_+_+__$+__$+$$$+_+__$+_$_+___+_+__$+_$_+__$+_+__$+_$_+_$_+_+__$+_$_+_$$+_+__$+_$_+$__+_+__$+_$_+$_$+_+__$+_$_+$$_+_+__$+_$_+$$$+_+__$+_$$+___+_+__$+_$$+__$+_+__$+_$$+_$_+__$+_$_+_$$+$__+$_$+$$_+$$$+$___+$__$+___+"')\"")())()

Я пробежал console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')через jjencode и вручную показал результат. Есть определенно больше оптимизаций, которые можно сделать.

Befunge, 73 72 59 57 55 53 байта

"{"< ^+`"`"\+*`\":"\`"/":\*`\"["\`"@":::::-!!
#@_^,_!

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

Это один цикл с обратным отсчетом {(т. Е. Один символ после z). На первой итерации "{"<последовательность помещает две копии {в стек: одна является начальным счетчиком цикла, а другая используется для уменьшения этого счетчика с помощью последовательности !!-(две операции NOT делают 1, а затем вычитают). На последующих итерациях счетчик цикла уже находится в стеке, поэтому {для настройки последовательности декремента требуется только одна .

Остальная часть кода - это просто длинное логическое выражение, вычисляющее, находится ли символ в диапазоне. Если это так, ветвь во второй строке разделяется влево, чтобы вывести значение. Если нет, то правильная ветвь оборачивается, чтобы проверить, достигли ли мы нуля и должны ли завершиться. Две ветви сливаются в середине, чтобы подняться и повторить цикл. Обратите внимание, что все команды вертикального направления идут вверх, поскольку мы не можем использовать a v, но это нормально, потому что указатель инструкции автоматически переносится в верхнюю часть игрового поля.

Спасибо Мисте Фиггинсу за то, что он изначально придумал лучшую технику для увеличения цикла.

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

Желе , 17 16 байт

“:[{“/@`‘Ḷḟ"/ỌḊ€

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

Как это устроено

“:[{“/@`‘Ḷḟ"/ỌḊ€  Main link. No arguments.

“:[{“/@`‘         Yield [[58, 91, 123], [47, 64, 96]].
         Ḷ        Unlength; map each n to [0, ..., n-1].
          ḟ"/     Reduce by vectorizing filter-false.
                  This yields [[47, ..., 57], [64, ..., 90], [96, ..., 122]].
             Ọ    Unordinal; replace each n with the corr. Unicode character.
              Ḋ€  Deqeue each; remove the first character of each of the three
                  generated strings ('/', '@', and '`').

Самомодифицирующийся Brainfuck , 32 байта

<[-<+.>]<<[-<+.>]<<[-<+.>]`@/

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

xxd -rобратимый hexdump (содержит непечатаемые):

00000000: 3c5b 2d3c 2b2e 3e5d 3c3c 5b2d 3c2b 2e3e  <[-<+.>]<<[-<+.>
00000010: 5d3c 3c5b 2d3c 2b2e 3e5d 601a 401a 2f0a  ]<<[-<+.>]`.@./.

C, 128 байтов

Да, C. И это даже короче, чем некоторые из эзотерических.

__($$,_,$,_$,$_){$>_$?_$=_$?!$:$,$=*(""-_+$_++)&*"{":_;_$?*(""-_+$$++)=$++:_;$&&__($$,_,$,_$,$_);}_(_){__(_,"",_,!!_,"½´ÞÅþå");}

Вызовите _достаточно большой пустой char *буфер.

_{Может быть, крошечный бит зависит от компилятора. Протестировано с использованием GCC; файл был сохранен в кодовой странице 1252.}

JavaScript (ES6), 812 745 657 650 536 520 416 байт

(À=(Á=!($={})+(Ø=""))[Â=_=+[]],Ã=(Ä=!_+Ø)[Å=++_],Æ=(Ç=$+Ø)[_],È=(É=$.$+Ø)[_],Ê=Ä[Ë=++_],Ì=Ä[Í=++_],Î=++_,Ï=Ç[Ð=++_],Ñ=Ç[Ò=++_],Ó=++_,$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô],$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)()))

Изменить: Используя кодировку ISO8859-1, это решение составляет 416 байт вместо 520 байт. Полная программа составляет 432 байта, с учетом дополнительных 16 байтов для

f=\r\n
416 byte submission here\r\n
alert(f())

Это функция представления, а не полная программа. Я потратил довольно много времени на игру в гольф JJEncode (хет- кон к darrylyeo для этого), но вместо игры в гольф

console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

Я играл в гольф

for($ of[[48,58],[65,91],[97,123]])for(_=$[0];_<$[1];)Ø+=String.fromCharCode(_++);return Ø

где Øинициализируется ""в накладные расходы.

Переписано с запятыми операторами, преобразованными в новые строки:

À=(Á=!($={})+(Ø=""))[Â=_=+[]]
Ã=(Ä=!_+Ø)[Å=++_]
Æ=(Ç=$+Ø)[_]
È=(É=$.$+Ø)[_]
Ê=Ä[Ë=++_]
Ì=Ä[Í=++_]
Î=++_
Ï=Ç[Ð=++_]
Ñ=Ç[Ò=++_]
Ó=++_
$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô]
// function that returns string
$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)())

объяснение

Этот скрипт начинается с инициализации нескольких встроенных типов и преобразования их в строки. Строки, которые мы можем получить без использования буквенно-цифровых символов:

{}+""     -> "[object Object]"
!{}+""    -> "false"
!+[]+""   -> "true"
{}[{}]+"" -> "undefined"

Из этих строк и необходимых цифр для ссылки на отдельные символы мы можем получить строки returnи constructor, которые можно использовать так:

$={}[Ô="constructor"][Ô]
$(("return"+`"encoded script"`)())

Конструктор объекта есть Object(), а его конструктор есть Function(), который мы можем использовать по существу как eval().

В этом случае выполняемый кодированный скрипт представляет собой вложенные forциклы, объединяющие все буквенно-цифровые символы в строку с использованием их кодовых точек и возвращающие ее.

Для алфавитных символов в закодированном скрипте, к которым нельзя получить доступ с помощью встроенных модулей, JJEncode использует восьмеричные экранированные символы для их представления, а затем декодирует всю строку, возвращая ее из внутренней функции. Внешняя функция затем может быть вызвана для выполнения источника.

демонстрация

f=
(À=(Á=!($={})+(Ø=""))[Â=_=+[]],Ã=(Ä=!_+Ø)[Å=++_],Æ=(Ç=$+Ø)[_],È=(É=$.$+Ø)[_],Ê=Ä[Ë=++_],Ì=Ä[Í=++_],Î=++_,Ï=Ç[Ð=++_],Ñ=Ç[Ò=++_],Ó=++_,$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô],$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)()))
console.log(f())

Brain-Flak , 171 байт

Включает +3 для -A

(((((()()()){}){}){}){})(((()()())){}{}){({}[()]<(({})())>)}{}(({})(()()()()){})(((((()()()){}){}){}())<{({}[()]<(({})())>)}{}(({})(()()()){}())>){({}[()]<(({})())>)}{}

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

(((((()()()){}){}){}){}) # push 48
(((()()())){}{})         # push 9
{({}[()]<                # for 9..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for
(({})(()()()()){})       # pop a, push a, push a + 8
(((((()()()){}){}){}())< # push 26 and save a 26 for later
{({}[()]<                # for 26..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for
(({})(()()()){}())       # pop a, push a, push a + 7
>)                       # push that 26 that we held
{({}[()]<                # for 26..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for

Вероятно, есть способ сделать это без необходимости повторения «функции 1» add.

Юлия 0,4 , 46 байт

_()=['¥':'®';'¶':'Ï';'Ö':'ï'].-['~'-'	']

Это универсальная функция, которая возвращает массив символов.

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

Альтернативная версия, 47 байтов, только ASCII

_(_=_==_)=['/'+_:':'-_;'@'+_:'['-_;'`'+_:'{'-_]

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

J, 171 байт

(+:>.+:^^*_){.".(':',~(+:+:>.^*_){(*:>.^*_)!:(+:<.^+:*_)''),',',(":(>:*:+:+:+:*_),(<.^<:^<:^*_),<:*:<.^+:*_),'+/',('.',~(+:<.+:^*_){(*:>.^*_)!:(+:<.^+:*_)''),":+:<.*:>:^*_

Ой ... мой мозг болит ... Попробуй онлайн!

Вот так вы можете увидеть все это одной строкой (хотя она не будет работать с переносами строк).

(+:>.+:^^*_){.".(':',~(+:+:>.^*_){(*:>.^*_)!:(+:<.^+:*_)''),',',(":(>:*:+:+:+:*_),(<.^<:^<:^*
_),<:*:<.^+:*_),'+/',('.',~(+:<.+:^*_){(*:>.^*_)!:(+:<.^+:*_)''),":+:<.*:>:^*_

Гарантируется работа только с J-версией j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52в указанном порядке. (Только первые 12 символов имеют значение.)

объяснение

Большая часть программы посвящена постоянному поколению. С заменой этих констант на их значения программа выглядит так:

(62){.".(':',~(12){(9)!:(14)''),',',(":(65),(97),48),'+/',('.',~(10){(9)!:(14)''),":26

С некоторыми скобками удалены, а некоторые числа стали лучше:

62{.".(':',~12{9!:14''),',',(":65 97 48),'+/',('.',~10{9!:14''),":26

Это состоит из группы ,и ,~s, которые добавляют и дополняют аргументы. Вот отдельные значения:

1. ":26
2. ('.',~10{9!:14'')
3. '+/'
4. (":65 97 48)
5. ','
6. (':',~12{9!:14'')

1это 26как строка.

9!:14'' генерирует следующую строку в TIO:

j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52

с 2, мы получаем 10th-й символ ( iиз linux) и добавляем в .его конец, получая i..

3и 5говорят сами за себя.

4список чисел 65 97 48в виде строки

6аналогично 2, за исключением того, что это 12символ th ( ufrom linux) и добавляет :в конец, уступая u:.

Это все вместе дает u:,65 97 48+/i.26. ".оценивает это, давая нам:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:;<=>?@ABCDEFGHI

(Примечание: +/это табличное дополнение.)

Затем, с помощью 62{., мы берем первые 62символы из этого, давая нам ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.

05AB1E , 18 15 11 байт

-4 благодаря Adnan, потому что если размер ввода равен 1, 05AB1E будет использовать 0 для b в первой команде.

•£•Ýç©á®þ«˜

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

•£•Ÿ            # Push [0..122] using implicit 0 and the base-214 of `£`.
    ç           # Convert to ASCII chars.
     ©          # Store full array in register.
      á         # Push the same array with ONLY letters.
       ®        # Push contents of register (char)[0..122].
        þ       # Push only the digits.
         «˜     # Concat to list, flatten it. 

Я пробовал так много разных подходов, но ключевые моменты, которые усложнили:

- Basic commands will not work, only extended and a select few of the basics.
- Extended commands are pretty complex.
- Eval (.V) will not work.
- To push numbers you can do a base 214 compression.
- ALL sequence pushes (E.G. žK) won't work.
- ALL number pushes won't work, except for compression and the -1 an empty register pushes.

Brainfuck, 55 байтов

+++[[<+>->++<]>]<<[-<->]<<<<++[->>+.>+.<<<]<--[->>.+<<]

Выход:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789

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

Инициализирует ленту до 3 · 2 ⁿ и работает оттуда.

+++[[<+>->++<]>]    initialize the tape
                    |   0 |   3 |   6 |  12 |  24 |  48 |  96 | 192 | 128 |   0 |   0 |
                                                                                    ^
<<[-<->]            subract 128 from 192
                    |   0 |   3 |   6 |  12 |  24 |  48 |  96 |  64 |   0 |   0 |   0 |
                                                                        ^
<<<<++              increment 24 twice
                    |   0 |   3 |   6 |  12 |  26 |  48 |  96 |  64 |   0 |   0 |   0 |
                                                ^
[->>+.>+.<<<]       output aAbBcC ~ zZ
                    |   0 |   3 |   6 |  12 |   0 |  48 | 122 |  90 |   0 |   0 |   0 |
                                                ^
<--[->>.+<<]        decrement 12 twice; output 0 ~ 9
                    |   0 |   3 |   6 |   0 |   0 |  58 | 122 |  90 |   0 |   0 |   0 |
                                          ^

Perl 6 , 43 байта - неконкурентоспособен

{|('`'^..^'{'),|('@'^..^'['),|('/'^..^':')}

Лямбда, которая возвращает список символов.
Объяснение:

   '`'                                       # The character before "a" (in Unicode order)
          '{'                                # The character after "z"
      ^..^                                   # Endpoint-exclusive range between them
 |(          )                               # Slip the range into the outer list
               |('@'^..^'[')                 # Same thing for "A" to "Z"
                             |('/'^..^':')}  # Same thing for "0" to "9"

Зависит от исправления в интерпретаторе Rakudo Perl 6, который был связан только с git repo сегодня и пока не является частью официального релиза Rakudo. Фактически, я столкнулся с ошибкой, отвечая на этот вызов, и мне удалось исправить ее с помощью одного из разработчиков ядра Perl 6. Правила этого сайта, насколько я понимаю, не позволяют ответам конкурировать в такой ситуации, поэтому я отметил их как неконкурентные.

PHP 7.0+, 110 байт

Да благословит Бог побитовые струны!

<?=($__='`@`@'^'*/).')(($_='->.<:'^'__@[_')('>'^_,'%'^_)),$__($_('|'^'=','|'^'&')),$__($_(':'^"\n",';'^']'^_));

Замените \nреальным символом новой строки * NIX.
Он присутствует в коде, чтобы избежать проблем с переводом строки, но не учитывается в счете.

Это создает кучу предупреждений, но они могут быть подавлены добавлением @перед каждым заблудшим _.

Предупреждение свободно , 113 байт

<?=($__='`@`@'^'*/).')(($_='->.<:'^'__@[_')('>'^@_,'%'^@_)),$__($_('|'^'=','|'^'&')),$__($_(':'^"\n",';'^']'^@_));

65c02 машинный язык + Apple] [ROM, 25 байт

A9 E0 20 0F 80 A9 C0 20 0F 80 A2 0A A9 AF 2C A2 1A 1A 20 ED FD CA D0 F9 60

Печать abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.

Должен начинаться с $8000.

разборка

8000-   A9 E1       LDA   #$E0
8002-   20 0F 80    JSR   $800F
8005-   A9 C1       LDA   #$C0
8007-   20 0F 80    JSR   $800F
800A-   A2 0A       LDX   #$0A
800C-   A9 B0       LDA   #$AF
800E-   2C          HEX   2C     ; SKIPS NEXT 2 BYTES
800F-   A2 1A       LDX   #$1A
8011    1A          INC   
8012-   20 ED FD    JSR   $FDED
8015-   CA          DEX   
8016-   D0 F9       BNE   $8011
8018-   60          RTS   

Bash (на Linux), 507 493 490 485 байт

это хранит массив символов в глобальной переменной __

: {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_
__=(/????/????/??/??)
___=${__%??}
__=(${__[@]#$___?})
____=${___#/*/?}
____=${____%?/*/}
_____=${____%?}
____=${____#?}
___=${___%??/}
______=($___*_??)
______=${______#$___???????}
______=${______%??_*}
_______=($___$_____???*)
_______=${_______#$___??}
_______=${_______%????}
___=$#
___=$((++___))$((___+++++___+___--))$___
$_____$_______$______$____{,} ___="\({$______..$'\\$___'}\)"
__=(${__[@]} ${___[@]} ${___[@]^})

это должно быть выполнено на недавно загруженной машине linux с /proc, или чем-то вроде пространства имен pid

объяснение:

# {var}>file opens a file descriptor >= 10 to that file
: {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_
# at startup no pid is > 999 so there's no other /proc/pid/fd/??
__=(/????/????/??/??)                                 # /proc/self/fd/1[0-9]
___=${__%??}                                          # /proc/self/fd/
__=(${__[@]#$___?})                                   # {0..9}
____=${___#/*/?}                                      # elf/fd/
____=${____%?/*/}                                     # el
_____=${____%?}                                       # e
____=${____#?}                                        # l
___=${___%??/}                                        # /proc/self/
______=($___*_??)                                     # /proc/self/timerslack_ns
______=${______#$___???????}                          # ack_ns
______=${______%??_*}                                 # a
_______=($___$_____???*)                              # /proc/self/environ
_______=${_______#$___??}                             # viron
_______=${_______%????}                               # v

___=$#                                                # 0
___=$((++___))$((___+++++___+___--))$___              # 172 (z in octal)

# eval eval                   ___="\({a..$'\172'}\)"
$_____$_______$______$____{,} ___="\({$______..$'\\$___'}\)"
#   {0..9}   {a..z}    {A..Z}
__=(${__[@]} ${___[@]} ${___[@]^})

чтобы попробовать это мы можем добавить declare -p __в конце, чтобы отобразить результат

$ sudo unshare --fork --pid --mount-proc bash golf
declare -a __=([0]="0" [1]="1" [2]="2" [3]="3" [4]="4" [5]="5" [6]="6" [7]="7" [8]="8" [9]="9" [10]="a" [11]="b" [12]="c" [13]="d" [14]="e" [15]="f" [16]="g" [17]="h" [18]="i" [19]="j" [20]="k" [21]="l" [22]="m" [23]="n" [24]="o" [25]="p" [26]="q" [27]="r" [28]="s" [29]="t" [30]="u" [31]="v" [32]="w" [33]="x" [34]="y" [35]="z" [36]="A" [37]="B" [38]="C" [39]="D" [40]="E" [41]="F" [42]="G" [43]="H" [44]="I" [45]="J" [46]="K" [47]="L" [48]="M" [49]="N" [50]="O" [51]="P" [52]="Q" [53]="R" [54]="S" [55]="T" [56]="U" [57]="V" [58]="W" [59]="X" [60]="Y" [61]="Z")

Javascript, 1273 1351 1610 байтов

Это решение работает практически так же, как и другие два ответ на эту тему здесь и здесь , где он использует букву из true, false, undefinedи [object Object]строк для создания функций , которые он должен генерировать другие буквы.

Поскольку большое количество букв уже введено в объект, я попытался добавить все оставшиеся крошечные буквы и цифры к объекту, а затем применил toUpperCaseко всем значениям в объекте, чтобы сгенерировать пропущенные большие буквы.

Обновить:

Мне удалось улучшить способ установки восьмеричных значений, но они по-прежнему занимают 13 х 30 байт (или они будут 30 байт каждый после того, как я изменю числа на разные ключи), теперь каждый из них следует этому общему правилу. картина: $.ž=\'\\'+$.一+$.七+$.二+'\';.

Дополнительные 49 байтов можно легко извлечь, переключив клавиши для цифр на 2 байта.

Текущее представление:

$=~[];_={ť:!""+"",ň:![]+"",û:$._+'',ô:{}+"",ø:''};$={零:++$,ƒ:_.ň[$],ť:_.ť[$],一:++$,â:_.ň[$],ř:_.ť[$],ô:_.ô[$],ň:_.û[$],二:++$,ľ:_.ň[$],û:_.ť[$],ƅ:_.ô[$],ď:_.û[$],三:++$,ŝ:_.ň[$],ĵ:_.ô[$],四:++$,ě:_.ň[$],五:++$,ĉ:_.ô[$],î:_.û[$],六:++$,七:++$,八:++$,Ô:_.ô[$],九:++$};_.ĉ=$.ĉ+$.ô+$.ň+$.ŝ+$.ť+$.ř+$.û+$.ĉ+$.ť+$.ô+$.ř;_.ř=$.ř+$.ě+$.ť+$.û+$.ř+$.ň;_.ƒ=(0)[_.ĉ][_.ĉ];_.ƒ(_.ƒ(_.ř+' "$.Û=\'\\'+$.一+$.二+$.五+'\';$.Ĉ=\'\\'+$.一+$.零+$.三+'\';$.Ě=\'\\'+$.一+$.零+$.五+'\';$.ĝ=\'\\'+$.一+$.四+$.七+'\';$.ĥ=\'\\'+$.一+$.五+$.零+'\';$.ǩ=\'\\'+$.一+$.五+$.三+'\';$.ӎ=\'\\'+$.一+$.五+$.五+'\';$.ƥ=\'\\'+$.一+$.六+$.零+'\';$.ǫ=\'\\'+$.一+$.六+$.一+'\';$.ư=\'\\'+$.一+$.六+$.六+'\';$.ŵ=\'\\'+$.一+$.六+$.七+'\';$.ӽ=\'\\'+$.一+$.七+$.零+'\';$.ŷ=\'\\'+$.一+$.七+$.一+'\';$.ž=\'\\'+$.一+$.七+$.二+'\';"')())();_.ƒ(_.ƒ(_.ř+' "_.â=\''+$.Ô+$.ƅ+$.ĵ+$.ě+$.ĉ+$.ť+'.'+$.ǩ+$.ě+$.ŷ+$.ŝ+'($).'+$.ƒ+$.ô+$.ř+$.Ě+$.â+$.ĉ+$.ĥ+'\';_.ƅ=\''+$.ť+$.ô+$.Û+$.ƥ+$.ƥ+$.ě+$.ř+$.Ĉ+$.â+$.ŝ+$.ě+'\';"')())();_.ƒ(_.ƒ(_.ř+' "'+_.â+'((ǩ)=>{$[ǩ.'+_.ƅ+"()]=($[ǩ]+'')."+_.ƅ+"()});"+_.â+"((ǩ)=>{_.ø+=$[ǩ];});"+$.â+$.ľ+$.ě+$.ř+$.ť+'(_.ø);"')())()

C (лязг) , 164 байта

é,ú,í,ó;_(*$){ú-=ú;ú++;í=ú+ú;ó=í<<í*í<<ú;!é?é++,é<<=í*í+ú,é+=í<<í+ú:é;*$++=é++;é+=é==ó-(í*í+í)?(í<<í)-ú:ú-ú;é+=é==ó+(í<<í<<í)-í*í-ú?í*í+í:ú-ú;é<í*ó-(í*í)-ú?_($):ú;}

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

Это рекурсивная функция, которая получает символы, начиная со значения 1 (вычитая из себя и увеличивая), и создавая все остальные числа из этого.

Ungolfed / Explaination:

é,ú,í,ó;
_(*$){ //function "_" taking a pointer "$"
	ú-=ú;ú++; //constant ú=1
	í=ú+ú; //constant í=2
	ó=í<<í*í<<ú; //constant ó=64
	!é?é++,é<<=í*í+ú,é+=í<<í+ú:é; //if é isn't initialized, seek to character '0'
	*$++=é++; //write to string and increase string index
	é+=é==ó-(í*í+í)?(í<<í)-ú:ú-ú; //skip to 'A'
	é+=é==ó+(í<<í<<í)-í*í-ú?í*í+í:ú-ú; //skip to 'a'
	é<í*ó-(í*í)-ú?_($):ú; //keep recursing until end of alphabet
}

CJam , 15 байтов

"{`[@:/"_:,:^\-

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

объяснение

"{`[@:/" e# Push this string. Note that these are the characters just above and
         e# below the a-z, A-Z and 0-9 ranges, respectively.
_        e# Get a copy of the string.
:,       e# Turn each character into a range, i.e. all characters from the null byte
         e# to the the character below the given one. E.g. { is turned into "...xyz".
:^       e# Fold symmetric set difference over the list. Gives us the characters that
         e# appear in an odd number of the strings. Those are the letters, the digits
         e# as well as `, @ and /.
\        e# Pull the other copy of the string on top.
-        e# Remove these characters from the string. That leaves only the alphanumerics.

𝔼𝕊𝕄𝕚𝕟, 8 символов / 19 байтов

ᶐ+ᶛ+⩥Ⅹă⬯

Попробуй это здесь!

ᶐалфавит в верхнем регистре, алфавит ᶛв нижнем регистре и ⩥Ⅹă⬯диапазон ( ⩥) от 0до 10( Ⅹминус римская цифра в юникоде) минус 1, соединенный с ( ă) ничем ( ⬯).