# Hell0 W0rld! scored by ASCII values

Write a program that outputs Hell0 W0rld!. It must match this output exactly, including capitalization, zeroes instead of o's, exactly one space, etc. Trailing new lines are allowed.

Lowest score wins. Scoring is based on the sum of the values of each character in the language's code page - otherwise Unicode values should be used. New lines are treated as spaces.

Here are a few example scores:

abc //Score: 294

print(Hell0 W0rld!) //Score: 1597

//Score: 1454
multi
line
code


You can check your ASCII score by inputting your code here. You can view individual ASCII values here.

• Tabs are lower than spaces, but I seem to be getting a higher score using tabs. Are whitespace characters taken into account? That would shave a nice chunk off my score(s). – ouflak Nov 12 '19 at 11:26
• @ouflak Whitespace counts. Only change is that new lines count as spaces. So yes, tabs are cheaper than spaces. – Evorlor Nov 12 '19 at 11:43
• @Evordor, got it. Thanks. – ouflak Nov 12 '19 at 12:05

# Lenguage, score 0

Well, this is quite boring and obvious, but it seems to achieve the perfect score (assuming I understand the challenge correctly). To fix this loophole, you should probably add the program's length to the sum of the code points; I'm pretty sure that won't break the relative order of the current answers.

The program is

2282524454641945458940768311481012240407465625061984267694778013056442426959468031225640633070772676474431950201473533908


null bytes. Fortunately, 0 multiplied by the number above is still 0.

I believe this decompresses (alternatively, it compresses) to the automatically generated (with the help of a random web page that claims "Original Java program not from me") brainfuck program:

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


