Code Golf: Code Golf

Code Golf: Code Golf is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

First, show the shortest possible program that will emit the nine-character string “Code Golf”, without the quotation marks and without anything after the final “f”. Then show the shortest possible program that does the same thing but without itself containing any string or character literals, and without requiring any input or any environment variables or command-line arguments, though the name of the running program can be used.

Extra credit: how big is the executable required to perform the first task? Skip details about any prior compilation steps that might be involved.

11l

Translation of: Python

Using string literals, the following weighs in at 23 bytes.

print(end' ‘Code Golf’)

Without string literals, this is 60 bytes long.

L(c)[37,9,2,3,70,33,9,10,0]{print(end' Char(code' c(+)102))}

6502 Assembly

Not counting vector tables, disk/cartridge headers, and/or font graphics data, here is as small as I could get (example is for commodore 64)

With Quoted Literals

m
LDX #0
LDA G,x
BEQ d
jsr -46
jmp m+2
d
rts
G
db "Code Golf",0

Without Quoted Literals

p equ -46
LDA #67
JSR p
LDA #111
JSR p
LDA #100
JSR p
LDA #101
JSR p
LDA #32
JSR p
LDA #71
JSR p
LDA #111
JSR p
LDA #108
JSR p
LDA #102
JMP p

Action!

With Quoted Literals

PROC M()Print("Code Golf")

Output:

Code Golf

Without Quoted Literals

PROC M()Put(67)Put(111)Put(100)Put(101)Put(32)Put(71)Put(111)Put(108)Put(102)

Output:

Code Golf

ALGOL 68

Works with: ALGOL 68G version Any - tested with release 2.8.3.win32

With Quoted Literals

Source size is 18 bytes; as ALGOL 68G is an interpreter, there isn't a compiled object. The interpreter itself is 2780 K.

print("Code Golf")

Output:

Code Golf

Without Quoted Literals

Source file size is 65 bytes; as noted above, ALGOL 68G is an interpreter so there isn't a compiled object. The interpreter itself is 2780 K.
Declares and uses a unary operator ! which is effectively an abbreviation for REPR (which converts an INT to a CHAR) and then uses this with the builtin + operator which appends CHARs or STRINGS to form another STRING.

OP!=(INTc)CHAR:REPR(111-c);print(!44+!0+!11+!10+!79+!40+!0+!3+!9)

Output:

Code Golf

Arturo

prints"Code Golf"
prints join to[:char]digits.base:112 1683633059109764774
prints join to[:char][67 111 100 101 32 71 111 108 102]

Output:

Code GolfCode GolfCode Golf

AWK

# syntax: GAWK -f CODE_GOLF.AWK
#
# Under MS-Windows 10 using Thompson Automation's TAWK 5.0c AWKW -xm                   
# the compiled length of each program is 34,936 bytes and all three is 35,140 bytes.   
# Each requires the Awkr50w.EXE runtime of 231,936 bytes.                              
#                                                                                      
# Under MS-Windows 10 using Thompson Automation's TAWK 5.0c AWKW -xe                   
# the compiled length of each program is 244,856 bytes and all three is 245,060 bytes. 
# This is a completely stand-alone executable.                                         
#
# 24 bytes
BEGIN{printf"Code Golf"}

Using a string literal as conversion argument only:

# 64 bytes
BEGIN{for(n=15162543273030444;n;n=int(n/80))printf"%c",111-n%80}

This should work with POSIX-compliant implementations (support for hex literals is not mandatory), in double-precision floating-point arithmetic.

BASIC256

With a quoted string, the following weighs in at 12 bytes.

?"Code Golf"

For the second task, this is 66 bytes long.

dim a={37,81,70,71,2,41,81,78,72}
for i=0 to 8
?chr(30+a[i]);
next

Note: BASIC256 is an interpreter, it does not generate executables.

BQN

By using a string literal:

•Out"Code Golf"

Without quoted literals:

•Out@+111-44‿0‿11‿10‿79‿40‿0‿3‿9

EasyLang

With string literal (16 characters):

write"Code Golf"

Without quoted literals (66 characters):

c[]=[44 0 11 10 79 40 0 3 9];for i=1 to 9;write strchar 111-c[i];.

