แหล่งที่มา: Dilbert, 8 กันยายน 2535

ฉันหวังว่าจะเพิ่มความแปลกใหม่ให้กับ "Hello World!" โครงการ

โค้ดโปรแกรมที่เอาต์พุตHello World!โดยไม่มี:

• ตัวอักษรสตริง / ตัวอักษร
• ตัวเลข (ฐานใด ๆ )
• ฟังก์ชั่นที่สร้างไว้ล่วงหน้าที่กลับมา "Hello World!"
• ตัวอักษร RegEx

ด้วยข้อยกเว้นของ "O" ^†และ 0

† "O" เป็นตัวพิมพ์ใหญ่ "o" ไม่เป็นที่ยอมรับ

Windows PowerShell มากเกินไป

ใช่แน่นอนในวันที่เราต้องเขียน»สวัสดีชาวโลก«ใช้ศูนย์ (เกือบเฉพาะ) ...

&{-join[char[]]($args|% Length)} `
O00000000000000000000000000000000000000000000000000000000000000000000000 `
O0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O0000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000

เมื่อทราบอย่างจริงจังมากขึ้น:

Windows PowerShell, 25

Write-Host Hello World!

ไม่มีตัวอักษรสตริง Hello World!ในมีเพียงแค่เกิดขึ้นจะแยกวิเคราะห์เป็นสตริงตั้งแต่ PowerShell อยู่ในโหมดการแยกอาร์กิวเมนต์มี

C, 327 ตัวอักษร

#define O(O)-~O
#define OO(o)O(O(o))
#define Oo(o)OO(OO(o))
#define oO(o)Oo(Oo(o))
#define oo(o)oO(oO(o))
#define O0 putchar
main() {
    O0(OO(oO(!O0(~O(Oo(OO(-O0(~O(Oo(-O0(O(OO(O0(oo(oO(O0(O(oo(oO(OO(Oo(oo(oO(
    O0(oo(oo(!O0(O(OO(O0(O0(O(OO(Oo(O0(O(Oo(oo(oO(O0(oo(oo(oO(oo(oo(0))))))))
    ))))))))))))))))))))))))))))))))))))));
}

น่าแปลกที่มันไม่เสียความงามหลังจากประมวลผลล่วงหน้า:

main() {
putchar(-~-~-~-~-~-~-~-~-~-~!putchar(~-~-~-~-~-~-~-~-putchar(~-~-~-~-~-~-
putchar(-~-~-~putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-~-~-~-~-~-~-~-~-~-~-~-~-~!putchar(-~-~-~putchar(putchar(-~-~-~-~-~-~-~putchar
(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(-~-~-~-~-~-
~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~0))))))))))));
}

BrainFuck, 102 111ตัวอักษร

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

ตรงตามกฎทั้งหมด

เครดิตไปที่แดเนียล Cristofani

C, 182 ไบต์

#define decode(c,o,d,e,g,O,l,f) e##c##d##o
#define HelloWorld decode(a,n,i,m,a,t,e,d)
#define Puzzles(flog) #flog
#define CodeGolf Puzzles(Hello World!)
HelloWorld(){puts(CodeGolf);}

โปรแกรม C - 45

(โกง)

อย่างย่อนี่ไม่ได้ใช้ตัวอักษรสตริงหรือตัวอักษร regex ใด ๆ ใช้ประโยชน์จากคุณสมบัติการทำให้เป็นสตริงของตัวประมวลผลล่วงหน้า C s(x)เป็นแมโครที่เปลี่ยนอาร์กิวเมนต์เป็นสตริง

#define s(x)#x
main(){puts(s(Hello World!));}

Haskell - 143 ตัวอักษร

o%y=o.o.o$y;o&y=(o%)%y;o!y=o$o$(o%)&y
r=succ;w=pred;a=r%y;e=r$w&l;l=r!'O';o=r e;u=(w&)&a;y=r%l
main=putStrLn[w!o,o,l,l,y,w u,w$r&'O',y,a,l,e,u]

เอ่อนั่นมันขน!

ไม่มีตัวเลขไม่มีการดำเนินการที่เป็นตัวเลขตัวแปรที่ถูกเปลี่ยนชื่อเพื่อความสนุก

การแสดงออกบางอย่างอาจดี:

