# Hello ASCII World!

Construct a full program which outputs Hello, World!. The score of your submission will be equal to the sum of all of the ASCII values of the distinct characters. The lowest score wins!

## Rules

• It must be a full program which takes no input
• It must only print to STDOUT, nothing else
• It must be strictly less than 1000 bytes long
• It may only include printable ASCII (meaning no \n allowed)
• The objective is to find the lowest score for every language, so no answer will be marked "accepted"

## Example

Here is an example submission in Python, which has a score of 1279:

print"Hello, World!"


• This answer shows how to write any Python program using only exc="% (which would have a score of 452), but it would be insanely long without newline. Mar 24 '20 at 4:00
• On further thought, the above scheme is impossible without newline :( Mar 24 '20 at 4:06
• @SurculoseSputum This one uses 9 chars exc%'(1+), no newline. CJam can do it in just 3: ')~. Mar 24 '20 at 4:12
• Would it then be preferrable to include newlines, or maybe add a penalty for solutions which are too long? Mar 24 '20 at 4:15
• And if you won't change the text "Hello, World!", Stuck will win as always. Mar 24 '20 at 4:31

# C (gcc)-zexecstack-Wl,-e$-nostartfiles on Linux x86-64, 876 914 bytes, score 798 293 $=1111+1111+1111+111+111-11-11-11-11+1+1+1;$$=1111111111+111111111-11111111+1111111+1111111-111111+1111+1111+111+111+111+111+111-11-11-11-11+1+1+1+1+1;$$$=111111+111111-11111-1111+111+111+111-11-1-1-1-1-1;=111111111+111111111+11111111+11111111+11111111+1111111+1111111+111111-1111-1111-1111-1111-111-111-111+11+11+11+11+1+1+1+1+1;$=1111111111+1111111111-111111111-111111111-111111111-111111111+11111111+11111111+11111111+11111111-1111111-1111111-1111111-111111-111111-111111+11111+11111-1111+111+111+11+1;$$=111111111+111111111+111111111+111111111+111111111-11111111-1111111-1111111-1111111-1111111-111111-111111+1111+1111+1111+1111+1111-111-111-111+11+11-1-1;$$$=1111111111+1111111111-111111111-111111111-111111111-111111111+11111111+11111111+11111111+11111111-1111111-1111111-111111-111111-111111-111111-111111-1111-1111-1111-1111-1111+11+11+11+11+1;=11111-1111-1111-111-111-111-11+1+1+1;  Try it online! Charset: A[]={+,-1}; 1+-$=;

Same method as the previous answer, with even more hacking to supply a custom entry point named $ (which has the smallest ASCII value among a-zA-Z_$). Credit to this SO answer for identifying the flags and assembly setup to make this work. Also got a hint from ceilingcat's awesome linker hack to remove []{} from the code.

Assembly: (NASM syntax)

bits 64
global _start
_start:
mov edx, 13
pop rax
push rax
lea rsi, [rel s]
pop rdi
syscall
s: db "Hello, World!"


Uses the argc=1 set up on the stack to load the value 1 to rax and rdi. The instructions are slightly mixed up in order to get the minimal code length in C.

Here is the Python script that generates the "ones decomposition" from the xxd -i output (C include-style hex output) of the compiled binary.

# C (gcc)-zexecstack on Linux x86-64, 891 bytes, score 1154

main[]={1111+1111+1111+111+111-11-11-11-11+1+1+1,1111111111-111111111-111111111+11111111-1111111-111111-111111-111111-111111+11111-1111-1111-1111-1111+111+111+111+11,1+1+1+1,111111111-11111111-11111111-1111111-1111111-1111111-1111111+111111+111111+111111+111111+11111+11111+11111+11111-111-111-111-111-111-11-11-11,1111111111+1111111111-111111111-111111111-111111111-111111111+11111111+11111111+11111111+11111111-1111111-1111111-1111111+111111+11111+11111+11111+11111-1111-111-111+11+11+11,1111111111+111111111+111111111+111111111+11111111+11111111-1111111-1111111-1111111-1111111-111111-111111-111111-111111-11111-11111-11111-11111-11111+1111+1111+1111+1111-111-111-111-11-1-1-1-1,1111111111+111111111+111111111+111111111+111111111+111111111+11111111+11111111-1111111-1111111-1111111-1111111+111111+111111+111111+11111+11111+11111+11111+11111-1111-1111-1111-1111-111+11-1-1-1-1-1,11+11+11};


Try it online!

