เป้าหมายของคุณคือการเขียน "สวัสดีโลก!" (ลบเครื่องหมายคำพูด) นี่คือการประกวดความนิยมดังนั้นคะแนนโหวตมากที่สุดชนะ ความยาวรหัสจะใช้ในการทำลายความสัมพันธ์
สิ่งใดก็ตามที่เกิดขึ้นตราบใดที่มันอยู่ในกฎต่อไปนี้:

• อักขระทั้งหมดต้องเป็นตัวอักษรหรือตัวเลขดังนั้นคุณอาจใช้อักขระในสตริง "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" เท่านั้น
• รหัสทั้งหมดที่คุณใช้จะต้องอยู่ในไฟล์เดียวยกเว้นโมดูล / คลาสที่นำเข้า / สิ่งที่พวกเขาถูกเรียกในภาษาที่คุณชื่นชอบ
• อนุญาตเฉพาะไลบรารี / กรอบงานมาตรฐานสำหรับภาษาที่คุณเลือก (ตัวอย่างเช่นอนุญาตให้ใช้โมดูลคณิตศาสตร์ของ Python แต่ไม่อนุญาตให้ใช้ Numpy, Scipy และ Pygame) ฉันจะอนุญาตให้ TkInter เป็นมาตรฐานจริงสำหรับ GUIs ใน Python
• ไม่อนุญาตให้ป้อนข้อมูลไม่ว่าจะเป็นการอ่านจาก stdin, อ่านไฟล์, ทำลายภาพหรืออ่านจากเว็บ

+10 บราวนี่ให้คะแนนถ้าคุณเข้าใจวิธีการทำใน Java โดยไม่ต้องก้มกฏ

ในเครื่องหมายของคุณรับชุดรหัส!

แก้ไข: วงเล็บปีกกา ({}), วงเล็บ ([]) และวงเล็บ (()) ได้รับอนุญาตเนื่องจากจะเป็นไปไม่ได้สำหรับภาษาส่วนใหญ่โดยไม่ต้อง ฉันลบกฎการ จำกัด ตัวอักษรด้วย หวังว่านี่จะทำให้มันน่าสนใจยิ่งขึ้น

แก้ไข ^ 2: อนุญาตให้ใช้พื้นที่สีขาว สมองของฉันทำงานผิดปกติขออภัย >. <

Perl

บางคนบอกว่า Perl เป็นภาษาที่เต็มไปด้วยสัญญาณรบกวน ascii และสัญลักษณ์สุ่มเช่น$... นั่นไม่เป็นความจริง: P

s zzHelloq worldmz and s zqzchr 44ze and s zmzchr 33ze and print

มาแบ่งย่อยเป็นนิพจน์ย่อย:

(s zzHelloq worldmz) and (s zqzchr 44ze) and (s zmzchr 33ze) and (print)

มันควรจะชัดเจนว่ามันดำเนินการจากซ้ายไปขวาตราบใดที่ทุกการแสดงออกกลับมาจริง แต่บนโลกนี้เป็นs zqzchr 44zeอย่างไร

ใน Perl มีกลุ่มของ"อ้างเหมือนผู้ประกอบการ"ซึ่งรวมถึง q(str), qw(li st), /regex/, s/from/to/เหนือสิ่งอื่นใด ปรากฎว่าผู้ประกอบการเหล่านี้สามารถใช้ตัวละครเกือบทุกตัวเป็นตัววัดความผิดพลาดโดยมีลักษณะเฉพาะสองประการ: การเปิด parethesis จะต้องปิดโดยวงเล็บปิดที่ตรงกันและถ้าคุณต้องการใช้ตัวอักษรเป็นตัวคั่นคุณต้องเว้นวรรค หลังจากตัวดำเนินการตัวอักษร (เพื่อ disambiguate จาก bareword)

ในกรณีนี้เราจะเห็นการใช้งานสามตัวของตัวดำเนินการs///(การแทนที่ regex):

s//Helloq worldm/
s/q/chr 44/e
s/m/chr 33/e

คั่นด้วยอักขระzทั้งหมด การ/eตั้งค่าสถานะในสองล่าสุดทำให้การแทนค่าจะถูกตีความเป็นรหัสเพื่อประเมินผลข้อความที่แท้จริง