Alternative method (69 characters):

n=15162543273030444;while n>0;write strchar 111-n mod 80;n=n div 80;.

Factor

Works with: Factor version 0.99 2020-08-14

[I Code GolfI]
{ 67 111 100 101 32 71 111 108 102 } write

The executable is 2,265 KB.

FreeBASIC

With a quoted string, the following weighs in at 13 bytes.

?"Code Golf";

Without quoted literals, this is 77 bytes long.

dim as byte i,a(8)={44,0,11,10,79,40,0,3,9}:for i=0 to 8:?chr(111-a(i));:next

Both compile to a file 27,016 bytes long.

Free Pascal

"Code Golf" as Hex in little Endian ending in 0x00 86 byte. linux executable fpc 3.2.2 : 8x386 183400 Byte | x64 191104 byte

var a:QWord=$006F472065646F43;b:DWord=$0000666C;BEGIN write(pChar(@a),pChar(@b));END.

Output:

Code Golf

Go

Go isn't well equipped for Code Golf as a certain amount of ceremony (package main and func main()) are needed for any executable.

The shortest possible program (44 bytes) to print the required string is:

package main;func main(){print("Code Golf")}

If the program itself cannot contain string or character literals, then the shortest program I've been able to come up with (81 bytes) is:

package main;func main(){print(string([]byte{67,111,100,101,32,71,111,108,102}))}

Output in both cases

Code Golf

The size of the executables are 1,158,158 and 1,158,174 bytes respectively though this will obviously depend on Go version, platform and build options being used.

Golfscript

With a quoted string, the following weighs in at 11 bytes.

"Code Golf"

For the second task, this is 78 bytes long.

67[]+''+111[]+''+100[]+''+101[]+''+32[]+''+71[]+''+111[]+''+108[]+''+102[]+''+

Output:

In both cases:

Code Golf

J

For this bit of silliness, eliminating a trailing newline on stdout is probably the most difficult issue. So, we limit our implementation to linux and use /proc/self/fd/1

Sadly, we need to use a character literal to reference /proc/self/fd/1

But we do not need that reference to live in the implementation -- this task explicitly allows us to use the name of the running program.

So, our program looks like this:

#!/usr/bin/env jconsole
exit".(a.C.~<45 47){~a.i.;}.ARGV

And we name our program "exit'Code Golf'fwrite'-proc-self-fd-1'"

Here's an example bash session, illustrating this incredibly useful program:

$ "exit'Code Golf'fwrite'-proc-self-fd-1'" | wc
      0       2       9
$ "exit'Code Golf'fwrite'-proc-self-fd-1'"
Code Golf$

Extra Credit: this program occupies 57 bytes (ignoring OS overhead, such as the name of the routine and the minimum size allocated to any file with any content).

