Output your Score!

Question

Challenge:

The concept is simple enough: write a full program to output its own code golf score!

Output should only be the byte count of your program and a trailing bytes.

BUT WAIT..... there is one restriction:

• Your source code can not include any of the digits from your byte count
• So if your score is 186 bytes, your program can not contain the characters 1 , 6 , or 8

Example Output:

315 bytes
27 Bytes
49 BYTES

Additional Rules:

• Unnecessary characters, spaces, and newlines are forbidden in the source code, however trailing spaces and newlines are perfectly acceptable in output
• There should be a single space between the number and bytes in the output
• Letters are case insensitive
• No self inspection or reading the source code

• standard loopholes are disallowed

• this is code-golf, so

Shortest code in bytes wins!

Answer 1

Deadfish~, 59 bytes

iisioiiiioii{ii}icii{iii}iic{ii}iiicdddddc{d}dddddc{i}iiiic

Try it online!

Answer 2

C++, 52 bytes

[]{std::string a="41 bytes";a[0]++;a[1]++;return a;}

Try it online!

facepalm is it even competable? it just barely wins against BF! but still, no 5s and 2s in the code.

Answer 3

C, 31 bytes

main(){printf("%d bytes",'');}

Try It Online!

The unprintable character is the unit separator which value is 31.

Answer 4

naz, 48 44 bytes

2a2a2o2s2m8m1o2m2a1o9a9a5a1o5s1o9s6s1o9a5a1o

Explanation

2a2a2o   # Output "4" twice
2s2m8m1o # Output a space
2m2a1o   # Output "B"
9a9a5a1o # Output "Y"
5s1o     # Output "T"
9s6s1o   # Output "E"
9a5a1o   # Output "S"

Original 48-byte solution: 2a2a1o2a2a1o2m2m1o3m2a1o9a9a5a1o5s1o9s6s1o9a5a1o

Answer 5

Zsh, 16 bytes

<<<$[8*2]\ bytes

Try it online!

Heavily inspired by the Bash answer. <<< usually saves two bytes, but we lose one to escape a space.

Answer 6

x86-16 ASM, IBM PC DOS, 36 29 bytes

Listing:

        START: 
B0 1D       MOV  AL, SZ         ; get program size 
D4 0A       AAM                 ; BCD convert byte (AH=ones, AL=tens) 
86 E0       XCHG AH, AL         ; endian convert (AH=tens, AL=ones) 
50          PUSH AX             ; save AH = 9 
3030        ADD  AX, '00'       ; ASCII convert 
BF 0114     MOV  DI, OFFSET S   ; output string in DI 
8B D7       MOV  DX, DI         ; and output string in DX 
AB          STOSW               ; write digits to beginning of string 
58          POP  AX             ; restore AH = 9 (DOS write string function) 
CD 21       INT  21H            ; write to console 
C3          RET                 ; return to DOS
        S   DB '   bytes$'      ; output string buffer
        SZ  EQU LOW $-START     ; subtract starting address from ending address

Calculates the difference between the START memory address and the ending memory address. Then writes that value as decimal ASCII followed by the string ' bytes'.

There are no 0x02, 0x09, ASCII '2' (0x32) or ASCII '9' (0x39) in the code.

Output:

Answer 7

International Phonetic Esoteric Language, 13 bytes

" bytes"94suo

Explanation:

" bytes"      (push the string)
        94s   (push 13 by adding)
           uo (print twice)

Alternative (also 13 bytes):

" bytes"{D}uo (D == 13 base 36)

Answer 8

BRASCA, 13 bytes

Ln`setyb `[o]

Try it!

Explanation

Ln              - Output 13 as number
  `setyb `      - Push "bytes "
          [o]   - Output the rest of the stack

Answer 9

Nim, 17 bytes

echo 8+9," bytes"

Try it online!

Answer 10

Pxem, 11 bytes.

• Filename: .n bytes.p
  • Escaped: \013.n bytes.p
• Content: empty.

Try it online!

Answer 11

PEP8 Assembly, 50 bytes

STRO 4,d
STOP
.WORD 13616
.ASCII " BYTES"
.END

13616 is "50" in ASCII

A programming language made as an introduction to assembly and low-level concepts. Not sure I've seen it used here before, so might be a first?

Answer 12

Python 3, 34 bytes

print(f'{chr(51)}{chr(52)} bytes')

Try it online!

Answer 13

TI-Basic, 27 BYTES