ความจริงที่รู้จักกันดีเกี่ยวกับ Perl คือการดำเนินงานส่วนใหญ่เริ่มต้นที่จะดำเนินการกับ$_ตัวแปร builtin เว้นแต่จะระบุไว้เป็นอย่างอื่น การทดแทนทั้งสามและการprintดำเนินการ$_ในกรณีนี้ดังนั้นก่อนอื่นเราใส่คำว่า Hello world ลงในตัวแปรจากนั้นเราแก้ไขเครื่องหมายวรรคตอนโดยใช้ค่าตัวเลข ASCII ของตัวอักษรจากนั้นเราพิมพ์เนื้อหาของตัวแปร

C

int main(void) {
  if (putchar(72))
    if (putchar(101))
      if (putchar(putchar(108)))
        if (putchar(111))
          if (putchar(44))
            if (putchar(32))
              if (putchar(87))
                if (putchar(111))
                  if (putchar(114))
                    if (putchar(108))
                      if (putchar(100))
                        if (putchar(33)) 
                        {
                        }
}

(แก้ไข - ขั้นพื้นฐานของ BBC ย้ายไปที่คำตอบแยกต่างหากตามที่แนะนำคะแนนโหวตส่วนใหญ่นี้เป็นคำตอบของโลโก้อย่างแน่นอน)

โลโก้

ล่ามที่http://www.calormen.com/jslogo/#

TO h        pd  fd 100 rt  90  pu  fd 50  rt 90  pd  fd 100  rt 180 fd 50  lt 90  fd 50  rt 90  pu END 
TO e        pu  fd 25  rt  90  pd  fd 25  rt 90  arc 270 25  lt 90  fd 25  lt 90  pu END  
TO l        pd  fd 100 pu  END  
TO o        rt  45 fd  35  pd  arc 360 25  lt  45  pu END 
TO comma    pd  rt 90  arc 90  15  lt  90  pu END 
TO w         l  rt 180 l   pd  lt  135 fd  35  rt  90  fd 35  lt 135  l  END  
TO r        pd  fd 25  rt  90  pu  fd  25  rt 180  arc 180 25 rt 90 END 
TO d         o  rt 135 fd  35  lt  135  l  END      
TO exclaim arc 360 5   fd  10  l  END 

clearscreen  
setpencolor 4 pu 
setxy 0 150      h 
setxy 100 150    e  
setxy 200 150    l 
setxy 250 150    l 
setxy 300 150    o 
setxy 350 150    comma  
setpencolor 1 
setxy 0 0        w 
setxy 100 0      o 
setxy 200 0      r  
setxy 300 0      l 
setxy 350 0      d 
setxy 450 0      exclaim 
fd 100

เอาท์พุท (สามเหลี่ยมสีเขียวคือเคอร์เซอร์เต่า)

Applescript

ไม่มีเครื่องหมายวงเล็บ[]วงเล็บ{}หรือวงเล็บ()เลยใน:

set s to ASCII character 72
set s to s as list
set end of s to ASCII character 101
set end of s to ASCII character 108
set end of s to end of s
set end of s to ASCII character 111
set end of s to ASCII character 44
set end of s to space
set end of s to ASCII character 87
set end of s to item 5 of s
set end of s to ASCII character 114
set end of s to third item of s
set end of s to ASCII character 100
set end of s to ASCII character 33
display dialog s as text

ผลลัพธ์คือ:

ทุบตี

ผลงานประเภทนี้ถ้าคุณเหล่ตา:

echo NN i NN i i i iNN NNi i i i i i i NN i NN i i i i i i i NNi i i NN NN
echo NN i NNi i i i NN NN i i i i i i iNN i NN i i i i i i i NN i i iNN NN
echo NN i NN iNNNNi NN NN iNNNNi i i i NN i NN iNNNNi NN NN iNN iNNN NN NN
echo NNNNNNN NN iNN NN NN NN iNN i i i NN i NN NN iNN NNN iN NN NN iNNN N
echo NN i NN NNNNNN NN NN NNi NN i i i NN N NN NNi NN NN i i NN NNi iNN N
echo NN i NN NN i i NN NN NN iNN i i i NNN NNN NN iNN NN i i NN NN i NN
echo NN i NN iNNNi iNN NN iNNNNi N i i NN i NN iNNNNi NN i i NN iNNNN N NN
echo i i i i i i i i i i i i i i N

base64

SGVsbG8sIFdvcmxkIQ

เป็นไปตามกฎดั้งเดิม

หลาม

แล้วเราแค่คิดว่าทุกคนอ่านในแนวนอน สำหรับผู้ใช้ที่ชอบอ่านแนวตั้ง:

print chr(72) 
print chr(101)
print chr(108)
print chr(108)
print chr(111)
print chr(44)
print chr(32)
print chr(87)
print chr(111)
print chr(114)
print chr(108)
print chr(100)
print chr(33)

หลายภาษา: HQ9 +, H9 +, HQ9 ++, CHIQRSX9 +, HQ9 + B และ HQ9 + 2D (1 ไบต์)

H

ขอบคุณ @victor สำหรับรายชื่อภาษา

OMGROFL

ฉันเป็นแฟนตัวยงของภาษาลึกลับ โชคดีที่ OMGROFL เป็นตัวอักษรและตัวเลข:

lol iz 72
rofl lol
lol iz 101
rofl lol
lol iz 108
rofl lol
rofl lol
lool iz 111
rofl lool
loool iz 44
rofl loool
loool iz 32
rofl loool
loool iz 87
rofl loool
rofl lool
lool iz 114
rofl lool
rofl lol
lol iz 100
rofl lol
lol iz 33
rofl lol
stfu

izคำสั่งกำหนดค่าให้กับตัวแปรในกรณีนี้lol,loolและlooolทำหน้าที่เป็นตัวแปร ...

roflก้องคำสั่งออก ASCII เทียบเท่าไปยังหมายเลขที่เก็บไว้ในตัวแปร

stfuคำสั่งยุติโปรแกรม;)

ภาษาโคบอล

   ID DIVISION 
   DATA DIVISION 
   01  HELLOWORLDBINARY 
       05  HE                       COMP    PIC 9999 
       05  LL                       COMP    PIC 9999 
       05  OCOMMA                   COMP    PIC 9999 
       05  SPACEW                   COMP    PIC 9999 
       05  ORTEXT                   COMP    PIC 9999 
       05  LD                       COMP    PIC 9999 
       05  EXCLAMATION              COMP    PIC 9999 
   01  FILLER REDEFINES HELLOWORLDBINARY 
       05  HELLOWORLDTEXT                   PIC XXXXXXXXXXXXX
       05  FILLER                           PIC X 
   PROCEDURE DIVISION 
       MOVE 51333                   TO HE 
       MOVE 37779                   TO LL 
       MOVE 38507                   TO OCOMMA 
       MOVE 16614                   TO SPACEW 
       MOVE 38553                   TO ORTEXT 
       MOVE 37764                   TO LD 
       MOVE 23104                   TO EXCLAMATION 
       DISPLAY HELLOWORLDTEXT 
       GOBACK 

ต้องการการเปลี่ยนแปลงบางอย่างเพื่อให้เป็นแหล่งที่มาของตัวอักษรและตัวเลขอย่างแท้จริงเท่านั้น

สามารถลบ PROGRAM-ID ได้ คุณได้รับชื่อโปรแกรมที่สร้างขึ้น (ดูข้อความ)

การทำงาน - การจัดเก็บสามารถลดลงได้ คอมไพเลอร์ครางอีกครั้ง

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

ในการเปลี่ยน COMP-5 เป็น COMP คำสั่ง VALUE จะไม่ได้รับอนุญาตอีกต่อไปเนื่องจาก COMP 9999 เป็นเพียงตัวเลขสี่หลักเท่านั้นในขณะที่ COMP-5 เป็นไบนารีแบบสองไบต์พร้อมด้วยค่าบิตทั้งหมด

ค่าใน MOVEs คือค่าทศนิยมที่ให้ค่าไบนารี่ซึ่งให้คู่ของอักขระ

แม้ว่าฟิลด์ COMP จะมีตัวเลขสี่หลักและไม่อนุญาตให้ VALUE clauses มีตัวเลขมากกว่าสี่หลักคุณสามารถใช้ตัวเลขเพิ่มเติมใน MOVE ของค่าตัวอักษรโดยไม่ต้องตัดทอนที่จุดนั้น ... อย่าถามฉันว่าทำไม ตัวเลือกคอมไพเลอร์ DIAGTRUNC (ซึ่งฉันปิดไปแล้ว) จะสร้างคำวินิจฉัยสำหรับคำเตือนเหล่านี้

ตัวเลือกคอมไพเลอร์ TRUNC (BIN) สามารถใช้ในการปฏิบัติต่อ COMP ในฐานะ COMP-5 แต่ MOVEs เป็นอีกวิธีในการทำ

เนื่องจากมันคือภาษาโคบอล, เอาต์พุตจึงต้องอยู่ในที่สูงกว่า (เป็นเรื่องโกหก แต่เพื่อความสนุก)

