nguồn: Dilbert, ngày 8 tháng 9 năm 1992

Tôi hy vọng sẽ thêm một bước ngoặt mới vào "Hello World!" Cổ điển chương trình.

Mã chương trình xuất ra Hello World!mà không có:

• Chuỗi / ký tự chữ
• Số (bất kỳ cơ sở)
• Các hàm dựng sẵn trả về "Hello World!"
• RegEx chữ

Với ngoại lệ của "O" ^† và 0.

"O" được viết hoa, "o" không được chấp nhận.

Windows PowerShell, quá nhiều

Vâng, thực sự, vào ngày trước, chúng tôi đã phải viết một »Xin chào thế giới« bằng cách sử dụng (hầu như độc quyền) số không ...

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

Trên một lưu ý nghiêm trọng hơn:

Windows PowerShell, 25

Write-Host Hello World!

Không có chuỗi chữ. Cái Hello World!trong đó tình cờ được phân tích cú pháp dưới dạng một chuỗi vì PowerShell đang ở chế độ phân tích cú pháp đối số ở đó.

C, 327 ký tự

#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))))))))
    ))))))))))))))))))))))))))))))))))))));
}

Kỳ lạ thay, nó không mất đi vẻ đẹp của nó sau khi tiền xử lý:

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

BrainFuck, 102 111 ký tự

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

Đáp ứng tất cả các quy tắc.

Tín dụng cho Daniel Cristofani .

C, 182 byte

#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);}

Chương trình C - 45

(gian lận)

Về mặt thực tế, điều này không sử dụng bất kỳ chuỗi ký tự hoặc chuỗi ký tự regex nào. Nó tận dụng tính năng xâu chuỗi của bộ tiền xử lý C. s(x)là một macro biến đối số của nó thành một chuỗi.

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

Haskell - 143 ký tự

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]

oy, đó là len!

Không có số, không có hoạt động số, các biến được đổi tên để giải trí.

Một số giải thích có thể là tốt đẹp:

• o%y, o&yvà o!ymỗi lần áp dụng hàm ocho ynhiều lần: 3, 9 và 29 lần. 29?!?! Vâng, 29!
• rvà wlà ký tự tiếp theo và trước đó, khi được áp dụng bằng các hàm bậc cao hơn ở trên có thể được tạo để lấy tất cả các ký tự cần thiết từ đó 'O'.

Trình tự nhảy cần thiết là:

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

• Chỉnh sửa: (134 -> 144) Quên xuất ra dấu chấm than, thở dài ....
• Chỉnh sửa: (144 -> 143) Removed một không cần thiết $, đổi tên #để !cho Hugs.

Unary , 10 ¹⁹⁷ 1137672766964589547169964037018563746793726105983919528073581559828 byte

Tôi ngạc nhiên khi chưa có ai làm điều này ...

Quá lâu để đăng ở đây, nhưng đó là 1137672766964589547169964037018563746793726105983919528073581559828 số không.

Hoặc, dễ đọc hơn: ~ 10 ⁶⁷ số không.

Cảm ơn @dzaima đã lưu 10 ¹⁹⁷ byte

Toán học 12 ký tự

Chỉ có biểu tượng, không có chuỗi.

Hello World!   

Các ! là một toán tử giai thừa, nhưng khi các ký hiệu Hello và World không được xác định, trả về đầu vào không thay đổi.

Nếu chúng tôi sửa đổi chương trình một chút:

Hello=2;
World=3;
Hello World!  

Sau đó, nó in 12(2 * 3!)

lắp ráp i386 (Linux, cú pháp gcc), 440 442 435

Hôm nay là ngày tập hợp của tôi, và sau đó tôi sẽ có đủ thời gian. Tôi cho phép mình số 128, xem chương trình dưới đây để thảo luận về lý do tại sao. Không có gì bất thường: Tôi chỉ đang mã hóa "Xin chào thế giới!" như opcodes lắp ráp trong đó có ý nghĩa mà không có hằng số, và điền vào phần còn lại với số học.

#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)

(lắp ráp với gcc -nostartfiles hello.S -o hello, có thể -m32tùy thuộc vào vòm của bạn)

Tại sao dung sai cho 128? Tôi cần các tòa nhà cao tầng để thực sự hiển thị bất cứ điều gì; Các tòa nhà Linux nằm trên INT 80h (128 thập phân); định dạng toán hạng duy nhất cho INT là ngay lập tức, do đó không thể có bất kỳ thứ gì khác ngoài hằng số (mã) ở đó. Tôi có thể (sau khi tôi tỉnh táo) cố gắng diễn đạt nó như là một hàm của các hằng số tượng trưng khác trong mã, có thể là n , nhưng điều đó trở nên rất nhàm chán vì không thu được nhiều. Tôi đọc các ràng buộc về các con số như là một cách để ngăn chặn mã hóa ASCII, và đó chắc chắn không phải là những gì tôi đang làm ở đây, vì vậy tôi cảm thấy đủ ngây thơ để gửi nó. (FWIW, tôi cũng đã thử mã tự sửa đổi, nhưng mã này bị lỗi) Bây giờ cũng không còn 128. Mã này là thuần túy!

• Edit1 được định dạng lại để lưu các dòng; đã xóa một số 1 (không ai nhận thấy?!)
• Edit2 được nén movvới các macro CPP; loại bỏ 128 còn lại.

Javascript - 305

Một chút dài nhưng tôi thích phương pháp được sử dụng.

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 ký tự)

141 ký tự 142 ký tự

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);}}