• o%y, o&yและo!yแต่ละฟังก์ชันใช้oกับyหลาย ๆ ครั้ง: 3, 9 และ 29 ครั้งตามลำดับ 29?!?! ใช่ 29!
• rและจะมีต่อไปและก่อนหน้านี้ตัวละครซึ่งเมื่อนำมาใช้โดยใช้ฟังก์ชั่นการสั่งซื้อดังกล่าวข้างต้นสูงกว่าสามารถทำเพื่อให้ได้รับตัวอักษรทั้งหมดที่จำเป็นจากw'O'

ลำดับของการข้ามที่จำเป็นคือ:

'O' +29    -> 'l'
'O'  +9 -1 -> 'W'
'l'  -9 +1 -> 'd'
'l'  +3    -> 'o'
'd'  +1    -> 'e'
'o'  +3    -> 'r'
'e' -29    -> 'H'
'r' -81    -> '!'
'!'  -1    -> ' '

• แก้ไข: (134 -> 144) ลืมเอาเครื่องหมายอัศเจรีย์ถอนหายใจ ....
• แก้ไข: (144 -> 143) ลบออกไม่จำเป็น$เปลี่ยน#ไป!สำหรับ Hugs

Unary , 10 ¹⁹⁷ 1137672766964589547169964037018563746793726105983919528073581559828 ไบต์

ฉันประหลาดใจที่ยังไม่มีใครทำสิ่งนี้ ...

มันนานเกินไปที่จะโพสต์ที่นี่ แต่ก็1137672766964589547169964037018563746793726105983919528073581559828เลขศูนย์

หรืออ่านง่ายขึ้น: ~ 10 ⁶⁷ zeroes

ขอบคุณ @dzaima สำหรับการบันทึก 10 ¹⁹⁷ไบต์

Mathematica 12 ตัวอักษร

สัญลักษณ์เท่านั้นไม่มีสตริง

Hello World!   

ตัว! เป็นตัวดำเนินการแฟคทอเรียล แต่เนื่องจากสัญลักษณ์ Hello และ World นั้นไม่ได้กำหนดไว้จะส่งคืนอินพุตที่ไม่เปลี่ยนแปลง

หากเราปรับเปลี่ยนโปรแกรมเล็กน้อย:

Hello=2;
World=3;
Hello World!  

จากนั้นจะพิมพ์12(2 * 3!)

ชุดประกอบ i386 (Linux, ไวยากรณ์ gcc), 440 442 435

วันนี้เป็นวันชุมนุมของฉันและหลังจากนั้นฉันก็จะมีเวลาพอ ฉันอนุญาตให้ตัวเองหมายเลข 128 ดูโปรแกรมด้านล่างเพื่อการอภิปรายว่าทำไม ไม่มีอะไรพิเศษ: ฉันแค่เข้ารหัส "Hello World!" ในฐานะที่เป็นแอสเซมบลี opcodes ที่ทำให้รู้สึกโดยไม่ต้องมีค่าคงที่ตัวเลขและเติมในส่วนที่เหลือด้วยเลขคณิต

#define M mov
M $0,%ecx;inc %cx;M %ecx,%ebx;inc %cx;M %ecx,%eax;add %ax,%ax
M %ecx,%edx;shl %cl,%dx;M (e),%ch;add %dl,%ch;dec %ch;M %ch,(l)
M %ch,(j);M %ch,(z);M $0,%ch;shl %cl,%edx;M %dl,(s);inc %dl
M %dl,(b);M (o),%dl;M %dl,(u);add %al,%dl;dec %dl;M %dl,(r)
M $m,%ecx;M $n,%edx;int $c;M %ebx,%eax;M $0,%ebx;int $c
.data
m:dec %eax;e:gs;l:es;j:es;o:outsl (%esi),(%dx)
s:es;push %edi;u:es;r:es;z:es;fs;b:es;n=.-m
t=(n+n)/n;c=t<<(t*t+t)

(ประกอบกับgcc -nostartfiles hello.S -o helloอาจ-m32ขึ้นอยู่กับส่วนโค้งของคุณ)