HELLO WORLD!

ตกลงผ่อนปรนตอนนี้ผลิต:

Hello, World!

ซึ่งเป็นตัวละครที่มีจำนวนคี่จำเป็นต้องมีการเปลี่ยนแปลงเพิ่มเติมเนื่องจากเราไม่สามารถมีฟิลด์ไบนารีคี่จำนวนไบต์ด้วยคอมไพเลอร์นี้ ดูบรรทัด 13 Xs นั้น! ปกติแล้วมันจะถูกเขียนเป็น X (13) แต่อาจจะเป็นอย่างที่ฉันได้แสดง ...

และจำเป็นต้องมี ORTEXT (หรือไม่หรือต่อไป) เป็นชื่อเพราะหรือเป็นคำที่สงวนไว้สำหรับคอมไพเลอร์ (หมายถึงหรือแน่นอน)

เหล่านี้คือค่า EBCDIC ไม่ใช่ ASCII เนื่องจากกำลังทำงานบนกล่อง EBCDIC-aware และ Big Endian

โอ้ COBOL ต้องการการหยุดแบบเต็ม / รอบจำนวนมาก ฉันออกไป (พวกเขาถูกแบน) จึงได้รับข้อความที่รวบรวมจำนวนมาก เพิ่งบอกคอมไพเลอร์เพื่อสร้างรหัสต่อไป (ไม่มีข้อความที่เกี่ยวข้องกับรหัสวัตถุ)

แม้ไม่มี DIAGTRUNC ข้อความจะสูงถึง 17 ...

  1  IGYDS1003-E   A "PROGRAM-ID" paragraph was not found. 
  Program-name "CBLNAM01" was assumed. 

  2  IGYDS1082-E   A period was required.  A period was assumed 
  before "DATA". 

  3  IGYDS1082-E   A period was required.  A period was assumed 
  before "01". 

                   Same message on line:     11 

  3  IGYDS1040-E   A data item was found in the "DATA DIVISION" 
                   before a section header was encountered. 
                   "WORKING-STORAGE SECTION" was assumed. 

  4  IGYDS1082-E   A period was required.  A period was assumed 
  before "05". 

                   Same message on line:      5      6      7      8
                   9     10     12     13 

 14  IGYDS1082-E   A period was required.  A period was assumed 
 before "PROCEDURE". 

 15  IGYPS2145-E   A period was required.  A period was assumed 
 before "MOVE". 

 23  IGYSC1082-E   A period was required.  A period was assumed 
 before "END OF PROGRAM". 

ทับทิม (ใช้ alnums และ whitespace เท่านั้น)

putc 72
putc 101
putc 108
putc 108
putc 111
putc 44
putc 32
putc 87
putc 111
putc 114
putc 108
putc 100
putc 33

เอาท์พุท: Hello, World!

จาวาสคริ

with (function SGVsbG8sIFdvcmxkIQ(){}) atob(name)

ใช้คอนโซลของเบราว์เซอร์เพื่อทดสอบ

JavaScript

with (String) with ([]) {
    push(fromCharCode(72))
    push(fromCharCode(101))
    push(fromCharCode(108))
    push(fromCharCode(108))
    push(fromCharCode(111))
    push(fromCharCode(44))
    push(fromCharCode(32))
    push(fromCharCode(87))
    push(fromCharCode(111))
    push(fromCharCode(114))
    push(fromCharCode(108))
    push(fromCharCode(100))
    push(fromCharCode(33))
    alert(join([]))
}

เฟอร์นันโด

h E R
e I S
h E
l L O
w O
r L
d U S
i N G
o N L
y L E
t T E
r S

H e L L o W O R
L d h E L l O w
O r l D h e L L
O w o R l d H E
L l o W o r l d
H E l L o w O R
L D h E L L O W
O r L d H e l l
O w o R l d h e
L l o w O R l D
H e l L o w O R
L d h E L l O W
O R l D H E L l
O w O
r L d

REBOL

วิธีแก้ปัญหาตัวอักษรและตัวเลข:

prin quote Hello prin add space 12 prin space prin quote World print add space 1

ด้านบนเป็นการอัปเดตที่ใช้คำแนะนำที่ยอดเยี่ยมของ Dr Rebmu add space 1(ซึ่งผลิต! ) เพื่อไปที่ตัวละครทั้งหมด

ด้านล่างเป็นรุ่นดั้งเดิม:

prin quote Hello prin pick mold system 264 prin space prin quote World print pick mold system 12

