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.
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.
#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))))))))))));
}
++++++++[>++++[>++>+++>+++>+<<<<-]>+>->+>>+[<]<-]>>.>>---.+++++++..+++.>.<<-.>.+++.------.--------.>+.
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\$
– zzzzBov
Mar 11 '11 at 21:32
#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\$
– MtnViewMark
Mar 13 '11 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\$
– zzzzBov
Mar 12 '11 at 19:31
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\$
– Cœur
Jul 8 '14 at 16:10
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\$
– Reinstate Monica
Nov 22 '13 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\$
– F. Hauri
Jan 28 '14 at 21:40
postscript, svg or other presentation languages already used there!? A way to encode is a language anyway... I think!
\$\endgroup\$
– F. Hauri
Feb 5 '14 at 10:07
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.
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.
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\$
– Timwi
Mar 12 '11 at 22:59
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\$
– Wug
Nov 9 '12 at 22:01
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\$
– Joey Adams
Mar 12 '11 at 23:03
Line 7: error: ISO C++ forbids declaration of 'main' with no type
\$\endgroup\$
– Nathan Osman
Mar 15 '11 at 2:31
int on g++
\$\endgroup\$
– fR0DDY
Mar 15 '11 at 3:07
<?=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\$
– zzzzBov
Mar 16 '11 at 18:07
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\$
– zzzzBov
Mar 16 '11 at 23:34
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=[[,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[],[,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,],[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,]];for(O_O=[].length;O.length>O_O;O_O++)document.write(String.fromCharCode((O[O_O].length||-Math.pow([,,].length,[,,,,,].length)-[,,,,,,,].length)+Math.pow([,,].length,[,,,,,,].length)+Math.pow(++[,].length,[,,,].length)-[,].length));document.write(String.fromCharCode(Math.pow([,,].length,[,,,,,].length)+[,].length))
What about abusing array literals just to have unary base. This program has advantage of not using 0.
0. What about O_O=0;?
\$\endgroup\$
– Erik the Outgolfer
Sep 15 '16 at 15:12
O_O=[].length can be written as O_O=false which decreases it by 4.
\$\endgroup\$
– Atmocreations
Oct 26 '16 at 14:54
"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\$ – Timwi Mar 12 '11 at 21:12