(Note: if we were careful about the current directory we were in when we executed this program, we could eliminate the part that swaps - and / characters ((a.C.~<45 47){~a.i.). Removing those 19 characters and creating four directories to hold the program and invoking the program as "exit'Code Golf'fwrite'"/proc/self/fd/"1'" might even be within the spirit of this task. However... we'll leave that as an exercise for the reader...)

jq

Works with: jq

Works with gojq, the Go implementation of jq

To skip the newline, the interpreter must be invoked with the -j option:

$ jq -nj '"Code Golf"' | wc -c
       9

For the second task, the following program clocks in at 38 bytes:

[44,0,11,10,79,40,0,3,9|111-.]|implode

Extra credit: The jq executable on my Mac is 461,864 bytes; gojq's is over 8 times larger.

Kotlin

Shortest program:

fun main()=print("Code Golf")

Without string literals, JVM only:

fun main()=print(String(byteArrayOf(67,111,100,101,32,71,111,108,102)))

Without string literals, platform-independent:

fun main()=print(byteArrayOf(67,111,100,101,32,71,111,108,102).decodeToString())

Ksh

Works with: ksh93

By just passing strings (17 bytes):

echo -n Code Golf

Let the shell generate every character (54 bytes):

typeset -i43 a=3066215 b=3384588;echo -n ${a:3} ${b:3}

Or, in case format strings are allowed for conversion (36 bytes):

printf %..39d%5..43d 2291147 3384588

Lua

With string literal (21 characters):

io.write("Code Golf")

Without quoted literals (55 characters):

io.write(string.char(67,111,100,101,32,71,111,108,102))

Microsoft Small Basic

Using a string literal, this program is 29 bytes long.

TextWindow.Write("Code Golf")

Without a string literal, the program is 221 bytes long.

TextWindow.Write(Text.GetCharacter(67)+Text.GetCharacter(111)+Text.GetCharacter(100)+Text.GetCharacter(101)+Text.GetCharacter(32)+Text.GetCharacter(71)+Text.GetCharacter(111)+Text.GetCharacter(108)+Text.GetCharacter(102))

OCaml

With string literal (29 characters):

let()=print_string"Code Golf"

Without quoted literals (75 characters):

let()=List.iter(fun c->print_char(Char.chr(111-c)))[44;0;11;10;79;40;0;3;9]

Openscad

With a quoted string, the following weighs in at 18 bytes.

text("Code Golf");

For the second task, this is 46 bytes long.

text(chr([67,111,100,101,32,71,111,108,102]));

Pascal

The shortest ISO-compliant Pascal program is 46 characters.

program p(output);begin write('Code Golf')end.

Unless you make certain presumptions about the target system, you cannot achieve the second task in Pascal (as defined by the ISO standards). Therefore, see Free Pascal for one method.

Perl

Using a string literal:

#         1         2
#12345678901234567890
 print'Code Golf'    # 16 bytes

Without quoted literals:

#         1         2         3         4         5
#12345678901234567890123456789012345678901234567890
 print map{chr(102^$_)}37,9,2,3,70,33,9,10,0    # 43 bytes

Phix

puts(1,"Code Golf")

Which is 19 bytes. Note that ?"Code Golf", while only 12 bytes, does print the quotation marks and therefore does not meet the task specifications.
Without using string literals, at 42 bytes we can have

puts(1,{67,111,100,101,32,71,111,108,102})

Slightly shorter, at 30 bytes, though it could be considered string/char:

puts(1,x"436F646520476F6C66")

The compiled size of the first is 276,992 bytes. You can actually make a smaller executable as follows:

include puts1h.e
puts1("Code Golf")

Then compile it with p -c -nodiag test.exw (or whatever) to yield an executable of 36,532 bytes - no diagnostics, which is itself non-trivial and otherwise pulls in file handling (for the ex.err it writes), printf, ffi, and they in turn pull in almost every builtin in existence between them. However even without all that lot it still needs stack, unassigned, and heap handlers, and unfortunately the latter also drags in delete() and therefore callfunc and therefore a whole bunch of subscript stuff we don't rightly need... still I suppose 36K ain't really all that bad. Oh, I should also say the compiler/interpreter/linker/debugger is itself (currently) 2,789,376 bytes, plus you'll still need most of builtins/ which is around the 9MB mark.

Phixmonti

/# Rosetta Code problem: http://rosettacode.org/wiki/Code_Golf
by Galileo, 10/2022 #/

include ..\Utilitys.pmt

"Code Golf" ?

( 67 111 100 101 32 71 111 108 102 ) len for get tochar print endfor nl

def >char tochar enddef
( 67 111 100 101 32 71 111 108 102 ) getid >char map lprint

Output:

Code Golf
Code Golf
Code Golf

Picat

As a string:

main => "Code Golf".print.

Output:

Code Golf

No quotes:

main => [67,111,100,101,32,71,111,108,102].map(chr).print.

Output:

Code Golf

Plain English

Using a string literal, this program is 89 bytes long.

To run:Start up.Write"Code Golf"to the console without advancing.Wait for the escape key.

Without a string literal, the program is 98 bytes long.

To run:Start up.Write$436F646520476F6C66 to the console without advancing.Wait for the escape key.

The executable compiled by the Plain English compiler weighs in at 143,360 bytes.

PureBasic

With a quoted string, the following weighs in at 18 bytes.

Print("Code Golf")

For the second task, this is 69 bytes long.

Dim a(8)
a(0)=37:a(1)=81:a(2)=70:a(3)=71
a(4)=2:a(5)=41:a(6)=81:a(7)=78:a(8)=72
For i=0 To 8
Print(Chr(30+a(i)))
Next

The size of the executables are 7680 and 10752 bytes respectively though this will obviously depend on PureBasic version, platform and build options being used.

Python

Python 3

Using string literals, the following weighs in at 22 bytes.

print(end="Code Golf")

Without string literals, this is 52 bytes long.

print(end=0x436f646520476f6c66.to_bytes(9).decode())

# or:

for c in 37,9,2,3,70,33,9,10,0:print(end=chr(c^102))

QBasic

Works with: QBasic version 1.1

With a quoted string, the following weighs in at 17 bytes.

PRINT "Code Golf"

For the second task, this is 91 bytes long.

DIM a(8)
DATA 37,81,70,71,2,41,81,78,72
FOR i = 0 TO 8
READ a(i)
PRINT CHR$(30 + a(i));

Note: QBasic is an interpreter, it does not generate executables.

Quackery

With Quoted Literals

say "Code Golf"

Without Quoted Literals

' [ 67 111 100 101 32 71 111 108 102 ] echo$ is marginally shorter but less interesting. For longer strings, encoding the text as a bignum rapidly becomes the more space efficient option. The text "Code Golf" is not quite long enough for the obvious improvement of using hexadecimal rather than decimal, as the digit reduction is less than the four character overhead of putting hex and a space before the number.

2549578149779768531 9 times [ 112 /mod emit ] drop

R

I suspect there may be shorter methods, but these are my best attempt.

## easy way
cat("Code Golf")

## no  quotes or string literals
cat(rlang::string(c(0x43, 0x6F, 0x64, 0x65, 0x20,
                    0x47, 0x6F, 0x6C, 0x66)))

Output:

Code Golf

Raku

Not very interesting, as it's pretty much just standard, non-obscure Raku. The output string is so short, there isn't any easy way to golf it shorter than just printing it directly. 17 bytes.

print <Code Golf>

Output:

Code Golf

Assuming we can't use the string literal in the source, the shortest I've come up with is:

print chrs 37,9,2,3,70,33,9,10,0 X+^102 # 39 chars, 39 bytes

Try it online!

print chrs -3,㊶,㉚,㉛,-㊳,1,㊶,㊳,㉜X+㉎ # 33 Chars, 49 bytes

Try it online!

print <Dpef!Hpmg>.ords».pred.chrs # 33 Chars, 34 bytes. Somewhat cheaty as it _does_ contain a string literal, but not the same literal as the output

Same output for each. Of course, to actually run any of that code you need the Raku compiler at 18.0Kb, the nqp vm interpreter at 17.9 Kb and the moar virtual machine at 17.9Kb. (Or the Java virtual machine, which is remarkably difficult to come up with a size for...)

REBOL

Using a string literal, this program is 15 bytes long.

prin"Code Golf"

Without a string literal, the program is 67 bytes long.

prin rejoin map-each c[67 111 100 101 32 71 111 108 102][to-char c]

Or, in case binary literals are allowed, the program is 51 bytes long.

s: enbase #{1A875E1A895F}insert at s 5 space prin s

Ruby

$><<"Code Golf"        #15 chars
puts
# Taken from Perl:
$><<['436F646520476F6C66'].pack('H*')  #37 chars

Run BASIC

With a quoted string, the following weighs in at 17 bytes.

print "Code Golf"

For the second task, this is 82 bytes long.

dim a(8):data 37,81,70,71,2,41,81,78,72:for i=0 to 8:read j:print chr$(30+j);:next

Note: Run BASIC is an interpreter, it does not generate executables.

sed

With sed, we can hardly stick to the rules. It requires at least one byte of input (to run the script at all), and cannot suppress a trailing newline on output.

$ echo | sed 's/.*/Code Golf/'
Code Golf

Sed cannot translate/insert characters without having the target being specified in the code. So the best we can do, is to hide them behind escape-sequences (even with that, we can't avoid all letters from the target string). And, to limit ourselves a bit, we use each escape-sequence only once). That script is not POSIX-compliant, but works at least with GNU sed.

$ echo | sed 's/.*/\x6f/;s/./\x43&\x64\x65\c`\x47&\x6c\x66/'
Code Golf

True BASIC

By using a string literal, the following weighs in at 22 bytes.

PRINT "Code Golf";
END

Without quoted literals, this is 92 bytes long.

DIM a(9)
DATA 44,0,11,10,79,40,0,3,9
FOR i=1 to 9
READ a(i)
PRINT CHR$(111-a(i));
NEXT i
END

Verilog

With a quoted string, the following weighs in at 64 bytes.

module main;
initial begin $write("Code Golf");
end
endmodule

For the second task, this is 102 bytes long.

module main;
initial begin $write("%c%c%c%c %c%c%c%c",67,111,100,101,71,111,108,102);
end
endmodule

Output:

In both cases:

Code Golf

V (Vlang)

Translation of: go

The shortest possible program to print the required string is:

print("Code Golf")

If the program itself cannot contain string or character literals, then use byte list:

print([u8(67),111,100,101,32,71,111,108,102].bytestr())

Output in both cases

Code Golf

Wren

The shortest possible program (25 bytes) to print the required string is:

System.write("Code Golf")

The size of the executable needed to run this or indeed any other standalone program (Wren-cli on Linux) is 414,760 bytes. However, if Wren were being embedded in a minimal C program, then the size of the executable would be 17,320 bytes.

If the program itself cannot contain string or character literals, then the shortest program we've been able to come up with (68 bytes) is:

for(c in[37,9,2,3,70,33,9,10,0])System.write(String.fromByte(c^102))

Output:

In both cases:

Code Golf

X86 Assembly

This is 100 bytes long (with CR+LF line endings). More useful than small, obfuscated source is small executable. This makes a 17-byte .COM file under MS-DOS. Assemble with: tasm and tlink /t. The xchg instruction is a single byte (as opposed to a straightforward 2-byte mov ah,9), and it takes advantage of the high byte of register bp being set to 09h when the program is started by MS-DOS. 09h selects the "display string" function.

.model tiny
.code
org 256
s:xchg ax,bp
mov dx,offset m
int 33
ret
m db "Code Golf$"
end s

XPL0

This is 19 characters long. I hate to say how big the executable is, but it's 54,400 bytes on the Raspberry Pi. Under MS-DOS a version of the compiler produces an executable as small as 6674 bytes.

Text(0,"Code Golf")

This version without a string or character literals is 33 characters long.

Text(0,[$65646f43,$6c6f4720,$e6])

Output:

Code Golf

Yabasic

With a quoted string, the following weighs in at 12 bytes.

?"Code Golf"

Without quoted literals, this is 65 bytes long.

data 44,0,11,10,79,40,0,3,9:for i=0 to 8 read n:?chr$(111-n);next

Note: Yabasic is an interpreter, it does not generate executables.

Z80 Assembly

Thanks to the Amstrad CPC's kernel, we can reduce our line count greatly by abstracting print routines to a single CALL statement. In addition, WinAPE lets us load our executable directly into memory without the need for a disk by simply using an ORG directive to define the starting address.

With Quoted Literals

Total: 11 lines.

org &200
ld hl,g
o:
ld a,(hl)
or a
ret z
call &bb5a
inc hl
jr o
g:
db "Code Golf",0

Hexdump of the executable:

7E B7 C8 CD 5A BB 23 18 F7 43 6F 64 65 20 47 6F 6C 66 00

Total: 19 bytes.

Without Quoted Literals

Total: 20 lines

org &200
q equ &bb5a
LD A,67
call q
LD A,111
call q
LD a,100
call q
LD a,101
call q
LD a,32
call q
LD a,71
call q
LD a,111
call q
LD a, 108
call q
LD a,102
jp q

Hexdump of the executable:

3E 43 
CD 5A BB 
3E 6F 
CD 5A BB 
3E 64 
CD 5A BB 
3E 65 
CD 5A BB 
3E 20 
CD 5A BB 
3E 47 
CD 5A BB 
3E 6F 
CD 5A BB 
3E 6C 
CD 5A BB 
3E 66 
C3 5A BB 

Total: 45 bytes.