Uses ceilingcat's minimal Turing-complete charset main[]={1+,};, plus - to meet the code length limit.

Assembly: (NASM syntax)

bits 64
global _start
_start:
mov edx, 13
lea rsi, [rel s]
mov eax, edi
syscall
s: db "Hello, World!"


Essentially calls write syscall once, and goes into arbitrary instructions formed by the string literal, causing segfault.

• This is a brilliant solution (I’ve upvoted it). But I think the language should be "C (gcc)/x86". It won’t work using gcc on a non-x86 machine. Mar 25 '20 at 13:33
• In fact, I just tried it on two x86 machines (one Linux and one OS X), and it failed to print "Hello, World!" on both. I don't know what the difference is between these and TIO, where it worked. Mar 25 '20 at 14:15
• One more comment: This program writes an error message to stderr (when it crashes), which I understood wasn't allowed in OP's specs ("It must only print to STDOUT, nothing else"). I could reduce my dc score, for instance, if spurious output to stderr was allowed, and that's probably true of some of the other solutions as well. Mar 25 '20 at 14:29
• @MitchellSpector This code is supposed to work in x86-64, with executable stack (-zexecstack flag in the compiler/linker). And as pointed out in the linked answer, you might need const in some environments. The error messages are printed by the OS, not the program. Mar 26 '20 at 0:58
• Thanks -- I missed that flag because it wasn't included with the language name in the answer heading, but it's clearly needed. That got it to work correctly on my Linux system. But I still can't get it to work under OS X, where I believe the equivalent compiler option is -Wl,-allow_stack_execute -- but even with that option, it doesn't print "Hello, World!". I tried it with and without the const keyword before main. If you know how to get this to work under OS X, I'd be interested. Mar 26 '20 at 1:54

# Stuck, 0 bytes, score 0

An empty program prints "Hello, World!"

Just as suggested in the comments, Stuck wins!

• Can we please stop the low-effort stuff? 1+ though.
– null
Sep 10 '20 at 5:22

# CJam, 652 bytes, score 120

'))))))))))))))))))))))))))))))))')))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))'))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))'))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))')))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))'))))''(((((((')))))))))))))))))))))))))))))))))))))))))))))))')))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))'))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))'))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))'))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))''((((((


Try it online!

Uses ')(.

# HQ9+, 1 byte, score 72

H


There is no TIO implementation for HQ9+.

# Malbolge, 71 bytes, 3963 points

(=<#9]=}5YXy1Uvv-Q+q)Mn&Jk#j!EC$dc.?}_<)L'8%oXW2qj|Q@yx+iba'Hd]\E!YX|z  Try it online! Uses the following unique characters !#$%&'()+-.12589<=?@CEHJLMQUWXY\]_abcdijknoqvxyz|}


# dc, 106 652 192 428 bytes, score 332 272 272 204

11 11+11+11+11+11+1+1+1+1+1+1+P11 11+11+11+11+11+11+11+11+1+1+P11 11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+P11 11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+P11 11+11+11+11+11+11+11+11+11+1+P11 11+11+11+P11 11+1+1+1+1+1+1+1+1+1+1+P11 11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+1+P11 11+11+11+11+11+11+11+11+11+1+P11 11+11+11+11+11+11+11+11+11+1+1+1+1+P11 11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+P11 11+11+11+11+11+11+11+11+1+P11 11+11+P


Try it online!

4 characters used: +1P and the space character.

• You need to sum the codepoints of all characters you use in your program.
– user92069
Mar 24 '20 at 5:25
• @a'_' You're right - I misread the scoring in the challenge. It's fixed. Mar 24 '20 at 5:29
• You may be interested in the bounty to codegolf.stackexchange.com/q/11336 for the dc solution with the lowest number of unique characters Feb 6 at 11:59
• @user41805 Thanks, I hadn’t seen the bounty. (I haven’t had time to do any code golf for a while.) Feb 7 at 2:17

# C (gcc), 344 $$\\cdots\$$ 254 242 bytes, score 1624 1575

Lowered score by 49 thanks to Arnauld!!!

Saved 12 bytes thanks to ceilingcat!!!

h;t;u;i;a;main(c){u+=u=i+=i=a=c+c+c;t=u+u+u;putchar(putchar(t+t)+u+u+a+c+c);putchar(putchar(putchar(h=t+t+t))+a);putchar(t+i+c+c);putchar(u+u+i+c+c);putchar(t+t+u+a);putchar(h+a);putchar(h+i);putchar(h);putchar(t+t+u+u+a+c);putchar(u+u+i+a);}


Try it online!

Uses characters: ()+;=achimnprtu{}

• You can get rid of 1 by retrieving it from argc, leading to 1575 points. Mar 24 '20 at 17:17
• @Arnauld Very clever - thanks! :-) Mar 24 '20 at 17:24
• @Arnauld Why not? Thanks! :-) Mar 24 '20 at 17:37
• @Arnauld Knocked down to a quarter K - thanks! :-) Mar 24 '20 at 17:50
• Yeah, that's a nice round figure. And that's why I didn't submit the 254-byte version. ;) Mar 24 '20 at 17:55

