# Hello World 0.0!

source: Dilbert, September 8, 1992

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.

• One of [code-golf] and [code-challenge] please, not both. The point of these tags to to help people find questions with the rules they want to use. Essentially every question on this site should be a game of some kind or another. – dmckee --- ex-moderator kitten Mar 11 '11 at 22:29
• -1 We've already had Obfuscated Hello World, and I think this challenge is too similar. I'd have cast a "close as duplicate" vote, if I weren't a mod. – Chris Jester-Young Mar 11 '11 at 22:35
• @zzzzBov: I don't think it's different enough to warrant another question in the "hello world" theme; a different theme would have been better. But, that's just my opinion. – Chris Jester-Young Mar 11 '11 at 23:39
• I think this is a fine code golf - and better than the prior one. – MtnViewMark Mar 12 '11 at 6:58
• Some people seem to assume that "O"* means they can have a string literal with any number of O’s, including zero. I don’t think that was the intention. Please clarify. – Timwi Mar 12 '11 at 21:12

## Burlesque, 28 bytes

blsq ) {Hello,}m]\[{world!}m]\[ClwD
Hello, world!


Explanation:

{Hello,} is actually a Block containing the commands He, ll and o,. The reason we can't use {Hello, world!} is because the parser skips whitespaces obviously. m] converts commands to strings and \[ concatenates them. With wD (which is unwords) we insert missing space.

For what it's worth a few notes about how Burlesque parses commands. Pretty much everything that does not start with a digit will be parsed as a command with the exception of the minus sign which tries to parse a double first, if that fails it tries to parse it as an integer and if that fails it tries to parse it as a command. For example a{b} contains NO block. That's the command a{ followed by the command b}. {ab} is a block that contains the command ab. {-}-}} is a block containing the command -} twice. a2.0 is the command a2 followed by the command .0. (That 2.0 is NOT a double in there).

# Hassium, 264 Bytes

Well this was interesting.

use Math;func main(){a=Math.pi;a/=a;b=a+a;t=Math.pow(b+b,b+a);o=t+Math.pow(b*b+b,b);d(t+(b*b*b));d(o+a);c=o+(b*b*b)d(c)d(c)d(c+b+a)d(Math.pow(b*b,b)*2)d(o-((b*(b*b)+(b*b+a))))d(c+b+a)d((c+b+a)+(b+a))d(c)d(o)d(Math.pow(b*b,b)*b+a);}func d(m)print(Convert.toChar(m))


Run online and see expanded here

# Prolog, 198 bytes

p:-atom_codes('O0',[O,N]),A is O-N,B is O/O,C is A-B-B,D is B+B+B,G is O+C,H is G+D,I is H+D,K is A+B,L is K+B,M is C*D,J is L*D+B,F is J+B,E is F-C,atom_codes(X,[E,F,G,G,H,K,M,H,I,G,J,L]),write(X).


Explanation

p:-atom_codes('O0',[O,N]),                      % O=79, N=48
A is O-N,                                    % A=79-48=31
B is O/O,                                    % B=79/79=1
C is A-B-B,                                  % C=31-1-1=29
D is B+B+B,                                  % D=1+1+1=3
G is O+C,                                    % G=79+29=108
H is G+D,                                    % H=108+3=111
I is H+D,                                    % I=111+3=114
K is A+B,                                    % K=31+1=32
L is K+B,                                    % L=32+1=33
M is C*D,                                    % M=29*3=87
J is L*D+B,                                  % J=33*3+1=100
F is J+B,                                    % F=100+1=101
E is F-C,                                    % E=101-29=72
atom_codes(X,[E,F,G,G,H,K,M,H,I,G,J,L]),     % X='Hello World!'
write(X).


# Emacs Lisp, 281 bytes

(defalias'O'string-to-char)
(setq O(1+(O"O"))O0(-(1+ O)(O"O"))OO(* O0 O0 O0 O0 O0 O0)O1(+ O(- O OO))OOO(+ O1 (* O0 O0 O0) O0 O0)OO1(1+ (+ OOO O0)))
(princ(string(-O(* O0 O0 O0))(1+(+ O1 O0 O0))OOO OOO OO1 (/ OO O0)(1+ (+ O O0 O0 O0))OO1(1+ (+ OO1 O0))OOO(+ O1 O0 O0)(1+(/ OO O0))))


1+ is not a number, but a function, that returns 1 + NUMBER with NUMBER as its argument.

Ungolfed:

(defalias'O'string-to-char)
(setq O (1+ (O"O"))                 ; 80 => "P"
O0 (-(1+ O)(O"O"))            ; 2
OO (* O0 O0 O0 O0 O0 O0)      ; 64
O1 (+ O(- O OO))              ; 96
OOO (+ O1 (* O0 O0 O0) O0 O0) ; 108 => "l"
OO1 (1+ (+ OOO O0)))          ; 111 => "o"
(princ
(string
(- O (* O0 O0 O0))   ; "H"
(1+(+ O1 O0 O0))     ; "e"
OOO                  ; "l"
OOO                  ; "l"
OO1                  ; "o"
(/ OO O0)            ; " "
(1+ (+ O O0 O0 O0))  ; "W"
OO1                  ; "o"
(1+ (+ OO1 O0))      ; "r"
OOO                  ; "l"
(+ O1 O0 O0)         ; "d"
(1+ (/ OO O0))))     ; "!"


## Clojure, 19 bytes