ทำไมต้องอดทนกับ 128 ฉันต้องการ syscalls เพื่อแสดงอะไรเลย Linux syscalls อยู่ใน INT 80h (128 ทศนิยม); รูปแบบตัวถูกดำเนินการเดียวสำหรับ INT นั้นทันทีดังนั้นจึงเป็นไปไม่ได้ที่จะมีสิ่งอื่นนอกเหนือจากค่าคงที่ ฉันสามารถ (หลังจากฉันเงียบขรึม) พยายามที่จะแสดงว่ามันเป็นฟังก์ชั่นของค่าคงที่เชิงสัญลักษณ์อื่น ๆ ในรหัสน่าจะเป็นnแต่นั่นก็น่าเบื่อมากสำหรับการได้รับไม่มาก ฉันอ่านข้อ จำกัด เกี่ยวกับตัวเลขเพื่อป้องกันการเข้ารหัส ASCII และนั่นไม่ใช่สิ่งที่ฉันทำที่นี่แน่นอนดังนั้นฉันจึงรู้สึกไร้เดียงสามากพอที่จะส่งสิ่งนี้ (FWIW ฉันยังลองแก้ไขรหัสด้วยตนเอง แต่แยกกันแล้ว) ตอนนี้ไม่มี 128 เหลือแล้ว รหัสบริสุทธิ์!

• Edit1ฟอร์แมตใหม่เพื่อบันทึกบรรทัด; ลบตัวเลข 1 (ไม่มีใครสังเกตเห็น?!)
• บีบอัดEdit2movด้วยมาโคร CPP; กำจัดส่วนที่เหลืออีก 128

Javascript - 305

ค่อนข้างยาว แต่ฉันชอบวิธีที่ใช้

O=0;O++;O=O.toString();alert([O+0+0+O+0+0+0,0+O+O+0+0+O+0+O,O+O+0+O+O+0+0,O+O+0+O+O+0+0,O+O+0+O+O+O+O,O+0+0+0+0+0,O+0+O+0+O+O+O,O+O+0+O+O+O+O, O+O+O+0+0+O+0,O+O+0+O+O+0+0,O+O+0+0+O+0+0,O+0+0+0+0+O].map(function(e){O=0;O++;O++;return String.fromCharCode(parseInt(e,O))}).reduce(function (a,b){return a+b}))

C # (131 ตัวอักษร)

141 ตัวอักษร 142 ตัวอักษร

enum X{Hello,World,A,B=A<<A<<A}class Y{static void Main(){var c=(char)X.B;System.Console.Write(X.Hello.ToString()+c+++X.World+c);}}

อ่านได้:

// Define some constants (B = 32)
enum X { Hello, World, A, B = A << A << A }
class Y
{
    static void Main()
    {
        // Generate the space (character #32)
        var c = (char) X.B;

        // Remember that “!” is character #33
        System.Console.Write(X.Hello.ToString() + c++ + X.World + c);
    }
}

JavaScript, 88

t=!0<<-~-~-~-~!0
r=[]
for(i in{Hello:"O",World:0})r+=i+String.fromCharCode(t++)
alert(r)

99

ขอบคุณ @Timwi สำหรับคำแนะนำ

ลบผู้ประกอบการที่ประกอบไปด้วย:

o={Hello:"O",World:0}
t=!0<<-~-~-~-~!0
c=String.fromCharCode
r=c(0)
for(i in o)r+=i+c(t++)
alert(r)

103
aliasedString.fromCharCode

o={Hello:"O",World:0}
t=!0<<-~-~-~-~!0
c=String.fromCharCode
for(i in o)o[i]?r=i+c(t):alert(r+i+c(++t))

117
เปลี่ยน if-else เป็น operator แบบประกอบ

o={Hello:"O",World:0},t=!0<<-~-~-~-~!0
for(i in o)o[i]?r=i+String.fromCharCode(t):alert(r+i+String.fromCharCode(++t))

125
ฉันกำลังจะเก็บ"O""โอ" ไว้ในรายการ

o={Hello:"O",World:0},t=!0<<-~-~-~-~!0
for(i in o)if(o[i])r=i+String.fromCharCode(t)
else alert(r+i+String.fromCharCode(++t))

133

o={Hello:"O",World:0},t=!0<<(!0+!0<<!0)+!0
for(i in o)if(o[i])r=i+String.fromCharCode(t)
else r+=i+String.fromCharCode(t+!0)
alert(r)

GolfScript 63 ตัวอักษร

