Thử thách

In các ký tự sau:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890

Điều hấp dẫn là bạn không được sử dụng bất kỳ một trong số chúng trong mã của mình.

Bạn có thể in chúng theo thứ tự tùy ý, có hoặc không có dòng mới hàng đầu hoặc dấu, nhưng bạn không thể in bất kỳ ký tự nào khác.

Quy tắc

• Bạn không được sử dụng bất kỳ ký tự nào từ bộ được đề cập ở trên
• Bạn có thể sử dụng bất kỳ nhân vật khác
• Không gian lận
• Sơ hở tiêu chuẩn bị cấm
• Đây là mã golf , câu trả lời ngắn nhất thắng.

Làm rõ

• Nếu ngôn ngữ của bạn sử dụng bộ ký tự khác, bạn không được sử dụng bảng mã trong bộ ký tự tương ứng với các ký tự chữ và số.
• Trả về một chuỗi từ một hàm được coi là một hình thức đầu ra hợp lệ.
• Bạn có thể trả về một mảng char.

V , 8 7 byte

Lưu 1 byte nhờ @DJMcMayhem bằng cách đặt tất cả trong một câu lệnh regex

¬/{Ó×ü_

Hãy thử trực tuyến!

Đầu ra:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Lưu ý: ×là không x hay X, nó là0xd7

Hexdump:

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

Giải trình

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

Bây giờ đầu ra trông như sau:

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

Chúng tôi phải xóa tất cả các ký tự không phải chữ và số và _(vì nó không được bao gồm trong \W), vì vậy hãy sử dụng regex

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

Octave , 52 46 40 byte

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

Điều này đánh giá

9876543210ZYXWVUTSRQPONMLKJIHGFEDCBAabcdefghijklmnopqrstuvwxyz

Giải trình

Ở đây chúng ta đang sử dụng thực tế là các ký tự được chuyển đổi hoàn toàn thành số nguyên khi các phép toán số học như +-hoặc hàm phạm vi :được áp dụng. Khi được nối với một chuỗi rỗng ( [...,'']), các số lại được chuyển đổi thành ký tự.

Hãy thử trực tuyến!

brainfuck , 77 76 75 72 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Trình thông dịch bắt đầu với một băng gồm 0 ô.

++++++++

Điều này đặt ô đầu tiên thành 8 , để lại băng ở trạng thái sau.

   8
   ^

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

Điều này làm tăng ô thứ hai một lần, ô thứ ba 6 lần, ô thứ tư 4 lần, giảm ô thứ năm một lần, sau đó quay trở lại đầu băng và giảm ô thứ nhất. Sau 8 lần lặp, băng trông như sau.

  0   8  48  32  -8
  ^

>++

Chúng tôi tiến tới ô thứ hai và tăng nó hai lần, sẵn sàng in các chữ số.

  0  10  48  32  -8
      ^

[>.+<-]

Cái này in ô thứ ba, tăng nó, rồi quay lại ô thứ hai và giảm nó. Sau 10 lần lặp, chúng tôi đã in 0123456789và băng trông như sau.

  0   0  58  32  -8
      ^

>>

Thời gian để chuẩn bị các băng cho các chữ cái! Chúng tôi bắt đầu bằng cách tiến lên hai tế bào.

  0   0  58  32  -8   0   0
              ^

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

Điều này làm tăng ô thứ năm một lần, ô thứ sáu hai lần, ô thứ ba, sau đó quay trở lại ô thứ tư và phân rã nó. Sau 32 lần lặp, băng trông như sau.

  0   0  58   0  24  64  96
              ^

>++

Bước cuối cùng trước khi in các chữ cái, chúng tôi tiến tới ô thứ năm và tăng nó hai lần.

  0   0  58   0  26  64  96
                  ^

[>+.>+.<<-]

Cuối cùng, chúng tôi tiến tới ô thứ sáu để tăng và in nó, làm tương tự cho ô thứ bảy, sau đó quay lại ô thứ năm và giảm dần. Sau 26 lần lặp, chúng tôi đã in Aa...Zz.

Ruby, 42 byte

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

Một hàm trả về một mảng char. Một chương trình chỉ xuất ra các ký tự là 49 byte:

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

Điều này chỉ đơn giản là sử dụng các ký tự ascii ở hai bên của các phạm vi có liên quan để xác định một phạm vi. Ví dụ: ?/...?:có nghĩa là các ký tự giữa dấu gạch chéo về phía trước và dấu hai chấm, không bao gồm phần cuối. Để thoát khỏi sự bắt đầu, chúng tôi trừ đi một mảng chứa ba ký tự bắt đầu.

Ngôn ngữ máy 6502, 74 70 68 byte

Kết xuất hex (các chương trình 6502 thường không thể định vị lại được; mã ở đây được lưu trữ bắt đầu từ vị trí $ 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

Bạn có thể thấy rằng điều này không sử dụng bất kỳ byte nào bị cấm: $ 41 đến $ 5a, $ 61 đến $ 7a hoặc $ 30 đến $ 39.

Đây là một hàm không có đối số mà khi được gọi sẽ trả về một con trỏ tới mảng ký tự "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" ở đầu ngăn xếp, theo tiêu chuẩn 650.

Bằng cách giải thích, đây là một sự tháo gỡ:

Địa chỉ tháo gỡ Hexdump
-------------------------------
$ 0603 a9 24 LDA # $ 24
$ 0605 0a NHƯ 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
$ 061a 
$ 061b aa THUẾ 
$ 061c 
$ 061đ a8 NGÀY 
$ 061e a9 00 LDA # $ 00
$ 0620 
$ 0621 e NOP 
$ 0622 98 TYA 
$ 0623 e NOP 
$ 0624 8a 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 $ 063đ
$ 0646 60 RTS

Mã ngôn ngữ máy là tự sửa đổi. Để thao tác ngăn xếp, tôi cần sử dụng PHA và PLA để đẩy và bật bộ tích lũy, nhưng các hướng dẫn này có mã số $ 48 và $ 68, bị cấm (chúng là mã ASCII cho các chữ cái 'H' và 'h'). Vì vậy, đối với PHA, tôi lấy số $ 24, thực hiện dịch chuyển số học sang trái (ASL) và lưu trữ kết quả $ 48 trong bốn vị trí trong mã cần thực thi. Sau đó, đối với PLA, tôi sử dụng bit OR hoặc trên 48 đô la trong bộ tích lũy để tính toán 68 đô la và lưu trữ nó ở hai vị trí trong mã khi cần.

Có một số hướng dẫn khác ngoài PHA và PLA mà tôi cũng không thể sử dụng vì các mã của chúng giống như các chữ cái hoặc chữ số ASCII, nhưng tôi đã tìm thấy cách giải quyết trực tiếp cho những người khác.

Mảng ký tự mong muốn được tính toán và lưu trữ bắt đầu từ vị trí 0 (thực sự không quan trọng nơi nó được lưu trữ vì chúng ta chỉ cần chắc chắn rằng một con trỏ tới nó được trả về đỉnh của ngăn xếp).

Bạn có thể thử điều này tại trình biên dịch và trình giả lập 6502 của Nick Morgan . Đây là một ảnh chụp màn hình; hộp màn hình ở phía dưới hiển thị chuỗi đầu ra (ở các vị trí $ 00 đến $ 3D) sau khi chương trình được chạy.

Haskell , 75 72 63 58 56 byte

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

Hãy thử trực tuyến! Gọi với __. Đầu ra:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Nhờ xnor đã đề xuất __và _'dưới dạng hai tên biến byte thay vì (!)hoặc tương tự, tiết kiệm 9 byte. Tôi đặc biệt thích cách _'phá vỡ cú pháp tô sáng. Và một lần nữa cảm ơn xnor vì đã khái quát các phạm vi, tiết kiệm thêm 4 byte.
Chỉnh sửa: Tôi phát hiện ra rằng các ký tự Unicode được phép làm định danh trong Haskell, vì vậy ä, ví dụ ö, ... cũng có thể được sử dụng làm định danh hai byte. Vì có một định danh ba byte còn lại trong chương trình tôi đã thay thế nó bằng cách älưu 2 byte khác.

Giải trình:

__và _'là tên biến hợp lệ. Từ đặc tả ngôn ngữ :

Một định danh bao gồm một chữ cái theo sau là 0 hoặc nhiều chữ cái, chữ số, dấu gạch dưới và dấu ngoặc đơn. [...] Gạch dưới, _được coi là một chữ cái viết thường và có thể xảy ra ở bất cứ nơi nào một chữ cái viết thường có thể. Tuy nhiên, _bản thân nó là một định danh dành riêng, được sử dụng làm thẻ hoang dã trong các mẫu.

Vì vậy, mã tương đương với

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

Trong danh sách hiểu ađược ràng buộc để '/'và bđể ':'( "/:"tương đương với ['/',':'], do đó phù hợp với mô hình thành công). Sau đó, phạm vi [a..]xây dựng chuỗi của tất cả các ký tự lớn hơn bằng nhau '/':

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

Đối với mỗi ký tự xtrong chuỗi này, sau đó kiểm tra xem '/'<xvà x<':', dẫn đến ký tự 0123456789. Sau đó avà bbị ràng buộc @ và [, mang lại các ký tự ABCDEFGHIJKLMNOPQRSTUVWXYZvà như vậy.

Perl (5.10 hoặc 5.12), 30 29 byte

Chương trình này bao gồm hầu hết các ký tự không thể in được, vì vậy đây là một 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          ............"

Chương trình này rất đơn giản: chúng tôi regexing ( =~) một dấu gạch dưới ( _; cảm ơn @Dennis vì đã chỉ ra rằng điều này hoạt động) chống lại regex. Regex được chỉ định là một biểu thức, chứ không phải theo nghĩa đen; cụ thể, chúng tôi đang lấy phần bù bit ( ~) của chuỗi. Đảo ngược bổ sung bitwise để có được chuỗi bên dưới, chúng ta có được biểu thức chính quy sau đây đang được thực thi:

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

Trong các phiên bản Perl 5.10 và 5.12, (?{…})cú pháp là một cú pháp thử nghiệm để cho phép các biểu thức chính chạy mã tùy ý khi chạy. Trong trường hợp này, chúng tôi sử dụng nó để chạy chương trình Perl đơn giản để in đầu ra mong muốn. (Phiên bản sớm hơn 5.10 không thể được sử dụng vì chúng không có say.)

Các phiên bản hiện đại của Perl đã bị tắt (?{…})theo mặc định vì lý do bảo mật, nhưng nếu bạn có phiên bản Perl như vậy, bạn có thể vô hiệu hóa kiểm tra (và do đó chạy chương trình này) thông qua -Mre=evalnhư một đối số dòng lệnh (cùng với tiêu chuẩn -M5.010chỉ định phiên bản của ngôn ngữ để thực hiện và không tính đến ngôn ngữ phụ).

Thực tế 8 5 4 byte

'>┘▀

Làm thế nào nó hoạt động:

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

In là ẩn ở cuối chương trình.

Chỉnh sửa 1: Thay thế đặt bảng chữ cái ở dạng chữ thường / chữ hoa và sau đó là dãy số (10) chỉ bằng cách lấy các ký tự có thể in của cơ sở 62.

Chỉnh sửa 2: đã thay đổi ">" thành '> nhờ Mego :) đã lưu 1 byte.

Hãy thử trực tuyến!

PHP, 69 byte

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

Mã được cách điệu bằng Windows-1252 tại đây. Dưới đây là một hexdump xxd đảo ngược .

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

Hãy thử trực tuyến!

Java (OpenJDK 9) , 277 byte

Vâng, Java, bạn đọc nó tốt!

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

Hãy thử trực tuyến!

Điều này in các phạm vi, nhưng đảo ngược, vì thứ tự không có tầm quan trọng.

zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

Tôi đã chơi khi không có quy tắc "không có đầu vào" để xác định ngầm định một quy định charbắt buộc để làm cho toàn bộ hoạt động. Nếu đó là gian lận, xin vui lòng nói như vậy.

Thử nghiệm & thử nghiệm

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

Vì dù sao não cũng bỏ qua các ký tự chữ và số, đây chỉ là một thử thách đầu ra không đổi ... (Chỉnh sửa: Xem Giải pháp của Dennis cho phiên bản ngắn hơn 10 byte)

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

Hãy thử trực tuyến!

Mã này là một ví dụ tốt về các vòng lặp được tính cơ bản trong 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)

Lưu ý rằng điều này sử dụng các phím tắt gói để tạo số, có nghĩa là trình thông dịch cần phải có các ô gói 8 bit (chẳng hạn như các ô tôi liên kết đến).

JavaScript (ES6), 983 byte

Hóa ra trong ES6 có rất nhiều ký tự bạn có thể sử dụng trong tên biến JavaScript ! Hoạt động tuyệt vời sau khi bạn sử dụng sáu tên biến 1-2 byte với $và _.

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

JavaScript, 1223 byte

Đây là câu trả lời của tôi trước khi tôi biết về những điều trên.

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

Tôi chạy console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')qua jjencode và đánh gôn kết quả bằng tay. Chắc chắn có nhiều tối ưu hóa có thể được thực hiện.

Befunge, 73 72 59 57 55 53 byte

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

Hãy thử trực tuyến!

Đây là một vòng lặp đếm ngược từ {(tức là một ký tự sau z). Trong lần lặp đầu tiên, "{"<trình tự đẩy hai bản sao {lên ngăn xếp - một bản là bộ đếm vòng lặp ban đầu và bản còn lại được sử dụng để giảm số lượt truy cập đó bằng cách sử dụng trình tự !!-(hai bản KHÔNG tạo ra 1, sau đó được trừ đi). Trong các lần lặp lại tiếp theo, bộ đếm vòng lặp đã có trên ngăn xếp, do đó chỉ cần một bộ {để thiết lập chuỗi giảm dần.

Phần còn lại của mã chỉ là một biểu thức boolean dài tính toán nếu ký tự nằm trong phạm vi. Nếu có, nhánh trên dòng thứ hai sẽ tách ra để viết ra giá trị. Nếu không, nhánh bên phải bao quanh để kiểm tra xem chúng ta có đạt đến 0 không và nên chấm dứt. Hai nhánh hợp nhất ở giữa để đi lên và lặp lại vòng lặp. Lưu ý rằng tất cả các lệnh hướng dọc đi lên, vì chúng ta không thể sử dụng một v, nhưng điều đó tốt vì con trỏ lệnh sẽ tự động bao bọc ở đầu sân chơi.

Cảm ơn Mistah Figgins ban đầu đã đưa ra một kỹ thuật tốt hơn để tăng vòng lặp.

Nhưng đặc biệt cảm ơn Jo King vì cách tiếp cận thậm chí tốt hơn là đếm ngược hơn là lên, cũng như bố trí chi nhánh nhỏ gọn hơn.

Thạch , 17 16 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

“:[{“/@`‘Ḷḟ"/ỌḊ€  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 tự sửa đổi , 32 byte

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

Hãy thử trực tuyến!

xxd -rhexdump -reversible (chứa unprintables):

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

C, 128 byte

Vâng, C. Và nó thậm chí còn ngắn hơn một vài trong số những người bí truyền.

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

Gọi _trên một char *bộ đệm đủ lớn, trống rỗng .

_{Có thể là một trình biên dịch bit thiếu niên Đã thử nghiệm bằng GCC; tập tin đã được lưu trong codepage 1252.}

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

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

Chỉnh sửa: Sử dụng mã hóa ISO8859-1, giải pháp này là 416 byte thay vì 520 byte. Chương trình đầy đủ là 432 byte, có tính đến 16 byte cho

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

Đây là một đệ trình chức năng, trái ngược với một chương trình đầy đủ. Tôi đã dành khá nhiều thời gian để chơi golf JJEncode (hat-tip để darrylyeo cho điều đó), nhưng thay vì chơi golf

console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

Tôi đã chơi gôn

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

nơi Øđược khởi tạo ""ở trên đầu.

Viết lại với các toán tử dấu phẩy được chuyển đổi thành dòng mới:

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

Giải trình

Kịch bản lệnh này bắt đầu bằng cách khởi tạo một vài loại tích hợp và buộc chúng thành chuỗi. Các chuỗi chúng ta có thể nhận được mà không cần sử dụng các ký tự chữ và số là:

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

Từ các chuỗi này và các chữ số cần thiết để tham chiếu các ký tự riêng lẻ, chúng ta có thể có được các chuỗi returnvà constructor, có thể được sử dụng như:

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

Hàm tạo của đối tượng là Object(), và hàm tạo của nó là Function(), mà chúng ta có thể sử dụng về cơ bản như thế nào eval().

Trong trường hợp này, tập lệnh được mã hóa sẽ được thực thi là các forvòng lặp lồng nhau nối tất cả các ký tự chữ và số thành một chuỗi bằng cách sử dụng các điểm mã của chúng và trả về nó.

Đối với các ký tự chữ cái trong tập lệnh được mã hóa không thể được truy cập bằng cách sử dụng các phần tử dựng sẵn, JJEncode sử dụng các lối thoát bát phân để biểu diễn chúng, sau đó giải mã toàn bộ chuỗi bằng cách trả về nó từ một hàm bên trong. Hàm ngoài có thể được gọi để thực thi nguồn.

Bản giới thiệu

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

Brain-Flak , 171 byte

Bao gồm +3 cho -A

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

Hãy thử trực tuyến!

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

Có lẽ có một cách để làm điều này mà không phải lặp lại chức năng thêm 1 ".

Julia 0,4 , 46 byte

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

Đây là một hàm chung trả về một mảng ký tự.

Hãy thử trực tuyến!

Phiên bản thay thế, 47 byte, chỉ ASCII

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

Hãy thử trực tuyến!

J, 171 byte

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

Ow ... não tôi đau ... Hãy thử trực tuyến!

Đây là để bạn có thể thấy tất cả một dòng (tuy nhiên, nó sẽ không chạy, với các ngắt dòng.)

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

Chỉ đảm bảo hoạt động với phiên bản J j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52, theo thứ tự đó. (Chỉ có 12 ký tự đầu tiên.)

Giải trình

Hầu hết các chương trình được dành cho thế hệ liên tục. Với các hằng số được thay thế bằng các giá trị của chúng, chương trình trông như thế này:

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

Với một số dấu ngoặc đơn được loại bỏ và một số số được làm đẹp hơn:

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

Điều này bao gồm một loạt các ,và ,~s, nối thêm và thêm vào các đối số. Dưới đây là các giá trị riêng biệt:

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

1là 26một chuỗi.

9!:14'' tạo chuỗi sau trên TIO:

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

với 2, chúng ta có được 10ký tự thứ ( itừ linux) và thêm a .vào cuối của nó, mang lại i..

3và 5là tự giải thích.

4là danh sách các số 65 97 48dưới dạng chuỗi.

6tương tự như 2, ngoại trừ đó là 12nhân vật thứ ( utừ linux) và thêm :phần cuối, mang lại kết quả u:.

Điều này, tất cả cùng nhau, mang lại u:,65 97 48+/i.26. ".đánh giá điều này, cho chúng tôi:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:;<=>?@ABCDEFGHI

(Lưu ý: +/được bổ sung theo bảng.)

Sau đó, với 62{., chúng tôi lấy các 62ký tự đầu tiên từ này, cho chúng tôi ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.

05AB1E , 18 15 11 byte

-4 nhờ Adnan, vì nếu kích thước đầu vào là 1, 05AB1E sẽ sử dụng 0 cho b trên lệnh đầu tiên.

•£•Ýç©á®þ«˜

Hãy thử trực tuyến!

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

Tôi đã thử rất nhiều cách tiếp cận khác nhau, nhưng những điểm chính ở đây đã làm cho nó khó khăn:

- 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

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

Đầu ra:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789

Hãy thử trực tuyến!

Khởi tạo băng thành 3 · 2 ⁿ và hoạt động từ đó.

+++[[<+>->++<]>]    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 - không lọc

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

Một lambda trả về một danh sách các nhân vật.
Giải trình:

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

Phụ thuộc vào một lỗi cho trình thông dịch Rakudo Perl 6, thứ chỉ được cam kết với repo git ngày hôm nay, và chưa phải là một phần của bản phát hành Rakudo chính thức. Trên thực tế, tôi đã gặp phải lỗi khi trả lời thử thách này và đã cố gắng khắc phục với sự trợ giúp của một trong những nhà phát triển cốt lõi Perl 6. Các quy tắc của trang web này, như tôi hiểu chúng, không cho phép các câu trả lời cạnh tranh trong tình huống như vậy, vì vậy tôi đã đánh dấu nó là không thể lọc.

PHP 7.0+, 110 byte

Chúa phù hộ bit bit chuỗi!

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

Thay thế \nbằng một dòng mới * kiểu NIX thực sự.
Nó có mặt trong mã để tránh các vấn đề với dòng mới, nhưng không được tính vào điểm số.

Điều này đưa ra một loạt các cảnh báo, nhưng những cảnh báo đó có thể được áp đặt bằng cách nối thêm @trước mỗi lần đi lạc _.

Cảnh báo miễn phí , 113 byte

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

Ngôn ngữ máy 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

In abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.

Nên bắt đầu từ $8000.

Tháo gỡ

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

cái này lưu trữ một mảng các ký tự trong biến toàn cục __

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

nó cần phải được thực thi trên một máy linux mới khởi động với /proc, hoặc một cái gì đó giống như một không gian tên pid

giải trình:

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

để dùng thử, chúng ta có thể thêm declare -p __vào cuối để hiển thị kết quả

$ 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

Giải pháp này làm việc về cơ bản giống như hai câu trả lời khác về chủ đề này ở đây và ở đây , nơi mà nó sử dụng thư từ true, false, undefined, và [object Object]chuỗi để xây dựng các chức năng mà nó cần phải tạo ra các chữ cái khác.

Vì một số lượng lớn các chữ cái đã được đưa vào đối tượng, tôi đã thử thêm tất cả các chữ cái cực nhỏ còn lại và các số vào đối tượng, sau đó áp dụng toUpperCasecho tất cả các giá trị trong đối tượng để tạo ra các chữ cái bị thiếu.

Cập nhật:

Tôi đã có thể cải thiện cách đặt các giá trị bát phân, nhưng chúng vẫn chiếm 13 x 30 byte (hoặc chúng sẽ là 30 byte mỗi sau khi tôi thay đổi các số thành các khóa khác nhau), mỗi cái hiện theo sau chung này mô hình : $.ž=\'\\'+$.一+$.七+$.二+'\';.

Có thể dễ dàng lấy thêm 49 byte bằng cách chuyển các phím cho các số thành 2 ký tự byte.

Trình hiện tại:

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

C (tiếng kêu) , 164 byte

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

Hãy thử trực tuyến!

Đây là một hàm đệ quy lấy các ký tự bằng cách bắt đầu với giá trị 1 (trừ đi từ tự và tăng) và tạo ra tất cả các số khác từ đó.

Ungolfed / Giải thích:

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

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

Hãy thử trực tuyến!

Giải trình

"{`[@:/" 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 ký tự / 19 byte

ᶐ+ᶛ+⩥Ⅹă⬯

Hãy thử nó ở đây!

ᶐlà bảng chữ cái viết hoa, ᶛlà bảng chữ cái chữ thường và ⩥Ⅹă⬯là phạm vi ( ⩥) từ 0đến 10( Ⅹ, chữ số La Mã unicode) trừ 1, được nối bởi ( ă) nothing ( ⬯).