# 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

## R, 78

paste(deparse(quote(Hello)),paste0(deparse(quote(World)),deparse(quote(!))))


Wanton abuse of deparse (which extracts the literal name of an object, i.e. "de-parsing" it, even if that object doesn't exist) and R's name class, which is not a string literal; is.character(quote(Hello)) returns FALSE. Also ! is a function in R, hence the backticks.

But for a (slightly) more honest solution,

## R, 391 after removing whitespace

u = !is.na("O")

paste(
paste0(letters[u+u+u+u+u+u+u+u],
letters[u+u+u+u+u],
letters[u+u+u+u+u+u+u+u+u+u+u+u],
letters[u+u+u+u+u+u+u+u+u+u+u+u],
letters[u+u+u+u+u+u+u+u+u+u+u+u+u+u+u]),
paste0(letters[u+u+u+u+u+u+u+u+u+u+u+u+u+u+u+u+u+u+u+u+u+u+u],
letters[u+u+u+u+u+u+u+u+u+u+u+u+u+u+u],
letters[u+u+u+u+u+u+u+u+u+u+u+u+u+u+u+u+u+u],
letters[u+u+u+u+u+u+u+u+u+u+u+u],
letters[u+u+u+u])
)


In R, there is a built-in object called letters that's, well, a vector of letters. is.na returns FALSE because "O" is not equal to the special value NA, and ! negates the logical (aka Boolean). Then + in R automatically coerces logicals to numerics.

## C# (130 chars)

class 聇聤聫聫聮耟聖聮聱聫聣耠{static void Main(){foreach(var c in typeof(聇聤聫聫聮耟聖聮聱聫聣耠).Name)System.Console.Write((char)(c-short.MaxValue));}}


Even though this beats my 131 chars solution, posting this as a separate answer because it works very differently and the other one is more interesting. (And also because the other one is ASCII-only and thus only 131 bytes long.)

# Python 2, 116

def Hello(n,m,j):print n.func_name,m.func_name+chr(j)
def World():pass
o=-~0;O=o+o;P=O<<O*O;Hello(Hello,World,P+o)


This is the best I can do so far. Hooray, func_name! (I may or may not try this in Befunge as well.)

# Python (99 bytes)

o=-~0
def World():0
def Hello():print Hello.__name__,World.__name__+chr(o+(o<<(o+o+o+o+o)))
Hello()


(similar to my bash version ).

EDIT: Cut another byte by optimising 0**0 to -~0 (== 1), thanks to @kasran for the tip!

• -~0 is a shorter way to get 1 than 0**0. – Kasran Nov 23 '14 at 1:36

## Ruby, 182 bytes

->{o=?O.ord;o/=o;t=o+o;"O00O000OO00O0OOO0OO00OO0OO00OO0OOOO0O00000O0O0OOOOO0OOOOOOO00O0OO0OO00OO00O000O0000O".tr(?O,o.to_s).chars.each_slice(t+t+t+o).map{|i|i.join.to_i(t).chr}.join}


Lambda function, returns desired value.

# Dyalog APL, 115 bytes

Needs ⎕IO←0 which is default on many systems.

Inspiration.

Plain ASCII encoding using 0 for 0 and O for 1.

⎕UCS(⍴⍬⍬)⊥'0O'⍳'OOOOO0OOOOO00OOOOO0OOOOO000000O0O000O0OOO00O0O000OOOO0OO0OO00000O0OOO0000O00O0OO000O'⍴⍨≢¨⎕TS(⎕D,⍬⍬)


⎕UCS Convert Unicode code points to character

(⍴⍬⍬)⊥ base-2 decode of (⍴⍬⍬ is the length of a list of two empty lists, i.e. 2)

'0O'⍳ indices into 0O for each character in

'OOO...00O' the 7×12 character encoded string

⍴⍨ reshaped into a matrix of dimensions

≢¨ the tally of each of

⎕TS(⎕D,⍬⍬) the Time Stamp and the Digits appended with two empty lists

TryAPL online!

# J, 134 124 bytes

Thanks to miles for a bugfix!

echo u:#.((+:+:>.^#a:),<.^+:*_)$'0O'i.'O00O000OO00O0OOO0OO00OO0OO00OO0OOOO0O00000O0O0OOOOO0OOOOOOO00O0OO0OO00OO00O000O0000O'  Try it online! This was much easier to write than the below. Alternatively, no strings, 134 bytes: echo u:(-:*:>.>:C),(>:*:<.C),A,A,B,(+:+:>.C),(+:*:<.^.A),(<.*:+:^.A),(B=:>:>:>:A),(+:>:>:>:-:A),A,(*:<.C=:%:A),>.*:>:^.A=:+:<.^+:+:#a:  Try it online! This. Was. A. Triumph Pain to write. I should really write a program to help me automate this... • I think _ counts as a number. Another way to get 1 is #a: – miles Jan 21 '17 at 2:40 • @miles True. I'll make the change accordingly. – Conor O'Brien Jan 21 '17 at 2:58 • Shorter 1: ^0 – Adám Oct 28 '19 at 23:15 • Shouldnt *_ be ^0 too, since _ is a non-zero number? – Adám Oct 28 '19 at 23:18 # PHP, 136 bytes a different approach, inspired by Adám´s APL answer: for(;$c=[O00O000,OO00O0O,$l=OO0OO00,$l,$o=OO0OOOO,O00000,O0O0OOO,$o,OOO00O0,$l,OO00O00,O0000O][+$i++];)echo chr(bindec(strtr($c,O,!0)));  loops through array of 0O encoded ASCII values to print corresponding characters. Run with -nr. breakdown for(;$c=[O00O000,OO00O0O,$l=OO0OO00,$l,$o=OO0OOOO, // binary ascii codes, O00000,O0O0OOO,$o,OOO00O0,$l,OO00O00,O0000O] // 1 replaced with O [+$i++];)           // loop through array
echo                    // 4. print
chr(                // 3. convert to character
bindec(             // 2. convert to decimal
strtr($c,O,!0) // 1. replace capital O with 1 ));  # JavaScript (ES5), 79 bytes b=-~!0;for(c in{Hello:a="",World:b<<=b*b})a+=c+String.fromCharCode(b++);alert(a)  # Explanation Like the other JavaScript answers, this is just a code snippet that alerts the string'Hello World!'. The first trick is creating an object with the key names Hello and World. These are not string literals, so it obeys the rules. It is not allowed to put the exclamation mark or the space in there, so we get those characters through the second trick. The second trick is getting the characters through their ASCII value. Sadly, we have to use String.fromCharCode for that, which is really long. Luckily, the space (32) and exclamation mark (33) are right next to each other in the ASCII table, and the character code for the space is a nice power of 2, which is easily obtainable though bitshifting. Getting 32 using only zeroes is a little bit tricky: 32 equals 1 << 5, which is not very golfable, but it also equals 2 << 4 = 2 << 2 * 2. All these two's allow us to assign 2 to a variable, and use that (note that -~!0 equals 2). The third trick is that we don't need the values in the object we loop over, and you can assign values to variables in the object declaration. This doesn't just save 2 semicolons, but also 2 dummy values, so 4 bytes in total. ## JavaScript (ES6) (non-competing), 82 bytes _=>eval('b=-~!0;for(c in{Hello:a="",World:b<<=b*b})a+=c+String.fromCharCode(b++)')  ## Explanation This is a full function with the same body as the competing version, but we use a fat-arrow function with "the eval trick". eval returns the value of the last variable it assigned to, which is a in this case. This is non-competing since ECMAScript 6 was released in 2015, more than 4 years after this challenge was made. ## C, 177 bytes enum{a,b,c=b+b,d=c*c,e=c*d,f=c*e,g=c*f,h=c*g,i=c*h};x[]={h+e,i-g+d+b,i-g+e+d,i-g+e+d,i-g+f-b,g,h+f+e-b,i-g+f-b,i-f+c,i-g+e+d,i-g+d,g+b,},j=a;main(){for(;j<f-d;putchar(x[j++]));}  Try it online # Lenguage, 12731474882444739483739382239546264946233453512894971245352595483589354073858968246926319892 bytes It is 12731474882444739483739382239546264946233453512894971245352595483589354073858968246926319892 zeros. Or Os. Both of them if you want. Any character in fact. Thanks Lenguage. Convert It Online! <-- Conversion from brainfuck Hello World! Try It Online! <-- brainfuck Hello World! in action # Tcl, 62 bytes proc Hello\ world! {} {puts {*}[info level 0]} [Hello\ world!]  Try it online! proc Hello\ World! is a function with name "Hello world"; [info level 0] gives the funtion name where I am presently now; [Hello\ world!] is a call to the "Hello world" function! • @Johannes Kuhn: I think my solution is farther from a literal than yours! – sergiol Apr 30 '18 at 0:20 # Forth (gforth), 38 bytes : f name type ; f Hello space f World!  Try it online! OR name World! name Hello type space type  Try it online! ### Explanation Uses the Forth built-in for processing code to convert the next character entered to a string, and then prints it ### Code Explanation : f \ start a new word definition name \ grabs the next word (space-delimited) from the input/code type \ output the string on top of the stack ; \ end word definition f Hello \ converts and outputs Hello, as name will grab Hello from the input before continuing space \ outputs a single space f World! \ converts World! to a string and outputs it  ## Keg, 14 bytes Hello World*  TIO • Keg does not have character literals, only instructions that push constants onto the stack, except for \, which pushes the character onto the stack. • This program does not use integers. • There are no built-functions that return the string in Keg. • Keg does not support regex. # JavaScript, 166 bytes (o=-~0,O=o+[],e=O+0,c=e+0,q=O+c,d=c+0,p=e+O+O+O)=>[c+d,q+e+O,a=O+e+q,a,g=O+p+O,d+0+0,e+p,g,O+q+e,a,q+c,d+0+O].map(b=>String.fromCharCode(parseInt(b,o+o))).join([]+[])  I tried to use most circular alphabet as possible for the variable names. # Runic Enchantments, 94 bytes mmXm-m-FFm-k$Xm+mm,+:m-:k$Fm+k::}$$::,:++k:}$mKymmmm+++k$mmqnmm,-k${${:FFm+k$k$Fmm+Xk$FFmmqnk@


Try it online!

Wouldn't surprise me if there's a shortcut or two I missed to construct the required values in fewer bytes (mmmm+++ is particularly gross), but managing the stack with duplicated values to be used later incurs its own overhead (as does adjusting the IP s mana value). As such only the o and l in World are utilized this way, as they are constructed in the order lo and required again later in the order ol, so only 6 total bytes are needed to dup and rotate.

The program functions by drawing on the inherent mana of the instruction pointer to generate numerical values, then performing arithmetic operations on that value as necessary to generate the decimal values 72, 101, 108, 111, 32, 87, 114, 100 in order, casting each to char and printing them.

m  -> push current mana value to stack (default 10)
F  -> lower mana value by 1 ("Fizzle")
mK -> increase mana value by 1 (spawns an IP with m mana, costs m-1, then they combine)
X  -> multiply top of stack by 10 (note that this is not a literal value)
k  -> cast top of stack to Char
$-> print top of stack  In this way the sequence mXm-m- gives the value 80. FFm gives the value 8. 80 - 8 = 72: mXm-m-FFm-k$ causes H to be printed.

# Microsoft Excel, 178 131 chars

Uses the following cells:

1. A1 - =0=0 TRUE. Since we don't need a real "1", we can just abuse coercion.
2. A2 - =A1+A1 TRUE + TRUE = 2
3. A3 - =A2+A1 2 + TRUE = 3
4. A4 - =A3+A1 3 + TRUE = 4
5. A6 - =A4+A2 4 + 2 = 6
6. A8 - =A6+A2 6 + 2 = 8
7. A9 - =A8+A1 8 + TRUE = 9
8. B8 - =A4&A2 42
9. B9 - =A3&A3 33
10. B1 - =PROPER(BASE(A8&0&A2&A9&B8&A2,A2&A6)&" "&BASE(A3&A8&A8&B8&0&A6&A9,B9)&CHAR(B9)) "Hello World!"

5 + 6 * 8 + 79 = 131 chars.

Only a 0 literal was used. Every other value is a reference dependent on that.

Unobfuscated, the formula is =PROPER(BASE(8029422,26)&" "&BASE(38842069,33)&CHAR(33))

## Ruby 45 chars

p [:Hello,:World!].join :_20[-~0..~0].hex.chr

• or :HelloWorld!.to_s.titleize in rails (26 chars) – Mikey Mar 20 '13 at 14:37
• Since the rules are already being bent I'm pretty sure :"Hello World!" is technically a Symbol literal. – Kevin Cox Nov 22 '13 at 2:23
• Never mind, added it as my own. – Kevin Cox Nov 22 '13 at 2:25
• If that is allowed I should just use #| Hello World␤sub h{};say &h.WHY in Perl 6. – Brad Gilbert b2gills May 12 '16 at 19:28

## Groovy, 117

def propertyMissing(p){p}
b="OOOOOOOO"
c={(char)it.size()}
a=b+b+b+b
println(Hello+c(a+b+"OOOO")+c(a)+World+c(a+"O"))


prints

Hello, World!


If we push the rules quite a bit.

# Ruby, 20

puts :"Hello World!"


Technically :"Hello World!" is just the Symbol syntax.

• Yeah... you are pushing the rules. – John Dvorak Nov 22 '13 at 14:13

# Befunge 98 - 37

:0!g,:0!0!+:::**+#@_0!+
Hello World!


The Hello World! is not a string literal. It is source code that would actually do something if you run it (I have no idea what it would do). This program works off the idea of a Befunge quine:

:            duplicate number on stack (note that if there is none, then pushes a 0)
0!           push 0 then not it, producing a 1
g            get the character at the location (:,1) (: = number determined by the previous :)
,            print that character
:            duplicate number on stack (same number as first duplicate)
0!0!+:::**+  push the number 10
compare the duplicated number with 10, if it is greater than it, push 1, else push 0.
#            jump over the next character, going to the _
_            move right if the number on the top of the stack is 0, otherwise, move left
@            end program
0!           push 0 then not it, producing a 1
+            add it to the counter (number on top of stack)


I'm working on a longer, more interesting version.

# C#, 130 characters

A friend of mine came up with this solution, which is one character shorter than my own solution of 131 (but longer if you count bytes).

class 聇聤聫聫聮耟聖聮聱聫聣耠{static void Main(){foreach(var c in typeof(聇聤聫聫聮耟聖聮聱聫聣耠).Name)System.Console.Write((char)(c-short.MaxValue));}}


class 聇聤聫聫聮耟聖聮聱聫聣耠
{
static void Main()
{
foreach (var c in typeof(聇聤聫聫聮耟聖聮聱聫聣耠).Name)
System.Console.Write((char)(c - short.MaxValue));
}
}

• I'm sorry, but counting by bytes is the standard here. – SuperJedi224 Oct 26 '16 at 15:04
• @SuperJedi224: It is now. This answer is quite old. – Timwi Oct 29 '16 at 22:21

## Rebol (23 chars)

print ['Hello 'World!]


NB. In Rebol these are word literals ('word) which are completely different to string literals ("string"):

>> type? 'Hello
== word!

>> type? "Hello"
== string!


Alternative if you think using word literals is cheating!

print [quote Hello quote World!]


# Forth (942)

I'm sure it's not the shortes forth solution... but it's binary! First 5 lines are driver.

: O0 0 ;
: OO 0 0 INVERT - ;
: 00 SWAP 2 * + ;
: OOOOOOOO EMIT ;
: O CR BYE ;

O0 OO 00 O0 00 O0 00 OO 00 O0 00 O0 00 O0 00  OOOOOOOO
O0 OO 00 OO 00 O0 00 O0 00 OO 00 O0 00 OO 00  OOOOOOOO
O0 OO 00 OO 00 O0 00 OO 00 OO 00 O0 00 O0 00  OOOOOOOO
O0 OO 00 OO 00 O0 00 OO 00 OO 00 O0 00 O0 00  OOOOOOOO
O0 OO 00 OO 00 O0 00 OO 00 OO 00 OO 00 OO 00  OOOOOOOO
O0 O0 00 OO 00 O0 00 O0 00 O0 00 O0 00 O0 00  OOOOOOOO
O0 OO 00 O0 00 OO 00 O0 00 OO 00 OO 00 OO 00  OOOOOOOO
O0 OO 00 OO 00 O0 00 OO 00 OO 00 OO 00 OO 00  OOOOOOOO
O0 OO 00 OO 00 OO 00 O0 00 O0 00 OO 00 O0 00  OOOOOOOO
O0 OO 00 OO 00 O0 00 OO 00 OO 00 O0 00 O0 00  OOOOOOOO
O0 OO 00 OO 00 O0 00 O0 00 OO 00 O0 00 O0 00  OOOOOOOO
O0 O0 00 OO 00 O0 00 O0 00 O0 00 O0 00 OO 00  OOOOOOOO

O


Edit #1: I'm stupid! I had to insert 2 noop instructions to make it look nearly like a real dump of /dev/zero...

: O0 0 ;
: OO 0 0 INVERT - ;
: 00 SWAP 2 * + ;
: OOOOOOOO EMIT ;
: 00000000 ;
: 0O ;
: O CR BYE ;

O0 OO 00 O0  00 O0 00 OO  00000000
00 O0 00 O0  00 O0 00 0O  OOOOOOOO
O0 OO 00 OO  00 O0 00 O0  00000000
00 OO 00 O0  00 OO 00 0O  OOOOOOOO
O0 OO 00 OO  00 O0 00 OO  00000000
00 OO 00 O0  00 O0 00 0O  OOOOOOOO
O0 OO 00 OO  00 O0 00 OO  00000000
00 OO 00 O0  00 O0 00 0O  OOOOOOOO
O0 OO 00 OO  00 O0 00 OO  00000000
00 OO 00 OO  00 OO 00 0O  OOOOOOOO
O0 O0 00 OO  00 O0 00 O0  00000000
00 O0 00 O0  00 O0 00 0O  OOOOOOOO
O0 OO 00 O0  00 OO 00 O0  00000000
00 OO 00 OO  00 OO 00 0O  OOOOOOOO
O0 OO 00 OO  00 O0 00 OO  00000000
00 OO 00 OO  00 OO 00 0O  OOOOOOOO
O0 OO 00 OO  00 OO 00 O0  00000000
00 O0 00 OO  00 O0 00 0O  OOOOOOOO
O0 OO 00 OO  00 O0 00 OO  00000000
00 OO 00 O0  00 O0 00 0O  OOOOOOOO
O0 OO 00 OO  00 O0 00 O0  00000000
00 OO 00 O0  00 O0 00 0O  OOOOOOOO
O0 O0 00 OO  00 O0 00 O0  00000000
00 O0 00 O0  00 OO 00 0O  OOOOOOOO

O

• You used a literal 2 in : 00 SWAP 2 * + ;, which is forbidden. – mbomb007 Nov 20 '15 at 18:20
• Look at the other solutions. That's driver. – max.haredoom Jan 21 '16 at 20:24
• It's still part of your source code? Also, I looked through every solution rated +1 or more, and there are none that contain any number other than 0, like the rules state, with the exception of one answer using it to specific a version of the language, which may or may not be allowed. What you're doing is not allowed. – mbomb007 Jan 22 '16 at 3:17
• You are free to ignore my solution. – max.haredoom Jan 25 '16 at 23:28
• Also, SWAP 2 * +, could be written as OVER + +. – mbomb007 Jan 26 '16 at 14:27

# Python:

print str().join([chr((~0*(~0+~0))**(~0*(~0+~0+~0))*(~0*(~0+~0+~0))**(~0*(~0+~(0)))),
chr((~0*(~0+~0))**(~0*(~0+~0))*(~0*(~0+~0+~0+~0+~0))**(~0*(~0+~0))+~0*~0),
chr((~0*(~0+~0))**(~0*(~0+~0))*(~0*(~0+~0+~0)**(~0*(~0+~0+~0)))),
chr((~0*(~0+~0))**(~0*(~0+~0))*(~0*(~0+~0+~0)**(~0*(~0+~0+~0)))),
chr((~0*(~0+~0))**(~0*(~0+~0+~0+~0))*~0*(~0+~0+~0+~0+~0+~0+~0)+~0),
chr((~0*(~0+~0))**(~0*(~0+~0+~0+~0+~0))),
chr((~0*(~0+~0))**(~0*(~0+~0+~0))*(~0*(~0+~0+~0))*(~0*(~0+~0+~0+~0+~0))+~0),
chr((~0*(~0+~0))**(~0*(~0+~0+~0+~0))*~0*(~0+~0+~0+~0+~0+~0+~0)+~0),
chr((~0*(~0+~0))**(~0*(~0+~0))*(~0*(~0+~0+~0+~0+~0))**(~0*(~0+~0))+(~0*(~0+~0))**((~0+~0)*(~0+~0))+~0+~0),
chr((~0*(~0+~0))**(~0*(~0+~0))*(~0*(~0+~0+~0)**(~0*(~0+~0+~0)))),
chr((~0*(~0+~0))**(~0*(~0+~0))*(~0*(~0+~0+~0+~0+~0))**(~0*(~0+~0))),
chr((~0*(~0+~0))**(~0*(~0+~0+~0+~0+~0))+~0*~0)
])


# Java @230 : Twisting the rules with Enumerator behavior

enum A{Hello,B,C,D,E,F,World;public static void main(String[]z){p(Hello);int b=(B.ordinal()),c=(b<<F.ordinal());p((char)(c|b<<D.ordinal()|b<<(b<<b)));p((char)c++);p(World);p((char)c);}static void p(Object o){System.out.print(o);}}


took me a while to figure the logic out, enums printed act like literals and cn donate numbers at the same time :P

# VBScript: 279

o = Asc("O")
n = 0 ^ 0
w = Round(Cos(o) / Sin(o), 0)
r = Cos(0) + Sgn(o) + Exp(0)
u = Fix(Log(o))
v = Left(o, o ^ 0)
e = Int(Sqr(o))

MsgBox Join(Array( _
Chr(v & w), _
Chr(n & 0 & n), _
Chr(n & 0 & e), _
Chr(n & 0 & e), _
LCase("O"), _
Chr(u & u), _
Chr(r & w), _
Chr(e & v), _
Chr(n & n & n), _
Chr(n & n & u), _
Chr(n & 0 & e), _
Chr(n & 0 & 0), _
Chr(r & r) _
), String(0, "O"))


## Strategy

1. Generate the numbers 1,2,3,4,7, and 8 from "O" and 0 and common functions

2. Concatenate the numbers together as strings to form ascii values

3. Put ascii values in an array

4. Join the array into a string using an empty string (repeat "o" 0 times) as the delimiter

5. Display!

This golfs down to (a very beatable) 279 by removing underscores, linebreaks, and all spaces except for one to seperate 'msgbox' and 'join' and more to keep &0s from behaving like hex literals

o=Asc("O"):n=0^0:w=Round(Cos(o)/Sin(o),0):r=Cos(0)+Sgn(o)+Exp(0):u=Fix(Log(o)):v=Left(o,o^0):e=Int(Sqr(o)):MsgBox Join(Array(Chr(v&w),Chr(n& 0&n),Chr(n& 0&e),Chr(n& 0&e),LCase("O"),Chr(u&u),Chr(r&w),Chr(e&v),Chr(n&n&n),Chr(n&n&u),Chr(n& 0&e),Chr(n& 0& 0),Chr(r&r)),String(0,"O"))


# Javascript - 129 chars

s=[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,];c=String.fromCharCode;alert(Object.keys({Hello:s,World:s}).join(c(s.length))+c(++s.length));

• You can make your code shorter by replacing console.log with alert and by removing the space between : and null. Also, you forgot to add the exclamation mark at the end of the output. – ProgramFOX Aug 28 '14 at 14:34
• Okay, I've corrected it. – vpzomtrrfrt Aug 28 '14 at 14:48

# Befunge-98, 120

'O0!::+::+*-++:,0!::+::*:**\::++-++:,0!::+::+*--+:,+:,0!::++++:,'O%+:,\#@_0!\0!::++/0!:++:0\-0!+:0!:+/:0!:++:0!-::0!:++*


One long line of Befunge. Yikes.

This basically just prints "Hello ", loads in a list of offsets, and then runs the Hello-printing bit again with some offsets applied to turn "Hello " into "World!". It can probably be golfed down a bit further with the representations of numbers.

Edit - Removed two extraneous spaces that had snuck in.

# Hieroglyphy With 0s, 6129

Golfed down from a generated expression in pure hieroglyphy (itself a variant of the infamous JSF***) which was 7999 bytes long.

Basically exploits the oddities of javascript's type system to generate the string using only the character set [](){}+!0.

[][(![]+[])[!0+!0+!0]+([]+{})[+!0]+(!0+[])[+!0]+(!0+[])[0]][([]+{})[!0+!0+!0+!0+!0]+([]+{})[+!0]+([][0]+[])[+!0]+(![]+[])[!0+!0+!0]+(!0+[])[0]+(!0+[])[+!0]+([][0]+[])[0]+([]+{})[!0+!0+!0+!0+!0]+(!0+[])[0]+([]+{})[+!0]+(!0+[])[+!0]]((!0+[])[+!0]+([][0]+[])[!0+!0+!0]+(!0+[])[0]+([][0]+[])[0]+(!0+[])[+!0]+([][0]+[])[+!0]+([]+{})[!0+!0+!0+!0+!0+!0+!0]+([][0]+[])[0]+([][0]+[])[+!0]+([][0]+[])[!0+!0+!0]+(![]+[])[!0+!0+!0]+([]+{})[!0+!0+!0+!0+!0]+(+{}+[])[+!0]+([]+[][(![]+[])[!0+!0+!0]+([]+{})[+!0]+(!0+[])[+!0]+(!0+[])[0]][([]+{})[!0+!0+!0+!0+!0]+([]+{})[+!0]+([][0]+[])[+!0]+(![]+[])[!0+!0+!0]+(!0+[])[0]+(!0+[])[+!0]+([][0]+[])[0]+([]+{})[!0+!0+!0+!0+!0]+(!0+[])[0]+([]+{})[+!0]+(!0+[])[+!0]]((!0+[])[+!0]+([][0]+[])[!0+!0+!0]+(!0+[])[0]+([][0]+[])[0]+(!0+[])[+!0]+([][0]+[])[+!0]+([]+{})[!0+!0+!0+!0+!0+!0+!0]+(![]+[])[!0+!0]+([]+{})[+!0]+([]+{})[!0+!0+!0+!0+!0]+(+{}+[])[+!0]+(!0+[])[0]+([][0]+[])[!0+!0+!0+!0+!0]+([]+{})[+!0]+([][0]+[])[+!0])())[!0+!0+!0]+([][0]+[])[!0+!0+!0])()([][(![]+[])[!0+!0+!0]+([]+{})[+!0]+(!0+[])[+!0]+(!0+[])[0]][([]+{})[!0+!0+!0+!0+!0]+([]+{})[+!0]+([][0]+[])[+!0]+(![]+[])[!0+!0+!0]+(!0+[])[0]+(!0+[])[+!0]+([][0]+[])[0]+([]+{})[!0+!0+!0+!0+!0]+(!0+[])[0]+([]+{})[+!0]+(!0+[])[+!0]]((!0+[])[+!0]+([][0]+[])[!0+!0+!0]+(!0+[])[0]+([][0]+[])[0]+(!0+[])[+!0]+([][0]+[])[+!0]+([]+{})[!0+!0+!0+!0+!0+!0+!0]+([][0]+[])[!0+!0+!0]+(![]+[])[!0+!0+!0]+([]+{})[!0+!0+!0+!0+!0]+(+{}+[])[+!0]+([]+[][(![]+[])[!0+!0+!0]+([]+{})[+!0]+(!0+[])[+!0]+(!0+[])[0]][([]+{})[!0+!0+!0+!0+!0]+([]+{})[+!0]+([][0]+[])[+!0]+(![]+[])[!0+!0+!0]+(!0+[])[0]+(!0+[])[+!0]+([][0]+[])[0]+([]+{})[!0+!0+!0+!0+!0]+(!0+[])[0]+([]+{})[+!0]+(!0+[])[+!0]]((!0+[])[+!0]+([][0]+[])[!0+!0+!0]+(!0+[])[0]+([][0]+[])[0]+(!0+[])[+!0]+([][0]+[])[+!0]+([]+{})[!0+!0+!0+!0+!0+!0+!0]+(![]+[])[!0+!0]+([]+{})[+!0]+([]+{})[!0+!0+!0+!0+!0]+(+{}+[])[+!0]+(!0+[])[0]+([][0]+[])[!0+!0+!0+!0+!0]+([]+{})[+!0]+([][0]+[])[+!0])())[!0+!0+!0]+([][0]+[])[!0+!0+!0])()(([]+{})[0])[0]+(!0+!0+!0+!0+[])+(!0+!0+!0+!0+!0+!0+!0+!0+[]))+([][0]+[])[!0+!0+!0]+(![]+[])[!0+!0]+(![]+[])[!0+!0]+([]+{})[+!0]+([]+{})[!0+!0+!0+!0+!0+!0+!0]+[][(![]+[])[!0+!0+!0]+([]+{})[+!0]+(!0+[])[+!0]+(!0+[])[0]][([]+{})[!0+!0+!0+!0+!0]+([]+{})[+!0]+([][0]+[])[+!0]+(![]+[])[!0+!0+!0]+(!0+[])[0]+(!0+[])[+!0]+([][0]+[])[0]+([]+{})[!0+!0+!0+!0+!0]+(!0+[])[0]+([]+{})[+!0]+(!0+[])[+!0]]((!0+[])[+!0]+([][0]+[])[!0+!0+!0]+(!0+[])[0]+([][0]+[])[0]+(!0+[])[+!0]+([][0]+[])[+!0]+([]+{})[!0+!0+!0+!0+!0+!0+!0]+([][0]+[])[0]+([][0]+[])[+!0]+([][0]+[])[!0+!0+!0]+(![]+[])[!0+!0+!0]+([]+{})[!0+!0+!0+!0+!0]+(+{}+[])[+!0]+([]+[][(![]+[])[!0+!0+!0]+([]+{})[+!0]+(!0+[])[+!0]+(!0+[])[0]][([]+{})[!0+!0+!0+!0+!0]+([]+{})[+!0]+([][0]+[])[+!0]+(![]+[])[!0+!0+!0]+(!0+[])[0]+(!0+[])[+!0]+([][0]+[])[0]+([]+{})[!0+!0+!0+!0+!0]+(!0+[])[0]+([]+{})[+!0]+(!0+[])[+!0]]((!0+[])[+!0]+([][0]+[])[!0+!0+!0]+(!0+[])[0]+([][0]+[])[0]+(!0+[])[+!0]+([][0]+[])[+!0]+([]+{})[!0+!0+!0+!0+!0+!0+!0]+(![]+[])[!0+!0]+([]+{})[+!0]+([]+{})[!0+!0+!0+!0+!0]+(+{}+[])[+!0]+(!0+[])[0]+([][0]+[])[!0+!0+!0+!0+!0]+([]+{})[+!0]+([][0]+[])[+!0])())[!0+!0+!0]+([][0]+[])[!0+!0+!0])()([][(![]+[])[!0+!0+!0]+([]+{})[+!0]+(!0+[])[+!0]+(!0+[])[0]][([]+{})[!0+!0+!0+!0+!0]+([]+{})[+!0]+([][0]+[])[+!0]+(![]+[])[!0+!0+!0]+(!0+[])[0]+(!0+[])[+!0]+([][0]+[])[0]+([]+{})[!0+!0+!0+!0+!0]+(!0+[])[0]+([]+{})[+!0]+(!0+[])[+!0]]((!0+[])[+!0]+([][0]+[])[!0+!0+!0]+(!0+[])[0]+([][0]+[])[0]+(!0+[])[+!0]+([][0]+[])[+!0]+([]+{})[!0+!0+!0+!0+!0+!0+!0]+([][0]+[])[!0+!0+!0]+(![]+[])[!0+!0+!0]+([]+{})[!0+!0+!0+!0+!0]+(+{}+[])[+!0]+([]+[][(![]+[])[!0+!0+!0]+([]+{})[+!0]+(!0+[])[+!0]+(!0+[])[0]][([]+{})[!0+!0+!0+!0+!0]+([]+{})[+!0]+([][0]+[])[+!0]+(![]+[])[!0+!0+!0]+(!0+[])[0]+(!0+[])[+!0]+([][0]+[])[0]+([]+{})[!0+!0+!0+!0+!0]+(!0+[])[0]+([]+{})[+!0]+(!0+[])[+!0]]((!0+[])[+!0]+([][0]+[])[!0+!0+!0]+(!0+[])[0]+([][0]+[])[0]+(!0+[])[+!0]+([][0]+[])[+!0]+([]+{})[!0+!0+!0+!0+!0+!0+!0]+(![]+[])[!0+!0]+([]+{})[+!0]+([]+{})[!0+!0+!0+!0+!0]+(+{}+[])[+!0]+(!0+[])[0]+([][0]+[])[!0+!0+!0+!0+!0]+([]+{})[+!0]+([][0]+[])[+!0])())[!0+!0+!0]+([][0]+[])[!0+!0+!0])()(([]+{})[0])[0]+(!0+!0+!0+!0+!0+[])+(!0+!0+!0+!0+!0+!0+!0+[]))+([]+{})[+!0]+(!0+[])[+!0]+(![]+[])[!0+!0]+([][0]+[])[!0+!0]+[][(![]+[])[!0+!0+!0]+([]+{})[+!0]+(!0+[])[+!0]+(!0+[])[0]][([]+{})[!0+!0+!0+!0+!0]+([]+{})[+!0]+([][0]+[])[+!0]+(![]+[])[!0+!0+!0]+(!0+[])[0]+(!0+[])[+!0]+([][0]+[])[0]+([]+{})[!0+!0+!0+!0+!0]+(!0+[])[0]+([]+{})[+!0]+(!0+[])[+!0]]((!0+[])[+!0]+([][0]+[])[!0+!0+!0]+(!0+[])[0]+([][0]+[])[0]+(!0+[])[+!0]+([][0]+[])[+!0]+([]+{})[!0+!0+!0+!0+!0+!0+!0]+([][0]+[])[0]+([][0]+[])[+!0]+([][0]+[])[!0+!0+!0]+(![]+[])[!0+!0+!0]+([]+{})[!0+!0+!0+!0+!0]+(+{}+[])[+!0]+([]+[][(![]+[])[!0+!0+!0]+([]+{})[+!0]+(!0+[])[+!0]+(!0+[])[0]][([]+{})[!0+!0+!0+!0+!0]+([]+{})[+!0]+([][0]+[])[+!0]+(![]+[])[!0+!0+!0]+(!0+[])[0]+(!0+[])[+!0]+([][0]+[])[0]+([]+{})[!0+!0+!0+!0+!0]+(!0+[])[0]+([]+{})[+!0]+(!0+[])[+!0]]((!0+[])[+!0]+([][0]+[])[!0+!0+!0]+(!0+[])[0]+([][0]+[])[0]+(!0+[])[+!0]+([][0]+[])[+!0]+([]+{})[!0+!0+!0+!0+!0+!0+!0]+(![]+[])[!0+!0]+([]+{})[+!0]+([]+{})[!0+!0+!0+!0+!0]+(+{}+[])[+!0]+(!0+[])[0]+([][0]+[])[!0+!0+!0+!0+!0]+([]+{})[+!0]+([][0]+[])[+!0])())[!0+!0+!0]+([][0]+[])[!0+!0+!0])()([][(![]+[])[!0+!0+!0]+([]+{})[+!0]+(!0+[])[+!0]+(!0+[])[0]][([]+{})[!0+!0+!0+!0+!0]+([]+{})[+!0]+([][0]+[])[+!0]+(![]+[])[!0+!0+!0]+(!0+[])[0]+(!0+[])[+!0]+([][0]+[])[0]+([]+{})[!0+!0+!0+!0+!0]+(!0+[])[0]+([]+{})[+!0]+(!0+[])[+!0]]((!0+[])[+!0]+([][0]+[])[!0+!0+!0]+(!0+[])[0]+([][0]+[])[0]+(!0+[])[+!0]+([][0]+[])[+!0]+([]+{})[!0+!0+!0+!0+!0+!0+!0]+([][0]+[])[!0+!0+!0]+(![]+[])[!0+!0+!0]+([]+{})[!0+!0+!0+!0+!0]+(+{}+[])[+!0]+([]+[][(![]+[])[!0+!0+!0]+([]+{})[+!0]+(!0+[])[+!0]+(!0+[])[0]][([]+{})[!0+!0+!0+!0+!0]+([]+{})[+!0]+([][0]+[])[+!0]+(![]+[])[!0+!0+!0]+(!0+[])[0]+(!0+[])[+!0]+([][0]+[])[0]+([]+{})[!0+!0+!0+!0+!0]+(!0+[])[0]+([]+{})[+!0]+(!0+[])[+!0]]((!0+[])[+!0]+([][0]+[])[!0+!0+!0]+(!0+[])[0]+([][0]+[])[0]+(!0+[])[+!0]+([][0]+[])[+!0]+([]+{})[!0+!0+!0+!0+!0+!0+!0]+(![]+[])[!0+!0]+([]+{})[+!0]+([]+{})[!0+!0+!0+!0+!0]+(+{}+[])[+!0]+(!0+[])[0]+([][0]+[])[!0+!0+!0+!0+!0]+([]+{})[+!0]+([][0]+[])[+!0])())[!0+!0+!0]+([][0]+[])[!0+!0+!0])()(([]+{})[0])[0]+(!0+!0+[])+(+!0+[]))


Because this "language" is a subset of javascript, you can run this right from your browser console. It returns the string "Hello World!".