# 2/9 of an esolang, 1 byte, score = 64

@

• But the article says "Every line of code must be exactly 21 characters" Mar 30 at 13:46

# brainfuck, 134 score

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


Try it online!

Alas, could have scored 89 if not for the 1000 character limit.

# Boolfuck, 102 score

;;;+;+;;+;+;+;+;+;+;;+;;+;;;+;;+;+;;+;;;+;;+;+;;+;+;;;;+;+;;+;;;+;;+;+;+;;;;;;;+;+;;+;;;+;+;+;+;+;+;;;;+;+;;+;;+;+;;+;;;+;;;+;;+;+;;+;;;+;+;;+;;+;+;+;;;;+;


Try it online!

"Standard".

• I was going to make a brainf*** solution (generated with Python) and it was exactly your solution, so I upvoted it. Nice going! :) Jun 7 at 21:25

# Brain-Flak, 618 bytes, score 265

((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())()()()()()()()())()()()()()())[()()()])[()()()()()()()()()()()()()()()()()()()()()()()()])(((((((()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())()()()()()()()()()()()())()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()())[()()()]))[()()()()()()()])[()()()()()()()()()()()()()()()()()()()()()()()()()()()()()])


Try it online!

Used characters: ()[]

Uses () (one), (...) (sum and push), [...] (negate). Can definitely be shorter by using [] (stack height) but it's not the point of the challenge (as long as the code is under 1000 bytes). Looks like the program can't fit into 1000 bytes using only () and (...).

# 05AB1E, score: 282 (251 bytes)

0>>>0>>>>>>>>>0>0>>>0>>>>>>>>0>>>>>0>>>0 0>>>>>>0>>>>>>>>0>>>>>>>>0>>>>0>>>>>>>0>>0 0>>>>>>>0>>>0 0>>>>>0>>>>>>>>>0>>0>>>0>0>>>>>>0 0>>>>>>>J 0>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>B


Try it online.

Five characters used: 0> JB

Explanation:

1. First we construct the number 39138530688472073059231607. We do this per digit, by pushing a 0 and increasing it by 1 per >, after which the entire stack of digits is joined together with J.
2. Then it pushes another 0 with 107 >s to get the number 107.
3. After which it will convert 39138530688472073059231607 to base-107 with B, which is "Hello, World!".

# Help, WarDoq!, 1 byte, Score: 72

H


Try It Online!

# H🌍, 2 bytes, score 223

hw


Try it online!

# Python 2, 574 bytes, score 564

exec"%c"%(111+1)+"%c"%(111+1+1+1)+"%c"%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1)+"%c"%(11+11+11+11+11+11+11+11+11+11)+"%c"%(111+1+1+1+1+1)+"%c"%(11+11+11+1+1+1+1+1+1)+"%c"%(11+11+11+11+11+11+1+1+1+1+1+1)+"e%c"%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+"%c"%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+"%c"%111+"%c"%(11+11+11+11)+"%c"%(11+11+1+1+1+1+1+1+1+1+1+1)+"%c"%(11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+1)+"%c"%111+"%c"%(111+1+1+1)+"%c"%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1)+"%c"%(11+11+11+11+11+11+11+11+11+1)+"%c"%(11+11+11)+"%c"%(11+11+11+1+1+1+1+1+1)


Try it online!

Used characters: exc"%(1+)

Constructs the string print'Hello, World!' using the characters "%c(1+), then execs it. Using the raw print with any single extra character costs more than this.

# Gol><>, 234 bytes, score 259

llllllll+++l+++++lllllllllllll+++++l++++++++llllllllllll+++++l+l+++++++llllllllllll+++l+++++++++lllllllllll+++l++++++++lllllll++ll++l+++++llll+++l+l+lll++l+$llllllll++++++l++l+llllll+++lll+++++llllllll+++++++lll++l+l+l+llllll++++l++$H


Try it online!