Since I am not allowed to comment (yet) both of atrociously long Clojure answers, here is mine:

(pr 'Hello 'World!)


3 bytes shorter than print

• 'something is a symbol, not string literal. Symbols evaluate to their names, which are string literals – Michael M Sep 30 '16 at 6:19
• don't symbols have all caps? – Destructible Lemon Oct 26 '16 at 5:13

# ZX Spectrum BASIC, 16 bytes

(including the end of line, but excluding the line number, since that is not part of the code itself)

The hexadecimal representation of the code is:

08 08 48 65 6c 6c 6f 2c 20 77 6f 72 6c 64 21 0d


Its "normal" entry would be:

1\x08\x08Hello, world!


where 1 is the (unimportant) line number, \x08 means byte with the value 0x08 - you might have to overcome some slight difficulties if you want to enter it from the keyboard.

Note that Hello, world! is not a string literal, but part of the code itself.

Bonus: you do not have to RUN the program, just "having" it in the computer is enough (in keyword mode) to display:

If you accept "garbage" around the message, the code could be made shorter by three bytes.

• loophole: As "part of the code", it´s a string literal; no matter how you call it. It is also no program, not even a code snippet. It´s actually just plain text. – Titus Jan 28 '17 at 12:33
• @Titus No, it most definitely is not a string literal - in ZX Spectrum BASIC there is a very sharp difference between code and literals - numbers and strings (also in how they are represented in RAM). And this is none of them, it's neither a string variable. – Radovan Garabík Jan 28 '17 at 13:47

# PHP, 160 157 bytes

no literals at all. Still wonder if it has golfing potential left:

for(;$c=[$h=($f=($t=++$n+$n)+$t)+$f+$s=$f*$f*$f,$e=$s+$s/$t+$v=$f+$n--,$l=$e+$f+--$f,$l,$o=$l+$f,$s/=$t,$h+$v*$f,$o,$o+$f,$l,--$e,++$s][+$i++];)echo chr($c);


creates an array with the ascii codes and loops through it to print the characters.
Run with -nr or try it online.

breakdown

for(;$c=[$h=
($f=($t=++$n+$n)+$t) #$n=1,$t=2,$f=4
+$f+$s=$f*$f*$f, # H$s=64,$h=72$e=$s+$s/$t+$v=$f+$n--, # e     $n=0,$v=5,$e=101$l=$e+$f+--$f,$l,       # ll    $f=3,$l=108
$o=$l+$f, # o$o=111
$s/=$t,                 # space $s=32$h+$v*$f,$o, # Wo$o+$f,$l,               # rl
--$e, # d$e=100
++$s # !$s=33
][+$i++];) # loop through array echo chr($c);           # print character


## F#, 103 bytes

let[<EntryPoint>]Hello world!a=System.Reflection.MethodBase.GetCurrentMethod().Name|>stdout.Write;0


Similar to some of the other answers here. The  characters around the method name are not literals, rather they "delimit an identifier that would otherwise not be a legal identifier, such as a language keyword." (Source)

They do make F# nice for writing tests, since you can give a long human-language name for the tests instead of a programming-language name.

C# (357)

class H
{
static void main()
{
Func<ConsoleKey, char> f = (k) => (char) k;
Func<char, char> l = (c) => char.ToLower(c);

Console.WriteLine(new[] {
f(ConsoleKey.H),
l(f(ConsoleKey.E)),
l(f(ConsoleKey.L)),
l(f(ConsoleKey.L)),
l(f(ConsoleKey.O)),
f(ConsoleKey.Spacebar),
f(ConsoleKey.W),
l(f(ConsoleKey.O)),
l(f(ConsoleKey.R)),
l(f(ConsoleKey.L)),
l(f(ConsoleKey.D)),
f(ConsoleKey.PageUp)
});
}
}


Golfed:

class H{static void main(){Func<ConsoleKey,char>f=(k)=>(char)k;Func<char,char>l=(c)=>char.ToLower(c);Console.WriteLine(new[]{f(ConsoleKey.H),l(f(ConsoleKey.E)),l(f(ConsoleKey.L)),l(f(ConsoleKey.L)),l(f(ConsoleKey.O)),f(ConsoleKey.Spacebar),f(ConsoleKey.W),l(f(ConsoleKey.O)),l(f(ConsoleKey.R)),l(f(ConsoleKey.L)),l(f(ConsoleKey.D)),f(ConsoleKey.PageUp)});}}

• using C = System.ConsoleKey; would save a number of chars. – zzzzBov Jan 28 '14 at 22:55
• I don't think it will. Enum constants can only be referred through Enum. – microbian Jan 28 '14 at 23:02
• Next time, please compile your programs before posting them. This needs a using System and Main needs to be capitalized. However, the suggestion made by @zzzzBov is correct; you can use using C=System.ConsoleKey; to abbreviate the code massively. Furthermore, you can remove the parentheses around the lambda parameters. That takes it down to 275. – Timwi Feb 5 '14 at 0:48

# Ruby 49 chars

def Hello World!;puts __method__;end
Hello World!


The whitespace in the method name is a UTF8 Emsp, a little wider then a normal space which would be a syntax error.

# Stuck, 0 bytes

Yup, an empty program in stuck prints Hello, World! I don't see any string literals or Regex here

echo Hello World!

• Does Hello World! not qualify as a string literal here? Curious. – shadowtalker Jul 7 '14 at 22:11