[0))):O.)?O.*-.O.?+)).O.*+((..O+.O(.O+?.O-O*@.O+O.+$.O.*-).O/]+

ยังไม่มีอะไรใน GolfScript?

อันนี้ใช้ตัวอักษรตัวเลขเดียว0และตัวแปรที่ชื่อว่าO(ซึ่งใช้เพื่อเก็บหมายเลข3) ทุกอย่างอื่นคือเลขคณิตและการจัดการกองซ้อน สตริงHello World!ถูกสร้างขึ้นจากรหัส ASCII ของตัวอักษรโดยตัวละคร

นี่คือวิธีการทำงาน:

[             # insert start-of-array marker
  0))):O      # increment 0 thrice to get 3, and save it in the variable O
  .)?O.*-     # calculate 3^(3+1) - 3*3 = 81 - 9 = 72 = "H" 
  .O.?+))     # calculate 72 + 3^3 + 1 + 1 = 72 + 27 + 2 = 101 = "e"
  .O.*+((     # calculate 101 + 3*3 - 1 - 1 = 101 + 9 - 2 = 108 = "l"
  .           # ...and duplicate it for another "l"
  .O+         # calculate 108 + 3 = 111 = "o"
  .           # ...and duplicate it for later use
  O(.O+?      # calculate (3-1)^(3-1+3) = 2^5 = 32 = " "
  .O-O*       # calculate (32 - 3) * 3 = 29 * 3 = 87 = "W"
  @           # pull the second 111 = "o" to the top of the stack
  .O+         # calculate 111 + 3 = 114 = "r"
  O.+$        # copy the (3+3 = 6)th last element on the stack, 108 = "l", to top
  .O.*-)      # calculate 108 - (3*3) + 1 = 108 - 9 + 1 = 100 = "d"
  .O/         # calculate int(100 / 3) = 33 = "!"
]             # collect everything after the [ into an array
+             # stringify the array by appending it to the input string

Brainfuck, 111 ไบต์

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

อัลกอริทึมอธิบาย

Increment cell 0 to 10 (it will be loop counter)
Repeat 10 times ; will stop at cell 0
  Increment cell 1 to 7
  Increment cell 2 to 10
  Increment cell 3 to 3
  Increment cell 4 to 1
Increment cell 1 by 2 and output it ; Thus, output ASCII 72 'H'
etc. for all symbols in 'Hello World!'

รุ่นที่ยาวกว่าโดยไม่มีลูป 389 ไบต์:

+++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++.+++++++++++++++++
++++++++++++.+++++++..+++.-------------------
---------------------------------------------
---------------.+++++++++++++++++++++++++++++
++++++++++++++++++++++++++.++++++++++++++++++
++++++.+++.------.--------.------------------
---------------------------------------------
----.-----------------------.

Lua 144 97 86 ตัวอักษร

วิธีการที่แตกต่างกันขึ้นอยู่กับความจริงที่ว่าปุ่มตารางเป็นสตริงและความจริงที่ว่า #Hello == #World == 32 == string.byte '\ n'

e=#"O"t=e+e for k,v in pairs{Hello=0,World=e}do T=t^#k io.write(k,string.char(T+v))end

วิธีแก้ปัญหาถ่าน 145

• ไม่มีสตริงยกเว้น "O" หรือ 0
• ไม่มี Regexes
• ไม่มีฟังก์ชั่นที่สร้างไว้ล่วงหน้า

ไม่ได้เข้ารหัสเดลต้าไบต์แล้วบาง primenumbers ฯลฯ ฯลฯ :)

รุ่น Golfed:

e=#"O"d=e+e t=d+e v=d+t z=v+t T=t^d*d^t n=0 for l,m in pairs{T,T/t-z,z,0,d,-T-z,z*z+t*d,T/d,d,-d*t,-t^d,-T+v}do n=n+m io.write(string.char(n))end

แสดงความคิดเห็น:

-- without numbers, strings, regex
-- except "O" and 0
e=#"0"
t=e+e --2
d=t+e -- 3
v=d+t -- 5
z=v+t -- 7
n=0
T=t^d*d^t -- 72 = 2^3+3^2
for l,m in pairs{T, --72
T/t-z, -- 29 = 72/2-7
z, --7
0, -- 0
d, -- 3
-T-z, -- -79 = -72 - 7
z*z+t*d, -- 55 = 7*7 + 2*3
T/d, -- 24 = 72/3
d, -- 3
-d*t, -- -6
-t^d, -- -8
-T+v -- -67 = -72+5
} do
    n=n+q[k]
    io.write(string.char(n))
