Tantangan

Cetak karakter berikut:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890

Tangkapannya adalah Anda tidak boleh menggunakan salah satu dari mereka dalam kode Anda.

Anda dapat mencetaknya dalam urutan sewenang-wenang, dengan atau tanpa baris awal atau akhir, tetapi Anda tidak dapat mencetak karakter lain.

Aturan

• Anda tidak boleh menggunakan karakter apa pun dari set yang disebutkan di atas
• Anda dapat menggunakan karakter lain
• Tidak selingkuh
• Celah standar dilarang
• Ini adalah kode-golf , jawaban terpendek menang.

Klarifikasi

• Jika bahasa Anda menggunakan rangkaian karakter yang berbeda, Anda tidak boleh menggunakan titik kode dalam rangkaian karakter yang sesuai dengan karakter alfanumerik.
• Mengembalikan string dari suatu fungsi dianggap sebagai bentuk output yang valid.
• Anda dapat mengembalikan array char.

V , 8 7 byte

1 byte disimpan berkat @DJMcMayhem dengan meletakkan semuanya dalam satu pernyataan regex

¬/{Ó×ü_

Cobalah online!

Output:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Catatan: ×ini tidak x atau X, itu adalah0xd7

Hexdump:

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

Penjelasan

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

Sekarang hasilnya terlihat seperti:

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

Kita harus menghapus semua karakter non-alfanumerik dan _(karena tidak termasuk dalam \W), jadi mari kita lakukan itu menggunakan regex

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

Oktaf , 52 46 40 byte

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

Ini mengevaluasi ke

9876543210ZYXWVUTSRQPONMLKJIHGFEDCBAabcdefghijklmnopqrstuvwxyz

Penjelasan

Di sini kita menggunakan fakta bahwa karakter secara implisit dikonversi ke bilangan bulat ketika operasi aritmatika suka +-atau fungsi rentang :diterapkan. Ketika digabungkan dengan string kosong ( [...,'']), angka-angka lagi dikonversi ke karakter.

Cobalah online!

brainfuck , 77 76 75 72 byte

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

Cobalah online!

Bagaimana itu bekerja

Penerjemah mulai dengan rekaman 0 sel.

++++++++

Ini menetapkan sel pertama ke 8 , meninggalkan rekaman dalam keadaan berikut.

   8
   ^

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

Ini menambah sel kedua satu kali, sel ketiga 6 kali, sel keempat 4 kali, mengurangi sel kelima sekali, kemudian kembali ke awal rekaman dan mengurangi sel pertama. Setelah 8 iterasi, rekaman itu terlihat seperti berikut.

  0   8  48  32  -8
  ^

>++

Kami maju ke sel kedua dan menambahkannya dua kali, bersiap-siap untuk mencetak digit.

  0  10  48  32  -8
      ^

[>.+<-]

Ini mencetak sel ketiga, menambahkannya, lalu kembali ke sel kedua dan menurunkannya. Setelah 10 iterasi, kami sudah mencetak 0123456789dan rekaman itu seperti berikut.

  0   0  58  32  -8
      ^

>>

Saatnya mempersiapkan kaset untuk surat-surat! Kita mulai dengan memajukan dua sel.

  0   0  58  32  -8   0   0
              ^

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

Ini menambah sel kelima satu kali, sel keenam dua kali, sel ketujuh tiga kali, kemudian kembali ke sel keempat dan menurunkannya. Setelah 32 iterasi, rekaman itu terlihat seperti berikut.

  0   0  58   0  24  64  96
              ^

>++

Sebagai langkah terakhir sebelum mencetak surat, kami naik ke sel kelima dan menambahkannya dua kali.

  0   0  58   0  26  64  96
                  ^

[>+.>+.<<-]

Akhirnya, kita naik ke sel ke enam untuk menambah dan mencetaknya, melakukan hal yang sama untuk sel ketujuh, lalu kembali ke sel kelima dan menurunkannya. Setelah 26 iterasi, kami sudah mencetak Aa...Zz.

Ruby, 42 byte

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

Fungsi yang mengembalikan array char. Program yang hanya menghasilkan karakter adalah 49 byte:

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

Ini hanya menggunakan karakter ascii di kedua sisi rentang yang relevan untuk menentukan rentang. Misalnya, ?/...?:berarti karakter antara garis miring ke depan dan titik dua, tidak termasuk bagian akhir. Untuk menghilangkan permulaan, kita kurangi array yang berisi tiga karakter awal.

6502 bahasa mesin, 74 70 68 byte

Hex dump (6502 program pada umumnya tidak dapat dipindahkan; kode di sini disimpan mulai dari lokasi $ 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

Anda dapat melihat bahwa ini tidak menggunakan byte yang dilarang: $ 41 hingga $ 5a, $ 61 hingga $ 7a, atau $ 30 hingga $ 39.

Ini adalah fungsi tanpa argumen yang, ketika dipanggil, mengembalikan pointer ke array karakter "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" di bagian atas tumpukan, sesuai dengan konvensi pemanggilan standar 6502.

Sebagai penjelasan, berikut ini adalah pembongkaran:

Address Hexdump Disassembly
-------------------------------
$ 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
$ 060d 8d 25 06 STA $ 0625
$ 0612 09 20 ORA # $ 20
$ 0614 8d 1a 06 STA $ 061a
$ 0617 8d 1c 06 STA $ 061c
$ 061a dan TIDAK 
$ 061b PAJAK 
$ 061c dan TIDAK 
$ 061d a8 TAY 
$ 061e a9 00 LDA # $ 00
$ 0620 ea NOP 
$ 0621 dan TIDAK 
$ 0622 98 TYA 
$ 0623 dan TIDAK 
$ 0624 8a TXA 
$ 0625 dan TIDAK 
$ 0626 a2 ff LDX # $ ff
$ 0628 a9 7b LDA # $ 7b
$ 062a a0 60 LDY # $ 60
$ 062c 20 3a 06 JSR $ 063a
$ 062d 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 
$ 063d 95 00 STA $ 00, X
$ 0641 c8 INY 
$ 0642 c4 80 CPY $ 80
$ 0644 d0 f7 BNE $ 063d
$ 0646 60 RTS

Kode bahasa mesin memodifikasi sendiri. Untuk manipulasi tumpukan, saya perlu menggunakan PHA dan PLA untuk mendorong dan mengeluarkan akumulator, tetapi instruksi ini memiliki opcodes $ 48 dan $ 68, yang dilarang (mereka adalah kode ASCII untuk huruf 'H' dan 'h'). Jadi, untuk PHA, saya mengambil angka $ 24, melakukan aritmatika bergeser ke kiri (ASL), dan menyimpan $ 48 yang dihasilkan di empat tempat dalam kode di mana ia perlu dijalankan. Kemudian, untuk PLA, saya menggunakan bitwise OR pada $ 48 di akumulator untuk menghitung $ 68, dan menyimpannya di dua tempat dalam kode di mana diperlukan.

Ada beberapa instruksi selain PHA dan PLA yang juga tidak bisa saya gunakan karena opcode mereka sama dengan huruf atau digit ASCII, tetapi saya menemukan solusi langsung untuk yang lain.

Array karakter yang diinginkan dihitung dan disimpan mulai dari lokasi 0 (tidak masalah di mana ia disimpan karena kita hanya perlu memastikan bahwa pointer ke itu dikembalikan ke atas tumpukan).

Anda dapat mencobanya di assembler dan emulator 6502 milik Nick Morgan . Ini screenshotnya; kotak monitor di bagian bawah menunjukkan string keluaran (di lokasi $ 00 hingga $ 3D) setelah program dijalankan.

Haskell , 75 72 63 58 56 byte

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

Cobalah online! Panggil dengan __. Keluaran:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Berkat xnor yang menyarankan __dan _'sebagai nama variabel dua byte, bukan (!)atau serupa, menghemat 9 byte. Saya terutama suka bagaimana _'memecah sintaks. Dan terima kasih lagi kepada xnor untuk menggeneralisasi rentang, menghemat 4 byte lagi.
Edit: Saya menemukan bahwa karakter Unicode diperbolehkan sebagai pengidentifikasi di Haskell, jadi misalnya ä, ö, ... juga dapat digunakan sebagai dua pengidentifikasi byte. Karena ada satu pengenal tiga byte yang tersisa dalam program, saya menggantinya ä, menghemat 2 byte lagi.

Penjelasan:

__dan _'merupakan nama variabel yang valid. Dari spesifikasi bahasa :

Identifier terdiri dari huruf yang diikuti oleh nol atau lebih huruf, digit, garis bawah, dan tanda kutip tunggal. [...] Garis Bawah,, _diperlakukan sebagai huruf kecil, dan dapat terjadi di mana huruf kecil bisa. Namun, _dengan sendirinya adalah pengidentifikasi yang dicadangkan, digunakan sebagai kartu liar dalam pola.

Jadi kodenya setara dengan

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

Dalam daftar pemahaman aterikat ke '/'dan bke ':'( "/:"sama dengan ['/',':'], sehingga pencocokan pola berhasil). Maka rentang [a..]membangun string semua karakter yang lebih besar sama '/':

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

Untuk setiap karakter xdalam string ini, lalu diperiksa apakah '/'<xdan x<':', menghasilkan karakter 0123456789. Kemudian adan bterikat ke @ dan [, menghasilkan karakter ABCDEFGHIJKLMNOPQRSTUVWXYZdan sebagainya.

Perl (5.10 atau 5.12), 30 29 byte

Program ini sebagian besar terdiri dari karakter yang tidak patut dicetak, jadi inilah 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          ............"

Program ini sangat sederhana: kami regexing ( =~) sebuah garis bawah ( _; terima kasih @ Dennis untuk menunjukkan bahwa ini berfungsi) terhadap regex. Regex ditentukan sebagai ekspresi, bukan secara harfiah; khusus, kami mengambil komplemen bitwise ( ~) dari sebuah string. Membalik komplemen bitwise untuk mendapatkan string yang mendasarinya, kita mendapatkan regex berikut yang sedang dijalankan:

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

Dalam Perl versi 5.10 dan 5.12, (?{…})sintaks adalah sintaks eksperimental untuk memungkinkan regex menjalankan kode arbitrer saat runtime. Dalam hal ini, kami menggunakannya untuk menjalankan program Perl langsung untuk mencetak output yang diinginkan. (Versi yang lebih awal dari 5.10 tidak dapat digunakan karena tidak ada say.)

Versi modern Perl telah dinonaktifkan (?{…})secara default karena alasan keamanan, tetapi jika Anda memiliki versi Perl, Anda dapat menonaktifkan centang (dan dengan demikian menjalankan program ini) via -Mre=evalsebagai argumen baris perintah (bersama dengan standar -M5.010yang menentukan versi) dari bahasa yang akan diterapkan, dan yang tidak diperhitungkan terhadap bytecount).

Sebenarnya 8 5 4 byte

'>┘▀

Bagaimana itu bekerja:

 '>    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]

Cetak tersirat di akhir program.

Sunting 1: Digantikan menempatkan alfabet dalam huruf kecil / besar dan kemudian kisaran angka (10) dengan hanya mendapatkan karakter dasar dicetak 62 itu.

Sunting 2: diubah ">" menjadi '> terima kasih kepada Mego :) menyimpan 1 byte.

Cobalah online!

PHP, 69 byte

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

Kode ini bergaya menggunakan Windows-1252 di sini. Di bawah ini adalah xxd hexdump reversibel .

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

Cobalah online!

Java (OpenJDK 9) , 277 byte

Ya, Jawa, Anda membacanya dengan baik!

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

Cobalah online!

Ini mencetak rentang, tetapi terbalik, karena urutannya tidak penting.

zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

Saya bermain dengan tidak adanya aturan "tidak ada input" untuk secara implisit mendefinisikan charmana yang diperlukan untuk membuat semuanya bekerja. Jika itu curang, tolong katakan begitu.

Tidak disatukan & diuji

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 byte

Karena Brainfuck mengabaikan karakter alfanumerik, ini hanya tantangan output konstan ... (Sunting: Lihat Solusi Dennis untuk versi yang lebih pendek 10 byte)

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

Cobalah online!

Kode ini adalah contoh yang baik dari loop terhitung dasar di 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)

Perhatikan bahwa ini menggunakan pintasan pembungkus untuk menghasilkan angka, artinya penerjemah harus memiliki sel pembungkus 8-bit (seperti yang saya tautkan).

JavaScript (ES6), 983 byte

Ternyata di ES6 ada banyak karakter yang dapat Anda gunakan dalam nama variabel JavaScript ! Bekerja dengan baik setelah Anda menghabiskan enam variabel nama 1-2 byte dengan $dan _.

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

JavaScript, 1223 byte

Ini adalah jawaban saya sebelum saya belajar tentang hal di atas.

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

Saya berlari console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')melalui jjencode dan memutarkan hasilnya secara manual. Pasti ada lebih banyak optimasi yang bisa dilakukan.

Befunge, 73 72 59 57 55 53 byte

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

Cobalah online!

Ini adalah satu loop menghitung mundur dari {(yaitu satu karakter setelah z). Pada iterasi pertama, "{"<urutan mendorong dua salinan {ke stack - satu menjadi penghitung loop awal, dan yang lainnya digunakan untuk mengurangi penghitung itu menggunakan urutan !!-(dua membuat NOT 1, yang kemudian dikurangi). Pada iterasi berikutnya, penghitung lingkaran sudah ada di tumpukan, jadi hanya satu {yang diperlukan untuk mengatur urutan penurunan.

Sisa kode hanyalah ekspresi boolean panjang yang menghitung jika karakternya dalam jangkauan. Jika ya, cabang pada baris kedua terpecah untuk menuliskan nilainya. Jika tidak, cabang kanan membungkus untuk menguji apakah kita telah mencapai nol dan harus berakhir. Dua cabang bergabung di tengah untuk naik dan ulangi loop. Perhatikan bahwa semua perintah arah vertikal naik ke atas, karena kita tidak dapat menggunakan v, tapi itu tidak masalah karena penunjuk instruksi secara otomatis membungkus di bagian atas playfield.

Berkat Mistah Figgins untuk awalnya datang dengan teknik yang lebih baik untuk kenaikan loop.

Tetapi terima kasih khusus kepada Jo King untuk pendekatan yang lebih baik menghitung mundur daripada naik, serta tata letak cabang yang lebih kompak.

Jelly , 17 16 byte

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

Cobalah online!

Bagaimana itu bekerja

“:[{“/@`‘Ḷḟ"/ỌḊ€  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 yang memodifikasi sendiri , 32 byte

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

Cobalah online!

xxd -r-hexdump reversibel (mengandung unsintables):

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

C, 128 byte

Ya, C. Dan itu bahkan lebih pendek dari beberapa yang esoteris.

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

Panggil buffer yang _cukup besar dan kosong char *.

_{Mungkin sedikit bergantung pada kompiler. Diuji menggunakan GCC; file disimpan dalam codepage 1252.}

JavaScript (ES6), 812 745 657 650 536 520 416 byte

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

Sunting: Menggunakan pengkodean ISO8859-1, solusi ini adalah 416 byte, bukan 520 byte. Program lengkapnya adalah 432 byte, dengan mempertimbangkan tambahan 16 byte untuk

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

Ini adalah pengiriman fungsi, sebagai lawan dari program lengkap. Saya menghabiskan cukup lama bermain golf JJEncode (topi-tip untuk darrylyeo untuk itu), tetapi bukannya bermain golf

console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

Saya bermain golf

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

di mana Ødiinisialisasi ""dalam overhead.

Ditulis ulang dengan operator koma yang dikonversi ke baris baru:

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

Penjelasan

Script ini dimulai dengan menginisialisasi beberapa tipe bawaan dan memaksa mereka menjadi string. String yang bisa kita dapatkan tanpa menggunakan karakter alfanumerik adalah:

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

Dari string ini, dan digit yang diperlukan untuk referensi karakter individu, kita dapat memperoleh string returndan constructor, yang dapat digunakan seperti:

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

Konstruktor objek adalah Object(), dan konstruktornya adalah Function(), yang pada dasarnya dapat kita gunakan eval().

Dalam hal ini, skrip yang disandikan untuk dieksekusi adalah forloop bersarang yang menggabungkan semua karakter alfanumerik ke string menggunakan titik kode mereka dan mengembalikannya.

Untuk karakter alfabet dalam skrip yang disandikan yang tidak dapat diakses menggunakan built-in, JJEncode menggunakan oktal escapes untuk mewakili mereka, lalu menerjemahkan seluruh string dengan mengembalikannya dari fungsi dalam. Fungsi luar kemudian dapat dipanggil untuk mengeksekusi sumber.

Demo

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

Brain-Flak , 171 byte

Termasuk +3 untuk -A

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

Cobalah online!

(((((()()()){}){}){}){}) # 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

Mungkin ada cara untuk melakukan ini tanpa harus mengulangi add 1 "fungsi".

Julia 0,4 , 46 byte

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

Ini adalah fungsi generik yang mengembalikan array karakter.

Cobalah online!

Versi alternatif, 47 byte, hanya ASCII

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

Cobalah online!

J, 171 byte

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

Ow ... otakku sakit ... Coba online!

Ini agar Anda dapat melihat semuanya satu baris (meskipun tidak akan berjalan, dengan jeda baris.)

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

Hanya dijamin untuk bekerja dengan versi J j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52, dalam urutan itu. (Hanya 12 karakter pertama yang penting.)

Penjelasan

Sebagian besar program dikhususkan untuk generasi konstan. Dengan konstanta yang diganti dengan nilai-nilai mereka, programnya terlihat seperti ini:

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

Dengan beberapa tanda kurung dihapus, dan beberapa nomor dibuat lebih bagus:

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

Ini terdiri dari sekelompok ,dan ,~s, yang menambahkan dan menambahkan argumen. Berikut adalah nilai-nilai yang terpisah:

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

1adalah 26sebagai string.

9!:14'' menghasilkan string berikut di TIO:

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

dengan 2, kita memperoleh 10karakter th ( idari linux), dan menambahkan a .ke akhir, menghasilkan i..

3dan 5sudah jelas.

4adalah daftar angka 65 97 48sebagai string.

6mirip dengan 2, kecuali itu 12karakter th ( udari linux) dan menambahkan a :sampai akhir, menghasilkan u:.

Ini, semuanya, menghasilkan u:,65 97 48+/i.26. ".mengevaluasi ini, memberi kami:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:;<=>?@ABCDEFGHI

(Catatan: +/adalah penambahan tabulasi.)

Kemudian, dengan 62{., kita ambil 62karakter pertama dari ini, memberi kita ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.

05AB1E , 18 15 11 byte

-4 Terima kasih kepada Adnan, karena jika ukuran input adalah 1, 05AB1E akan menggunakan 0 untuk b pada perintah pertama.

•£•Ýç©á®þ«˜

Cobalah online!

•£•Ÿ            # 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. 

Saya mencoba begitu banyak pendekatan berbeda, tetapi poin-poin penting di sini yang menyulitkan:

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

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

Keluaran:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789

Cobalah online!

Menginisialisasi rekaman ke 3 · 2 ⁿ , dan bekerja dari sana.

+++[[<+>->++<]>]    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 byte - tidak bersaing

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

Lambda yang mengembalikan daftar karakter.
Penjelasan:

   '`'                                       # 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"

Tergantung pada perbaikan bug pada penerjemah Rakudo Perl 6 yang hanya berkomitmen untuk repo git hari ini, dan belum menjadi bagian dari rilis Rakudo resmi. Bahkan, saya menemukan bug saat menjawab tantangan ini, dan berhasil diperbaiki dengan bantuan salah satu dev inti 6 Perl. Aturan situs ini, seperti yang saya pahami, tidak memungkinkan jawaban untuk bersaing dalam situasi seperti itu, jadi saya menandainya sebagai tidak bersaing.

PHP 7.0+, 110 byte

Tuhan memberkati string bitwise!

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

Ganti \ndengan baris * gaya NIX nyata.
Itu ada dalam kode untuk menghindari masalah dengan baris baru, tetapi tidak dihitung dalam skor.

Ini melempar banyak peringatan, tetapi itu bisa ditekan dengan menambahkan @di depan setiap nyasar _.

Peringatan gratis , 113 byte

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

Bahasa mesin 65c02 + Apple] [ROM, 25 byte

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

Cetakan abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.

Harus mulai $8000.

Membongkar

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 (di linux), 507 493 490 485 byte

ini menyimpan array karakter dalam variabel global __

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

itu perlu dijalankan pada mesin linux yang baru saja boot /proc, atau sesuatu seperti namespace pid

penjelasan:

# {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}
__=(${__[@]} ${___[@]} ${___[@]^})

untuk mencobanya kita dapat menambahkan declare -p __di akhir untuk menampilkan hasilnya

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

Solusi ini bekerja pada dasarnya dengan cara yang sama seperti dua jawaban yang lain di thread ini di sini dan di sini , di mana ia menggunakan surat dari true, false, undefined, dan [object Object]string untuk membangun fungsi-fungsi yang dibutuhkan untuk menghasilkan surat-surat lainnya.

Karena sejumlah besar huruf sudah dimasukkan ke dalam objek, saya mencoba menambahkan semua huruf sangat kecil yang tersisa dan angka-angka ke objek, dan kemudian diterapkan toUpperCaseke semua nilai dalam objek untuk menghasilkan huruf majuskule yang hilang.

Memperbarui:

Saya dapat meningkatkan cara nilai oktal sedang diatur, tetapi mereka masih mengambil 13 x 30 byte (atau masing-masing 30 byte setelah saya mengubah angka ke tombol yang berbeda), masing-masing sekarang mengikuti umum ini pola: $.ž=\'\\'+$.一+$.七+$.二+'\';.

49 byte tambahan dapat dengan mudah diambil dengan mengubah tombol angka menjadi 2 byte karakter.

Pengajuan saat ini:

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

C (dentang) , 164 byte

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

Cobalah online!

Ini adalah fungsi rekursif yang mendapatkan karakter dengan mulai dengan nilai 1 (mengurangi dari diri dan penambahan), dan membuat semua angka lain dari itu.

Tidak Disatukan / Penjelasan:

é,ú,í,ó;
_(*$){ //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 byte

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

Cobalah online!

Penjelasan

"{`[@:/" 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 karakter / 19 byte

ᶐ+ᶛ+⩥Ⅹă⬯

Coba di sini!

ᶐadalah alfabet huruf besar, ᶛadalah alfabet huruf kecil, dan ⩥Ⅹă⬯berkisar ( ⩥) dari 0hingga 10( Ⅹ, angka romawi unicode) dikurangi 1, bergabung dengan ( ă) tidak ada ( ⬯).