Code Golf: Code Golf: Difference between revisions
→{{header|Vlang}}: Rename "Vlang" in "V (Vlang)" |
→Nu: add |
||
(91 intermediate revisions by 31 users not shown) | |||
Line 4: | Line 4: | ||
Extra credit: how big is the executable required to perform the first task? Skip details about any prior compilation steps that might be involved. |
Extra credit: how big is the executable required to perform the first task? Skip details about any prior compilation steps that might be involved. |
||
=={{header|11l}}== |
|||
{{trans|Python}} |
|||
Using string literals, the following weighs in at 23 bytes. |
|||
<syntaxhighlight lang="11l">print(end' ‘Code Golf’)</syntaxhighlight> |
|||
Without string literals, this is 60 bytes long. |
|||
<syntaxhighlight lang="11l">L(c)[37,9,2,3,70,33,9,10,0]{print(end' Char(code' c(+)102))}</syntaxhighlight> |
|||
=={{header|AArch64 Assembly}}== |
|||
{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }} |
|||
<syntaxhighlight lang AArch64 Assembly> |
|||
/* ARM assembly AARCH64 Raspberry PI 3B */ |
|||
/* program codegolf64.s */ |
|||
/*********************************/ |
|||
/* Initialized data */ |
|||
/*********************************/ |
|||
.data |
|||
szString: .asciz "codeGolf" |
|||
.equ SIZESTRING, . - szString |
|||
/*********************************/ |
|||
/* code section */ |
|||
/*********************************/ |
|||
.text |
|||
.global main |
|||
main: // entry of program |
|||
mov x2,SIZESTRING // string length |
|||
ldr x1,=szString |
|||
mov x0,1 // output Linux standard |
|||
mov x8,64 // code call system "write" |
|||
svc 0 |
|||
mov x0,0 // return code |
|||
mov x8,93 // request to exit program |
|||
svc #0 // perform the system call |
|||
</syntaxhighlight> |
|||
{{Out}} |
|||
<pre> |
|||
Compilation 64 bits Rosetta de codegolf64.s |
|||
-rwx------ 1 u0_a344 u0_a344 1144 May 24 21:48 codegolf64 |
|||
-rw------- 1 u0_a344 u0_a344 960 May 24 21:48 codegolf64.o |
|||
-rw------- 1 u0_a344 u0_a344 813 May 24 21:45 codegolf64.s |
|||
Fin de compilation. |
|||
~/.../rosetta/asm4 $ codegolf64 |
|||
codeGolf~/.../rosetta/asm4 $ |
|||
</pre> |
|||
=={{header|Ada}}== |
|||
With String literal: |
|||
<syntaxhighlight lang="ada"> |
|||
with Ada.Text_IO;procedure C is begin Ada.Text_IO.Put("Code Golf");end; |
|||
</syntaxhighlight> |
|||
71 characters |
|||
Without Character or String literals (all one line): |
|||
<syntaxhighlight lang="ada"> |
|||
with Ada.Text_IO;procedure C is L:array(1 .. 9)of Integer:=(67,111,100,101,32,71,111,108,102);begin for C of L loop Ada.Text_IO.Put(Character'Val(C));end loop;end; |
|||
</syntaxhighlight> |
|||
163 characters; this should be portable to all Ada-12 compilers and all platforms |
|||
If we presume Linux, GNAT, and an executable name of "Code Golf", this can be shortened to (all one line): |
|||
<syntaxhighlight lang="ada"> |
|||
with Ada.Command_Line;with Ada.Text_IO;procedure C is begin Ada.Text_IO.Put(Ada.Command_Line.Command_Name(3..11));end; |
|||
</syntaxhighlight> |
|||
118 Characters |
|||
=={{header|6502 Assembly}}== |
=={{header|6502 Assembly}}== |
||
Line 60: | Line 127: | ||
===Without Quoted Literals=== |
===Without Quoted Literals=== |
||
Source file size is |
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.<br> |
||
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. |
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. |
||
<syntaxhighlight lang="algol68">OP!=(INTc)CHAR:REPR(c |
<syntaxhighlight lang="algol68">OP!=(INTc)CHAR:REPR(111-c);print(!44+!0+!11+!10+!79+!40+!0+!3+!9)</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>Code Golf</pre> |
<pre>Code Golf</pre> |
||
=={{header|ARM Assembly}}== |
|||
{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}} |
|||
<syntaxhighlight lang ARM Assembly> |
|||
/* ARM assembly Raspberry PI */ |
|||
/* program codegolf.s */ |
|||
/*********************************/ |
|||
=={{header|Arturo}}== |
|||
/* Initialized data */ |
|||
/*********************************/ |
|||
.data |
|||
szString: .asciz "codeGolf" |
|||
.equ SIZESTRING, . - szString |
|||
/*********************************/ |
|||
/* code section */ |
|||
/*********************************/ |
|||
.text |
|||
.global main |
|||
main: @ entry of program |
|||
mov r2,#SIZESTRING @ string length |
|||
ldr r1,=szString |
|||
mov r0,#1 @ output Linux standard |
|||
mov r7,#4 @ code call system "write" |
|||
svc 0 |
|||
mov r0, #0 @ return code |
|||
<syntaxhighlight lang="rebol">print"Code Golf" |
|||
mov r7, #1 @ request to exit program |
|||
print join to[:char][67 111 100 101 32 71 111 108 102]</syntaxhighlight> |
|||
svc #0 @ perform the system call |
|||
</syntaxhighlight> |
|||
{{Out}} |
|||
<pre> |
|||
Compilation 32 bits de codegolf.s |
|||
-rwx------ 1 u0_a252 u0_a252 904 May 24 21:32 codegolf |
|||
-rw------- 1 u0_a252 u0_a252 740 May 24 21:32 codegolf.o |
|||
-rw------- 1 u0_a252 u0_a252 816 May 24 18:35 codegolf.s |
|||
Fin de compilation. |
|||
~/.../rosetta/asm4 $ codegolf |
|||
codeGolf~/.../rosetta/asm4 $ |
|||
</pre> |
|||
=={{header|Arturo}}== |
|||
<syntaxhighlight lang="rebol">prints"Code Golf" |
|||
prints join to[:char]digits.base:112 1683633059109764774 |
|||
prints join to[:char][67 111 100 101 32 71 111 108 102]</syntaxhighlight> |
|||
{{out}} |
{{out}} |
||
<pre>Code GolfCode GolfCode Golf</pre> |
|||
<pre>Code Golf |
|||
Code Golf</pre> |
|||
=={{header|AWK}}== |
=={{header|AWK}}== |
||
<syntaxhighlight lang=" |
<syntaxhighlight lang="awk"> |
||
# syntax: GAWK -f CODE_GOLF.AWK |
# syntax: GAWK -f CODE_GOLF.AWK |
||
# |
# |
||
Line 88: | Line 191: | ||
# This is a completely stand-alone executable. |
# This is a completely stand-alone executable. |
||
# |
# |
||
# |
# 24 bytes |
||
BEGIN{ |
BEGIN{printf"Code Golf"}</syntaxhighlight> |
||
Using a string literal as conversion argument only: |
|||
# 52 bytes |
|||
<syntaxhighlight lang="awk"> |
|||
BEGIN{print("\x43\x6F\x64\x65\x20\x47\x6F\x6C\x66")} |
|||
# 64 bytes |
|||
BEGIN{print("\103\157\144\145\040\107\157\154\146")} |
|||
</syntaxhighlight> |
BEGIN{for(n=15162543273030444;n;n=int(n/80))printf"%c",111-n%80}</syntaxhighlight> |
||
This should work with POSIX-compliant implementations (support for hex literals is not mandatory), in double-precision floating-point arithmetic. |
|||
{{out}} |
|||
<pre> |
|||
Code Golf |
|||
Code Golf |
|||
Code Golf |
|||
</pre> |
|||
=={{header| |
=={{header|Bash}}== |
||
{{works with|UNIX_Shell}} |
|||
The directly executable source code is 14 bytes by using its script name instead of character literals: |
|||
<syntaxhighlight lang="sh">echo -n ${0:2}</syntaxhighlight> |
|||
To run: |
|||
<syntaxhighlight lang="sh">./Code\ Golf</syntaxhighlight> |
|||
=={{header|BASIC}}== |
|||
==={{header|BASIC256}}=== |
|||
With a quoted string, the following weighs in at 12 bytes. |
With a quoted string, the following weighs in at 12 bytes. |
||
<syntaxhighlight lang="freebasic">?"Code Golf"</syntaxhighlight> |
<syntaxhighlight lang="freebasic">?"Code Golf"</syntaxhighlight> |
||
Line 112: | Line 218: | ||
Note: BASIC256 is an interpreter, it does not generate executables. |
Note: BASIC256 is an interpreter, it does not generate executables. |
||
==={{header|SmallBASIC}}=== |
|||
12 characters with a quoted string: |
|||
<syntaxhighlight lang="qbasic">?"Code Golf"</syntaxhighlight> |
|||
49 characters without quoted literals: |
|||
<syntaxhighlight lang="qbasic">FOR i in [44,0,11,10,79,40,0,3,9] DO ?CHR(111-i);</syntaxhighlight> |
|||
=={{header|Binary Lambda Calculus}}== |
|||
shortest: 10 bytes |
|||
<pre>*Code Golf</pre> |
|||
avoiding ASCII: 23 bytes |
|||
<pre>46 60 17 ac 23 40 b0 02 cf f7 97 f7 ee 80 bc 90 9b 9a df b8 90 93 99</pre> |
|||
=={{header|BQN}}== |
=={{header|BQN}}== |
||
By using a string literal: |
|||
The second line printed is the automatically printed return value from the REPL. |
|||
<syntaxhighlight lang="bqn"> |
<syntaxhighlight lang="bqn">•Out"Code Golf"</syntaxhighlight> |
||
Without quoted literals: |
|||
<syntaxhighlight lang="bqn">•Out@+111-44‿0‿11‿10‿79‿40‿0‿3‿9</syntaxhighlight> |
|||
=={{header|C}}== |
|||
The following answers assume compilation using gcc 11.3.0 on ubuntu 22.04, without using any special options and ignoring the warnings. |
|||
The shortest possible program (28 bytes) to print the required string is: |
|||
<syntaxhighlight lang="c">main(){printf("Code Golf");}</syntaxhighlight> |
|||
The size of the executable needed to run this is 15,960 bytes. |
|||
If the program itself cannot contain string or character literals, then the shortest program I've been able to come up with (50 bytes) is: |
|||
<syntaxhighlight lang="c">a[]={0x65646f43,0x6c6f4720,102};main(){printf(a);}</syntaxhighlight> |
|||
The size of the executable needed is now 15,992 bytes. |
|||
Output in both cases: |
|||
<pre> |
|||
Code Golf |
Code Golf |
||
</pre> |
|||
"Code Golf" |
|||
•Out' '+35‿79‿68‿69‿0‿39‿79‿76‿70 |
|||
=={{header|dc}}== |
|||
By using a string literal (12 characters): |
|||
<syntaxhighlight lang="dc">[Code Golf]P</syntaxhighlight> |
|||
Without quoted literals (22 characters): |
|||
<syntaxhighlight lang="dc">16i436F646520476F6C66P</syntaxhighlight> |
|||
=={{header|Delphi}}== |
|||
{{works with|Delphi|6.0}} |
|||
{{libheader|}} |
|||
Delphi says the code size is 5,180 bytes. Looking at the assembly language that is generated, the size is 132 bytes. The difference must be the Windows overhead for a console application. |
|||
<syntaxhighlight lang="Delphi"> |
|||
program Project1; |
|||
{$APPTYPE CONSOLE} |
|||
begin |
|||
WriteLn('code golf'); |
|||
WriteLn(#67,#111,#100,#101,#32,#71,#111,#108,#102); |
|||
end. |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Code Golf |
Code Golf |
||
Code Golf |
|||
</pre> |
|||
=={{header|EasyLang}}== |
|||
<syntaxhighlight lang=text> |
|||
# with string literal (16 characters) |
|||
write"Code Golf" |
|||
# without quoted literals (54 characters) |
|||
for i in [44 0 11 10 79 40 0 3 9]write strchar(111-i). |
|||
</syntaxhighlight> |
|||
=={{header|ed}}== |
|||
The second part of the challenge is not accomplishable in ed, because there's no way to insert arbitrary characters with escape sequences. Also note that the trailing newline in the output is unavoidable, like in [[#sed]]. |
|||
<syntaxhighlight lang="sed"> |
|||
# by Artyom Bologov |
|||
a |
|||
Code Golf |
|||
. |
|||
p |
|||
Q |
|||
</syntaxhighlight> |
|||
=={{header|EMal}}== |
|||
<syntaxhighlight lang="emal"> |
|||
write("Code Golf") |
|||
^|EMal supports blobs (byte arrays) that can be initialized with single bytes|^ |
|||
write(blob().of(67,111,100,101,32,71,111,108,102)) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Code GolfCode Golf |
|||
</pre> |
|||
=={{header|Factor}}== |
=={{header|Factor}}== |
||
Line 129: | Line 321: | ||
=={{header|FreeBASIC}}== |
=={{header|FreeBASIC}}== |
||
With a quoted string, the following weighs in at |
With a quoted string, the following weighs in at 13 bytes. |
||
<syntaxhighlight lang="freebasic">?"Code Golf"</syntaxhighlight> |
<syntaxhighlight lang="freebasic">?"Code Golf";</syntaxhighlight> |
||
Without quoted literals, this is 77 bytes long. |
|||
<syntaxhighlight lang="freebasic">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</syntaxhighlight> |
|||
For the second task, this is 80 bytes long. |
|||
<syntaxhighlight lang="freebasic">dim as byte i,a(8)={37,81,70,71,2,41,81,78,72} |
|||
for i=0 to 8 |
|||
?chr(30+a(i)); |
|||
next</syntaxhighlight> |
|||
Both compile to a file 27,016 bytes long. |
Both compile to a file 27,016 bytes long. |
||
Line 148: | Line 335: | ||
{{out}}<pre>Code Golf</pre> |
{{out}}<pre>Code Golf</pre> |
||
=={{header|FutureBasic}}== |
|||
The shortest way (15 chars) is to use the '''stop''' function. Using the '''print''' function prints to a window, but it vanishes instantly without adding the lengthy '''handleevents''', which allows the code to be interactive. |
|||
<syntaxhighlight lang="futurebasic"> |
|||
stop"Code Golf" |
|||
</syntaxhighlight> |
|||
Without literals, I poked two values into a string, then printed it with the '''stop''' function: 50 chars. |
|||
<syntaxhighlight lang="futurebasic"> |
|||
str15 s:~@s,0x6F472065646F4309:%@s+8,0x666C:stop s |
|||
</syntaxhighlight> |
|||
Both produce this result: |
|||
{{out}} |
|||
[[File:Code Golf.png]] |
|||
=={{header|Go}}== |
=={{header|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. |
Go isn't well equipped for Code Golf as a certain amount of ceremony (''package main'' and ''func main()'') are needed for any executable. |
||
Line 198: | Line 397: | ||
(Note: if we were careful about the current directory we were in when we executed this program, we could eliminate the part that swaps <code>-</code> and <code>/</code> 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...) |
(Note: if we were careful about the current directory we were in when we executed this program, we could eliminate the part that swaps <code>-</code> and <code>/</code> 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...) |
||
Alternatively, if we are interested in the size of the J executable, jconsole currently clocks in at 140k bytes. However, this is misleading, as it ignores the size of necessary shared libraries (not to mention the OS Kernel and necessary supporting files)... |
|||
=={{header|Joy}}== |
|||
By using a string literal (20 characters): |
|||
<syntaxhighlight lang="Joy">"Code Golf"putchars.</syntaxhighlight> |
|||
Without string literals (48 characters): |
|||
<syntaxhighlight lang="Joy">[35 79 68 69 0 39 79 76 70][32 + chr putch]step.</syntaxhighlight> |
|||
=={{header|jq}}== |
=={{header|jq}}== |
||
{{works with|jq}} |
{{works with|jq}} |
||
'''Works with gojq, the Go implementation of jq''' |
'''Works with gojq, the Go implementation of jq''' |
||
'''Works with jaq, the Rust implementation of jq''' |
|||
To skip the newline, the interpreter must be invoked with the -j option: |
To skip the newline, the interpreter must be invoked with the -j option: |
||
Line 208: | Line 418: | ||
9 |
9 |
||
</pre> |
</pre> |
||
For the second task, the following program clocks in at |
For the second task, the following program clocks in at 38 bytes: |
||
<syntaxhighlight lang="text">[ |
<syntaxhighlight lang="text">[44,0,11,10,79,40,0,3,9|111-.]|implode</syntaxhighlight> |
||
'''Extra credit''': |
'''Extra credit''': |
||
The jq executable on my Mac is 461,864 bytes; gojq's is over 8 times larger. |
The jq executable on my Mac is 461,864 bytes; gojq's is over 8 times larger, and jaq's is slightly larger still. |
||
=={{header|Julia}}== |
|||
<syntaxhighlight lang="julia">print("Code Golf") |
|||
print(String(Char.([67,111,100,101,32,71,111,108,102]))) |
|||
</syntaxhighlight> |
|||
=={{header|Kotlin}}== |
|||
Shortest program: |
|||
<syntaxhighlight lang="kotlin">fun main()=print("Code Golf")</syntaxhighlight> |
|||
Without string literals, JVM only: |
|||
<syntaxhighlight lang="kotlin">fun main()=print(String(byteArrayOf(67,111,100,101,32,71,111,108,102)))</syntaxhighlight> |
|||
Without string literals, platform-independent: |
|||
<syntaxhighlight lang="kotlin">fun main()=print(byteArrayOf(67,111,100,101,32,71,111,108,102).decodeToString())</syntaxhighlight> |
|||
A shorter but hacky version: |
|||
<syntaxhighlight lang="kotlin">fun main(){listOf(35,79,68,69,0,39,79,76,70).map{print(' '+it)}}</syntaxhighlight> |
|||
=={{header|Ksh}}== |
|||
{{works with|ksh93}} |
|||
By just passing strings (17 bytes): |
|||
<syntaxhighlight lang="sh">echo -n Code Golf</syntaxhighlight> |
|||
Let the shell generate every character (54 bytes): |
|||
<syntaxhighlight lang="sh">typeset -i43 a=3066215 b=3384588;echo -n ${a:3} ${b:3}</syntaxhighlight> |
|||
Or, in case format strings are allowed for conversion (36 bytes): |
|||
<syntaxhighlight lang="sh">printf %..39d%5..43d 2291147 3384588</syntaxhighlight> |
|||
=={{header|Lang}}== |
|||
With text literal (19 Bytes): |
|||
<syntaxhighlight lang="lang">fn.print(Code Golf)</syntaxhighlight> |
|||
Without text literal (88 Bytes): |
|||
<syntaxhighlight lang="lang">parser.op(print(join(\e, arrayMapToNew([67,111,100,101,32,71,111,108,102], fn.toChar))))</syntaxhighlight> |
|||
=={{header|Lua}}== |
|||
With string literal (21 characters): |
|||
<syntaxhighlight lang="lua">io.write("Code Golf")</syntaxhighlight> |
|||
Without quoted literals (55 characters): |
|||
<syntaxhighlight lang="lua">io.write(string.char(67,111,100,101,32,71,111,108,102))</syntaxhighlight> |
|||
=={{header|Microsoft Small Basic}}== |
|||
Using a string literal, this program is 29 bytes long. |
|||
<syntaxhighlight lang="smallbasic">TextWindow.Write("Code Golf")</syntaxhighlight> |
|||
Without a string literal, the program is 221 bytes long. |
|||
<syntaxhighlight lang="smallbasic">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))</syntaxhighlight> |
|||
=={{header|min}}== |
|||
{{works with|min|0.37.0}} |
|||
By using a string literal (16 characters): |
|||
<syntaxhighlight lang="min">"Code Golf"print</syntaxhighlight> |
|||
Without string literals (52 characters): |
|||
<syntaxhighlight lang="min">(35 79 68 69 0 39 79 76 70) (32+ chr putchr) foreach</syntaxhighlight> |
|||
=={{header|Nim}}== |
|||
Using a string literal (24 characters): |
|||
<syntaxhighlight lang="Nim">stdout.write "Code Golf" |
|||
</syntaxhighlight> |
|||
Compiling on Linux with Nim 1.6.12 using command <code>nim c -d:danger --opt:size -d:lto --gc:arc code_golf.nim</code>, the executable size is 23584 bytes. |
|||
Without string literals (61 characters): |
|||
<syntaxhighlight lang="Nim">for n in[67,111,100,101,32,71,111,108,102]:stdout.write n.chr |
|||
</syntaxhighlight> |
|||
Compiling on Linux with Nim 1.6.12 using command <code>nim c -d:danger --opt:size -d:lto --gc:arc code_golf.nim</code>, the executable size is 22528 bytes. |
|||
=={{header|Nu}}== |
|||
{{works with|Nushell|0.96.1}} |
|||
With string literal (20 characters): |
|||
<syntaxhighlight lang="nu">print -n 'Code Golf'</syntaxhighlight> |
|||
Without quoted literals (38 characters): |
|||
<syntaxhighlight lang="nu">0x[436f646520476f6c66]|decode|print -n</syntaxhighlight> |
|||
=={{header|OCaml}}== |
|||
With string literal (29 characters): |
|||
<syntaxhighlight lang="ocaml">let()=print_string"Code Golf"</syntaxhighlight> |
|||
Without quoted literals (75 characters): |
|||
<syntaxhighlight lang="ocaml">let()=List.iter(fun c->print_char(Char.chr(111-c)))[44;0;11;10;79;40;0;3;9]</syntaxhighlight> |
|||
=={{header|Openscad}}== |
=={{header|Openscad}}== |
||
Line 227: | Line 514: | ||
Therefore, see [[#Free Pascal|Free Pascal]] for one method. |
Therefore, see [[#Free Pascal|Free Pascal]] for one method. |
||
=={{header| |
=={{header|PascalABC.NET}}== |
||
<syntaxhighlight lang=" |
<syntaxhighlight lang="delphi"> |
||
### |
|||
Pr('Code Golf') |
|||
</syntaxhighlight> |
|||
18 chars in a code. |
|||
<syntaxhighlight lang="delphi"> |
|||
### |
|||
Pr(#67#111#100#101#32#71#111#108#102) |
|||
</syntaxhighlight> |
|||
Without quotes |
|||
=={{header|Perl}}== |
|||
Using a string literal: |
|||
<syntaxhighlight lang="perl"> |
|||
# 1 2 |
# 1 2 |
||
#12345678901234567890 |
#12345678901234567890 |
||
print |
print'Code Golf' # 16 bytes</syntaxhighlight> |
||
Without quoted literals: |
|||
; print "\n"; |
|||
<syntaxhighlight lang="perl"> |
|||
# 1 2 3 4 |
# 1 2 3 4 5 |
||
#12345678901234567890123456789012345678901234567890 |
|||
#1234567890123456789012345678901234567890 |
|||
print |
print chr($_^102)for 37,9,2,3,70,33,9,10,0 # 42 bytes</syntaxhighlight> |
||
; print "\n";</syntaxhighlight> |
|||
Actually just for storage purpose it is possible (just not always) to store the bytes string as an UTF string. |
|||
<syntaxhighlight lang="perl">binmode STDOUT, ":encoding(UTF-8)"; |
|||
my $string = "\x{436F}\x{6465} \x{476F}\x{6C66}"; |
|||
print "\n"; |
|||
print "\n'$string' is an UTF string with length = ".length($string)."\n"; |
|||
print "\n"; |
|||
my ( $bytes, $offset ) = '', 0 ; |
|||
for ( map { ord $_ } split //, $string ) { |
|||
my @ar = (); |
|||
while ( $_ > 0 ) { unshift @ar, $_ & 0xff and $_ >>= 8 } |
|||
for ( @ar ) { vec( $bytes, $offset++, 8 ) = $_ } |
|||
} |
|||
print "Extract to bytes '$bytes' with length = ".length($bytes)."\n";</syntaxhighlight> |
|||
{{out}} |
|||
<pre>'䍯摥 䝯汦' is an UTF string with length = 5 |
|||
Extract to bytes 'Code Golf' with length = 9</pre> |
|||
=={{header|Phix}}== |
=={{header|Phix}}== |
||
<!-- |
<!--(phixonline)--> |
||
<syntaxhighlight lang="Phix"> |
|||
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Code Golf"</span><span style="color: #0000FF;">)</span> |
|||
puts(1,"Code Golf") |
|||
<!--</syntaxhighlight>--> |
|||
</syntaxhighlight> |
|||
Which is 19 bytes. Note that <code>?"Code Golf"</code>, while only 12 bytes, ''does'' print the quotation marks and therefore does not meet the task specifications.<br> |
Which is 19 bytes. Note that <code>?"Code Golf"</code>, while only 12 bytes, ''does'' print the quotation marks and therefore does not meet the task specifications.<br> |
||
Without using string literals, at 42 bytes we can have |
Without using string literals, at 42 bytes we can have |
||
<syntaxhighlight lang="Phix"> |
|||
puts(1,{67,111,100,101,32,71,111,108,102}) |
|||
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">67</span><span style="color: #0000FF;">,</span><span style="color: #000000;">111</span><span style="color: #0000FF;">,</span><span style="color: #000000;">100</span><span style="color: #0000FF;">,</span><span style="color: #000000;">101</span><span style="color: #0000FF;">,</span><span style="color: #000000;">32</span><span style="color: #0000FF;">,</span><span style="color: #000000;">71</span><span style="color: #0000FF;">,</span><span style="color: #000000;">111</span><span style="color: #0000FF;">,</span><span style="color: #000000;">108</span><span style="color: #0000FF;">,</span><span style="color: #000000;">102</span><span style="color: #0000FF;">})</span> |
|||
</syntaxhighlight> |
|||
Or quite long but deliciously cryptic: |
|||
<syntaxhighlight lang="Phix"> |
|||
puts(1,atom_to_float64(1.276409856e-152)[4..$]& |
|||
atom_to_float64(1.458406353e-258)[4..$]) |
|||
</syntaxhighlight> |
|||
Slightly shorter, at 30 bytes, though it could be considered string/char: |
Slightly shorter, at 30 bytes, though it could be considered string/char: |
||
<syntaxhighlight lang="Phix"> |
|||
puts(1,x"436F646520476F6C66") |
|||
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span>x"<span style="color: #0000FF;">436F646520476F6C66</span>"<span style="color: #0000FF;">)</span> |
|||
</syntaxhighlight> |
|||
While not exactly shorter, if you name the source code as Code Golf[.exw] or the executable as Code Golf[.exe], perhaps needing a substitute(s,'_',' ') [or (..,95,32)], this approach will also work: |
|||
<syntaxhighlight lang="Phix"> |
|||
puts(1,get_file_base(command_line()[2])) |
|||
</syntaxhighlight> |
|||
The compiled size of the first is 276,992 bytes. |
The compiled size of the first is 276,992 bytes. |
||
You can actually make a smaller executable as follows: |
You can actually make a smaller executable as follows: |
||
<syntaxhighlight lang="Phix"> |
|||
include puts1h.e |
|||
<span style="color: #008080;">include</span> <span style="color: #000000;">puts1h</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span> |
|||
puts1("Code Golf") |
|||
<span style="color: #000000;">puts1</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Code Golf"</span><span style="color: #0000FF;">)</span> |
|||
</syntaxhighlight> |
|||
Then compile it with p -c -nodiag ''test.exw'' (or whatever) to yield an executable of 36,532 bytes - |
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), |
no diagnostics, which is itself non-trivial and otherwise pulls in file handling (for the ex.err it writes), |
||
Line 287: | Line 575: | ||
of subscript stuff we don't rightly need... still I suppose 36K ain't really all that bad. |
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. |
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. |
||
=={{header|Phixmonti}}== |
=={{header|Phixmonti}}== |
||
Line 318: | Line 605: | ||
{{out}} |
{{out}} |
||
<pre>Code Golf</pre> |
<pre>Code Golf</pre> |
||
=={{header|Plain English}}== |
|||
Using a string literal, this program is 89 bytes long. |
|||
<syntaxhighlight lang="text">To run:Start up.Write"Code Golf"to the console without advancing.Wait for the escape key.</syntaxhighlight> |
|||
Without a string literal, the program is 98 bytes long. |
|||
<syntaxhighlight lang="text">To run:Start up.Write$436F646520476F6C66 to the console without advancing.Wait for the escape key.</syntaxhighlight> |
|||
The executable compiled by the Plain English compiler weighs in at 143,360 bytes. |
|||
=={{header|PureBasic}}== |
=={{header|PureBasic}}== |
||
Line 334: | Line 628: | ||
=={{header|Python}}== |
=={{header|Python}}== |
||
;Python 3 |
;Python 3: |
||
Using string literals, the following weighs in at 22 bytes. |
|||
<syntaxhighlight lang="python">print("Code Golf")</syntaxhighlight> |
<syntaxhighlight lang="python">print(end="Code Golf")</syntaxhighlight> |
||
Without string literals, this is 52 bytes long. |
|||
<syntaxhighlight lang="python"> |
<syntaxhighlight lang="python">print(end=0x436f646520476f6c66.to_bytes(9).decode()) |
||
for i in range(0,9): |
|||
print(chr(30+a[i]),end = "")</syntaxhighlight> |
|||
# or: |
|||
for c in 37,9,2,3,70,33,9,10,0:print(end=chr(c^102))</syntaxhighlight> |
|||
=={{header|QBasic}}== |
=={{header|QBasic}}== |
||
Line 382: | Line 677: | ||
{{out}} |
{{out}} |
||
<pre>Code Golf</pre> |
<pre>Code Golf</pre> |
||
=={{header|True BASIC}}== |
|||
With a quoted string, the following weighs in at 22 bytes. |
|||
<syntaxhighlight lang="qbasic">PRINT "Code Golf" |
|||
END</syntaxhighlight> |
|||
For the second task, this is 100 bytes long. |
|||
<syntaxhighlight lang="qbasic">DIM a(9) |
|||
DATA 37,81,70,71,2,41,81,78,72 |
|||
FOR i=1 to 9 |
|||
READ a(i) |
|||
PRINT CHR$(30+a(i)); |
|||
NEXT i |
|||
END</syntaxhighlight> |
|||
=={{header|Raku}}== |
=={{header|Raku}}== |
||
Line 407: | Line 686: | ||
Assuming we can't use the string literal in the source, the shortest I've come up with is: |
Assuming we can't use the string literal in the source, the shortest I've come up with is: |
||
<syntaxhighlight lang="raku" line>print chrs |
<syntaxhighlight lang="raku" line>print chrs 37,9,2,3,70,33,9,10,0 X+^102 # 39 chars, 39 bytes</syntaxhighlight> |
||
[https://tio.run/##K0gtyjH7/7@gKDOvRCE5o6hYwdhcx1LHSMdYx9xAx9gYyDY00DFQiNCOMzQw@v8fAA Try it online!] |
|||
<syntaxhighlight lang="raku" line>print chrs (-3,㊶,㉚,㉛,-㊳,1,㊶,㊳,㉜) »+»㉎ # 37 Chars, 56 bytes</syntaxhighlight> |
|||
<syntaxhighlight lang="raku" line>print chrs -3,㊶,㉚,㉛,-㊳,1,㊶,㊳,㉜X+㉎ # 33 Chars, 49 bytes</syntaxhighlight>[https://tio.run/##K0gtyjH7/7@gKDOvRCE5o6hYQddY53HXNp3HnbOAeLaO7uOuzTqGECEg63HnnAjtx519//8DAA Try it online!] |
|||
<syntaxhighlight lang="raku" line>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</syntaxhighlight> |
<syntaxhighlight lang="raku" line>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</syntaxhighlight> |
||
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...) |
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...) |
||
=={{header|REBOL}}== |
|||
Using a string literal, this program is 15 bytes long. |
|||
<syntaxhighlight lang="rebol">prin"Code Golf"</syntaxhighlight> |
|||
Without a string literal, the program is 67 bytes long. |
|||
<syntaxhighlight lang="rebol">prin rejoin map-each c[67 111 100 101 32 71 111 108 102][to-char c]</syntaxhighlight> |
|||
Or, in case binary literals are allowed, the program is 51 bytes long. |
|||
<syntaxhighlight lang="rebol">s: enbase #{1A875E1A895F}insert at s 5 space prin s</syntaxhighlight> |
|||
=={{header|RPL}}== |
|||
≪ "Code Golf" ≫ |
|||
The above code costs 48 nibbles (e.g. 4 bits) of memory (e.g. 24 bytes); the string itself requires 28 quartets. |
|||
≪ #102d #108d #111d #71d #32d #101d #100d #111d 67 CHR 1 8 START SWAP B→R CHR + NEXT ≫ |
|||
This string-free code costs 233 nibbles (117 bytes). Unsigned integers - numbers starting with a <code>#</code> - have been used whenever possible since they use 9 nibbles less than floating-point numbers to store a value up to #FF |
|||
=={{header|Ruby}}== |
|||
<syntaxhighlight lang="Ruby"> |
|||
$><<"Code Golf" #15 chars |
|||
puts |
|||
# Taken from Perl: |
|||
$><<['436F646520476F6C66'].pack('H*') #37 chars</syntaxhighlight> |
|||
=={{header|Run BASIC}}== |
=={{header|Run BASIC}}== |
||
Line 420: | Line 721: | ||
Note: Run BASIC is an interpreter, it does not generate executables. |
Note: Run BASIC is an interpreter, it does not generate executables. |
||
=={{header|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. |
|||
<syntaxhighlight lang="sh">$ echo | sed 's/.*/Code Golf/' |
|||
Code Golf</syntaxhighlight> |
|||
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. |
|||
<syntaxhighlight lang="sh">$ echo | sed 's/.*/\x6f/;s/./\x43&\x64\x65\c`\x47&\x6c\x66/' |
|||
Code Golf</syntaxhighlight> |
|||
=={{header|True BASIC}}== |
|||
By using a string literal, the following weighs in at 22 bytes. |
|||
<syntaxhighlight lang="qbasic">PRINT "Code Golf"; |
|||
END</syntaxhighlight> |
|||
Without quoted literals, this is 92 bytes long. |
|||
<syntaxhighlight lang="qbasic">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</syntaxhighlight> |
|||
=={{header|UNIX Shell}}== |
|||
By using a string literal (18 characters): |
|||
<syntaxhighlight lang="sh">echo 'Code Golf\c'</syntaxhighlight> |
|||
By using just a format specifier (56 characters): |
|||
<syntaxhighlight lang="sh">printf $(printf \\\\%o 67 111 100 101 32 71 111 108 102)</syntaxhighlight> |
|||
=={{header|Uxntal}}== |
|||
Using a "string literal" / raw ASCII rune (59 characters): |
|||
<syntaxhighlight lang="Uxntal">|0100 #0110 2194 06 #18 1720 fff7 #800f 1700 "Code 20 "Golf</syntaxhighlight> |
|||
Without raw ASCII runes (67 characters): |
|||
<syntaxhighlight lang="Uxntal">|0100 #0110 2194 06 #18 1720 fff7 #800f 1700 436f 6465 2047 6f6c 66</syntaxhighlight> |
|||
Both programs assemble to the same 26 byte ROM: |
|||
<pre>a001 1021 9406 8018 1720 fff7 a080 0f17 |
|||
0043 6f64 6520 476f 6c66</pre> |
|||
The 9 byte string accounts for almost 35% of the final ROM. |
|||
The golfed code works very similarly to the following code: |
|||
<syntaxhighlight lang="Uxntal">|00 @System &vector $2 &expansion $2 &wst $1 &rst $1 &metadata $2 &r $2 &g $2 &b $2 &debug $1 &state $1 |
|||
|10 @Console &vector $2 &read $1 &pad $4 &type $1 &write $1 &error $1 |
|||
|0100 |
|||
( get pointer to byte before str ) |
|||
;str #0001 SUB2 |
|||
@loop |
|||
( load a byte, pre-increment, and write it ) |
|||
INC2 LDAk DUP .Console/write DEO |
|||
( loop again if the byte was non-null ) |
|||
?loop |
|||
( exit ) |
|||
#80 .System/state DEO |
|||
BRK |
|||
@str |
|||
"Code 20 "Golf 00</syntaxhighlight> |
|||
The main trick used in golfing of this program was to encode the raw instruction bytes in hex in the source code. |
|||
=={{header|Verilog}}== |
=={{header|Verilog}}== |
||
Line 453: | Line 814: | ||
=={{header|Wren}}== |
=={{header|Wren}}== |
||
The shortest possible program (25 bytes) to print the required string is: |
The shortest possible program (25 bytes) to print the required string is: |
||
<syntaxhighlight lang=" |
<syntaxhighlight lang="wren">System.write("Code Golf")</syntaxhighlight> |
||
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. |
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 ( |
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: |
||
<syntaxhighlight lang=" |
<syntaxhighlight lang="wren">for(c in[37,9,2,3,70,33,9,10,0])System.write(String.fromByte(c^102))</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
In both cases: |
In both cases: |
||
Line 497: | Line 858: | ||
With a quoted string, the following weighs in at 12 bytes. |
With a quoted string, the following weighs in at 12 bytes. |
||
<syntaxhighlight lang="yabasic">?"Code Golf"</syntaxhighlight> |
<syntaxhighlight lang="yabasic">?"Code Golf"</syntaxhighlight> |
||
Without quoted literals, this is 63 bytes long. |
|||
<syntaxhighlight lang="yabasic">data 44,0,11,10,79,40,0,3,9:for i=0to 8read n:?chr$(111-n);next</syntaxhighlight> |
|||
For the second task, this is 118 bytes long. |
|||
<syntaxhighlight lang="yabasic">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 |
|||
?chr$(30+a(i)); |
|||
next</syntaxhighlight> |
|||
Note: Yabasic is an interpreter, it does not generate executables. |
Note: Yabasic is an interpreter, it does not generate executables. |
||
Latest revision as of 12:11, 15 August 2024
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
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))}
AArch64 Assembly
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program codegolf64.s */
/*********************************/
/* Initialized data */
/*********************************/
.data
szString: .asciz "codeGolf"
.equ SIZESTRING, . - szString
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: // entry of program
mov x2,SIZESTRING // string length
ldr x1,=szString
mov x0,1 // output Linux standard
mov x8,64 // code call system "write"
svc 0
mov x0,0 // return code
mov x8,93 // request to exit program
svc #0 // perform the system call
- Output:
Compilation 64 bits Rosetta de codegolf64.s -rwx------ 1 u0_a344 u0_a344 1144 May 24 21:48 codegolf64 -rw------- 1 u0_a344 u0_a344 960 May 24 21:48 codegolf64.o -rw------- 1 u0_a344 u0_a344 813 May 24 21:45 codegolf64.s Fin de compilation. ~/.../rosetta/asm4 $ codegolf64 codeGolf~/.../rosetta/asm4 $
Ada
With String literal:
with Ada.Text_IO;procedure C is begin Ada.Text_IO.Put("Code Golf");end;
71 characters
Without Character or String literals (all one line):
with Ada.Text_IO;procedure C is L:array(1 .. 9)of Integer:=(67,111,100,101,32,71,111,108,102);begin for C of L loop Ada.Text_IO.Put(Character'Val(C));end loop;end;
163 characters; this should be portable to all Ada-12 compilers and all platforms
If we presume Linux, GNAT, and an executable name of "Code Golf", this can be shortened to (all one line):
with Ada.Command_Line;with Ada.Text_IO;procedure C is begin Ada.Text_IO.Put(Ada.Command_Line.Command_Name(3..11));end;
118 Characters
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
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
ARM Assembly
/* ARM assembly Raspberry PI */
/* program codegolf.s */
/*********************************/
/* Initialized data */
/*********************************/
.data
szString: .asciz "codeGolf"
.equ SIZESTRING, . - szString
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: @ entry of program
mov r2,#SIZESTRING @ string length
ldr r1,=szString
mov r0,#1 @ output Linux standard
mov r7,#4 @ code call system "write"
svc 0
mov r0, #0 @ return code
mov r7, #1 @ request to exit program
svc #0 @ perform the system call
- Output:
Compilation 32 bits de codegolf.s -rwx------ 1 u0_a252 u0_a252 904 May 24 21:32 codegolf -rw------- 1 u0_a252 u0_a252 740 May 24 21:32 codegolf.o -rw------- 1 u0_a252 u0_a252 816 May 24 18:35 codegolf.s Fin de compilation. ~/.../rosetta/asm4 $ codegolf codeGolf~/.../rosetta/asm4 $
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.
Bash
The directly executable source code is 14 bytes by using its script name instead of character literals:
echo -n ${0:2}
To run:
./Code\ Golf
BASIC
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.
SmallBASIC
12 characters with a quoted string:
?"Code Golf"
49 characters without quoted literals:
FOR i in [44,0,11,10,79,40,0,3,9] DO ?CHR(111-i);
Binary Lambda Calculus
shortest: 10 bytes
*Code Golf
avoiding ASCII: 23 bytes
46 60 17 ac 23 40 b0 02 cf f7 97 f7 ee 80 bc 90 9b 9a df b8 90 93 99
BQN
By using a string literal:
•Out"Code Golf"
Without quoted literals:
•Out@+111-44‿0‿11‿10‿79‿40‿0‿3‿9
C
The following answers assume compilation using gcc 11.3.0 on ubuntu 22.04, without using any special options and ignoring the warnings.
The shortest possible program (28 bytes) to print the required string is:
main(){printf("Code Golf");}
The size of the executable needed to run this is 15,960 bytes.
If the program itself cannot contain string or character literals, then the shortest program I've been able to come up with (50 bytes) is:
a[]={0x65646f43,0x6c6f4720,102};main(){printf(a);}
The size of the executable needed is now 15,992 bytes.
Output in both cases:
Code Golf
dc
By using a string literal (12 characters):
[Code Golf]P
Without quoted literals (22 characters):
16i436F646520476F6C66P
Delphi
Delphi says the code size is 5,180 bytes. Looking at the assembly language that is generated, the size is 132 bytes. The difference must be the Windows overhead for a console application.
program Project1;
{$APPTYPE CONSOLE}
begin
WriteLn('code golf');
WriteLn(#67,#111,#100,#101,#32,#71,#111,#108,#102);
end.
- Output:
Code Golf Code Golf
EasyLang
# with string literal (16 characters)
write"Code Golf"
# without quoted literals (54 characters)
for i in [44 0 11 10 79 40 0 3 9]write strchar(111-i).
ed
The second part of the challenge is not accomplishable in ed, because there's no way to insert arbitrary characters with escape sequences. Also note that the trailing newline in the output is unavoidable, like in #sed.
# by Artyom Bologov
a
Code Golf
.
p
Q
EMal
write("Code Golf")
^|EMal supports blobs (byte arrays) that can be initialized with single bytes|^
write(blob().of(67,111,100,101,32,71,111,108,102))
- Output:
Code GolfCode Golf
Factor
[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
FutureBasic
The shortest way (15 chars) is to use the stop function. Using the print function prints to a window, but it vanishes instantly without adding the lengthy handleevents, which allows the code to be interactive.
stop"Code Golf"
Without literals, I poked two values into a string, then printed it with the stop function: 50 chars.
str15 s:~@s,0x6F472065646F4309:%@s+8,0x666C:stop s
Both produce this result:
- Output:
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...)
Alternatively, if we are interested in the size of the J executable, jconsole currently clocks in at 140k bytes. However, this is misleading, as it ignores the size of necessary shared libraries (not to mention the OS Kernel and necessary supporting files)...
Joy
By using a string literal (20 characters):
"Code Golf"putchars.
Without string literals (48 characters):
[35 79 68 69 0 39 79 76 70][32 + chr putch]step.
jq
Works with gojq, the Go implementation of jq
Works with jaq, the Rust 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, and jaq's is slightly larger still.
Julia
print("Code Golf")
print(String(Char.([67,111,100,101,32,71,111,108,102])))
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())
A shorter but hacky version:
fun main(){listOf(35,79,68,69,0,39,79,76,70).map{print(' '+it)}}
Ksh
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
Lang
With text literal (19 Bytes):
fn.print(Code Golf)
Without text literal (88 Bytes):
parser.op(print(join(\e, arrayMapToNew([67,111,100,101,32,71,111,108,102], fn.toChar))))
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))
min
By using a string literal (16 characters):
"Code Golf"print
Without string literals (52 characters):
(35 79 68 69 0 39 79 76 70) (32+ chr putchr) foreach
Nim
Using a string literal (24 characters):
stdout.write "Code Golf"
Compiling on Linux with Nim 1.6.12 using command nim c -d:danger --opt:size -d:lto --gc:arc code_golf.nim
, the executable size is 23584 bytes.
Without string literals (61 characters):
for n in[67,111,100,101,32,71,111,108,102]:stdout.write n.chr
Compiling on Linux with Nim 1.6.12 using command nim c -d:danger --opt:size -d:lto --gc:arc code_golf.nim
, the executable size is 22528 bytes.
Nu
With string literal (20 characters):
print -n 'Code Golf'
Without quoted literals (38 characters):
0x[436f646520476f6c66]|decode|print -n
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.
PascalABC.NET
###
Pr('Code Golf')
18 chars in a code.
###
Pr(#67#111#100#101#32#71#111#108#102)
Without quotes
Perl
Using a string literal:
# 1 2
#12345678901234567890
print'Code Golf' # 16 bytes
Without quoted literals:
# 1 2 3 4 5
#12345678901234567890123456789012345678901234567890
print chr($_^102)for 37,9,2,3,70,33,9,10,0 # 42 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})
Or quite long but deliciously cryptic:
puts(1,atom_to_float64(1.276409856e-152)[4..$]&
atom_to_float64(1.458406353e-258)[4..$])
Slightly shorter, at 30 bytes, though it could be considered string/char:
puts(1,x"436F646520476F6C66")
While not exactly shorter, if you name the source code as Code Golf[.exw] or the executable as Code Golf[.exe], perhaps needing a substitute(s,'_',' ') [or (..,95,32)], this approach will also work:
puts(1,get_file_base(command_line()[2]))
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
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
print chrs -3,㊶,㉚,㉛,-㊳,1,㊶,㊳,㉜X+㉎ # 33 Chars, 49 bytes
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
RPL
≪ "Code Golf" ≫
The above code costs 48 nibbles (e.g. 4 bits) of memory (e.g. 24 bytes); the string itself requires 28 quartets.
≪ #102d #108d #111d #71d #32d #101d #100d #111d 67 CHR 1 8 START SWAP B→R CHR + NEXT ≫
This string-free code costs 233 nibbles (117 bytes). Unsigned integers - numbers starting with a #
- have been used whenever possible since they use 9 nibbles less than floating-point numbers to store a value up to #FF
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
UNIX Shell
By using a string literal (18 characters):
echo 'Code Golf\c'
By using just a format specifier (56 characters):
printf $(printf \\\\%o 67 111 100 101 32 71 111 108 102)
Uxntal
Using a "string literal" / raw ASCII rune (59 characters):
|0100 #0110 2194 06 #18 1720 fff7 #800f 1700 "Code 20 "Golf
Without raw ASCII runes (67 characters):
|0100 #0110 2194 06 #18 1720 fff7 #800f 1700 436f 6465 2047 6f6c 66
Both programs assemble to the same 26 byte ROM:
a001 1021 9406 8018 1720 fff7 a080 0f17 0043 6f64 6520 476f 6c66
The 9 byte string accounts for almost 35% of the final ROM.
The golfed code works very similarly to the following code:
|00 @System &vector $2 &expansion $2 &wst $1 &rst $1 &metadata $2 &r $2 &g $2 &b $2 &debug $1 &state $1
|10 @Console &vector $2 &read $1 &pad $4 &type $1 &write $1 &error $1
|0100
( get pointer to byte before str )
;str #0001 SUB2
@loop
( load a byte, pre-increment, and write it )
INC2 LDAk DUP .Console/write DEO
( loop again if the byte was non-null )
?loop
( exit )
#80 .System/state DEO
BRK
@str
"Code 20 "Golf 00
The main trick used in golfing of this program was to encode the raw instruction bytes in hex in the source code.
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)
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 63 bytes long.
data 44,0,11,10,79,40,0,3,9:for i=0to 8read 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.
- Draft Programming Tasks
- 11l
- AArch64 Assembly
- Ada
- 6502 Assembly
- Action!
- ALGOL 68
- ARM Assembly
- Arturo
- AWK
- Bash
- BASIC
- BASIC256
- SmallBASIC
- Binary Lambda Calculus
- BQN
- C
- Dc
- Delphi
- EasyLang
- Ed
- EMal
- Factor
- FreeBASIC
- Free Pascal
- FutureBasic
- Pages with broken file links
- Go
- Golfscript
- J
- Joy
- Jq
- Julia
- Kotlin
- Ksh
- Lang
- Lua
- Microsoft Small Basic
- Min
- Nim
- Nu
- OCaml
- Openscad
- Pascal
- PascalABC.NET
- Perl
- Phix
- Phixmonti
- Picat
- Plain English
- PureBasic
- Python
- QBasic
- Quackery
- R
- Raku
- REBOL
- RPL
- Ruby
- Run BASIC
- Sed
- True BASIC
- UNIX Shell
- Uxntal
- Verilog
- V (Vlang)
- Wren
- X86 Assembly
- XPL0
- Yabasic
- Z80 Assembly
- Simple
- Code Golf