Used characters: l (length of stack), + (add top two numbers), $ (swap top two numbers), H. $ was needed because some characters (space, H) were impossible to create at that specific stack height; it is cheaper than any number literal (minimum being 0).

# Gol><>, 182 bytes, score 315

ssP0ssssssPPPP0ssssssPPPPPPPPPPPP0sssssssPP0ssssssPPPPPPPPPPPPPPP0sssssPPPPPPP0ss0ssPPPPPPPPPPPP0ssssssPPPPPPPPPPPPPPP0ssssssPPPPPPPPPPPP0ssssssPPPPPPPPPPPP0ssssssPPPPP0ssssPPPPPPPPH


Try it online!

Used characters: 0 (push zero to the stack), s (add 16 to top), P (increment top), H (halt and print everything on the stack as characters).

# C (gcc), 540 bytes, score 1563

main(){putchar(11+11+11+11+11+11+1+1+1+1+1+1);putchar(11+11+11+11+11+11+11+11+11+1+1);putchar(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1);putchar(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1);putchar(11+11+11+11+11+11+11+11+11+11+1);putchar(11+11+11+11);putchar(11+11+1+1+1+1+1+1+1+1+1+1);putchar(11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+1);putchar(11+11+11+11+11+11+11+11+11+11+1);putchar(11+11+11+11+11+11+11+11+11+11+1+1+1+1);putchar(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1);putchar(11+11+11+11+11+11+11+11+11+1);putchar(11+11+11);}


Try it online!

This is just a straightforward solution that prints the ASCII code of each character in turn, like some of the other solutions here. I'm not aware of any tricky way to reduce the score in C.

# Rust, 35 bytes, Score: 1916

fn main(){print!("Hello, World!")}


I don't know if you can get any shorter in Rust.

# Bash, 18 bytes, score 1005

echo Hello, World!


Try it online!

# PHP, 13 bytes, score 802

Hello, World!


Try it online!

# naz, 732 bytes, score 372

1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o1a1a1a1a1a1a1a1o1o1a1a1a1o1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1o1s1s1s1s1s1s1s1s1s1s1s1s1o1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1o1a1a1a1o1s1s1s1s1s1s1o1s1s1s1s1s1s1s1s1o1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1s1o


Uses 1, a, s and o.

Without the size restriction, naz -u could achieve a theoretical score of 257 by foregoing s.

# G*, 15 bytes, score = 914

p Hello, World!


# Wolfram Language (Mathematica), 321 bytes, score 399

charset: \013456

\043\1333311\05313311\0531133\135\133\043\13311\0534011\0534031\135\133\043\1331343\05311354\135\13331\05341\054101\0544\053104\0544\053104\054111\05444\0541\05331\05443\05344\054111\054114\0544\053104\054100\05433\135\135\135\046\1330\133\1330\0540\135\135\133\116\141\155\145\163\133\135\133\133\043\135\135\135\046\135


Try it online!

I feel it's best to try to explain this one. First, Mathematica allows character inputs with octal triplets (From this point on, I'll be using my local copy), after decoding, looks like so

#[1000+31111][#[3304+11135][#[10000+13003][31+41,101,4+104,4+104,111,44,1+31,43+44,111,114,4+104,100,33]]]&[0[[0,0]][Names[][[#]]]&]


All of the addition is just to avoid getting a 2, 7, 8, or 9, which in octal have 2s and 7s, which are trivially avoidable, all the other characters are the minimum needed to get Names[]. When the actual functions are shown,

Print[FromCharacterCode[List[72,101,108,108,111,44,32,87,111,114,108,100,33]]]


Where all the functions are hidden inside a Names[][[1234]] so that they can all be numerically decided, but Names[], at minimum, needs \13456 to derive everything else, the 0 is needed to turn Names's string output into Functions, as 0[[0,0]] returns Symbol.

I know that after making this whole thing it can be golfed to do without 0, as the only time it comes up is in addition, inside the octal for the + symbol, and getting the symbol header, meaning that if 0 can be derived elsewhere then in the charset 0 can be switched to +, lowering the score by 5. All it would need is to not use commas inside list. The only function that I recall that can do this is the Append family, but calling Append instead of each comma makes the program over 2k in size.

In case you want to see how it was generated, I will put most of my code here

# Nim, 387 bytes, score 601

ecHO cHR 11+11+11+11+11+11+1+1+1+1+1+1,cHR 11+11+11+11+11+11+11+11+11+1+1,cHR 11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1,cHR 11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1,cHR 111,cHR 11+11+11+11,cHR 11+11+1+1+1+1+1+1+1+1+1+1,cHR 11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+1,cHR 111,cHR 111+1+1+1,cHR 11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1,cHR 11+11+11+11+11+11+11+11+11+1,cHR 11+11+11


