ท้าทาย

พิมพ์ตัวอักษรต่อไปนี้:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890

จับคือคุณไม่สามารถใช้หนึ่งในนั้นในรหัสของคุณ

คุณสามารถพิมพ์ตามลำดับโดยไม่ว่าจะมีหรือไม่มีบรรทัดใหม่นำหน้าหรือต่อท้าย แต่คุณไม่สามารถพิมพ์อักขระอื่น ๆ ได้

กฎระเบียบ

• คุณไม่สามารถใช้อักขระใด ๆ จากชุดที่กล่าวถึงข้างต้น
• คุณสามารถใช้อักขระอื่น ๆ
• ไม่มีการโกง
• ช่องโหว่มาตรฐานถูกแบน
• นี่คือรหัสกอล์ฟคำตอบที่สั้นที่สุดชนะ

ชี้แจง

• หากภาษาของคุณใช้ชุดอักขระที่แตกต่างกันคุณอาจไม่สามารถใช้ codepoints ในชุดอักขระที่สอดคล้องกับอักขระตัวอักษรและตัวเลข
• การส่งคืนสตริงจากฟังก์ชันถือว่าเป็นรูปแบบที่ถูกต้องของเอาต์พุต
• คุณอาจส่งคืนอาร์เรย์ถ่าน

V , 8 7 ไบต์

บันทึก 1 ไบต์ด้วย @DJMcMayhem ด้วยการใส่ไว้ในคำสั่ง regex เดียว

