Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It only takes a minute to sign up.
Sign up to join this community
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:
With the exceptions of "O"† and 0.
†"O" is capitalized, "o" is not acceptable.
#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))))))))))));
}
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:
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.
++++++++[>++++[>++>+++>+++>+<<<<-]>+>->+>>+[<]<-]>>.>>---.+++++++..+++.>.<<-.>.+++.------.--------.>+.
Meets all of the rules.
Credit goes to Daniel Cristofani.
0 and/or "O" must be used. It's a little mean to BrainFuck and golfscript, but they don't exactly have a hard time with this challenge.
\$\endgroup\$
#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);}
(cheating)
Lexically, this doesn't use any string literals or regex literals. It takes advantage of the stringification 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!));}
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 -> ' '
$, renamed # to ! for Hugs.
r=succ and w=pred run afoul of how Hugs implements the monomorphism restriction. Changing to r x=succ x and w x=pred x makes it work (at the cost of 4 characters). These seem to be problems in Hugs.
\$\endgroup\$
Mar 13, 2011 at 18:09
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.
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!)
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!
mov with CPP macros; eliminated the remaining 128.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}))
OO, OOO, but of course that would make it longer.
\$\endgroup\$
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);
}
}
enum X{Hello,World,A,B=A<<A<<A}void Main(){var c=(char)X.B;(X.Hello.ToString()+c+++X.World+c).Dump();}
\$\endgroup\$
t=!0<<-~-~-~-~!0
r=[]
for(i in{Hello:"O",World:0})r+=i+String.fromCharCode(t++)
alert(r)
99
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)
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++
.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.
------.--------.>+.>.
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!'
+++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++.+++++++++++++++++
++++++++++++.+++++++..+++.-------------------
---------------------------------------------
---------------.+++++++++++++++++++++++++++++
++++++++++++++++++++++++++.++++++++++++++++++
++++++.+++.------.--------.------------------
---------------------------------------------
----.-----------------------.
[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.
[ # 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
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])
[:0].
\$\endgroup\$
Nov 22, 2013 at 15:39
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! (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> ▛▀▀▌▚▝▐▀▌▛▀▀▌
▌█▌▌▖▞▚▚▘▌█▌▌
▌▀▘▌ ▚▛▞ ▌▀▘▌
▀▀▀▘▚▌▙▘▌▀▀▀▘
▄▙▛▚▜▀▄▀█▖▝▄▌
▖▄▄▘▖▄▄▄▟▗ ▀▘
▜Code golf!▌
▚▟▘▘▝▙▛▚▐▀▖▜▘
▘▘ ▀▛▗▚▗▛▀▌▄
▛▀▀▌▟▌▜▖▌▘█▐▘
▌█▌▌▘█▌▟█▜▙▐
▌▀▘▌▚▌▌█▗▝▌▚▘
▀▀▀▘ ▝▘▘▀▀▀▀▘
Idealy, this could look like:
zbar under linux. (sample: xwd | xwdtopnm | zbarimg /dev/stdin )
\$\endgroup\$
Jan 28, 2014 at 21:40
postscript, svg or other presentation languages already used there!? A way to encode is a language anyway... I think!
\$\endgroup\$
Feb 5, 2014 at 10:07
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.
!dlroW olleH{}+~(~~@#)
uses ForWhiles ability to read its own source code
! 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)
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
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.
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}}
"") and strings/character literals containing the character zero ('0') are not allowed. Only the string "O" (capital O) and the number 0 are.
\$\endgroup\$
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
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
}
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 :(
std::, etc etc
\$\endgroup\$
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 (which deserves many many upvotes, by the way) and other answers, better compression can be achieved by using more than just + and -.
(map print(butlast(rest(str'(Hello World!)))))
Note that Hello and World! are symbols, not literals of any kind.
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);
}
100 violates the rule about numbers. Please replace it with something more amusing.
\$\endgroup\$
Mar 12, 2011 at 23:03
Line 7: error: ISO C++ forbids declaration of 'main' with no type
\$\endgroup\$
Mar 15, 2011 at 2:31
int on g++
\$\endgroup\$
<?=Hello.chr(($a=-~-~-~0).~-$a).World.chr($a.$a);
Changelog:
<?$a=-~-~-~0;echo Hello.chr($a.$a-1).World.chr($a.$a); works, but it's 54 chars.
\$\endgroup\$
1 in there. There I go breaking my own rules...<?$a=-~-~-~0;echo Hello,chr($a.~-$a),World,chr($a.$a); is what I should have used, still 54 chars.
\$\endgroup\$
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,_])
@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.
@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
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**@_})
"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. \$\endgroup\$