Có thể đọc đượ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

Rất cám ơn @Timwi vì những gợi ý

loại bỏ toán tử ternary:

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
bí danhString.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 Đã
chuyển đổi if-other sang toán tử ternary

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
Tôi đang giữ "O"chỉ để có một chữ "O" trong chương trình.

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 ký tự

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

Gì, chưa có mục GolfScript nào?

Cái này sử dụng một chữ số duy nhất 0và một biến có tên O(được sử dụng để lưu trữ số 3). Tất cả mọi thứ khác là số học và thao tác ngăn xếp. Chuỗi Hello World!được xây dựng từ mã ASCII của nó, theo từng ký tự.

Đây là cách nó hoạt động:

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

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

Thuật toán giải thích

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

Phiên bản dài hơn không có vòng lặp, 389 byte:

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

Lua 144 97 86 ký tự

Một cách tiếp cận khác, dựa trên thực tế là các khóa bảng cũng là các chuỗi và thực tế là #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

Giải pháp 145 char

• không có chuỗi nào ngoại trừ "O" hoặc 0
• không có chế độ
• không có chức năng dựng sẵn

Đã mã hóa delta của byte, sau đó một số primenumbers, v.v. :)

Phiên bản chơi gôn:

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

Đã bình luận:

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

Chỉnh sửa: Thay đổi nhiều chuỗi O và tìm thấy một số tối ưu hóa hơn.

Con trăn ( 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

Tôi đã hoàn toàn có quá nhiều niềm vui với cái này và tôi đã học được thêm một chút J để khởi động. Ngoài ra, ooo ooo ooocó thể là mã ngu ngốc nhất tôi từng viết.

QR với Halfblocks (169) 121 ký tự

Với Mã QR bằng cách sử dụng các ký tự nửa khối UTF-8:

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

Thật không may, điều này sẽ không hiển thị độc đáo ở đó. Có một đoạn nhỏ với bảng kiểu thích hợp, nhưng .. Không! Ngôn ngữ được trình bày ở đây không phải là HTML! Ngôn ngữ được trình bày ở đây là Mã QR ! (HTML và CSS được sử dụng ở đây chỉ để khắc phục lỗi trình bày!)

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

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

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

Ý tưởng, điều này có thể trông giống như:

Scala ( 357 423 361 ký tự)

Thật không may, câu trả lời ngắn nhất, không may, nhưng hy vọng sẽ nhận được điểm thưởng cho việc sử dụng nhiều nhất 'O'và'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)}

Trước đây:

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)))}}

Phiên bản cũ (bất hợp pháp):

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 (hoặc C ++) (đoạn cơ thể: 49) (gian lận)

khi biên dịch, biên dịch thành một nhị phân được gọi Hello\ World\!, mã là:

#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);
}

Các strrchrphân khúc được yêu cầu để loại bỏ đường dẫn đầy đủ trong trường hợp tên chương trình thông qua năm chứa đường dẫn đầy đủ, cũng không có đối số phải được thông qua trong ..

Dòng biên dịch điển hình có thể là: gcc -o Hello\ World\! foo.c

C ++, 141, 146

Lần đầu tiên thử một trong những thứ này, có lẽ có thể được cải thiện khá nhiều:

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;

BIÊN TẬP:

Lấy trộm thủ thuật chia bài từ một bài đăng khác, không thể tin rằng tôi đã không nghĩ về điều đó :(

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

Tôi cho rằng việc khớp mẫu sẽ giúp Haskell có một bước tiến lớn, đặc biệt bởi vì bạn có thể khởi tạo sức mạnh của hai người như vậy:

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

Tuy nhiên, như đã thấy trong câu trả lời Haskell của MtnViewMark (xứng đáng với nhiều câu trả lời, nhân tiện) và các câu trả lời khác, có thể đạt được nén tốt hơn bằng cách sử dụng nhiều hơn chỉ +và -.

Clojure - 46 ký tự

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

Lưu ý rằng Hellovà World!là biểu tượng, không phải bằng chữ nào.

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 ký tự

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

Thay đổi :

• (73 -> 86) Quên xuất ra dấu chấm than ... thở dài
• (86 -> 57) Sử dụng một biến duy nhất với mức tăng
• (57 -> 51) Thay đổi để sử dụng toán tử bitwise trên 0
• (51 -> 49) Các toán tử bitwise khác

Con trăn, 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 byte

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

Mỗi chararcter được in thông qua số thứ tự của nó, đó là chiều dài của một mảng. Việc xây dựng các mảng được tối ưu hóa thông qua biểu diễn nhị phân của các số ký tự.

Ung dung:

@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 ký tự

phát hiện một tuyên bố không cần thiết

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),_});}}

Lịch sử là trong lịch sử chỉnh sửa bây giờ phiên bản không có bản gốc có thể đọc được:

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

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**@_})

(dòng mới được thêm vào để giảm chiều rộng, nhưng không cần thiết nên không được tính)

Hello World! được mã hóa dưới dạng một danh sách các danh sách quyền hạn của 2 chữ cái.

Có chính xác một nơi mà tôi có một nghĩa đen 0được sử dụng cho bất cứ điều gì khác ngoài a 0. Nó được sử dụng để tạo danh sách một thành phần, ngay lập tức được chuyển thành số 1với toán tử tiền tố số ( +[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**@_})

Ký tự 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))

Điều gì về việc lạm dụng các mảng chữ chỉ để có cơ sở unary. Chương trình này có lợi thế là không sử dụng 0.