¬/{Ó×ü_

ลองออนไลน์!

ขาออก:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

หมายเหตุ: ×เป็นไม่ได้ xหรือXมันเป็น0xd7

hexdump:

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

คำอธิบาย

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

ตอนนี้ผลลัพธ์ดูเหมือนว่า:

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

เราต้องลบอักขระที่ไม่ใช่ตัวอักษรและตัวเลขทั้งหมดและ_(เนื่องจากไม่รวมอยู่ใน\W) ดังนั้นเรามาใช้ regex กันเถอะ

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

อ็อกเทฟ52 52 40 ไบต์

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

สิ่งนี้ประเมินว่า

9876543210ZYXWVUTSRQPONMLKJIHGFEDCBAabcdefghijklmnopqrstuvwxyz

คำอธิบาย

ที่นี่เราจะใช้ความจริงที่ว่าตัวละครจะถูกแปลงโดยปริยายจำนวนเต็มเมื่อดำเนินการทางคณิตศาสตร์เช่น+-หรือฟังก์ชั่นช่วง:ถูกนำมาใช้ เมื่อเชื่อมต่อกับสตริงว่าง ( [...,'']) ตัวเลขจะถูกแปลงเป็นอักขระอีกครั้ง

ลองออนไลน์!

brainfuck , 77 76 75 72 ไบต์

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

ลองออนไลน์!

มันทำงานอย่างไร

ล่ามเริ่มต้นด้วยเทป0เซลล์

++++++++

ตั้งค่าเซลล์แรกเป็น8ปล่อยให้เทปอยู่ในสถานะต่อไปนี้

   8
   ^

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

สิ่งนี้จะเพิ่มเซลล์ที่สองหนึ่งครั้งเซลล์ที่สาม6ครั้งเซลล์ที่สี่4ครั้งลดเซลล์ที่ห้าหนึ่งครั้งจากนั้นกลับไปที่จุดเริ่มต้นของเทปและลดเซลล์แรก หลังจากทำซ้ำ8ครั้งเทปจะมีลักษณะดังนี้

  0   8  48  32  -8
  ^

>++

เราเลื่อนไปที่เซลล์ที่สองและเพิ่มขึ้นเป็นสองเท่าเตรียมพร้อมที่จะพิมพ์ตัวเลข

  0  10  48  32  -8
      ^

[>.+<-]

สิ่งนี้จะพิมพ์เซลล์ที่สามเพิ่มขึ้นจากนั้นกลับไปที่เซลล์ที่สองและลดค่าลง หลังจากทำซ้ำ10ครั้งเราได้พิมพ์0123456789แล้วและเทปมีลักษณะดังนี้

  0   0  58  32  -8
      ^

>>

ถึงเวลาเตรียมเทปสำหรับตัวอักษร! เราเริ่มต้นด้วยการเพิ่มเซลล์สองเซลล์

  0   0  58  32  -8   0   0
              ^

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

นี่เป็นการเพิ่มเซลล์ที่ห้าหนึ่งครั้งเซลล์ที่หกสองครั้งเซลล์ที่เจ็ดสามครั้งจากนั้นกลับไปที่เซลล์ที่สี่และลดค่าลง หลังจากทำซ้ำ32ครั้งเทปจะมีลักษณะดังนี้

  0   0  58   0  24  64  96
              ^

>++

เป็นขั้นตอนสุดท้ายก่อนที่จะพิมพ์ตัวอักษรเราเลื่อนไปที่เซลล์ที่ห้าและเพิ่มขึ้นสองครั้ง

  0   0  58   0  26  64  96
                  ^

[>+.>+.<<-]

สุดท้ายเราไปยังเซลล์ที่หกเพื่อเพิ่มและพิมพ์ทำเช่นเดียวกันสำหรับเซลล์ที่เจ็ดจากนั้นกลับไปที่เซลล์ที่ห้าและลดจำนวนลง หลังจากการวนซ้ำ26ครั้งเราได้พิมพ์Aa...Zzแล้ว

ทับทิมขนาด 42 ไบต์

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

ฟังก์ชั่นที่ส่งกลับอาร์เรย์ถ่าน โปรแกรมที่ให้ผลลัพธ์เฉพาะอักขระคือ 49 ไบต์:

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

สิ่งนี้ใช้ตัวอักษร ascii ที่ด้านใดด้านหนึ่งของช่วงที่เกี่ยวข้องเพื่อกำหนดช่วง ตัวอย่างเช่น?/...?:หมายถึงอักขระระหว่างเครื่องหมายสแลชและเครื่องหมายโคลอนยกเว้นส่วนท้าย เพื่อกำจัดจุดเริ่มต้นเราจะลบอาร์เรย์ที่มีอักขระเริ่มต้นสามตัว

ภาษาเครื่อง 6502, 74 70 68 ไบต์

Hex dump (โดยทั่วไปแล้วโปรแกรม 6502 ไม่สามารถ relocatable รหัสที่นี่จะถูกเก็บไว้เริ่มต้นที่ตำแหน่ง $ 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 ถึง $ 5a, $ 61 ถึง $ 7a หรือ $ 30 ถึง $ 39

นี่คือฟังก์ชันที่ไม่มีอาร์กิวเมนต์ที่เมื่อเรียกใช้จะส่งคืนตัวชี้ไปยังอาร์เรย์อักขระ "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" ที่ด้านบนสุดของสแต็กตามมาตรฐาน 6502 การเรียกประชุม

โดยวิธีการอธิบายนี่คือการถอดชิ้นส่วน:

ที่อยู่ถอด Hexdump
-------------------------------
$ 0603 a9 24 LDA # $ 24
$ 0605 0a ASL A
$ 0606 8 วัน 20 06 STA $ 0620
$ 0609 8d 21 06 STA $ 0621
$ 060c 8 วัน 23 06 STA $ 0623
$ 060f 8 วัน 25 06 STA $ 0625
$ 0612 09 20 ORA # $ 20
$ 0614 8 วัน 1 ก 06 STA $ 061a
$ 0617 8 วัน 1 ต.ค. 06 STA $ 061c
$ 061a ea NOP 
$ 061b aa ภาษี 
$ 061c ea NOP 
$ 061d a8 TAY 
$ 061e a9 00 LDA # $ 00
$ 0620 ea NOP 
$ 0621 ea NOP 
$ 0622 98 TYA 
$ 0623 ea NOP 
$ 0624 8a 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 
$ 063e 98 TYA 
$ 063f 95 00 STA $ 00, X
$ 0641 c8 INY 
$ 0642 c4 80 CPY $ 80
$ 0644 d0 f7 BNE $ 063d
$ 0646 60 RTS

รหัสภาษาของเครื่องกำลังแก้ไขตัวเอง สำหรับการจัดการกองซ้อนฉันต้องใช้ PHA และ PLA เพื่อผลักดันและสะสมป๊อปอัพ แต่คำแนะนำเหล่านี้มี opcodes $ 48 และ $ 68 ซึ่งเป็นสิ่งต้องห้าม (เป็นรหัส ASCII สำหรับตัวอักษร 'H' และ 'h') ดังนั้นสำหรับ PHA ฉันใช้หมายเลข $ 24 ทำการคำนวณทางซ้าย (ASL) และเก็บผลลัพธ์ $ 48 ในจุดสี่จุดในรหัสที่จะต้องดำเนินการ จากนั้นสำหรับ PLA ฉันใช้บิตหรือ OR $ 48 ในตัวสะสมเพื่อคำนวณ $ 68 และเก็บไว้ในจุดสองจุดในรหัสที่จำเป็น

มีคำแนะนำอื่น ๆ นอกเหนือจาก PHA และ PLA ที่ฉันไม่สามารถใช้เพราะ opcodes ของพวกเขานั้นเหมือนกับตัวอักษรหรือตัวเลข ASCII แต่ฉันพบวิธีแก้ปัญหาโดยตรงสำหรับผู้อื่น

อาร์เรย์อักขระที่ต้องการถูกคำนวณและจัดเก็บเริ่มต้นที่ตำแหน่ง 0 (ไม่สำคัญว่าจะเก็บไว้ที่ไหนเพราะเราแค่ต้องแน่ใจว่าตัวชี้ไปที่มันถูกส่งกลับด้านบนสุดของสแต็ก)

คุณสามารถลองนี้ออกที่นิคมอร์แกน 6502 ประกอบและจำลอง นี่คือภาพหน้าจอ; กล่องมอนิเตอร์ที่ด้านล่างแสดงสตริงเอาต์พุต (ในตำแหน่ง $ 00 ถึง $ 3D) หลังจากเรียกใช้โปรแกรม

Haskell , 75 72 63 58 56 ไบต์

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

ลองออนไลน์! __โทรหา เอาท์พุท:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

ขอบคุณ xnor ที่แนะนำ__และ_'เป็นชื่อตัวแปรไบต์ที่สองแทน(!)หรือคล้ายกันช่วยประหยัด 9 ไบต์ ฉันชอบโดยเฉพาะวิธี_'แบ่งการเน้นไวยากรณ์ และขอขอบคุณอีกครั้งที่ xnor สำหรับการกำหนดช่วงทั่วไปบันทึกอีก 4 ไบต์
แก้ไข:ฉันพบว่าตัวอักษร Unicode จะได้รับอนุญาตเป็นตัวบ่งชี้ใน Haskell ดังนั้นเช่นä, ö... นอกจากนี้ยังสามารถนำมาใช้เป็นตัวบ่งชี้สองไบต์ เนื่องจากมีตัวระบุสามไบต์เหลืออยู่ในโปรแกรมที่ฉันแทนที่ด้วยโดยäบันทึกอีก 2 ไบต์

คำอธิบาย:

__และ_'เป็นชื่อตัวแปรที่ถูกต้อง จากข้อกำหนดภาษา :

ตัวระบุประกอบด้วยตัวอักษรตามด้วยตัวอักษรศูนย์ตัวเลขขีดล่างและเครื่องหมายคำพูดเดี่ยว [... ] ขีด_ล่าง, ถือเป็นตัวอักษรตัวพิมพ์เล็กและสามารถเกิดขึ้นได้ทุกที่ที่ตัวพิมพ์เล็กสามารถ อย่างไรก็ตาม_ตัวเองทั้งหมดเป็นตัวบ่งชี้ที่สงวนไว้ใช้เป็น wild card ในรูปแบบ

ดังนั้นรหัสจึงเท่ากับ

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

ในรายการความเข้าใจaได้รับการผูกมัด'/'และbไปที่':'( "/:"เทียบเท่าเพื่อ['/',':']ให้การจับคู่รูปแบบประสบความสำเร็จ) จากนั้นช่วง[a..]จะสร้างสตริงของตัวละครทุกตัวให้มีค่ามากกว่ากัน'/':

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

สำหรับตัวละครแต่ละตัวxในสายนี้มันจะถูกตรวจสอบว่า'/'<xและx<':'ส่งผลให้ตัวอักษร0123456789หรือไม่ จากนั้นaและbถูกผูกไว้กับ@ และ[ยอมจำนนตัวอักษรABCDEFGHIJKLMNOPQRSTUVWXYZและอื่น ๆ

Perl (5.10 หรือ 5.12), 30 29 ไบต์

โปรแกรมนี้ประกอบด้วยอักขระที่ไม่สามารถพิมพ์ได้ส่วนใหญ่ดังนั้นนี่คือ hexdump:

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

โปรแกรมนี้ง่ายมาก: เรากำลัง regexing ( =~) เครื่องหมายขีดล่าง ( _; ขอบคุณ @Dennis ที่ชี้ให้เห็นว่าสิ่งนี้ใช้ได้) กับ regex regex ถูกระบุว่าเป็นนิพจน์แทนที่จะเป็นตัวอักษรอย่างแท้จริง โดยเฉพาะเรากำลังเอา bitwise complement ( ~) ของสตริง การย้อนกลับส่วนเสริม bitwise เพื่อรับที่สตริงพื้นฐานเราได้รับ regex ต่อไปนี้ที่ถูกดำเนินการ

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

ใน Perl เวอร์ชัน 5.10 และ 5.12 (?{…})ไวยากรณ์เป็นไวยากรณ์ทดลองสำหรับการอนุญาตให้ regexes เรียกใช้รหัสโดยพลการในขณะใช้งานจริง ในกรณีนี้เราใช้มันเพื่อรันโปรแกรม Perl ตรงไปตรงมาเพื่อพิมพ์ผลลัพธ์ที่ต้องการ (ไม่สามารถใช้sayรุ่นที่เก่ากว่า 5.10 ได้เนื่องจากไม่มี)

Perl รุ่นที่ทันสมัยได้ปิดการใช้งาน(?{…})โดยค่าเริ่มต้นด้วยเหตุผลด้านความปลอดภัย แต่ถ้าคุณมีรุ่นของ Perl คุณสามารถปิดการตรวจสอบ (และเรียกใช้โปรแกรมนี้) ผ่านทาง-Mre=evalอาร์กิวเมนต์บรรทัดคำสั่ง (พร้อมกับมาตรฐาน-M5.010ที่ระบุรุ่น) ของภาษาที่ต้องนำไปปฏิบัติและไม่นับรวมกับจำนวน bytecount)

ที่จริง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 ที่นี่ ด้านล่างเป็นhexxump แบบย้อนกลับได้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 ไบต์

ใช่แล้ว Java คุณอ่านได้ดี!

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

ลองออนไลน์!

สิ่งนี้จะพิมพ์ช่วง แต่กลับด้านเนื่องจากลำดับไม่มีความสำคัญ

zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

ฉันเล่นโดยไม่มีกฎ "ไม่มีอินพุต" เพื่อกำหนดสิ่งcharที่จำเป็นต้องใช้เพื่อให้การทำงานทั้งหมดเป็นไปโดยปริยาย ถ้าเป็นการโกงโปรดพูดอย่างนั้น

Ungolfed & การทดสอบ

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

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

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

Brainfuck, 89 85 ไบต์

เนื่องจาก 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และgolfedผลลัพธ์ด้วยตนเอง มีการเพิ่มประสิทธิภาพอย่างแน่นอนมากขึ้นที่สามารถทำได้

Befunge, 73 72 59 57 55 53 ไบต์

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

ลองออนไลน์!

นี่คือลูปเดียวนับถอยหลังจาก{(เช่นหนึ่งตัวละครหลังจากz) ในการย้ำแรก"{"<ลำดับผลักดันสองฉบับ{ลงบนสแต็ค - หนึ่งเป็นเคาน์เตอร์ห่วงเริ่มต้นและอื่น ๆ ที่ถูกใช้ในการพร่องนับว่าการใช้ลำดับ!!-(สอง nots ให้1ซึ่งถูกลบออกแล้ว) ในการวนซ้ำครั้งต่อไปตัวนับลูปจะอยู่ในสแต็กแล้วดังนั้นจึง{จำเป็นต้องมีเพียงอันเดียวในการตั้งค่าลำดับการลดลง

ส่วนที่เหลือของรหัสเป็นเพียงการแสดงออกแบบบูลยาวที่คำนวณว่าตัวละครอยู่ในช่วง ถ้าเป็นเช่นนั้นสาขาในบรรทัดที่สองจะแยกซ้ายเพื่อเขียนค่า ถ้าไม่สาขาที่ถูกต้องล้อมรอบเพื่อทดสอบว่าเราถึงศูนย์แล้วและควรยุติ กิ่งก้านทั้งสองผสานกันตรงกลางเพื่อขึ้นและวนซ้ำ โปรดทราบว่าคำสั่งในแนวตั้งทั้งหมดขึ้นไปข้างบนเนื่องจากเราไม่สามารถใช้ a vได้ แต่ก็ใช้ได้เพราะตัวชี้คำสั่งล้อมรอบด้านบนของสนามเด็กเล่นโดยอัตโนมัติ

ขอบคุณMistah Figginsสำหรับการเริ่มต้นด้วยเทคนิคที่ดีกว่าสำหรับการเพิ่มลูป

แต่ขอขอบคุณเป็นพิเศษกับJo Kingสำหรับวิธีการที่ดียิ่งขึ้นนับถอยหลังมากกว่าขึ้นเช่นเดียวกับรูปแบบสาขาขนาดกะทัดรัดมากขึ้น

เยลลี่ , 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 -rhexdump แบบย้อนกลับได้ (มี unprintables):

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

C, 128 ไบต์

ใช่ซีและมันก็สั้นกว่าบางอย่างที่ลึกลับ

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

เรียก_ใช้char *บัฟเฟอร์ที่ใหญ่และว่างเปล่า

_{อาจเป็นคอมไพเลอร์เล็ก ๆ น้อย ๆ ทดสอบโดยใช้ GCC ไฟล์ถูกบันทึกใน codepage 1252}

JavaScript (ES6), 812 745 657 650 536 520 416 ไบต์

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

แก้ไข:ใช้การเข้ารหัส ISO8859-1 โซลูชันนี้คือ 416 ไบต์แทนที่จะเป็น 520 ไบต์ โปรแกรมเต็มรูปแบบคือ 432 ไบต์โดยคำนึงถึง 16 ไบต์พิเศษสำหรับ

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

นี่คือการส่งฟังก์ชั่นซึ่งตรงข้ามกับโปรแกรมเต็มรูปแบบ ฉันใช้เวลาเล่นกอล์ฟเป็นเวลานานมากJJEncode (ปลายหมวกถึงdarrylyeoสำหรับเรื่องนั้น) แต่แทนที่จะเล่นกอล์ฟ

console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

ฉันเล่นกอล์ฟ

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

ที่Øเริ่มต้นได้""ในค่าใช้จ่าย

เขียนใหม่ด้วยเครื่องหมายจุลภาคที่แปลงเป็นบรรทัดใหม่:

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

คำอธิบาย

สคริปต์นี้เริ่มต้นด้วยการเริ่มต้นประเภทที่มีอยู่แล้วไม่กี่ชนิดและบีบบังคับให้เป็นสตริง สตริงที่เราสามารถทำได้โดยไม่ใช้ตัวอักษรและตัวเลขคือ:

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

จากสตริงเหล่านี้และตัวเลขที่จำเป็นเพื่ออ้างอิงถึงอักขระแต่ละตัวเราสามารถรับสตริงreturnและconstructorซึ่งสามารถใช้เช่น:

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

ตัวสร้างวัตถุที่เป็นObject()และตัวสร้างของมันคือการที่เราสามารถใช้เป็นหลักเช่นFunction()eval()

ในกรณีนี้สคริปต์ที่เข้ารหัสที่จะดำเนินการคือforลูปซ้อนซ้อนกันเชื่อมอักขระตัวอักษรและตัวเลขทั้งหมดเข้ากับสตริงโดยใช้จุดโค้ดของพวกเขาและส่งคืน

สำหรับอักขระที่เป็นตัวอักษรในสคริปต์ที่เข้ารหัสที่ไม่สามารถเข้าถึงได้โดยใช้บิวด์อิน JJEncode จะใช้การยกเว้นฐานแปดเพื่อเป็นตัวแทนของพวกเขาแล้วถอดรหัสสตริงทั้งหมดโดยส่งคืนจากฟังก์ชันภายใน ฟังก์ชั่นด้านนอกนั้นสามารถเรียกใช้ในการดำเนินการแหล่งที่มา

การสาธิต

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

Brain-Flak , 171 ไบต์

รวมถึง +3 สำหรับ -A

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

ลองออนไลน์!

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

อาจมีวิธีการทำเช่นนี้โดยไม่ต้องเพิ่มฟังก์ชัน "1" ซ้ำ

Julia 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ตัวอักษร TH ( iจากlinux) และเพิ่มไปยังจุดสิ้นสุดของมันยอม.i.

3และ5อธิบายตนเองได้

4คือรายการของตัวเลข65 97 48เป็นสตริง

6จะคล้ายกับการ2ยกเว้นมันเป็น12ตัวอักษร TH ( uจากlinux) และเพิ่มไปยังจุดสิ้นสุดยอม:u:

u:,65 97 48+/i.26นี้ทั้งหมดเข้าด้วยกันอัตราผลตอบแทน ".ประเมินสิ่งนี้ทำให้เรา:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:;<=>?@ABCDEFGHI

(หมายเหตุ: +/เป็นตารางนอกจากนี้)

จากนั้นด้วย62{.เราใช้ครั้งแรกที่ตัวละครจากนี้ให้เรา62ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789

05AB1E , 18 15 11 ไบต์

-4 ต้องขอบคุณ Adnan เพราะถ้าขนาดอินพุตเป็น 1, 05AB1E จะใช้ 0 สำหรับ b กับคำสั่งแรก

•£•Ýç©á®þ«˜

ลองออนไลน์!

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

ฉันลองใช้วิธีการต่าง ๆ มากมาย แต่ประเด็นสำคัญที่ทำให้ยาก:

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

Brainfuck, 55 ไบต์

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

เอาท์พุท:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789

ลองออนไลน์!

เริ่มต้นเทปถึง3 · 2 ⁿและทำงานจากที่นั่น

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

Perl 6 , 43 ไบต์ - ไม่ใช่การแข่งขัน

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

แลมบ์ดาที่ส่งคืนรายการอักขระ
คำอธิบาย:

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

ขึ้นอยู่กับการแก้ไขข้อผิดพลาดกับล่าม Rakudo Perl 6 ซึ่งมุ่งมั่นที่จะ repo คอมไพล์วันนี้และยังไม่ได้เป็นส่วนหนึ่งของรุ่น Rakudo อย่างเป็นทางการเลย ในความเป็นจริงฉันพบข้อผิดพลาดในขณะที่ตอบคำถามนี้และจัดการเพื่อแก้ไขด้วยความช่วยเหลือจากหนึ่งใน devs Perl 6 แกน กฎของเว็บไซต์นี้ตามที่ฉันเข้าใจพวกเขาไม่อนุญาตให้มีคำตอบให้แข่งขันในสถานการณ์ดังกล่าวดังนั้นฉันจึงทำเครื่องหมายว่าไม่ใช่การแข่งขัน

PHP 7.0+, 110 ไบต์

ขอพระเจ้าทรงอวยพรสตริงบิทมิง!

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

แทนที่\nด้วยบรรทัดใหม่สไตล์ * NIX จริง
มันมีอยู่ในรหัสเพื่อหลีกเลี่ยงปัญหากับการขึ้นบรรทัดใหม่ แต่จะไม่ถูกนับในคะแนน

นี้โยนพวงของคำเตือน แต่ผู้ที่จะได้รับการ supressed โดยท้ายในด้านหน้าของทุกคนจรจัด@_

เตือนฟรี 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 ไบต์

นี้เก็บอาร์เรย์ของตัวละครในตัวแปรทั่วโลก __

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

จะต้องมีการดำเนินการบนเครื่องที่ใช้ลินุกซ์ที่บูตใหม่/procหรืออะไรบางอย่างเช่น pid namespace

คำอธิบาย:

# {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กับค่าทั้งหมดในวัตถุเพื่อสร้างตัวอักษร majuscule ที่หายไป

ปรับปรุง:

ฉันสามารถปรับปรุงวิธีการตั้งค่าเลขฐานแปด แต่พวกเขายังคงเพิ่มขึ้น 13 x 30 ไบต์ (หรือพวกเขาจะเป็น 30 ไบต์ต่อกันหลังจากที่ฉันเปลี่ยนตัวเลขเป็นปุ่มที่แตกต่างกัน) ตอนนี้แต่ละคนจะติดตามทั่วไปนี้ รูปแบบ: $.ž=\'\\'+$.一+$.七+$.二+'\';.

สามารถเพิ่ม 49 ไบต์ได้อย่างง่ายดายโดยการเปลี่ยนปุ่มสำหรับตัวเลขเป็น 2 ไบต์

การส่งปัจจุบัน:

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

C (เสียงดังกราว) , 164 ไบต์

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

ลองออนไลน์!

นี่คือฟังก์ชั่นวนซ้ำที่รับอักขระโดยเริ่มต้นด้วยค่า 1 (ลบออกจากตัวเองและเพิ่มจำนวน) และสร้างตัวเลขอื่นทั้งหมดจากนั้น

Ungolfed / ชี้แจง:

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

CJam , 15 ไบต์

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

ลองออนไลน์!

คำอธิบาย

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

𝔼𝕊𝕄𝕚𝕟, 8 ตัวอักษร / 19 ไบต์

ᶐ+ᶛ+⩥Ⅹă⬯

ลองที่นี่!

ᶐเป็นตัวอักษรตัวพิมพ์ใหญ่ᶛเป็นตัวอักษรตัวพิมพ์เล็กและ⩥Ⅹă⬯เป็นช่วง ( ⩥) จาก0ถึง10( Ⅹตัวเลขยูนิโคดเลขโรมัน) ลบ1ร่วมกับ ( ă) ไม่มีอะไร ( ⬯)