Text(0,0,3*3²," BYTES

outputs on the graph. Text( allows to chain things to output, which Output( or Disp don't allow

there is probably room for improvement with one of those

• 27 in 2 or 3 bytes is possible but useless (3^3, 3³)
• 26 in 3 bytes
• 25 in 2 bytes (5² not valid)
• 24 in 1 byte ??

This solution should work on all TI-83 and 84. See also the 14 byte solution for the TI-84+ CE.

Answer 14

C, 50 49 46 28 bytes

m(){printf("%i bytes",' ');}

we need to tell the linker about our custom entry point and make sure stdio.h is included:

cc -o x x.c -e _m -include stdio.h

Notice, that the character in the printf statement is should not be a space but the ascii character for 28 (FS) in decimal. I am not able to edit the answer and add this.

Answer 15

Python 3, 22 19 bytes

print(22-3,'bytes')

Try it online!

Thanks to @twentysix for -3 bytes

Answer 16

Behaviour, 12 bytes

6+6+" bytes"

The output is implicit, but if we need explicit print, here's one for 13 bytes:

@6+7+" bytes"

Answer 17

GeoGebra, 13 12 bytes

Thanks Lince Assassino for -1 bytes

6+6+" bytes"

Pasting that into the GeoGebra calculator and pressing Enter gives the string 12 bytes.

Answer 18

Aussie++, 35 bytes

G'DAY MATE!
GIMME ""+70/2+" bytes";

Tested in commit 9522366.

---

This was more annoying to golf than I thought it would be. At first I tried this (33 bytes):

G'DAY MATE!
GIMME 11+22+" bytes";

But for some bizarre reason, this prints out bytes33, not 33 bytes (see this github issue). So then I tried this (36 bytes):

G'DAY MATE!
GIMME ""+12+24+" bytes";

But that printed out 1224 bytes. I thought I could be clever and tried this (35 bytes):

G'DAY MATE!
GIMME ""+41-6+" bytes";

Only to be given the error THOSE AREN'T FUCKIN NUMBERS MATE!. It became apparent that I had to use parens if I wanted to use addition or subtraction.

However, parens aren't necessary for multiplication. I tried multiplication, but I reached an impasse: using 17*2 made it be 35 bytes but print 34, using 4*9 made it be 34 bytes but print 36, etc. I could use (4*9) to be 36 and print 36, but then I'd be breaking the rule on unnecessary characters (I think).

Only after considering using (9+28) for 37 bytes did the idea of division come to mind.

Answer 19

Befunge-93, 19 bytes

82*3+."setyb">:#,_@

Outputs 19 bytes.

Try it online!

Version with no numbers:

"D""/"-."setyb">:#,_@

Outputs 21 bytes.

Try it online!

Answer 20

Lexurgy, 15 bytes

a:
*=>15\ bytes

Answer 21

Minecraft Command Blocks, 198 bytes

A series of five command blocks with these commands:

scoreboard objectives add s dummy
scoreboard players set s s 33
scoreboard players set b s 6
scoreboard players operation s s *= b s
tellraw @a [{"score":{"name":"s","objective":"s"}},{"text":" bytes"}]

Pretty simple, it calculates 6 * 33 and prints the answer + bytes. I got lucky and didn't have to adjust the length of anything.

Answer 22

Microscript II, 13 bytes

7s6+p" bytes"

Pretty trivial, just adds 7 and 6 to get 13, and uses implicit output for the trailing bytes.

Answer 23

Knight, 17 bytes

O++''-8~9' bytes'

Try it online!

My second attempt at a second entry for the August 2022 language of the month event.

The original solution is left here for posterity

OUTPUT++''%60 36' bytes'

Answer 24

Headascii, 55 BYTES

++++[]]]][]^^]]+++++PPDP++]]P^]+++++++P-----P(D+++P<-P!

Try it here, code will have to be pasted in and executed as shown below:

erun("++++[]]]][]^^]]+++++PPDP++]]P^]+++++++P-----P(D+++P<-P!")

Outputs 55 BYTES

Code breakdown:

++++[]]]][]^^]]+++++PPDP++]]P^]+++++++P-----P(D+++P<-P! full program
++++[]]]][                                              save 16 to R2
          ]^^                                           save 32 to R1
             ]]+++++PP                                  append "55" to string register
                      DP                                append " " to string register
                        ++]]P                           append "B" to string register
                             ^                          save 66 to R1
                              ]+++++++P                 append "Y" to string register
                                       -----P           append "T" to string register
                                             (          store 84 in R3
                                              D+++P     append "E" to string register
                                                   <-P  append "S" to string register
                                                      ! print string register

This breakdown isn't great but the basic idea is that [^( store to registers and ]D< return values from registers, and treat the rest like brainfuck basically :P

Answer 25

RProgN 2, 12 bytes

34*" bytes"+

Try it online!

Answer 26

Attache, 18 bytes

Print[!4-6,$bytes]

Try it online!

This is simply printing !4-6 (which is factorial(4) - 6) followed by bytes.

Answer 27

Jotlin, 17 bytes

P("${8+9} bytes")

Uses the println builtin

Answer 28

Groovy, 22 bytes

{print"${0x16} bytes"}

Try it online!

Answer 29

Pyt, 35 bytes

2⁵1⁺ᴇ⁻⁻1ᴇ⁺²2ᴇ4²+9⁺²⁺1ᴇ⁺²6-áƇǰ8Ḟ1+⇹ǰ

Try it online!

Explanation:

2⁵         Push 32
1⁺ᴇ⁻⁻      Push 98
1ᴇ⁺²       Push 121
2ᴇ4²+      Push 116
9⁺²⁺       Push 101
1ᴇ⁺²6-     Push 115
á          Convert stack to array, and push the array onto the stack
Ƈ          Cast to characters ([" ","b","y","t","e","s"])
ǰ          Join the elements of the array (" bytes")
8Ḟ1+       Push 35
⇹          Swap the top two elements on the stack
ǰ          Concatenate the stack as a string ("35 bytes")
           Implicit print

Answer 30

Swift, 22 bytes

print("\(18+4) bytes")

Try it online!