เวอร์ชันที่สั้นกว่าพร้อมวงเล็บ:

print rejoin [quote Hello pick mold system 264 space quote World pick mold system 12] 

และเวอร์ชันที่สั้นลงด้วยเครื่องหมายปีกกา:

print join {Hello} join pick mold system 264 join { World} pick mold system 12

และเวอร์ชันที่สั้นที่สุดที่มีทั้งวงเล็บและวงเล็บปีกกา:

print rejoin [{Hello} pick mold system 264 { World} pick mold system 12]

Rebol ใช้เครื่องหมายปีกกา{}สำหรับการอ้างอิงหลายบรรทัด ถูกต้องสมบูรณ์ภายใต้การเปลี่ยนแปลงกฎ แต่ไม่เต็มจิตวิญญาณ (IMHO) เป็นสองคำตอบแรกของฉันข้างต้น

NB การพิมพ์!เป็นความเจ็บปวด!

Rebol อนุญาตและใช้อักขระเครื่องหมายวรรคตอนเป็นประจำสำหรับชื่อฟังก์ชันและประเภทข้อมูล ตัวเลือกที่ชอบto-char 33หรือto char! 33ไม่อนุญาตภายใต้กฎ (แม้ว่าเครื่องหมายวรรคตอนเหล่านี้ไม่ใช่ตัวดำเนินการพาร์)

โชคดีที่ฉันพบวิธีที่หน้าด้านโดยเปลี่ยนวัตถุระบบ Rebol: make object! [...]เป็นสตริงและเชอร์รี่เลือก!มันจาก :)

ปรับปรุง: และตอนนี้เชอร์รี่ยังเลือกจุลภาคจากข้อความลิขสิทธิ์ในวัตถุระบบ

C

ใช้เฉพาะอักขระตัวอักษรและตัวเลขช่องว่างและเครื่องหมายวงเล็บปีกกา {}, วงเล็บ [] และวงเล็บ ()

main()
{
        if(printf((long long []){0x202c6f6c6c6548}))
                if(printf((long long []){0x21646c726f57})){}
}

