[Question]
  [
[![Dilbert is awesome](https://i.stack.imgur.com/eOwqR.gif)  
 source: Dilbert, September 8, 1992](http://dilbert.com/strips/comic/1992-09-08/)
I'm hoping to add a new twist on the classic "Hello World!" program.
Code a program that outputs `Hello World!` without:
* String/Character literals
* Numbers (any base)
* Pre-built functions that return "Hello World!"
* RegEx literals
With the exceptions of "O"† and 0.
†"O" is capitalized, "o" is not acceptable.
  
[Answer]
## C, 327 chars
```
#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))))))))
    ))))))))))))))))))))))))))))))))))))));
}
```
Strangely, it does't lose its beauty after preprocessing:
```
main() {
putchar(-~-~-~-~-~-~-~-~-~-~!putchar(~-~-~-~-~-~-~-~-putchar(~-~-~-~-~-~-
putchar(-~-~-~putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-~-~-~-~-~-~-~-~-~-~-~-~-~!putchar(-~-~-~putchar(putchar(-~-~-~-~-~-~-~putchar
(-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~putchar(-~-~-~-~-~-
~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~0))))))))))));
}
```
[Answer]
## Windows PowerShell, *way too much*
Yes, indeed, back in the day we had to write a ¬ªHello world¬´ using (almost exclusively) zeroes ...
```
&{-join[char[]]($args|% Length)} `
O00000000000000000000000000000000000000000000000000000000000000000000000 `
O0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O0000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
O00000000000000000000000000000000
```
On a more serious note:
## Windows PowerShell, 25
```
Write-Host Hello World!
```
No string literal. The `Hello World!` in there just happens to be *parsed* as a string since PowerShell is in argument parsing mode there.
[Answer]
## BrainFuck, 102 ~~111~~ characters
```
++++++++[>++++[>++>+++>+++>+<<<<-]>+>->+>>+[<]<-]>>.>>---.+++++++..+++.>.<<-.>.+++.------.--------.>+.
```
Meets all of the rules.
Credit goes to [Daniel Cristofani](http://www.hevanet.com/cristofd/brainfuck/short.b).
[Answer]
# C, 182 bytes
```
#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);}
```
[Answer]
## C program - 45
(cheating)
Lexically, this doesn't use any string literals or regex literals. It takes advantage of the [stringification](http://gcc.gnu.org/onlinedocs/cpp/Stringification.html) feature of the C preprocessor. `s(x)` is a macro that turns its argument into a string.
```
#define s(x)#x
main(){puts(s(Hello World!));}
```
[Answer]
# [Unary](http://esolangs.org/wiki/Unary), ~~10197~~ 1137672766964589547169964037018563746793726105983919528073581559828 bytes
I'm surprised that no one's done this yet...
It's too long to post here, but it's **1137672766964589547169964037018563746793726105983919528073581559828** zeroes.
Or, more easily read: ***~1067*** zeroes.
[Thanks to @dzaima for saving 10197 bytes](https://chat.stackexchange.com/transcript/message/46201745#46201745)
[Answer]
## Haskell - 143 characters
```
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, that was woolly!
No numbers, no numeric operations, variables renamed for amusement.
Some exposition might be nice:
* `o%y`, `o&y`, and `o!y` each applies the function `o` to `y` multiple times: 3, 9, and 29 times respectively. 29?!?! Yes, 29!
* `r` and `w` are next and previous character, which when applied using the above higher- order functions can be made to get all the characters needed from `'O'`.
The sequence of jumps needed is:
```
'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    -> ' '
```
---
* Edit: (134 -> 144) Forgot to output an exclamation point, sigh....
* Edit: (144 -> 143) Removed a unnecessary `$`, renamed `#` to `!` for Hugs.
[Answer]
## Mathematica 12 chars
Only symbols, no strings.
```
Hello World!   
```
The ! is a factorial operator, but as the symbols Hello and World are undefined, returns the input unchanged. 
If we modify the program a bit: 
```
Hello=2;
World=3;
Hello World!  
```
Then it prints `12` (2 \* 3!)
[Answer]
## i386 assembly (Linux, gcc syntax), ~~440~~ ~~442~~ 435
Today's my assembly day, and after that I'll have had enough for a while. ~~I allowed myself number 128, see below program for discussion of why.~~ Nothing extraordinary: I'm just encoding "Hello World!" as assembly opcodes where that made sense without numeric constants, and filled in the rest with arithmetic.
```
#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)
```
(assemble with `gcc -nostartfiles hello.S -o hello`, possibly `-m32` depending on your arch)
~~Why the tolerance for 128? I need syscalls to actually show anything; Linux syscalls are on INT 80h (128 decimal); the only operand format for INT is immediate, so it's not possible to have anything else than a constant (to the code) there. I *could* (after I get sober) attempt to express it as a function of other symbolic constants in the code, likely *n*, but that's getting *very* boring for not much gain. I read the constraint on numbers as a way to prevent ASCII coding, and that's definitely not what I'm doing here, so I feel innocent enough to submit this. (FWIW, I also tried self-modifying code, but that segfaulted)~~ There's now no 128 left either. The code's pure!
* **Edit1** reformatted to save lines; removed a numeric 1 (nobody
noticed?!)
* **Edit2** compressed `mov` with CPP macros; eliminated the remaining 128.
[Answer]
# Javascript - 305
A bit long but I like the method used.
```
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}))
```
[Answer]
# C# (131 chars)
~~141 chars~~ ~~142 chars~~
```
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);}}
```
Readable:
```
// 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);
    }
}
```
[Answer]
# JavaScript, 88
```
t=!0<<-~-~-~-~!0
r=[]
for(i in{Hello:"O",World:0})r+=i+String.fromCharCode(t++)
alert(r)
```
99
### Many thanks to @Timwi for the suggestions
removed ternary operator:
```
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  
aliased `String.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  
Switched if-else to ternary 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  
I'm keeping the `"O"` just to have an "O" in the program.
```
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)
```
[Answer]
# Brainfuck, 111 bytes
```
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++
.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.
------.--------.>+.>.
```
## Algorithm explained
```
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!'
```
## Longer version without loop, 389 bytes:
```
+++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++.+++++++++++++++++
++++++++++++.+++++++..+++.-------------------
---------------------------------------------
---------------.+++++++++++++++++++++++++++++
++++++++++++++++++++++++++.++++++++++++++++++
++++++.+++.------.--------.------------------
---------------------------------------------
----.-----------------------.
```
[Answer]
## GolfScript, 63 chars
```
[0))):O.)?O.*-.O.?+)).O.*+((..O+.O(.O+?.O-O*@.O+O.+$.O.*-).O/]+
```
What, no GolfScript entry yet?
This one uses a single numeric literal `0` and a variable named `O` (which is used to store the number `3`). Everything else is arithmetic and stack manipulation. The string `Hello World!` is built up from its ASCII codes, character by character.
### Here's how it works:
```
[             # 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
```
[Answer]
## 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])
```
[Answer]
### QR with halfblocks ~~(169)~~ 121 characters
With QR-Code by using UTF-8 Half-blocks characters:
```
‚ñó‚ñÑ‚ñÑ‚ñÑ‚ñó‚ñÑ‚ññ‚ñó‚ñÑ‚ñÑ‚ñÑ  
‚ñê‚ñó‚ñÑ‚ñê‚ñù‚ñà‚ñô‚ñê‚ñó‚ñÑ‚ñê  
‚ñê‚ñê‚ñà‚ñê‚ñù‚ñÑ ‚ñê‚ñê‚ñà‚ñê  
‚ñê‚ñÑ‚ñÑ‚ñü‚ñó‚ñó‚ñó‚ñê‚ñÑ‚ñÑ‚ñü  
‚ñó‚ñó‚ññ‚ñÑ‚ñû‚ñù ‚ñó ‚ññ‚ñÑ  
 ‚ñü‚ñú Code ‚ñÄ‚ñü  
 ‚ñô‚ñÄ Golf ‚ñò‚ñö  
‚ñó‚ñÑ‚ñÑ‚ñÑ‚ñê‚ñó‚ñò‚ñü‚ñô‚ñù‚ñù  
‚ñê‚ñó‚ñÑ‚ñê‚ñù‚ñÄ‚ñõ‚ñò‚ñò‚ñà‚ññ  
‚ñê‚ñê‚ñà‚ñê‚ñê‚ññ‚ñê‚ñù‚ññ‚ñú‚ñò  
‚ñê‚ñÑ‚ñÑ‚ñü‚ñó ‚ñå‚ñà‚ñõ‚ñó‚ñù  3
```
Unfortunely, this won't render nicely there. There is a little snippet with appropriate style sheet, but.. No! The language presented here is **not** HTML! Language presented here is [QR Code](https://en.wikipedia.org/wiki/QR_code)! (HTML and CSS is used here only to work around presentation bug!)
```
 body {
    font-family: monospace;
    line-height:97%;
 }
```
```
‚ñó‚ñÑ‚ñÑ‚ñÑ‚ñó‚ñÑ‚ññ‚ñó‚ñÑ‚ñÑ‚ñÑ¬†¬†<br>
‚ñê‚ñó‚ñÑ‚ñê‚ñù‚ñà‚ñô‚ñê‚ñó‚ñÑ‚ñê¬†¬†<br>
‚ñê‚ñê‚ñà‚ñê‚ñù‚ñÑ¬†‚ñê‚ñê‚ñà‚ñê¬†¬†<br>
‚ñê‚ñÑ‚ñÑ‚ñü‚ñó‚ñó‚ñó‚ñê‚ñÑ‚ñÑ‚ñü¬†¬†<br>
‚ñó‚ñó‚ññ‚ñÑ‚ñû‚ñù¬†‚ñó¬†‚ññ‚ñÑ¬†¬†<br>
¬†‚ñü‚ñú¬†Code¬†‚ñÄ‚ñü¬†¬†<br>
¬†‚ñô‚ñÄ¬†Golf¬†‚ñò‚ñö¬†¬†<br>
‚ñó‚ñÑ‚ñÑ‚ñÑ‚ñê‚ñó‚ñò‚ñü‚ñô‚ñù‚ñù¬†¬†<br>
‚ñê‚ñó‚ñÑ‚ñê‚ñù‚ñÄ‚ñõ‚ñò‚ñò‚ñà‚ññ¬†¬†<br>
‚ñê‚ñê‚ñà‚ñê‚ñê‚ññ‚ñê‚ñù‚ññ‚ñú‚ñò¬†¬†<br>
‚ñê‚ñÑ‚ñÑ‚ñü‚ñó¬†‚ñå‚ñà‚ñõ‚ñó‚ñù¬†¬†<br>
¬†¬†¬†¬†¬†¬†¬†¬†¬†¬†¬†¬†¬†<br>
```
### QR with halfblocks (169)
```
  ‚ñõ‚ñÄ‚ñÄ‚ñå‚ñö‚ñù‚ñê‚ñÄ‚ñå‚ñõ‚ñÄ‚ñÄ‚ñå
  ‚ñå‚ñà‚ñå‚ñå‚ññ‚ñû‚ñö‚ñö‚ñò‚ñå‚ñà‚ñå‚ñå
  ‚ñå‚ñÄ‚ñò‚ñå‚ÄÉ‚ñö‚ñõ‚ñû‚ÄÉ‚ñå‚ñÄ‚ñò‚ñå
  ‚ñÄ‚ñÄ‚ñÄ‚ñò‚ñö‚ñå‚ñô‚ñò‚ñå‚ñÄ‚ñÄ‚ñÄ‚ñò
  ‚ñÑ‚ñô‚ñõ‚ñö‚ñú‚ñÄ‚ñÑ‚ñÄ‚ñà‚ññ‚ñù‚ñÑ‚ñå
  ‚ññ‚ñÑ‚ñÑ‚ñò‚ññ‚ñÑ‚ñÑ‚ñÑ‚ñü‚ñó‚ÄÉ‚ñÄ‚ñò
  ‚ñúCode‚ÄÉ‚ÄÉgolf!‚ñå
  ‚ñö‚ñü‚ñò‚ñò‚ñù‚ñô‚ñõ‚ñö‚ñê‚ñÄ‚ññ‚ñú‚ñò
  ‚ñò‚ñò‚ÄÉ‚ñÄ‚ñõ‚ñó‚ñö‚ñó‚ñõ‚ñÄ‚ñå‚ñÑ‚ÄÉ
  ‚ñõ‚ñÄ‚ñÄ‚ñå‚ñü‚ñå‚ñú‚ññ‚ñå‚ñò‚ñà‚ñê‚ñò
  ‚ñå‚ñà‚ñå‚ñå‚ñò‚ñà‚ñå‚ñü‚ñà‚ñú‚ñô‚ñê‚ÄÉ
  ‚ñå‚ñÄ‚ñò‚ñå‚ñö‚ñå‚ñå‚ñà‚ñó‚ñù‚ñå‚ñö‚ñò
  ‚ñÄ‚ñÄ‚ñÄ‚ñò‚ÄÉ‚ñù‚ñò‚ñò‚ñÄ‚ñÄ‚ñÄ‚ñÄ‚ñò
```
Idealy, this could look like:
![QR:Hello World!](https://i.stack.imgur.com/INyyi.png)
[Answer]
# 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
```
I had entirely too much fun with this one, and I learned a little bit more J to boot. Also, `ooo ooo ooo` may be the stupidest code I've ever written.
[Answer]
# [ForWhile](https://esolangs.org/wiki/ForWhile) 22 bytes
`!dlroW olleH{}+~(~~@#)`
uses ForWhiles ability to read its own source code
[online Interpreter](https://bsoelch.github.io/OneChar.js/?lang=forwhile&src=IWRscm9XIG9sbGVIe30rfih-fkAjKQ==)
# Explanation
`!` invert empty stack, will push one
`dlroW olleH` no-ops (all letters and white spaces are interpreted as comments)
`{}` empty procedure, push current instruction pointer (`-14`)
`+~` add one and flip bits (`12` length of the string)
`(~~@#)` print the first 12 characters of the program (stored at address `-1` to `-12`)
[Answer]
## Lua 144 97 86 chars
A different approach, based on the fact that table keys are also strings, and the fact that #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 char solution**
* no strings except "O" or 0
* no Regexes
* no pre-built functions
Did delta encoding of the bytes, then some primenumbers etc etc :)
Golfed version:
```
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
```
Commented:
```
-- 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
```
**Edit:** Changed multiple O strings, and found some more optimalisations.
[Answer]
## Scala (357 423 361 characters)
Not the shortest answer, unfortunately, but hoping to get bonus marks for the most use of `'O'` and `'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)}
```
Previously:
```
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)))}}
```
Old (illegal) version:
```
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}}
```
[Answer]
**C (or C++)** (body segment: 49)
(cheating)
when compiling, compile to a binary called `Hello\ World\!`, the code is:
```
#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);
}
```
The `strrchr` segment is required to remove the full path in the event the program name passed in contains the full path, also *no arguments must be passed in*..
Typical compile line could be: `gcc -o Hello\ World\! foo.c`
[Answer]
# Java 389 characters
spotted a unnecessary declaration
```
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),_});}}
```
History is in edit history
now the original ungolfed version readable:
```
// 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
    }
```
[Answer]
# C++, 141, ~~146~~
First time trying one of these, can probably be improved quite a bit yet:
```
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;
```
EDIT:
Stole the divide trick from another post, can't believe I didn't think of that :(
[Answer]
## 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
```
I figured pattern matching would give Haskell a huge leg up, in particular because you can initialize powers of two like so:
```
one:two:four:eight:sixteen:thirty_two:sixty_four:the_rest = iterate (*2) 1
```
However, as seen in [MtnViewMark's Haskell answer](https://codegolf.stackexchange.com/questions/1536/hello-world-0-0/1555#1555) (which deserves many many upvotes, by the way) and other answers, better compression can be achieved by using more than just `+` and `-`.
[Answer]
## Clojure - 46 chars
```
(map print(butlast(rest(str'(Hello World!)))))
```
Note that `Hello` and `World!` are symbols, not literals of any kind.
[Answer]
**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);
}
```
[Answer]
## PHP ‚Äì 49 chars
```
<?=Hello.chr(($a=-~-~-~0).~-$a).World.chr($a.$a);
```
**Changelog**:
* (73 -> 86) Forgot to output an exclamation point... *sigh*
* (86 -> 57) Uses a single variable with incrementing
* (57 -> 51) Changed to use bitwise operators on 0
* (51 -> 49) More bitwise operators
[Answer]
# 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,_])
```
[Answer]
# Perl, 186 bytes
```
@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]
```
Each chararcter is printed via its ordinal number, which is the length of an array. The construction of the arrays are optimized via the binary representation of the character numbers.
## 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
```
[Answer]
## [Perl 6](http://perl6.org), 199 bytes
```
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**@_})
```
(newlines are added to reduce width, but are unnecessary so are not counted)
---
`Hello World!` is encoded as a list of lists of the powers of 2 of each letter. 
There is exactly one place where I have a literal `0` that is used for anything other than a `0`. It is used to create a one-element list, which is immediately turned into the number `1` with the numeric prefix operator (`+[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**@_})
```
]