Виклик

Роздрукуйте наступні символи:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890

Привід полягає в тому, що ви не можете використовувати жоден із них у своєму коді.

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

Правила

• Ви не можете використовувати жодних символів із зазначеного вище набору
• Ви можете використовувати будь-які інші символи
• Жодного обману
• Стандартні лазівки заборонені
• Це кодовий гольф , виграє найкоротша відповідь.

Роз'яснення

• Якщо у вашій мові використовується інша діаграма, ви не можете використовувати в цьому коді точкові коди, які відповідають буквено-цифровим символам.
• Повернення рядка з функції вважається допустимою формою виводу.
• Ви можете повернути масив char.

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

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

Функція, яка повертає масив char. Програма, яка видає лише символи, становить 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 $ 0a 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 ОРА №20
$ 0614 8d 1a 06 STA $ 061a
$ 0617 8d 1c 06 STA $ 061c
$ 061a ea NOP 
$ 061b на обклад 
$ 061c ea NOP 
$ 061d a8 ТАЙН 
$ 061e a9 00 LDA # $ 00
$ 0620 ea NOP 
$ 0621 ea NOP 
0622 доларів 98 тис. Грн 
$ 0623 ea NOP 
$ 0624 8а TXA 
$ 0625 ea NOP 
$ 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 
$ 063е 98 тис. Дол 
$ 063f 95 00 STA $ 00, X
$ 0641 c8 INY 
$ 0642 c4 80 CPY $ 80
$ 0644 d0 f7 BNE $ 063d
$ 0646 60 RTS

Машиномовний код самовиправляється. Для маніпуляції зі стеком мені потрібно було використовувати 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 байт

Ця програма складається в основному з недрукованих символів, тому ось шістнадцятковий набір:

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          ............"

Ця програма дуже проста: ми повторно виражаємо =~підкреслення ( _; дякуємо @Dennis, що вказали, що це працює) проти регулярного вираження. Режекс задається як вираз, а не буквально; конкретно, ми беремо побітове доповнення ( ~) рядка. Повернувши побітове доповнення для отримання в нижній рядку, ми отримаємо наступний регулярний вираз, який виконується:

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

У версіях Perl 5.10 та 5.12 (?{…})синтаксис був експериментальним синтаксисом, що дозволяє регулярним виразам запускати довільний код під час виконання. У цьому випадку ми використовуємо його для запуску прямої програми Perl для друку потрібного виводу. (Версії раніше 5.10 не можна використовувати, оскільки їх немає say.)

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

Насправді 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 шестигранник.

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 байт

Так, Ява, ти це добре читаєш!

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

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

Це друкує діапазони, але зворотні, оскільки порядок не має значення.

zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

Я грав на відсутності правила "без введення", щоб неявно визначити, charщо потрібно для роботи всієї справи. Якщо це обман, скажіть так.

Невикористані та тестування

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 байт

Оскільки brainfuck ігнорує буквено-цифрові символи так чи інакше, це лише виклик постійного виходу ... (Редагувати: Див . Рішення Деніса для версії, яка на 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, але це добре, оскільки вказівник інструкції автоматично загортається у верхній частині поля.

Завдяки Mistah Figgins за те, що спочатку придумав кращу техніку для збільшення петлі.

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

Желе , 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-оборотний гекс-дамп (містить недруковані матеріали):

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

C, 128 байт

Так, С. І навіть коротше, ніж у кількох езотеричних.

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

Викличте _достатньо великий порожній 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())

Мозок-Флак , 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 "."

Джулія 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, отримуємо й- 10й символ ( iвід linux) і додаємо .до кінця його, поступаючись i..

3і 5є самостійними.

4перелік чисел 65 97 48у вигляді рядка.

6подібний 2, за винятком того, що він є 12символом ( uвід linux) і додає a :до кінця, поступаючись u:.

Це, все разом, дає результат u:,65 97 48+/i.26. ".оцінює це, даючи нам:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:;<=>?@ABCDEFGHI

(Примітка: +/додаток у таблиці.)

Тоді, з 62{., ми беремо перші 62символи з цього, даючи нам ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.

05AB1E , 18 15 11 байт

-4 завдяки Аднану, тому що якщо розмір вводу дорівнює 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 (віднімання від самоврядування та збільшення) та створює з цього всі інші числа.

Недоліковані / Пояснення:

é,ú,í,ó;
_(*$){ //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( Ⅹ, римська цифра unicode) мінус 1, приєднаний ( ă) нічого ( ⬯).