Try it online!

Chars: ecHRO, +1

# Pyth, 430 bytes, score 191

++++++++++++C+++++++++++11 11 11 11 11 11 1 1 1 1 1 1C++++++++++11 11 11 11 11 11 11 11 11 1 1C+++++++++++++++++11 11 11 11 11 11 11 11 11 1 1 1 1 1 1 1 1 1C+++++++++++++++++11 11 11 11 11 11 11 11 11 1 1 1 1 1 1 1 1 1C111C+++11 11 11 11C+++++++++++11 11 1 1 1 1 1 1 1 1 1 1C++++++++111 1 1 1 1 1 1 1 1C111C+++111 1 1 1C+++++++++++++++++11 11 11 11 11 11 11 11 11 1 1 1 1 1 1 1 1 1C+++++++++11 11 11 11 11 11 11 11 11 1C++11 11 11


Try it online!

w


Try it online!

Not so interesting

• As this is code challenge and has special scoring, please also specify “score 119”. Mar 31 at 1:57

# Erlang (escript), 439 bytes, score: 1706

Port of the 540 byte C answer. Unique characters:


main([])->o:fwrte1+,.


Which is of length 23, sum 1706.


main([])->io:fwrite([11+11+11+11+11+11+1+1+1+1+1+1,11+11+11+11+11+11+11+11+11+1+1,11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1,11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1,11+11+11+11+11+11+11+11+11+11+1,11+11+11+11,11+11+1+1+1+1+1+1+1+1+1+1,11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+1,11+11+11+11+11+11+11+11+11+11+1,11+11+11+11+11+11+11+11+11+11+1+1+1+1,11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1,11+11+11+11+11+11+11+11+11+1,11+11+11]).


Try it online!

• Newlines are not allowed. Dec 11 '20 at 21:32

# Perl 5, 386 bytes, score = 818

say chr 11+11+11+11+11+11+1+1+1+1+1+1,chr 11+11+11+11+11+11+11+11+11+1+1,chr 11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1,chr 11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1,chr 111,chr 11+11+11+11,chr 1+1+1+1+1+1+1+1+1+1+11+11,chr 11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+1,chr 111,chr 111+1+1+1,chr 11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1,chr 11+11+11+11+11+11+11+11+11+1,chr 11+11+11


Try it online!

# Zsh, 464 bytes, score 552

Try it Online!       charset: <${(#)1+} <<<${(#)$((11+11+11+11+11+11+1+1+1+1+1+1))}${(#)$((11+11+11+11+11+11+11+11+11+1+1))}${(#)$((11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1))}${(#)$((11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1))}${(#)$((111))}${(#)$((11+11+11+11))}${(#)$((11+11+1+1+1+1+1+1+1+1+1+1))}${(#)$((11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1+1))}${(#)$((111))}${(#)$((111+1+1+1))}${(#)$((11+11+11+11+11+11+11+11+11+1+1+1+1+1+1+1+1+1))}${(#)$((11+11+11+11+11+11+11+11+11+1))}${(#)\$((11+11+11))}


# Julia, 107 bytes, score 815

print('i'-11-11-11,'p'-11,'n'-1-1,'n'-1-1,'p'-1,',',','-11-1,'n'-11-11-1,'p'-1,'r','n'-1-1,'p'-11-1,','-11)


characters used print('-1,)

Try it online!

# Java (JDK), 468 bytes, score 1234

\u0063\u006c\u0061\u0073\u0073\u0020\u0041\u007b\u0070\u0075\u0062\u006c\u0069\u0063\u0020\u0073\u0074\u0061\u0074\u0069\u0063\u0020\u0076\u006f\u0069\u0064\u0020\u006d\u0061\u0069\u006e\u0028\u0053\u0074\u0072\u0069\u006e\u0067\u005b\u005d\u0061\u0029\u007b\u0053\u0079\u0073\u0074\u0065\u006d\u002e\u006f\u0075\u0074\u002e\u0070\u0072\u0069\u006e\u0074\u0028\u0022\u0048\u0065\u006c\u006c\u006f\u0020\u0057\u006f\u0072\u006c\u0064\u0021\u0022\u0029\u003b\u007d\u007d


Try it online!

Note: I'm stumped on how to make it have less score. Oracle really does make it hard to golf. Thanks to @ceilingcat for and halfing the score.