printf () ยอมรับ char * เป็นอาร์กิวเมนต์ แต่เนื่องจากเราไม่สามารถใช้เครื่องหมายอัญประกาศ (") ได้ฉันพิมพ์สตริงเป็นอาร์เรย์ยาวที่ยาวค่าที่เห็นที่นี่คือสตริง ASCII ใน endian น้อย (0x48 = H, 0x65 = e, 0x6c = l และอื่น ๆ ) ฉันพิมพ์มันยาวเป็นเวลานาน [] เนื่องจากวิธีที่ฉันสามารถส่งอาร์กิวเมนต์ 8 ไบต์และใช้การเรียก printf () เพียงสองครั้งแทนที่จะเป็นสี่สาย

BBC BASIC

Emulator ที่ bbcbasic.co.uk

แยกจากคำตอบโลโก้ของฉัน

วิธีง่ายๆ

ตัวเลขทางด้านขวาเป็นเพียงรหัส ASCII นี่เป็นเหมือนกับการพิมพ์ ถ้าฉันได้รับอนุญาตให้ใช้เครื่องหมายจุลภาคฉันสามารถทำได้ในบรรทัดเดียว ( VDU 72,101,108,etc.)

   10 VDU 72
   20 VDU 101
   30 VDU 108
   40 VDU 108
   50 VDU 111
   55 VDU 44
   60 VDU 32
   70 VDU 87
   80 VDU 111
   90 VDU 114
  100 VDU 108
  110 VDU 100
  120 VDU 33

วิธีที่สร้างสรรค์มากขึ้น

    5 MODE 6
   10 READ B
   12 WHILE B
   15   PROC1(B)
   16   PRINT
   17   READ B
   18 ENDWHILE
   20 END

REM procedure prints first square on line, 
REM then calls itself recursively with A DIV 2 to print the next
REM VDU 17 tell VDU controller we want to change colour
REM Next line changes background colour. 
REM Then following line VDU 32 prints a space in that background colour.

  110 DEFPROC1(A)
  115 VDU 17
  120 IF A AND 1 THEN VDU VPOS DIV 6 EOR 133 ELSE VDU 128
  125 VDU 32
  130 IF A THEN PROC1(A DIV2)
  140 ENDPROC

REM binary bitmap data for each row, least significant at left
  150 DATA 463221
  160 DATA 332053
  170 DATA 332151
  180 DATA 332053
  190 DATA 2586485
  200 DATA 1048576
  210 DATA 4395895
  220 DATA 4527447
  230 DATA 4526935
  240 DATA 333143
  250 DATA 4420981
  260 DATA 0

มาติกา

Unprotect[Times]
ClearAll[Times]
Print[Hello FromCharacterCode[44] world FromCharacterCode[33]]

กระแสตรง

DC เป็นเครื่องมือที่สมบูรณ์แบบสำหรับงาน

5735816763073854918203775149089P

พลPคำสั่งปรากฏหมายเลขหนึ่งจากสแต็คและผลตัวแทนคอมพิวเตอร์ดิบเพื่อ stdio เห็นเป็น5735816763073854918203775149089 = 0x48656C6C6F2C20576F726C6421ซึ่งจะแสดงเป็น0x21, 0x64, 0x6C... = 'H', 'e', 'l'...ในสถาปัตยกรรมน้อย endian Hello, World!มันเอาท์พุท

JavaScript!

และพวกเขาบอกว่ามันทำไม่ได้ ... ไม่มีผู้ดำเนินการที่ได้รับมอบหมายไม่มีผู้ต่อเชื่อมไม่มีคำพูด! Arghhhh!

อย่ากลัว ... เพราะพลังคือwithคุณ ...

function w(x){
    with(document){
        with(String){
            write(fromCharCode(x))
        }
    }
}
w(72)
w(101)
w(108)
w(108)
w(111)
w(44)
w(32)
w(87)
w(111)
w(114)
w(108)
w(100)
w(33)

Output (on browser screen): Hello, World!

จาวาสคริ

อัปเดต:จัดการเพื่อตัดอักขระจำนวนมากด้วยการแนะนำฟังก์ชันโลกเช่นกัน

โซลูชัน Javascript อื่นที่เขียนถึง console.log:

function World() { with (World) return name }
function Hello() {}
with (console)
with (String)
with (Hello)
with (name)
with (concat(fromCharCode(44)))
with (concat(fromCharCode(32)))
with (concat(World()))
log(concat(fromCharCode(33)))

แรงบันดาลใจจากรายการนี้นี้

ก่อนอื่นฉันจะนิยามฟังก์ชันที่ชื่อ Hello และ World สิ่งนี้จะถูกใช้ในภายหลัง

จากนั้นฉันก็เริ่มห่วงโซ่ของฉันซ้อนกับ with (console)และwith (String)ถูกนำมาใช้เพื่อให้ฉันสามารถเรียกใช้ในภายหลังconsole.logและString.fromCharCodeไม่ต้องใช้จุด

ตอนนี้แผนการสร้างสตริงHello, World!โดยใช้การซ้อนกับ ทุกครั้งที่ฉันเรียกใช้ concat () สตริงผลลัพธ์จะเป็นบริบทในบล็อกถัดไป ฉันใช้เวลาสั้น ๆ เพื่อให้ได้อย่างรวดเร็ว"Hello"โดยการเข้าถึงnameคุณสมบัติของHelloฟังก์ชัน แล้วฉัน concatenate String.fromCharCodeจุลภาคและพื้นที่โดยใช้ตัวอักษร

เคล็ดลับต่อไปคือการได้รับ"World"ส่วนหนึ่งของสตริง ฉันไม่สามารถใช้วิธีเดียวกันกับที่เคยได้รับHelloเนื่องจากฉันไม่สามารถเรียกใช้ World.name ได้ ฉันใส่ตรรกะนั้นเข้าไปในวิธีการของโลกแล้วเรียกมันออกมา

ในที่สุดฉันก็ผนวกเครื่องหมายอัศเจรีย์สุดท้ายและส่งผลลัพธ์ไปยังฟังก์ชันบันทึกซึ่งเป็นหลักสูตร console.log

Perl

ใน Perl ที่ทันสมัย ​​(5.10 หรือใหม่กว่า):

print q{Hello} and print chr 44 and print q{ World} and say chr 33

ใน Perl ที่เก่ากว่า:

print q{Hello} and print chr 44 and print q{ World} and print chr 33 and print chr 10

โซลูชันทั้งสองข้างต้นใช้qตัวดำเนินการคล้ายเครื่องหมายคำพูดPerl และอนุญาตให้ตัวคั่นที่เลือกสำหรับการอ้างอิงสตริงเช่น q{} q[] q() q//

โซลูชันนี้ต้องการการเปลี่ยนแปลงกฎที่อนุญาตให้จัดฟันวงเล็บหรือ parens ดังนั้นในขณะที่ถูกต้องโดยสิ้นเชิงฉันคิดว่าmniipคำตอบ Perl ที่ยอดเยี่ยมมีมากกว่าในจิตวิญญาณที่แท้จริงของกฎ (+1)

อย่างไรก็ตามการเขียนmniipคำตอบของฉันอาจเขียนได้เช่น:

print q xHellox and print chr 44 and print q x Worldx and say chr 33

และในขณะที่ทำงานหนักขึ้น

Perl

print chr hex for qw z48 65 6c 6c 6f 2c 20 57 6f 72 6c 64 21z

งูหลาม:

import antigravity 

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

ช่องว่าง

โอเคเราสามารถใช้ช่องว่าง มันใช้เพียงSpace, Tab, LineFeedและไม่สนใจตัวละครอื่น ๆ

ด้วยกับความคิดเห็น: S, TหรือLหมายถึงSpace, TabหรือLineFeedตามลำดับ

S S S T S S T   S S S L
T   L
S S S S S T T   S S T   S T L
T   L
S S S S S T T   S T T   S S L
T   L
S S S S S T T   S T T   S S L
T   L
S S S S S T T   S T T   T   T   L
T   L
S S S S S T S T T   S S L
T   L
S S S S S T S S S S S L
T   L
S S S S S T T   T   S T T   T   L
T   L
S S S S S T T   S T T   T   T   L
T   L
S S S S S T T   T   S S T   S L
T   L
S S S S S T T   S T T   S S L
T   L
S S S S S T T   S S T   S S L
T   L
S S S S S T S S S S T   L
T   L
S S L
L
L

ด้วยการเน้นสี: http://en.wikipedia.org/wiki/Whitespace_(programming_language)#Sample_code

dc, (26 ไบต์สำหรับนักกอล์ฟ)

[]ขณะนี้อนุญาตให้มีช่องว่างและวงเล็บ:

[Hello]n44P[ World]n33P[]p

เอาท์พุท:

$ dc <<< "[Hello]n44P[ World]n33P[]p"
Hello, World!
$ 

Rebmu , 46 ตัวอักษร

pnUPPqHELLO01pnADsp12pnSPpnUPPqWORLD01pnADsp01

แก้ปัญหาแนวของ@ dragetun ใน Rebol ได้ดี (เนื่องจาก Rebmu เป็นเครื่องมือการสอน Rebol / Red ซึ่งเป็น "ภาษาถิ่น" ที่มีจุดมุ่งหมายเพื่อดึงดูดความสนใจภาษาโดยโยกที่ Code Golf :-P)

อย่างไรก็ตามเพื่อให้ได้ตัวละครที่หายไปฉันก็ทำอะไรที่ชัดเจนกว่านี้ ฉันเพิ่งเพิ่มลงในช่องว่างแทนที่จะไปดูที่สตริงของระบบ คุณสามารถเพิ่มพื้นที่ 1เพื่อให้ได้ตัวอักษร # "!" และเพิ่มพื้นที่ 12เพื่อรับตัวอักษร # ","

ถ้าเราทำสิ่งนี้เราจะเห็นว่ามันเป็น "unmushed":

>> rebmu/debug/stats "pnUPPqHELLO01pnADsp12pnSPpnUPPqWORLD01prADsp01"
Original Rebmu string was: 46 characters.
Rebmu as mushed Rebol block molds to: 46 characters.
Unmushed Rebmu molds to: 62 characters.
Executing: [pn upp q hello 1 pn ad sp 12 pn sp pn upp q world 1 pr ad sp 1]
Hello, World!

ซึ่งเป็น logial ธรรม:

; print with no newline the result of doing an uppercase/part
; on the quoting of the symbolic word hello, of only the first
; N characters (where N is 1)
pn upp q hello 1

; print the character you get when you add 12 to the space
; character literal, a.k.a. comma...again no newline
pn ad sp 12

; print a space, no newline
pn sp

; do the same trick of printing the quoted word hello with the
; first letter converted to uppercase
pn upp q world 1

; print the character you get when you add 1 to the space
; character literal, a.k.a. exclamation point...with newline now
pr ad sp 1

T-SQL, 52

อ่านี่มันดีกว่า! การแปลงไบนารีโดยตรงเพียง 52 ตัวอักษร

SELECT CAST(0x48656C6C6F2C20576F726C6421 AS VARCHAR)

ก่อนหน้านี้ ...

มีวิธีการแก้ปัญหาที่ชาญฉลาดและนักกอล์ฟที่จะทำงานถ้าเราสามารถใช้=และ+ (ค้นหาข้อมูลมาตรฐานในตัวใน msdb และใช้เพื่อสร้างสตริงการสืบค้นที่สามารถใช้ EXEC ได้)

แต่เนื่องจากเราทำไม่ได้คุณจะได้รับแนวทางไร้เดียงสานี้:

SELECT CHAR(72)SELECT CHAR(101)SELECT CHAR(108)SELECT CHAR(108)SELECT CHAR(111)SELECT CHAR(44)SELECT CHAR(32)SELECT CHAR(87)SELECT CHAR(111)SELECT CHAR(114)SELECT CHAR(108)SELECT CHAR(100)SELECT CHAR(33)

งูหลาม:

Pfff ใครต้องการส่วนที่เป็นตัวเลขของตัวอักษรและตัวเลข?

from string import lowercase
from string import uppercase
from string import punctuation
print uppercase[len(str([[[len(str())]]]))]
print lowercase[len(str([[]]))]
print lowercase[len(str([[[[[len(str())]]]]]))]
print lowercase[len(str([[[[[len(str())]]]]]))]
print lowercase[len(str([[[[[[[]]]]]]]))]
print punctuation[len(str([[[[[len(str())]]]]]))]
print
print uppercase[len(str([[[[[[[[[[[]]]]]]]]]]]))]
print lowercase[len(str([[[[[[[]]]]]]]))]
print lowercase[len(str([[[[[[[[len(str())]]]]]]]]))]
print lowercase[len(str([[[[[len(str())]]]]]))]
print lowercase[len(str([len(str())]))]
print punctuation[len(str())]

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

lowercase="abcdefghijklmnopqrstuvwxyz"
uppercase="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
punctuation="!\"#$%&'()*+,-./:;<=>?@[\]^_`{|}~"

(นี่ไม่ใช่ส่วนหนึ่งของการส่งของฉันมันเป็นเพียงการแบ่งปันคนในพื้นที่ของฉันสำหรับการกู้คืนได้)

J - 73 ตัวอักษร

มันสามารถทำได้หลังจากทั้งหมด!

72 101 108 108 111 44 32 87 111 114 108 100 33{do 1 8{show 0 def 0
take
)

นี่คือสิ่งที่เกี่ยวกับ J ส่วนใหญ่ของดั้งเดิมคือเครื่องหมายวรรคตอน ASCII ตามด้วยจุดหรือโคลอนสูงสุดสองจุด สิ่งดั้งเดิมที่ไม่ได้ทำด้วยเครื่องหมายวรรคตอนคือตัวอักษรและตัวเลขที่ตามด้วยจุดหรือโคลอนสูงสุดสองจุด { } [ ]ดังนั้นเราจึงได้รับอนุญาตไม่มีผู้ยกเว้น [และ]เป็นคำกริยาเอกลักษณ์และจึงไร้ประโยชน์

โชคดีที่ {อาร์เรย์มีดัชนีดังนั้นถ้าเราบอกว่าสตริงที่มีตัวอักษร ASCII ทุกตัว ( a.เรียกว่าตัวอักษร ) เราสามารถดึงตัวอักษรออกมาได้ด้วยรหัสคู่ ASCII ของพวกเขา เรายังมีวิธีการสำรองข้อมูลของการทำสตริง , 0 : 0และสิ่งนั้นแล้วคนเดียว); โคลอนที่มีนามแฝงในไลบรารีมาตรฐานdef .

จากนั้นก็มีคำกริยาในไลบรารีมาตรฐานshowที่ให้คุณเป็นตัวแทนของคำกริยาภายในถ้าคุณส่งชื่อเป็นสตริง มันมีกริยาอีกอันหนึ่งdoซึ่งจะทำให้เกิดสตริง ดังนั้นหากเราสามารถดึงออกa.จากการเป็นตัวแทนใด ๆ ดังกล่าวเราสามารถ eval Hello, World!ที่และดึงออก

ผู้ช่วยให้รอดของเรามาในรูปแบบของtakeนามแฝง{.ว่ามีaชื่อใน show'take'จะกลับมาtake=: {.ดังนั้นเรามีของเราa.จึงมีวิธีแก้ปัญหาของเรา

เราสามารถกำจัดได้{โดยใช้สิ่งที่เทียบเท่าpickจากไลบรารี่มาตรฐาน แต่ไม่สามารถหลีกเลี่ยง paren ที่ส่วนท้ายสุดได้