end

แก้ไข:เปลี่ยนสตริง O หลายรายการและพบว่ามีตัวเลือกที่เหมาะสมที่สุด

Python ( 126 130)

O=ord("O")
N=O/O
T=N+N
R=N+T
E=T**R
E<<T
print'O'[0].join(chr(c+O)for c in[N-E,E*R-T,_-R,_-R,_,N-_-E-E,E,_,_+R,_-R,E*R-R,T-_-E-E])

J, 250

oo=:#a.
o0=:<.o.^0
o0o=:%:%:%:oo
ooo=:p:^:(-*oo)
o=:<.(^^^0)*(^^0)*(^^0)
o00=:o,~(,[)o0(**(**[))o0o
oo0=:*/p:(!0),>:p:!0
echo u:(o0(**(**]))o0o),(ooo ooo ooo(o.o.^^^0)*oo),o00,(+:%:oo),(oo0-~!p:>:>:0),o,(<.-:o.o.^o.^0),(>:p:(]^])#o00),(*:#0,#:oo),oo0

ฉันสนุกไปกับสิ่งนี้มากเกินไปและฉันเรียนรู้ที่จะบู๊ต J อีกเล็กน้อย นอกจากนี้ooo ooo oooอาจเป็นรหัสที่โง่ที่สุดที่ฉันเคยเขียน

QR พร้อม halfblocks (169) 121 ตัวอักษร

ด้วย QR-Code โดยใช้ UTF-8 อักขระครึ่งตัว:

▗▄▄▄▗▄▖▗▄▄▄  
▐▗▄▐▝█▙▐▗▄▐  
▐▐█▐▝▄ ▐▐█▐  
▐▄▄▟▗▗▗▐▄▄▟  
▗▗▖▄▞▝ ▗ ▖▄  
 ▟▜ Code ▀▟  
 ▙▀ Golf ▘▚  
▗▄▄▄▐▗▘▟▙▝▝  
▐▗▄▐▝▀▛▘▘█▖  
▐▐█▐▐▖▐▝▖▜▘  
▐▄▄▟▗ ▌█▛▗▝  3

โชคไม่ดีที่สิ่งนี้จะไม่แสดงที่นั่น มีตัวอย่างเล็กน้อยที่มีสไตล์ชีทที่เหมาะสม แต่ .. ไม่! ภาษาที่แสดงที่นี่ไม่ใช่ HTML! ภาษาที่นำเสนอที่นี่คือรหัส QR ! (HTML และ CSS ใช้ที่นี่เพื่อแก้ไขข้อผิดพลาดในการนำเสนอเท่านั้น!)

 body {
    font-family: monospace;
    line-height:97%;
 }

▗▄▄▄▗▄▖▗▄▄▄  <br>
▐▗▄▐▝█▙▐▗▄▐  <br>
▐▐█▐▝▄ ▐▐█▐  <br>
▐▄▄▟▗▗▗▐▄▄▟  <br>
▗▗▖▄▞▝ ▗ ▖▄  <br>
 ▟▜ Code ▀▟  <br>
 ▙▀ Golf ▘▚  <br>
▗▄▄▄▐▗▘▟▙▝▝  <br>
▐▗▄▐▝▀▛▘▘█▖  <br>
▐▐█▐▐▖▐▝▖▜▘  <br>
▐▄▄▟▗ ▌█▛▗▝  <br>
             <br>

  ▛▀▀▌▚▝▐▀▌▛▀▀▌
  ▌█▌▌▖▞▚▚▘▌█▌▌
  ▌▀▘▌ ▚▛▞ ▌▀▘▌
  ▀▀▀▘▚▌▙▘▌▀▀▀▘
  ▄▙▛▚▜▀▄▀█▖▝▄▌
  ▖▄▄▘▖▄▄▄▟▗ ▀▘
  ▜Code  golf!▌
  ▚▟▘▘▝▙▛▚▐▀▖▜▘
  ▘▘ ▀▛▗▚▗▛▀▌▄ 
  ▛▀▀▌▟▌▜▖▌▘█▐▘
  ▌█▌▌▘█▌▟█▜▙▐ 
  ▌▀▘▌▚▌▌█▗▝▌▚▘
  ▀▀▀▘ ▝▘▘▀▀▀▀▘