It almost certainly could be golfed (but I haven't tried), but that is unnecessary.

• Since the JavaScript submission was not a serious contender, I've edited it out of the answer. – Doorknob Dec 20 '19 at 17:43

# 05AB1E, score 513 252

-261 points thanks to @Dorian

Posting this separately from my other answer, as this one is arguably less cheating. I've been waiting for somebody else to do this for a while, but nobody did. I tried multiple languages. Pyth has extremely short code for this (Cl"...", if I remember correctly), but it turned out it can't input null bytes, and most other golfing languages I found have painfully large char codes for quotes (and I couldn't write this piece of code in the rest).

"ǝǝǝǝǝǝǝǝǝǝǝǝ...ǝǝǝǝǝ"gтB


Where there are 174047470094320053473995 ǝ characters, that conveniently happen to have a value of 0 in the code page.

Explanation:

"ǝǝǝǝǝǝǝǝǝǝǝǝ...ǝǝǝǝǝ"        push the long string
g       pop and get its length
тB     push 100 and convert to that base


You definitely shouldn't try the full version online, but you can try online the version with the length finding part skipped.

• I make this one 513 too. (I went with the same approach in Jelly for 998 - two different ways. Expensive quotes indeed.) – Jonathan Allan Oct 20 '19 at 23:22
• You can also use B to convert the number directly to a string. That will lead to a score of only 252 "ǝǝǝ...ǝǝ"gтB. Try it online – Dorian Oct 21 '19 at 7:51
• @Dorian Are you sure that can produce a space character? I tried that. UPD: turns out it can; will update slightly later. – the default. Oct 21 '19 at 9:24

# 7, 41 characters, code point sum 81

32002453003001200522231203103002440537403

Try it online!

Unlike with many of my 7 programs, there's nothing particularly clever going on here; this basically just prints a string in the simplest possible way (which in 7 involves encoding the string into a piece of source code, evaluating it, analysing the resulting stack element to figure out what source code is most likely to have created it, and then giving the resulting source code directly to the output routines).

The reason this scores so well is that 7 has a code page consisting of only 8 characters, and the code that's used to represent string literals tends to use only 0, 1, 2, 3, 4, 5 (as those commands have much easier-to-analyse effects on the stack than 6 and 7 do, so it's more likely that the original source will be accurately reproduced by the 0 command). This means that none of the code points in the bulk of the program will go above 5 (the assignment of code points to characters in 7 is the obvious one), leading to an average code point value of around 2½ (for this program, happenstance means it's more like 2). Thus, although there are a lot of characters in the program, the sum of the codepoints continues to stay low. (Unlike the Lenguage answer, the code point sum + character count is also very low, so this answer isn't even really cheating.)

# COW, Score: 117799

MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MoO MoO
MoO MoO MoO MoO MoO Moo Moo OOO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MOo MOo MOo
MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo Moo MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MOo MOo MOo MOo MOo
MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo
MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo
MOo MOo MOo MOo Moo MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MOo MOo MOo
MOo MOo MOo Moo MOo MOo MOo MOo MOo MOo MOo MOo Moo OOO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO Moo


Try it online!

My cow could not understand that the lower score in this challenge is better, so they scored very high! I kept telling them: "Please score lower, it is better", but they kept responding: "MoO"!

• But the score is a perfect sample input for Is It Double Speak! – user85052 Oct 20 '19 at 9:12

# HTML, Score: 959

Hell0
W0rld!

If newlines (\r and \n) would have been count as their ASCII code (10 and 13) the score would be 937 or 940 because in HTML, new lines in "inline" elements are rendered as space.

• How does one "run" a html page? This is the browser parsing a file, not your code actually doing anything :/ – Rob Oct 21 '19 at 12:20
• @RobQuist, so isn't the browser interpreting my HTML code? – Night2 Oct 21 '19 at 12:22
• @RobQuist, also please see this: "Answering in non-programming languages is allowed" – Night2 Oct 21 '19 at 12:26
• In my opinion, no, since its not a programming language but markup. – Rob Oct 21 '19 at 12:26

# Keg, sum = 966868853843

� +HOO��� +�UOG�(�+"


Try it online!

-15 score from cutting out the 0 (with a bit of help from the awful old Python script).

-10 score from A__'s idea to use " and implicit print over the costlier ,.

Based on a comment by Night2, as well as Jo King's old 32-byte quine.

� +HOO��� +�UOG�(�+"        Push the shifted codepoints beginning-first.
� +     � +                 ('H' and 'W' are pushed as sums,
because '+' is cheaper than '\'.)
�          29
"        then rotate the stack
(           once for every item on the stack.


If newlines weren't treated as spaces for scoring, this would be 832:


+GNN���TNF�� +(�+"


Try it online!

• Ah, thanks for catching that--my guess was it was some sort of CRLF issue but that didn't explain why the difference is 22. – Unrelated String Oct 20 '19 at 9:44
• Score: 843. TIO – user85052 Oct 20 '19 at 13:14

# MineFriff, Score: 3725

Cff3,a*a,9*c,a*b4,6*8,8*a7,ff2,8*6,9*c,:a*a1,9*8,
>l?#;o~


Try it online!

This ain't winning any competitions any time soon I tell you (I dread seeing what Scratch's score would be...). I'll post an image of what this looks like in-game soon, but first I have to actually re-install the python-in-minecraft mod and actually get it all working first.

See y'all soon! (I hope...)

## Actual In-Game Progess Report

### 10 mins in

• I managed to finally get Forge opened on my mac. That really shouldn't have taken 10 minutes but it did
• All star seems like a nice song to listen to while doing this

### 14 mins in

• Minecraft 1.8 finally opened
• All star finished playing
• Moving on to actually using forge

### 17 mins in

• Forge successfully has installed and I'm loading in the mod now
• Jake Paul is apparently number one. Send help please.

### 20 mins in

• Help received. No longer listening to cringey songs
• I think I've properly installed the mod. No clue if it works because minecraft doesn't want to load.

### 23 mins in

• And I downloaded the wrong version of the mod. Oops. Nothing broken, just wasted, oh, I don't know, 6 minutes. Sigh.

### 27 mins in

• I still can't read the documentation. Apparently, I needed to drag all the folders from the extracted zip into the mods folder

### 30 mins in

• MOD IS FINALLY INSTALLED
• Thank goodness. Robbie Rotten is now number one. No help needed this time.
• Time to see if everything still works.

### 34 mins in

• About to test if actual interpreter works in-game. Wish me luck!

### 36 mins in

• Nup. Game crashed. :(

### Tomorrow

• I'll be trying 1.10 instead of 1.8

### Next day, 1 min in

• Minecraft 1.10 has somehow deleted itself from my list of available installations. Now I have to manually find it somewhere and then somehow get Forge to make a 1.10 profile. Problem is, I won't be able to work on it for another 4 hours. See y'all then!
• Boy, what a journey – squid Oct 21 '19 at 16:39
• Cliffhanger!!!! – S.S. Anne Apr 7 at 17:52

# PHP, Score: 959

"Classic" answer. PHP outputs by default.

Hell0 W0rld!


Try it online!

# Bash, score: 1360

echo    Hell0   W0rld!


Try it online!

• If you can replace the spaces with tabs, you can save 23*2 = 46 points: tio.run/##S0oszvj/PzU5I5/TIzUnx4Az3KAoJ0Xx/38A - Bash word-splits on any whitespace char. – Digital Trauma Oct 21 '19 at 19:17
• @DigitalTrauma Thanks for the improvment – Delta Oct 21 '19 at 19:47

# Keg, Score: 1051

Hell0 W0rld\!


Try it online!

# Zsh, Score 1207

<<<"Hell0 W0rld!"


Try it online, with a self-scorer!

Using <<<Hell0\ W0rld! is shorter, but more expensive: \ = 92, but 2⨯" = 68.

# Forth (gforth), Score: 1105

." Hell0 W0rld!"


Try it online!

Prints the given string to stdout.

# bit**, Score: 2519

#72/#101/#108/#108/#48/#32/#87/#48/#114/#108/#100/#33/


Try it online!

# Japt, Score: 863

")FMM8SME"c+#


Test it

# Jelly, Score:1213

Just the string. Nothing interesting.

“Hell0 W0rld!


## Score: 1744

Simply a compression.

“ØƲṡhḍḊF®Ḍ?»


Try it online!

Code page summator

# Charcoal, score 722

⍘Ｌ”y；；；(...231699726063762276300861 in total...)；；；”γ


Port of @someone's 05AB1E answer. Explanation: If you convert 231699726063762276300861 to base 95 using the printable ASCII character set then you get the desired output. Only printable ASCII characters are automatically turned into string literals, so our null bytes have to be quoted with ”y”. Using Charcoal's code page, the special characters have the byte values 148 + 204 + 9 + 121 + 0 + ... + 0 + 9 + 231 = 722.

As proof of concept, you can see it just for the letters He: Try it online!

# Malbolge, Score: 6087

Just because I can.

('<;_#!7[}4{2VxTv-QsqNo'K+k)"Fgf|Bcc>=O<;(Kq7XXm3TjSng-x+)((%d#"E~Y|{{>g,;;ut

• 6081 is (presumably) your score, but it's not in bytes. You could list the byte count separately for interest if you wanted, or just remove that word. – Peter Cordes Oct 22 '19 at 4:11
• Whoops, that was a typo, thanks for noting. – dingledooper Oct 22 '19 at 4:15

# x86-64 machine code (Linux executable w/ system calls), score 1508

274 bytes: 18 code bytes, 12 data bytes, and 244 zero-padding bytes to make a rel32 = 00 01 00 00 instead of some larger number in the lowest byte.

The natural character-set of x86 machine code is 1 binary byte. No argument can be made for word, unlike with a RISC with fixed-length instructions.

Hexdump of the .text section of the executable (actually from assembling the same thing into a flat binary for hexdump -C). I'm not counting the metadata bytes of the whole executable emitted by the linker.

00000000  8d 35 00 01 00 00 5f 04  0c 92 04 01 0f 05 04 30  |.5...._........0|
00000010  0f 05 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000020  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
00000100  00 00 00 00 00 00 48 65  6c 6c 30 20 57 30 72 6c  |......Hell0 W0rl|
00000110  64 21                                             |d!|
00000112


Disassembly (objdump -d -Mintel).

0000000000400080 <_start>:            # Entry point
400080:       8d 35 00 01 00 00       lea    esi,[rip+0x100]        # 400186 <msg>

0000000000400086 <_start.lea_ref>:
400086:       5f                      pop    rdi      # fd = argc = 1
400089:       92                      xchg   edx,eax
40008c:       0f 05                   syscall         # write(argc=edi, msg=rsi, msglen=rdx) leaves RAX=msglen
400090:       0f 05                   syscall         # exit(edi=1)
... (a bunch of 00 bytes)

0000000000400186 <msg>:
48 65  6c 6c 30 20 57 30 72 6c 64 21    db "Hell0 W0rld!"


Note that Linux static executables start with all registers = 0 (except RSP which points to argc on the stack).

add al, imm8 has opcode 04, and is the lowest opcode that takes an immediate. Using that to turn a 0 into a number we want, and xchg-with-eax for another zero, is the best way I've found to construct small numbers under these scoring rules. push imm8/pop is somewhat worse, and mov reg,imm8 has a high opcode.

The opcode map at http://ref.x86asm.net/coder64.html was very useful for this.

Built with nasm -felf64 hell0.asm && ld -o hell0 hell0.o from this source: (Including a mess of commented out possibilities, many with their instruction bytes to remind me why I didn't use them.)

If MSGXOR is %defined to a non-zero value, link with ld -N (aka --omagic) to make .text read+write. In that case, the %if includes a loop that XORs every byte of the string. 0x60 and 0x64 are both equal. Subtraction with 0x30 doesn't save enough, and subtraction with larger values wraps around for too many bytes creating larger bytes.

BITS 64                     ; for flat binary.
%define MSGXOR 0x60

default rel
_start:
lea    esi,[rel msg]  ; small positive offset.  Truncating the address to 32-bit is ok in a non-PIE
;    mov esi, msg         ; better than   rsi, msg  or strict qword
.lea_ref:

;    add    al, 1        ; nr_write.  04  add al, imm8 is the lowest-opcode immediate instruction
;cmovnz edi, eax     ; 0f 45 f8    RDI is the highest-numbered register, and mode=11 is killer in ModRM
;    xchg   edi, eax          ; 9x
;    mov    edi, [rsp]        ; 8b 3c 24
pop    rdi                ; 5f      fd = argc=1

;    lea    edx, [rax+msglen]     ; 8d 50 0d
xchg   edx, eax                ; len = msglen

%if 0
lea    edi, [rax]   ; 8d 38
mov    esi, eax
%endif
;    push  "Hell"  ; 68 48 65 6c 6c  ; then would need to deal with 64-bit addresses

;    add cl, msglen    ; 80 c1 0c
;    mov cl, msglen    ; b1 0d

%if MSGXOR != 0
add al, msglen-2      ; last byte is a '!' which grows when XORed with 0x60
.loop:
xor byte [rsi+rax], MSGXOR
sub eax, strict dword 1      ; longer immediate makes the backwards jcc farther from FF
;sub al, 1; 2c 01
jnc  .loop                   ; }while(rax>=0); jnc has a lower opcode than jge or jns

;    lea ecx, [.loop]     ; at the top: 8d 0d 00 00 00 00       ; loop back with an indirect jump so the loop exit can jump forwards?
;        push  rcx    ; 51
;        ret          ; c3
;       jmp  rcx    ; ff e1   nope, doesn't look good.  Just have to eat the nearly-FF rel8

;    loop .loop   ; e2 f2
.break:
;;; AL = -1     after the loop
%else
add    al, 1                  ; RAX = 1 = _NR_write
%endif
; %else EAX = 0 still

;    add    al, 1 + !!MSGXOR      ; RAX = 1 = _NR_write
;    mov    al, 1
syscall                      ; write(argc, msg, msglen) returns RAX=msglen

;    xor    al, 60 ^ msglen
add    al, 60-msglen       ; or sub to wrap to 231 _NR_exit_group?
;    or     al, 60
;    mov    al, 60     ; exit.
;    mov    eax, 60
syscall

padbytes equ 0x100 - ($- .lea_ref) times padbytes db 0 ; in the same section as the code so we can control the rel32 to have one non-zero byte of 01 X equ MSGXOR ;msg: db "Hell0 W0rld!" msg: db 'H'^X, 'e'^X, 'l'^X, 'l'^X, '0'^X, ' '^X, 'W'^X, '0'^X, 'r'^X, 'l'^X, 'd'^X, '!' ; last byte not XORed msglen equ$-msg
;ml: db msglen

;msg: db 0x28, 0x5, 0xc, 0xc, 0x50, 0x40, 0x37, 0x50, 0x12, 0xc, 0x4, 0x41   ; with ^0x60


Score counted with hexdump | awk with a custom format to dump bytes in decimal, and awk to add them up.

nasm hell0.asm -o hell0.bin &&
<hell0.bin hexdump -e '32/1 "%d " "\n"' |
awk '{for(i=1; i<=NF; i++)tot+= i;} END{printf "score = %#x = %d\n", tot, tot}'  With MSGXOR = 0x60, score = 1668, the loop does not pay for itself with this short message, especially with 0 digits instead of o lower-case ASCII. cmp al,imm8 is 3C, but cmp/jcc and counting up towards mslen-1 instead of materializing msglen and msglen-2 separately might help. But it wouldn't help enough; we're 160 score away from break-even. # with MSGXOR = 0x60 0000000000400080 <_start>: 400080: 8d 35 00 01 00 00 lea esi,[rip+0x100] # 400186 <msg> 0000000000400086 <_start.lea_ref>: 400086: 5f pop rdi 400087: 04 0c add al,0xc 400089: 92 xchg edx,eax 40008a: 04 0a add al,0xa 000000000040008c <_start.loop>: 40008c: 80 34 06 60 xor BYTE PTR [rsi+rax*1],0x60 400090: 2d 01 00 00 00 sub eax,0x1 400095: 73 f5 jae 40008c <_start.loop> 0000000000400097 <_start.break>: 400097: 05 02 00 00 00 add eax,0x2 40009c: 0f 05 syscall 40009e: 04 30 add al,0x30 4000a0: 0f 05 syscall ... 0000000000400186 <msg>: 400186: 28 05 0c 0c 50 40 # not really instructions, deleted disassembly 40018c: 37 40018d: 50 40018e: 12 0c 04 400191: 21 .byte 0x21  I can't find a way to jump backwards that isn't horrible. Register-indirect jump sucks, and short displacements need a 0xF? byte. Padding with any non-zero byte to change the displacement costs at least as much as it reduces the rel8 displacement, and 00 00 is add [rax], al. Hmm, Possibly with a 256-byte-aligned address in RAX, we could pad with 00 00 without modifying memory? But xchg with EAX is a 9? byte and getting an address into RAX is costly. But if we have a pointer in RAX, we can't use add al, 1 or sub al, 1 to loop. In 32-bit code we'd have 4? inc/dec, but not RIP-relative addressing. x86-64 inc/dec are terrible, using the ff /0 modrm encoding. (I considered using a linker script to set the absolute virtual address to something even lower, but LEA's opcode is lower than mov r32, imm32. Hrm, for EAX there is 05 add eax, imm32 with an absolute address. So looping another reg with inc or dec might be viable. Or looping EAX with a pointer-compare, especially if I can make the absolute data address something like 00 00 01 00 just outside the low 64k where Linux disallows memory-mapping by default. But then I'd feel like I had to count the linker script or its resulting metadata. Or if I'm messing around with the metadata (ELF headers) in the executable, maybe have to count the whole thing instead of just the .text section.) 32-bit code needs int 0x80 for system calls, not 0f 05 syscall. # Turing Machine Code, Score: 71056279 5175 0 _ ! l ! ! _ d l " " _ l l # # _ r l
$_ 0 l % % _ W l & & _ _ l ' ' _ 0 l ( ( _ l l ) ) _ l l + + _ e l , , _ H l -  Implemented suggestions by Naruyoko Shaved off another 1100+ using tabs instead of spaces Try it online! # Turing Machine But Way Worse, Score: 69695 55343 0 0 0 1 1 0 0 0 1 1 1 2 0 0 0 2 0 1 3 0 0 0 3 0 1 4 0 0 0 4 1 1 5 0 0 0 5 0 1 6 0 0 0 6 0 1 7 0 0 0 7 0 1 8 1 0 0 8 0 1 9 0 0 0 9 1 1 10 0 0 0 10 1 1 11 0 0 0 11 0 1 12 0 0 0 12 0 1 13 0 0 0 13 1 1 14 0 0 0 14 0 1 15 0 0 0 15 1 1 16 1 0 0 16 0 1 17 0 0 0 17 1 1 18 0 0 0 18 1 1 19 0 0 0 19 0 1 20 0 0 0 20 1 1 21 0 0 0 21 1 1 22 0 0 0 22 0 1 23 0 0 0 23 0 1 24 1 0 0 24 0 1 25 0 0 0 25 1 1 26 0 0 0 26 1 1 27 0 0 0 27 0 1 28 0 0 0 28 1 1 29 0 0 0 29 1 1 30 0 0 0 30 0 1 31 0 0 0 31 0 1 32 1 0 0 32 0 1 33 0 0 0 33 0 1 34 0 0 0 34 1 1 35 0 0 0 35 1 1 36 0 0 0 36 0 1 37 0 0 0 37 0 1 38 0 0 0 38 0 1 39 0 0 0 39 0 1 40 1 0 0 40 0 1 41 0 0 0 41 0 1 42 0 0 0 42 1 1 43 0 0 0 43 0 1 44 0 0 0 44 1 1 45 0 0 0 45 1 1 46 0 0 0 46 0 1 47 0 0 0 47 0 1 48 1 0 0 48 0 1 49 0 0 0 49 0 1 50 0 0 0 50 1 1 51 0 0 0 51 0 1 52 0 0 0 52 0 1 53 0 0 0 53 0 1 54 0 0 0 54 0 1 55 0 0 0 55 0 1 56 1 0 0 56 0 1 57 0 0 0 57 1 1 58 0 0 0 58 0 1 59 0 0 0 59 1 1 60 0 0 0 60 0 1 61 0 0 0 61 1 1 62 0 0 0 62 1 1 63 0 0 0 63 1 1 64 1 0 0 64 0 1 65 0 0 0 65 0 1 66 0 0 0 66 1 1 67 0 0 0 67 1 1 68 0 0 0 68 0 1 69 0 0 0 69 0 1 70 0 0 0 70 0 1 71 0 0 0 71 0 1 72 1 0 0 72 0 1 73 0 0 0 73 1 1 74 0 0 0 74 1 1 75 0 0 0 75 1 1 76 0 0 0 76 0 1 77 0 0 0 77 0 1 78 0 0 0 78 1 1 79 0 0 0 79 0 1 80 1 0 0 80 0 1 81 0 0 0 81 1 1 82 0 0 0 82 1 1 83 0 0 0 83 0 1 84 0 0 0 84 1 1 85 0 0 0 85 1 1 86 0 0 0 86 0 1 87 0 0 0 87 0 1 88 1 0 0 88 0 1 89 0 0 0 89 1 1 90 0 0 0 90 1 1 91 0 0 0 91 0 1 92 0 0 0 92 0 1 93 0 0 0 93 1 1 94 0 0 0 94 0 1 95 0 0 0 95 0 1 96 1 0 0 96 0 1 97 0 0 0 97 0 1 98 0 0 0 98 1 1 99 0 0 0 99 0 1 100 0 0 0 100 0 1 101 0 0 0 101 0 1 102 0 0 0 102 0 1 103 0 0 0 103 1 1 104 1 1  Tabs instead of spaces, saving over 14,000 Try it online! • You could probably improve by changing the state name to a much earlier character, and move left instead of right. – Naruyoko Oct 21 '19 at 16:30 • @Naruyoko, Done, and added a couple of other improvements as well. – ouflak Nov 12 '19 at 15:55 # C (gcc), Score: 2021 Thanks to GammaFunction A(){puts("Hell0 W0rld!");}  Also, just for fun, here is a C program that had a score of 1 using overflow. It's a base64 encoded rar file https://pastebin.com/SJMcRnLj Try it online! • Trailing newlines are allowed, so puts saves a bit. Also, functions are allowed by default unless "full program" is specified in the challenge. – GammaFunction Oct 20 '19 at 4:05 • @GammaFunction how would I make it into a function? – girobuz Oct 20 '19 at 4:15 • Like this, using the footer to call the function. I called it A because it's the least expensive valid C identifier. – GammaFunction Oct 20 '19 at 4:17 • 1956 – ceilingcat Mar 29 at 1:26 # J, Score: 1452 echo'Hell0 W0rld!'  Try it online! # evil, Score: 12853 Hard-code the characters zaeeeaeeewzaeeaeeaeawzuueeueueawzuueeueueawzaeeeaeewzaeeeeewzaeeeeeuewzaeeeaeewzuueeueeaaawzuueeueueawzaeeaeeaewzaeeeeeaw  Try it online! # Labyrinth, Score:2151 72.101.108.108.48.32.87.48.114.108.100.33.@  ## Explanation 72 Push ord code of 'H' . Output 101.108.108.48.32.87.48.114.108.100.33. And so on @ And exit.  Try it online! ## MSM, Score: 1465 !dlr0W 0lleH...........  It is great that ! is not an MSM instruction. Half of the program pushes onto stack, half of it concatenates them. # brainfuck, score: 5822 ++++++++++[>+++++++>++++++++++>+++++++++++>+++++>+++>+++++++++<<<<<<-]>++.>+.>--..>--.>++.>---.<<.<++++++.------.<-.>>>+.  Try it online! # Befunge, Score: 1385 "!dlr0W 0lleH">:#,_@  This is my first legitimate code golf so it's probably not the best. Still not sure how the scoring system works. Is lower or higher better? • Lower score is better. – pppery Oct 21 '19 at 19:04 • @pppery thanks, I'm guessing it's the addition of all the ASCII values? – Jachdich Oct 21 '19 at 19:17 • That understanding is correct. – pppery Oct 21 '19 at 19:18 # 80186 machine code (MS-DOS .COM format), score: 1799 (2061 bytes) Nothing particularly special about this except that I used literal values on the stack to save score over MOV statements. To be able to use the same value for the function number and string location, I used just a little bit of padding. 68 00 09 58 50 5A CD 21 C3 (2039 zeroes) 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 48 65 6C 6C 30 20 57 30 72 6C 64 21 24  ## TASM (ideal mode) source IDEAL P186 MODEL TINY CODESEG ORG 100H MAIN: PUSH 0900H POP AX PUSH AX POP DX INT 21H RET PADDING DB 7F7H DUP (0) HELLO DB "Hell0 W0rld!$"

END MAIN
ENDS

• Oh the luxury of having a system call that takes implicit-length strings :) Related: my x86-64 Linux version, score 1508. For this, can't you arrange for the offset of HELLO to be 0200h or something, and save 7 score? Also, if your AX has a known value on process entry, you can use 05 add ax, imm16 instead of mov or push. – Peter Cordes Oct 22 '19 at 9:46

# HTML, score: 936

Hell0	W0rld!

HTML treats any whitespace as a space.

# Python 2, Score:1584

Prints the string...

print"Hell0 W0rld!"


Try it online!

# shortC, Score:1166

ShortC version of this.

AJ"Hell0 W0rld!"


Try it online!