Idealy สิ่งนี้อาจมีลักษณะ:

สกาล่า ( 357 423) 361 ตัวอักษร)

ไม่ใช่คำตอบที่สั้นที่สุดน่าเสียดาย แต่หวังว่าจะได้รับคะแนนโบนัสสำหรับการใช้งาน'O'และ'0'

def h(){type t=scala.Char;def OO(c:t)={(c-('O'/'O')).toChar};def O(c:t)={OO(OO(OO(c)))};def O00(c:t)={(c+('O'/'O')).toChar};def O0(c:t)={O00(O00(O00(c)))};val l=O('O');val z=O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(0)))))))))));print(OO(O(O('O'))).toString+(OO(O(O(O('O')))).toString+l+l+'O'+OO(z)+O0(O0(O0(OO('O'))))+'O'+O0('O')+l+OO(OO(O(O(O('O')))))+z).toLowerCase)}

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

def h(){type t=scala.Char;print(OO(O(O('O'))).toString+(OO(O(O(O('O')))).toString+O('O')+O('O')+'O'+OO(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(0))))))))))))+O0(O0(O0(OO('O'))))+'O'+O0('O')+O('O')+OO(OO(O(O(O('O')))))+O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(O0(0)))))))))))).toLowerCase);def OO[Char](c:t)={(c-('O'/'O')).toChar};def O[Char](c:t)={OO(OO(OO(c)))};def O00[Char](c:t)={(c+('O'/'O')).toChar};def O0[Char](c:t)={O00(O00(O00(c)))}}

รุ่นเก่า (ผิดกฎหมาย):

def h(){type t=scala.Char;print(""+OO(O(O('O')))+(""+OO(O(O(O('O'))))+O('O')+O('O')+'O'+OO(O(O(O(O(O('0'))))))+O0(O0(O0(OO('O'))))+'O'+O0('O')+O('O')+OO(OO(O(O(O('O')))))+O(O(O(O(O('0')))))).toLowerCase);def O0[Char](c:t)={O00(O00(O00(c)))};def O[Char](c:t)={OO(OO(OO(c)))};def OO[Char](c:t)={(c-('O'/'O')).toChar};def O00[Char](c:t)={(c+('O'/'O')).toChar}}

C (หรือ C ++) (ส่วนของร่างกาย: 49) (โกง)

เมื่อรวบรวมรวบรวมเป็นเลขฐานสองที่เรียกว่าHello\ World\!รหัสคือ:

#include <stdio.h>
#include <string.h>
int main(int i,char**a)
{
  int j=i+i,k=j<<j;puts(strrchr(*a,'O'-(k<<j))+i);
}

strrchrส่วนจะต้องลบเส้นทางแบบเต็มในกรณีที่ชื่อโปรแกรมผ่านมีเส้นทางแบบเต็มยังไม่มีข้อโต้แย้งจะต้องผ่านใน ..

บรรทัดการคอมไพล์ทั่วไปอาจเป็น: gcc -o Hello\ World\! foo.c

C ++, 141, 146

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

char o='O'/'O',T=o+o,X=T+o,f=T+X,t=f+f,F=t*f,h=F+F,l=h+t-T,O=l+X;
char c[]={F+t+t+T,h+o,l,l,O,o<<f,h-t-X,O,l+f+o,l,h,0};
cout<<c;

แก้ไข:

ขโมยเคล็ดลับการหารจากโพสต์อื่นไม่น่าเชื่อว่าฉันไม่คิดอย่างนั้น :(

Haskell - 146

a:b:c:f:g:s:j:z=iterate(\x->x+x)$succ 0
y=[f+j,d+a,c+s+h,l,a+b+l,s,f-s+o,o,a+b+o,l,l-f,a+s]
[h,e,l,_,o,_,w,_,r,_,d,x]=y
main=putStrLn$map toEnum y

ฉันคิดว่าการจับคู่รูปแบบจะทำให้ Haskell มีขนาดใหญ่ขึ้นโดยเฉพาะอย่างยิ่งเพราะคุณสามารถเริ่มต้นพลังของสองอย่างดังนี้:

one:two:four:eight:sixteen:thirty_two:sixty_four:the_rest = iterate (*2) 1

แต่เท่าที่เห็นในMtnViewMark ของ Haskell คำตอบ (ซึ่งสมควรได้รับ upvotes หลายหลายโดยวิธีการ) และคำตอบอื่น ๆ การบีบอัดที่ดีขึ้นสามารถทำได้โดยการใช้มากกว่าเพียงแค่การและ+-

Clojure - 46 ตัวอักษร

(map print(butlast(rest(str'(Hello World!)))))

โปรดทราบว่าHelloและWorld!เป็นสัญลักษณ์ไม่ใช่ตัวอักษรใด ๆ

C ++

/*
Hello World!
*/
#define CodeGolf(r) #r
#include<iostream>
using namespace std;
int main()
{
    char str[*"O"];
    freopen(__FILE__,CodeGolf(r),stdin);
    gets(str);gets(str);puts(str);
}

PHP - 49 ตัวอักษร

<?=Hello.chr(($a=-~-~-~0).~-$a).World.chr($a.$a);

รายการเปลี่ยนแปลง :

• (73 -> 86) ลืมเอาเครื่องหมายอัศเจรีย์ ... ถอนหายใจ
• (86 -> 57) ใช้ตัวแปรเดี่ยวพร้อมการเพิ่มขึ้น
• (57 -> 51) เปลี่ยนเป็นใช้ตัวดำเนินการ bitwise ใน 0
• (51 -> 49) ตัวดำเนินการระดับบิตเพิ่มเติม

Python, 106

o=-~-~-~0
L=o+o
d,W=-~L,o**o
_=o*W
print str().join(chr(L+W+_-i)for i in[d*L,L+d,L,L,o,-~_,W,o,0,L,d+d,_])

Perl, 186 ไบต์

@A=(0,0,0,0);@B=(@A,@A);@C=(@B,@B);@D=(@C,@C);@E=(@D,@D);@d=(@E,@D,@A);$l=[@d,@B];$o=[@$l,0,0,0];print(chr@$_)for[@E,@B],[@d,0],$l,$l,$o,\@D,[@E,@C,@A,0,0,0],$o,[@$o,0,0,0],$l,\@d,[@D,0]

ตัวอักษรแต่ละตัวจะถูกพิมพ์ผ่านหมายเลขลำดับซึ่งเป็นความยาวของอาร์เรย์ การสร้างอาร์เรย์ได้รับการปรับให้เหมาะสมผ่านการแสดงเลขฐานสองของตัวเลขตัวอักษร

Ungolfed:

@A = (0, 0, 0, 0);          # A = 2^2
@B = (@A, @A);              # B = 2^3
@C = (@B, @B);              # C = 2^4
@D = (@C, @C);              # D = 2^5
@E = (@D, @D);              # E = 2^6

# d = 100 = 0x64 = 1100100b
@d = (@E, @D, @A);          # d = 2^6 + 2^5 + 2^2 

# l = 108 = 0x6C = 1101100b
$l = [@d, @B];              # l = d + 2^3

# o = 111 = 0x6F = 1101111b
$o = [@$l, 0, 0, 0];        # o = l + 3

print (chr @$_) for
    [@E, @B],              # "H"    H  =  72 = 0x48 = 1001000b = 2^6 + 2^3
    [@d, 0],               # "e"    e  = 101 = 0x65 = 1100101b = d + 1  
    $l, $l, $o,            # "llo"
    \@D,                   # " "   ' ' =  32 = 0x20 = 0100000b = 2^5
    [@E, @C, @A, 0, 0, 0], # "W"    W  =  87 = 0x57 = 1010111b = 2^6 + 2^4 + 2^2 + 3
    $o,                    # "o"
    [@$o, 0, 0, 0],        # "r"    r  = 114 = 0x72 = 1110010b = o + 3
    $l, \@d,               # "ld"
    [@D,0]                 # "!"    !  =  33 = 0x21 = 0100001b = 2^5 + 1

Java 389 ตัวอักษร

พบการประกาศที่ไม่จำเป็น

class A{static int a=0,b=a++,f=a,e=a++;static char p(String s){return(char)Byte.parseByte(s,a);}public static void main(String[]z){long x=e,y=b;String c=((Long)x).toString(),d=((Long)y).toString();char l=p(c+c+d+c+c+d+d),m=p(c+c+d+d+c+d+c),o=(char)(l+a+f),_=p(c+d+d+d+d+d),$=_++;System.out.print(new char[]{p(c+d+d+c+d+d+d),m,l,l,o,$,p(c+d+c+d+c+c+c),o,(char)(o+a+f),l,(char)(m-f),_});}}

ประวัติอยู่ในประวัติการแก้ไขในขณะนี้ซึ่งเป็นเวอร์ชันดั้งเดิมที่อ่านได้:

// H  e  l    l   o      W  o  r   l    d  !
//72,101,108,108,111,32,87,111,114,108,100 33
import static java.lang.Integer.*;
class A
{


    public static void main(String[] args)
    {
        Integer a=0,b=a++,e=a++;  // making a 0 a 1 and a 2 which is required later;
        String c=e.toString(),d=b.toString(),z=c.substring(0,0);  //

        String H = ((char)parseInt(d+c+d+d+c+d+d+d,a))+z+  // make binary values and then to char
                (char)parseInt(d+c+c+d+d+c+d+c,a)+
                (char)parseInt(d+c+c+d+c+c+d+d,a)+
                (char)parseInt(d+c+c+d+c+c+d+d,a)+
                (char)parseInt(d+c+c+d+c+c+c+c,a)+
                (char)parseInt(d+d+c+d+d+d+d+d,a)+
                (char)parseInt(d+c+d+c+d+c+c+c,a)+
                (char)parseInt(d+c+c+d+c+c+c+c,a)+
                (char)parseInt(d+c+c+c+d+d+c+d,a)+
                (char)parseInt(d+c+c+d+c+c+d+d,a)+
                (char)parseInt(d+c+c+d+d+c+d+d,a)+
                (char)parseInt(d+d+c+d+d+d+d+c,a)
                ;
        System.out.println(H);  //obvious
    }

Perl 6 , 199 ไบต์

my \O=+[0];my \t=O+O;my \T=t+O;my \f=(t+t,O);my \F=t+T;my \S=T+T;my \L=(S,F);
say [~] ((S,T),(|L,t,0),(my \l=(|L,T,t)),l,(my \o=(|l,O,0)),F,(S,|f,t,0),o,(|L,|f),l,(|L,t),(F,0),)
.map({chr [+] t X**@_})

(มีการเพิ่มบรรทัดใหม่เพื่อลดความกว้าง แต่ไม่จำเป็นจึงไม่นับ)

Hello World! ถูกเข้ารหัสเป็นรายการของพลังของ 2 ตัวอักษรแต่ละตัว

มีเป็นสิ่งที่เดียวที่ฉันมีตัวอักษรที่ใช้สำหรับอะไรอื่นนอกจาก0 0มันถูกใช้เพื่อสร้างรายการองค์ประกอบหนึ่งซึ่งจะกลายเป็นหมายเลขทันที1ด้วยตัวดำเนินการคำนำหน้าตัวเลข ( +[0])

my \O=+[0];    # one          # (List.elems)
my \t=O+O;     # two
my \T=t+O;     # Three
my \f=(t+t,O); # (four, one)  # <W r>
my \F=t+T;     # five
my \S=T+T;     # six

my \L=(S,F);   # lowercase letter  # (6,5)

say [~] (
  (S,T),            # H
  (|L,t,0),         # e
  (my \l=(|L,T,t)), # l
  l,                # l  reuse <l>
  (my \o=(|l,O,0)), # o  reuse <l>, add 0,1
  F,                # ␠
  (S,|f,t,0),       # W
  o,                # o  reuse <o>
  (|L,|f),          # r
  l,                # l  reuse <l>
  (|L,t),           # d
  (F,0),            # !
).map({chr [+] t X**@_})

JavaScript 662 ตัวอักษร

O=[[,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[],[,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,]];for(O_O=[].length;O.length>O_O;O_O++)document.write(String.fromCharCode((O[O_O].length||-Math.pow([,,].length,[,,,,,].length)-[,,,,,,,].length)+Math.pow([,,].length,[,,,,,,].length)+Math.pow(++[,].length,[,,,].length)-[,].length));document.write(String.fromCharCode(Math.pow([,,].length,[,,,,,].length)+[,].length))

สิ่งที่เกี่ยวกับการใช้อาเรย์ตัวอักษรในทางที่ผิดเพียงเพื่อให้มีฐานเป็นนารี 0โปรแกรมนี้จะได้ประโยชน์จากการไม่ได้ใช้