Setanta, 21 bytes

scriobh(3*7,"bytes")

try-setanta.ie link

Bespoke, 171 bytes

Bes-pok-e:OneHund-r-edAndS-e-ven-tyO-n-e bytes
the way I programmed a set for A-Z:simple way for A-to-Z
let us output number
now we put in letters
finally,repeat to type Z

Outputs 171 Bytes using a pretty standard loop.

ACCUMULATOR, 74 bytes

AAAAAAACMMMORAAACMURAAAAAACURAAAAAAAACAUMMMMMURAAAAAACAAAURAAAAAAACAAAAAAU

Outputs 74 BYTES

Google Sheets / Excel, 13 bytes

=6+7&" bytes"

No matter what I try, I could not go down from 23 bytes.

Tcl, 23 bytes

puts [expr 0x17]\ bytes

Try it online!

Tcl, 23 bytes

puts [scan  %c]\ bytes

Try it online!

Tcl, 23 bytes

puts [expr 19+4]\ bytes

Try it online!

SAKO, 42 bytes

1)DRUKUJ(0):39+3
TEKST
 BYTES
STOP1
KONIEC

Basic solution that prints result of 39+3 followed by BYTES.

SAKO, 49 bytes

1)A[61
DRUKUJ(0):ENT(A)
TEKST
 BYTES
STOP1
KONIEC

This solution uses an octal number to print the decimal one. Just thought it would be fun to include it.

SAKO, 74 bytes

1)CALKOWITE:*T
TABLICA(1):T
55 52
DRUKUJWIERSZ:T
TEKST
 BYTES
STOP1
KONIEC

This solution is for people who really don't like unnecessary whitespace in the output. I included it because while trailing whitespace is explicitly allowed, preceding whitespace isn't.

Raku (Perl 6) (rakudo), 16 bytes

say 8+8~' bytes'

Attempt This Online!

Not too exciting, still new to Raku.

x86 16-bit machine code + DOS, 23 bytes

Hexdump:

b4 09 20 42 59 54 45 53 24 00 81 36 00 01 86 3a
ba 00 01 cd 21 cd 20

Doesn't contain the characters 2 and 3; doesn't contain bytes with values 2 or 3. Does contain a byte with value 1 though — that was close!

Disassembled code:

0x0000000000000000:  B4 09                mov  ah, 9
0x0000000000000002:  20 42 59             and  byte ptr [bp + si + 0x59], al
0x0000000000000005:  54                   push sp
0x0000000000000006:  45                   inc  bp
0x0000000000000007:  53                   push bx
0x0000000000000008:  24 00                and  al, 0
0x000000000000000a:  81 36 00 01 86 3A    xor  word ptr [0x100], 0x3a86
0x0000000000000010:  BA 00 01             mov  dx, 0x100
0x0000000000000013:  CD 21                int  0x21
0x0000000000000015:  CD 20                int  0x20

Fortunately, executing the message as code doesn't do any harm (except randomly altering some memory and registers). After that, the code patches initial two bytes and prints the message.

I had to append explicit code to terminate the program because otherwise it printed some garbage instead of hanging (which I would expect).

Execution screenshot:

punchcode, 12 bytes

hexdump:

00000000: 01 0C 20 17 20 62 79 74 65 73 18 0B  | .. . bytes..

uncompiled:

-START  |
-------O|
----OO--|
--O-----|
---O-OOO|
--O-----|
-OO---O-|
-OOOO--O|
-OOO-O--|
-OO--O-O|
-OOO--OO|
---OO---|
----O-OO|

Javascript: 15 bytes

not sure the exact rules, but I am treating a function as the program.

n=>0xF+" bytes"

// other variants
// (there are a few, all basically ways to get 15 using 3 characters)

n=>8+7+" bytes"
n=>9+6+" bytes"
n=>8|7+" bytes"
n=>8^7+" bytes"
n=>9|6+" bytes"
n=>9^6+" bytes"
n=>9|7+" bytes"

Try It Online!

Python 3, 144 bytes

try:
 (lambda x:(type(lambda:0))(compile('','','exec'),{},'',tuple('69'*(x+6))))(66)(0)
except TypeError as e:
 print(str(e)[30-7:32-6],'bytes')

Try it online!

Still a refreshing 69, but now golfed!

tinylisp, 47 bytes

(string(c 52(c 55(c(a 31 1)(chars(q bytes))))))

Try it online!

Malbolge, 106 69 bytes

('&%:9]!~}|92VxwvusrOqpn,%Iji!hDe#z@aw=^t:x&I$GVlDj0{@,,M*((9e%]\"`2B

Try it online!

Created with zb3 malbolge tools

Uiua, 12 bytes

-3"45#e|whv"

Try it here!

J-uby, 28 bytes

I know more succinct solutions are possible but this one amused me.

:join&:succ*[?1,?7," byter"]

Attempt This Online!

YASEPL, 16 bytes

=a$**^~>" bytes"

ibe, 28 bytes

dheoslresluuslopslotslupslor

Pascal, 48 Bytes

Pascal according to ISO standard 10206 “Extended Pascal” allows you to specify integer literals up to a base of 36.

program p(output);begin write(7#66,' Bytes')end.

program p(output);begin write(9#53,' Bytes')end.

See also the FreePascal submission.

TypeScript's type system, 24 bytes

type F=`${0o30} bytes`;;

Try it at the TS playground

TIL TypeScript has octal literal types. Two dead bytes because 0o26 has a 2 in it.

TypeScript's type system, 65 55 bytes

type Z=[1,1,1,1,1]["length"]
type F=`${Z}${Z} bytes`;;;

Try it at the TS playground

3 dead bytes there, in order to get both digits the same.

05AB1E, 15 bytes

30 2/ò" bytes"J

Try it online!

RProgN 2, 12 bytes

34*" bytes"+

Try it online!

Thunno, 14 bytes

7 2*J" bytes"+

Attempt This Online!

Explanation

7 2*             # Push 7 * 2 (14)
    J            # Convert to string
     " bytes"    # Push the string " bytes"
             +   # Concatenate
                 # Implicit output

dc, 14 bytes

7d+n[ bytes]p

Double it

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

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'

Zsh, 16 bytes

<<<$[##␐]\ bytes

Attempt This Online!

␐ should be a literal 0x10 byte, but that doesn't show up in SE markdown.

Zsh -BCDEFGHIJ, 13 bytes

<<<$#-\ bytes

Attempt This Online!

Cheating.

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.

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.

Lexurgy, 15 bytes

a:
*=>15\ bytes

Haskell, 34 bytes

main=putStr$show(0x1D+5)++" bytes"

Try it online!

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!

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.

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.

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"

Python 3, 22 19 bytes

print(22-3,'bytes')

Try it online!

Thanks to @twentysix for -3 bytes

Vyxal ṡ, 5 bytes

4›`¨∞

Try it Online!

Explanation :

4     # push 4
 ›    # increment
  `¨∞ # push "Bytes"
      # flag `ṡ` => join with space
      # implicit output

Risky, 32 bytes

*+}*!*1!**/*1*1++*{*1*1!}*}*1+1+*+1**+1!***+{*{+***+1*1!***+!*/

Try it online!

><>, 13 bytes

dn'setyb '>o<

Try it online!

PICO-8, 25 bytes

print(ord("」").." bytes")

ord() gets the index of a character, and 」 is character 25 in P8SCII.

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.

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.

Vyxal ṡ, 7 6 bytes

^{-1 bytes thanks to Bubbler}

kṄt`¨ƈ

Explanation

kṄ                - Push "4096"
  t               - Get the final item (6)
   `¨ƈ            - Push "bytes"
<flag>            - Join by spaces ("6 bytes")
<implicit>        - Print it.

Try it Online!

Python 3, 34 bytes

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

Try it online!

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?

RAMDISP, 133 26 bytes

There's room for improvement.

[P[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]][*[[[[]]]]][+[[[]]]][S[; bytes]]]]

i honestly don't even remember how i did this, i attached a debugger, and found it it calculates 3 * 37 + 2.

[P[5[*5][+1][S[; bytes]]]]

26 = 5*5+1

Red, 43 bytes

print[to-integer 8.6 * length? b: "bytes"b]

Pxem, 11 bytes.

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

Try it online!

Templates Considered Harmful, 30 bytes

St<51,48,' ','B',89,84,69,'S'>

Try it online!

This should be the best possible score. Every character here can be represented by a 2 byte ascii (ex. 66) value, or a 3 byte char literal (ex. 'B'). 28 is the theoretical minimum representing every character as ascii, but it is blocked by space being value 32. 29 is also blocked by Y and E. 30 works.

Nim, 17 bytes

echo 8+9," bytes"

Try it online!

BRASCA, 13 bytes

Ln`setyb `[o]

Try it!

Explanation

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

GolfScript, 10 bytes

n)" bytes"

Try it online!

n is a variable that represents \n, ) separates the last char from n and parses it to an integer. The ascii value of \n is 10.

Pyramid Scheme, 477 440 BytEs

     ^   ^       ^   ^       ^   ^
    ^-  / \     ^-  / \     ^-  / \
   / \ /out\   / \ /out\   / \ /out\
  /out\-----^ /out\-----^ /out\-----^
 ^-----^   / \-----^   / \-----^   / \
 -^   / \ /chr\   / \ /chr\   / \ /chr\
  -^ /chr\-----^ /chr\-----^ /chr\-----^
  /*\-----^   / \-----^   / \-----^   / \
 ^---^   / \ /66 \   / \ /116\   / \ /115\
/8\ / \ /32 \-----  /121\-----  /69 \-----
---/55 \-----       -----       -----
   -----

Try it online!

Outputs 440 BytEs by multiplying 8 by 55.

Brain-Flak, 100 BYTES 80 bYTES

((((((()()()))[]{})))((({}){})(((({}){}))<([]([](([][][])([{}]()({{}}))))[])>)))

Try it online!

Outputs the bytes part in reverse title case. Does away with the (<>) abuse to pad the stack height and instead reuses those elements to add up to 83 for the final push, as well as contributing to pushing the 80 part.

Initially, this pushes 3 8 8 32 32 to the main stack while pushing 8 16 32 to the "third" stack (this is used to produce 80 (8+16+32,16+32,32)). Then inside that we push the bytes part inside a < >. Here we use the stack height (5) to get the differences between the elements (9 5 15 -14) before finally summing the stack to produce 83 (S).

Brain-Flak, 90 bYTES

((((((<>))))[])[]([]((((([][][]))))([{}]()([]({}{}){}{}<>)))))(([][])[()]((([]{}))({}{})))

Try it online!

It took a while but I got us down to double digits.

I stole a technique of pushing a bunch of zeros in order to abuse [] from JoKing's answer. However I have modified it a bit.

Instead of pushing zeros I just push whatever is convenient (which does happen to include zeros). This is ok since JoKing gets rid of them with a loop that doesn't pick up zeros (which is reversing the stack), I use <> to switch to the other stack.

Other than that shared trick out answers are quite divergent.

Javascript, 15 bytes

j=>0xf+' bytes'

Seems like the obvious answer.

Alternative:

j=>9+6+' bytes'

Perl 5 + -Mfeature+say, 14 bytes

Relies on a generated program, so TIO link is to Bash which generates the program from xxd output. Uses -Mfeature+say instead of -M5.10.0 although I don't think it matters that much...

say~"ÎËß"

Try it online!

Golfscript, 12 bytes

6 6+" bytes"

Try it online!

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)

C# (Mono C# Shell), 27 bytes

Console.Write(3*9+" bytes")

Try it online!

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:

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.

RProgN 2, 10 bytes

°' Bytes'.

Explination

°           # Push 10 to the stack
 ' Bytes'   # Push the literal string " Bytes" to the stack
         .  # Concatenate. Implicit print.

Try it online!

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

W d, 7 bytes

♣êæ█☺₧K

Explanation

Unpacked:

7 bytes"

Runic Enchantments, 10 bytes

` ā`XESa@

Try it online!

Huh, I thumbed this one up and never answered it.

ā encodes the value 257 (still shorter than any other method) which gets multiplied by 10 and converted to a word via a dictionary. 2570 happens to be bytes. a encodes 10 (b-f encode 11 through 15) and gets around the "no digits" restriction. And conveniently enough, the rest of the program is 9 bytes.

Doesn't end up being shorter than " bytes"a@ (also 10 bytes), but oh well.

Poetic, 277 bytes

for the A.I. system i did, i tried to put in humans
i know i am one of those
i am trying human testing for cyber-enabled virtual brains
a for-profit company rakes in massive loads of cash educating interns,
& then force-feeding things to all the interns until we earn a diploma

Outputs 277 bytes.

Try it online!

Poetic is an esolang I made in 2018 for a class project. It's basically brainfuck with word-lengths instead of symbols.

This was a fun program to write, although I'm not entirely sure I've fulfilled the "no unnecessary characters" requirement. If my answer needs to be amended, let me know!

Keg, 6 bytes

bytes

Uses an unprintable character at the beginning to push 6 to the stack. Then when it gets printed at the end, a space is automatically added after the 6 due to it being an integer.

Try it Online!

C, 31 bytes

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

Try It Online!

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

Commodore 64 - 74 tokenized and BASIC bytes

Assuming by score in bytes, you mean tokens and bytes used by the BASIC interpreter, this works:

0 def fn b(x) = 38911-(fre(x)-2^16*(fre(x)<x)): print fnb(.);"bytes

There is a bug in the FRE() function on the Commodore 64 as it assumes maximum size of BASIC is 32K, or 32768 bytes.

Commodore VIC-20 (unexpanded) - 29 tonkenized and BASIC bytes

0?(60*60-17)-fre(.)"bytes

33, 14 bytes

Technically non-competing, as I made the language after this challenge was posted.

2c7xo" bytes"p

Pretty simple. Multiplies 2 and 7.

Forth (gforth), 14 13 bytes

$d . ." bytes

Try it online!

Bash, 20 18 17 bytes

echo $[8+9] bytes

Try it online!

-2 bytes thanks to @manatwork.
-1 byte thanks to @boboquack.

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.

Deadfish~, 59 bytes

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

Try it online!

Chevron, 12 bytes

^n<<3*4
>^n

This is a fairly new language of my own creation - prototype interpreter, documentation, and example programs can be found at https://github.com/superloach/chevron.

Explanation:

• ^n<<3*4 - calculate 3*4, store as n
• >^n - output n
• nothing else - implicit exit

Python 2, 17 bytes

print 9+8,'bytes'

Output: 17 bytes

k (oK), 16 bytes

Try it online!

($:4*4)," bytes"

String result of 4*4 and concatenate

Python 3, 18 bytes

print(9*2,'bytes')

Try it online!

C#, 68 65 64 bytes

class P{static void Main(){System.Console.Write(8*8+" bytes");}}

Try it online!

C (gcc), 32 bytes

main(){printf("%d bytes",8*4);}

Nothing crazy here.

Go, 46 Bytes

package main;func main(){print(38+8," bytes")}

Pascal (FPC), 29 bytes

begin write($1D,' bytes')end.

Try it online!

$1D is a hexadecimal constant. I'm glad Pascal has something shorter than other languages!

MBASIC, 17 bytes

6 PRINT 8+9"bytes

MBASIC requires line numbers; "6" doesn't appear in the output either. Turns out that the trailing quote is optional.

Output:

RUN
 17 bytes
Ok

LOLCODE, 66 bytes

Just because it's funny

HAI 1.2,VISIBLE SMOOSH PRODUKT OF 2 AN 33 AN " bytes" MKAY,KTHXBYE

Output

66 bytes

Hexagony, 26 22 Bytes

B{3'/bs.<t>;ey;:!$@P0/

-4 Bytes @Jo King

Try it online!

   B { 3 '
  / b s . <
 t > ; e y ;
: ! $ @ P 0 /
 . . . . . .
  . . . . .
   . . . .

Reuses every semicolon twice similar to this answer.

Cubix, 23 bytes

@"!w"SETYB"uUo<S;O'$.;

Try it online!

Cubified:

    @ "
    ! w
" S E T Y B " u
U o < S ; O  '
    $ .
    ; .

Watch it run

Failrly simple pushes SETYB onto the stack, pushes character 23 (ETB) and outputs as an integer. Push 32 (space) onto the stack then start outputting chars and popping until stack is empty.

vim, 12 bytes

a9 bytes<ESC>03<C-A>

<ESC> is 0x1b. <C-A> is 0x01

Try it online!

Python (REPL), 16 bytes

'%d bytes'%(8*2)

Output :

16 bytes

Emojicode, 46 bytes

🏁🍇😀🍪🔡38 8🔤 bytes🔤🍪🍉

Try it online!

I wanted to add my own answer to this question, but seeing as y’all took all the GOOD languages, I had to pick one of the weird ones 😜

Pepe, 74 bytes

rEeEeeEeEereEEreeeEeeeeereeEEeeeEereeEEEEeeEreeEEEeEeereeEEeeEeEreeEEEeeEE

Try it online!

It's a boring answer, rEeEeeEeEereEE pushes 74 into stack r and outputs the number, and the rest of the code prints bytes

MathGolf, 9 bytes

G½ "bytes

Try it online!

Explanation

Quite simple really

G            Push 18
 ½           Halve the result, giving 9
             Push a space character
   "bytes    Push "bytes"

Backhand, 11 bytes

"" sbbeOytH

Try it online!

Non-linear pointer progression makes for weird looking programs. Outputs 11 bytes.

The orde: of commands is such:

"  s  e  t      Start string literal to push letters
                Bounce and go left
     b  y       Finish pushing " bytes"
                Bounce and go right
 "  b  O  H   Push 11 to print and then halt and output the stack

Attache, 19 bytes

Print&$bytes!STN!$t

Try it online!

Explanation

Print&$bytes!STN!$t
Print       !          print
     &$bytes           (with "bytes" as a right argument)
             STN!      convert string to number...
                 $t    "t" (corresponds to 19)

In sane syntax, this is: Print[STN["t"], "bytes"], which joins the arguments by spaces.

Make, 96 bytes

d=$1 $1 $1 $1 $1 $1 $1 $1
all:
	@echo $(words $(call d,x x x x x x x) $(call d,x x x x x)) bytes

Try it online!

Befunge-98 (FBBI), 12 bytes

"c.4k,@setyb

Try it online!

Thank you Jo King and Mistah Figgins for -3 bytes.

7, 23 characters, 9 bytes

54340045141332401057403

Try it online!

This is a fairly hard challenge in a language that consists entirely of digits, but I managed it…

This is just 9 bytes in 7's encoding. (Strictly speaking, it's 8⅜ bytes (23 × ⅜ − ¼ because the final two trailing 1 bits can be omitted), but for the first time, PPCG's requirement to round up to a whole number of bytes is actually an advantage because it means that the extra trailing 1 bits are necessary and thus not banned by the question.) A reversible hex dump:

00000000: b1c0 2530 b6a0 22f8 1f                   ..%0.."..

The main challenge of writing this program in 7 was golfing it to under 10 bytes (as writing 7 without using 0 or 1 is pretty hard.) This uses the same structure as the standard "Hello world" program:

54340045141332401057403
5434004514133240105      commands 0-5 append literals to data space
                   7     start a new section of data space
                    403  another literal appended to data space
                         {implicit: eval the last section as commands}
                    4    swap 1st and 2nd sections with an empty section between
                     6   reconstruct the commands that would create the 1st section
                      3  output (+ some other effects we don't care about)

In other words, we start by creating two sections of the data space; we have two literals, each of which pushes a sequence of commands there. The second section (they're pushed stack-style so first push = last pop) is a fairly arbitrary sequence of commands but is pushed using the command sequence 5434004514133240105 (thus producing the data sequence 5434664574733246765; when discussing 7 in text, I normally use normal font for a command that pushes a literal, and bold for the corresponding resulting literal). The first section is pushed using the command sequence 403, producing 463. Then the first section is copied back to the program (an implicit behaviour of 7).

The 463 is now composed of (bold) commands that do something immediately, rather than (non-bold) commands that just push literals. 4 rearranges the sections to get our "string literal" into the first section. Then 0 does the operation that 7 is most known for: taking a section of data space, and reconstructing the command sequence that's most likely to have created it. In the case where the original command sequence was all 0-5, this is 100% accurate (unsurprisingly, as those commands purely push data and thus leave obvious evidence of what they did), and so we get our original sequence 5434004514133240105 back. Finally, 3 prints it.

So the remaining thing to look at here is the encoding of the string. This has its own domain-specific language:

5434004514133240105
5                    change encoding: 6 bits per character
 43                  select character set: digits and common symbols
   40                '9'
     04              space
       51            select character set: uppercase letters
         4133240105  'B' 'Y' 'T' 'E' 'S'

(There's no "select character set: lowercase letters" in the "digits and common symbols" character set – you have to go via a different character set first – so I needed to use uppercase to golf this short enough to fit underneath the effective 10-byte limit.)

TI-Basic (TI-84 Plus CE with OS 5.2+), 14 bytes

toString(9+5)+" BYTES

toString( is a two-byte token, all other characters used are one-byte tokens.

toString( can be replaced with eval( for the same output and score.

Explanation:

• toString(9+5) Returns the string "14"

• +" BYTES Adds the string " BYTES", to get "14 BYTES"

• TI-Basic implicitly returns/prints the last item evaluated, so 13 BYTES is output.

JavaScript (Node.js), 22 bytes

alert(`${8+14} bytes`)

LOWER, 93 bytes

ₔ₉₃ₔₓ₃₂ₔₓ₉₈ₔₓ₁₂₁ₔₓ₁₁₆ₔₓ₁₀₁ₔₓ₁₁₅

Try it online!

This is all Unicode characters, so no 9s or 3s here.

Ruby, 16 bytes

p "#{9+7} bytes"

Try it online!

Vim, 12 10 bytes

i9<C-o><C-a> bytes

Excel, 13 bytes

=4+9&" bytes"

Using CONCATENATE for 28 bytes:

=CONCATENATE(4*6+4," bytes")

Aceto, 16 15 bytes

es7+
t"8p
ybp
"

We first push " bytes", then 78+ (15) and then print both.

edit: Fixed counting final newline character edit2: Saved 1 byte thanks to Jo King

Mathematica frontend, 18 bytes (maybe 10?)

Row@{2*9," bytes"}

Thanks to @ovs

A naughty way ... as I don't know whether this counts (10)

2" bytes"5

Well it depends on how you define space.

Wolfram Language (Mathematica), solution w/o frontend (30)

Print[ToString[5*6]<>" bytes"]

Try it online!

K4, 18 15 bytes

Solution:

($6+9)," bytes"

Example:

q)k)($6+9)," bytes"
"15 bytes"

Explanation:

Evaluated right-to-left, don't think I can get lower than 15 this way:

($6+9)," bytes" / the solution
      ," bytes" / join " bytes" with...
(    )          / do together
  6+9           / 6+9 = 15
 $              / cast to string

Alternative:

Another 15 byte solution, has potential to be golfed if anyone can make "41" in 4 chars or "31" in 3 chars:

|"setyb ",$49+2

m4, 15 bytes

As in the m4 POSIX macro processor.

eval(8+7) bytes

Lua, 21 bytes

print(3*7 ..' bytes')

The space before .. (string concatenation operator) is required or the parser sees 7.. as a malformed number.

Swift 4, 19 18 bytes

^{Saved 1 byte thanks to Jo King.}

print(9*2,"bytes")

Try it online!

Husk, 8 bytes

+sD4¨₆Ẏ¿

Try it online!

Explanation

+sD4¨₆Ẏ¿
    ¨₆Ẏ¿  Compressed string of " bytes"
  D4        Multiply 4 by 2
 s          Convert to string
+         Concatenate the strings

ArnoldC, 216 Bytes

Try it online!

IT'S SHOWTIME
    HEY CHRISTMAS TREE i
    YOU SET US UP 4
    GET TO THE CHOPPER i
        HERE IS MY INVITATION i
        YOU'RE FIRED 54
    ENOUGH TALK
    TALK TO THE HAND i
    TALK TO THE HAND "BYTES"
YOU HAVE BEEN TERMINATED

Output

216
BYTES

Well, i took too long with my php answer, i had to try this.

As far as i read, i can't write without a line break or concatenate an integer with a string :(

Clojure, 24 bytes

(println(+ 17 7)"bytes")

Try it online!

Applescript, 15 bytes

Yes, I’m going there.

9+6&”bytes”

C++ (GCC), 51 bytes

Thanks to @ceilingcat!

#import<iostream>
main(){std::cout<<063<<" bytes";}

Try it online!

C++ (GCC), 56 bytes

#import<iostream>
main(){std::cout<<(int)'8'<<" bytes";}

Try it online!

More portable version (60 bytes):

#import<iostream>
int main(){std::cout<<(int)'<'<<" bytes";}

#import is not standard C++, but should work at least with GCC, Clang, and MSVC.

Try it online!

Standard compliant version (61 bytes):

#include<iostream>
int main(){std::cout<<(int)'='<<" bytes";}

Try it online!

Batch, 31 bytes

@set /a r=29+2 
@echo %r% bytes

MySQL, 28 bytes

SELECT CONCAT(7*4,' bytes');

Octave, 42 bytes

I figured I'd try a more interesting approach that's Octave-specific (and only works on some platforms).

printf('%i bytes',printf('%c',8+~(10:51)))

Note: This doesn't work on TIO or Octave-online.net, but it does work on Octave 4.2.0 on my laptop.

Explanation:

printf('%i bytes',... ) specifies that we will print a string starting with an integer %i followed by the characters ' bytes'. The second part of the first printf-function call is another call to printf('%c',...). When printf is called with an output argument, it returns the number of characters in the output string, as well as the string. The second part of the second printf call is 8+~(10:51). This is a shorter way to write [8, 8, 8 ...] 42 times. 8 is the ASCII-value of the backspace. The string to be printed is therefore 42 backspaces. This doesn't show when typing it in the terminal, so we'll get 42 bytes without a trailing newline:

Jstx, 4 bytes

♦─]P

Try it online!

Ly, 14 bytes

72*u" bytes"&o

Try it online!

I tried a solution based on Ly's quine, but it quickly turned out to cost more bytes than it saved.

JavaScript, 20 bytes

alert(5*4+" bytes");

V, 13 bytes

a20 bytes<esc>^7<C-x>

<esc> is \x1B and <C-x> is \x18.

Try it online!

Pyke, 9 bytes

75 02 94 0A 09 58 EF 64 4A

Try it here!

u 02 94 0A 09      - integer list, length 2 ([2570, 9])
             X     - splat(^)
              .o   - lookup 2570 in dictionary (bytes)
                dJ - join by " "

FerNANDo, 79 bytes

3 3
1
2 2
0 1 3 3 1 2 2 3
0 1 3 3 2 1 0 2
0 1 3 0 0 1 0 1
0 3 3 1 0 0 3 1
1 1
1

Try it online!

SQL, 18 bytes

SELECT 2*9,'bytes'

Windows Command Line, 20 bytes

set/a4*5&echo  bytes

Run Windows Command Prompt (cmd.exe), type the command and hit Enter.

Hoon, 23 bytes

(runt 1^0vcpi " bytes")

(runt [p q] "tape") prepends a byte sequence q to a string p number of times. p^q is sugar for [p q], and 0vXXX is base32 (@uv) encoding for the byte string '23'.

Go, 66 64 bytes

package main;import"fmt";func main(){fmt.Printf("%d bytes",'@')}

Javascript,26 bytes

console.log(78/3+" bytes")

Try it online!

C# (.NET Core), 16 bytes

n=>8*2+" bytes";

Try it online!

39 bytes

n=>System.Console.Write(~-40+" bytes");

Not sure whether returning the output from a function is valid, if not, here's a 39 byte solution.

Try it online!

Haxe, 20 bytes

trace(4*5+' bytes');

Try it online!

F#, 24 23 bytes

I hope this counts. Never code golfed before

printfn "%i bytes" 0x17

Just switched 24 to octal 23 to hex

Try it online!

Java 5 or 6, 44 bytes (full program)

enum A{A;{System.out.print(0x2C+" bytes");}}

No TIO-link, because Java 5/6 is old.. In Java 5/6 it was possible to have an enum with code instead of the mandatory main-method, making it shorter for full program challenges.

Also errors with java.lang.NoSuchMethodError: main\nException in thread "main" in STDERR after printing to STDOUT, which is fine according to the meta (but if the challenge would have disallowed additional errors to STDERR, System.exit(0); can be added (and the octal numbers has to be updated) to prevent the error.

Suggested by @OlivierGrégoire (and his relevant Java tip).

Java 8+, 74 bytes (full program)

interface M{static void main(String[]a){System.out.print(0112+" bytes");}}

Try it online.

Java 8+, 16 15 bytes (lambda function)

v->0xF+" bytes"

-1 byte thanks to @OliverGégoire.

Try it online.

MSSQL, 26 24 bytes

print str(8*3) +' bytes'

T-SQL, 32 bytes

print char(51)+char(50)+' bytes'

Best I could come up with.

Excel VBA, 10 bytes

An anonymous VBE immediate window function that takes no input and outputs to the vbe immediate window.

?2*5"bytes

Output

10 bytes

Google Sheets, 12 bytes

An anonymous worksheet function that takes no input and outputs to the calling cell

=3*4&" bytes

PHP, 14 bytes

<?=7*2?> bytes

FALSE, 11 bytes

'\u000B." bytes"

\u000B should be replaced by the corresponding character.

Excel, 13 bytes

=6+7&" bytes"

Output: 13 bytes

Nothing fancy. It's different from the other Excel answers as those are both based in VBA. This formula version is longer.

Vim, 13 Bytes

i<Ctrl-r>=7+6<Enter> bytes

Bash, 17 Bytes

echo $[8+9] bytes

output:

17 bytes

Whitespace, 112 bytes

Just because nobody's done it yet:

Try it online!

Prints " BYTES" in caps, since uppercase letters have shorter binary ASCII codes. The commands in the program, in my own made up visible notation, are:

Push 112
PrintNum
Push 0
Push 0x53
Push 0x45
Push 0x54
Push 0x59
Push 0x42
Push 0x20
Label _
PrintChr
Dup
JumpZ S
Jump _
Label S
End

Japt, 8 bytes

#+` ßs

char-code 8 concatenated with " bytes" compressed.

Try it online!

AWK, 19 14 bytes

$0=2*7" bytes"

Try it online!

Neim, 10 bytes

μ( bytes)B

μ represents 10.

Try it online!

C, 33 32 bytes

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

There is a trailing newline, which is not "unnecessary" since the C standard demands it. Try it online here.

Thanks to NieDzejkob for golfing 1 byte.

Alternative with the same bytecount, thanks to ErikF:

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

Try it online here.

C# (Visual C# Interactive Compiler), 20 bytes

Write(11+9+" bytes")

Try it online!

Haskell, 26 bytes

main=putStr$"\50\54 bytes"

Try it online!

29 bytes

main=putStr$pred<$>"3:!czuft"

Try it online!

Perl 5, 16 bytes

There are many other ways to get 16 but this one is mine

say afpbytes^PPP

Try it online!

jshell, 12 bytes

9+3+" bytes"

I don't think it's on TIO.run despite having an article on Wikipedia.

PHP older than 7.2, 13 bytes

Assumes default settings (E_NOTICE warnings disabled) and PHP version older than 7.2.

Needs to be decoded with xxd -r

00000000: 3c3f 3d7e cecc df9d 868b 9a8c 3b         <?=~........;

Or if you prefer Base64

PD89fs7M352Gi5qMOw==

Try it online!

Rust, 34 bytes

fn main(){print!("{} bytes",17*2)}

Try it online!

Red, 19 bytes

prin[22 - 3 'bytes]

Try it online!

Python 2, 18 17 bytes

print 8+9,'bytes'

-1 byte thanks to @Wondercricket.

Try it online.

Pyth, 11 bytes

+hT" bytes"

Try it online!

Gol><>, 11 bytes

bn"setyb "H

Try it online!

How it works

bn"setyb "H
b            push number 11
 n           pop and print as integer
  "setyb "   push " bytes" in reverse order
          H  print the stack content as chars, then halt

CJam, 10 10 bytes

Ao" bytes"

Try it online!

Visual Basic .NET (Mono), 66 bytes

A declared Subroutine that takes no input and outputs to the console.

Module M
Sub Main
Console.Write(3*22 &" bytes")
End Sub
End Module

Try it online!

MY-BASIC, 18 bytes

An anonymous MY-BASIC answer that outputs to STDOUT.

Print 9+9," bytes"

Try it online!

uBASIC, 14 bytes

An anonymous ubasic answer.

0?2*7;" bytes"

Try it online!

Yabasic, 15 bytes

An anonymous yabasic answer that takes no input and outputs to STDOUT.

?7+8;
?" bytes"

Try it online!

brainfuck, 53 BYTES

+[[<+>->->++>----<<<]>-]>-.--.<<<+.<.<.-----.>+++.<-.

Try it online!

Another submission with capitalised bytes. Found with the help of the excellent BF-crunch helper by primo.

PHP + HTML, 16 bytes

16 bytes

Yes, this is getting pretty close to loophole abuse, but I felt this needed to be posted. And the use of PHP means that this answer technically is written in a Turing-complete programming language. Of course, any other similar HTML templating language would work just as well.

Live demo (without PHP):

16 bytes

Foo, 13 bytes

&9+4$i" bytes

Try it online!

Explanation

&9+4$i" bytes
&9              push 9
  +4            add 4 (13)
    $i          output as integer
      " bytes   print out " bytes"

14 bytes

@20&$h" bytes"

Same general idea, but (ab)uses hexadecimal printing.

brainfuck, 95 bytes

+[--------->+<]>.----.--[--->++<]>--.[->+++<]>++.[--->+<]>+++.-----.+++[->+++<]>.[--->+<]>----.

Try it online!

97 bytes:

>-[++>+[+<]>]>+.--.>++++[->++++++++<]>.[->+++<]>++.[--->+<]>+++.-----.+++[->+++<]>.[--->+<]>----.

7Zip - 90 14 bytes

Hex dump:

00 75 0d 08 c0 00 0d 08 03 00 00 03 04 1d  

To use:

save into a source file, named anything.

run the compiler from the command line: 7z e [source name]

JavaScript, 16 15 bytes

x=>0xf+' bytes'

Ruby, 15 bytes

p"#{0xf} bytes"

Try it online!

TeX, 16 bytes

^^q^^v bytes\bye

Pip, 10 bytes

t." bytes"

Try it online!

Conveniently, there's a preset variable for the number 10.

Ruby, 18 bytes

puts"#{6*3} bytes"

Try it online!

Batch, 32 bytes

@@echo %COMSPEC:~-10,-010% bytes

COMSPEC is usually %WINDIR%\system32\cmd.exe so I extract the substring from 10 to 8 characters from the end. Old 16-byte self-referencing version:

@echo %~z0 bytes

Fortunately the byte count wasn't a multiple of 10.

Swift, 22 bytes

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

Try it online!

APL (Dyalog Unicode), 12 bytes

Full program which implicitly prints to STDOUT.

'bytes',⍨3×4

Try it online!

,⍨ is appends the string to the result of the multiplication. APL's default display of mixed-type data puts a space between a number and subsequent text.

Retina, 15 bytes

 bytes
*>w`..+

This program counts the number of substrings with at least two characters in the string " bytes", and then prints this count and the string itself.

Try it online!

PowerShell, 14 bytes

"$(2*7) bytes"

Try it online!

Ho-hum. Uses an inline code block $(...) to put 14 into the string before leaving it on the pipeline. Output is implicit.

Canvas, 8 bytes

８ bytes＋

Try it here!

A more interesting 20 byte solution:

bytecount.innerText＃

Try it here!

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

Excel (Immediate Window), 12 bytes

?3*4&"bytes"

This solution assumes that leading space is allowed.
Below the one without leading space in output (14 bytes):

?2*7&&" bytes"

It's the result of suspicious behaviour of the concatenate operator &. When only one, it surrounds the number with spaces; however two consecutive ones strip the spaces. Weird.

Petit Computer BASIC, 11 bytes

?9+2,"bytes

Using a comma in a print statement will move the cursor over to the next multiple of the current tab size. In SmileBASIC, that is 4 by default, so this would output 11 bytes (2 spaces) but PTC BASIC used 3 instead, so the output has the correct spacing.

Fortran (GFortran), 24 bytes

PRINT*,11+13,'BYTES'
END

Try it online!

Outputs "24 BYTES" with some leading spaces, because, you know, it's Fortran... you can't tell him to do something and expect that he will do exactly as you said, specially if it involves strings :)

jamal, 14 characters

{@* 2 7} bytes

Sample run:

bash-4.4$ perl jamal.pl ownsize.jam 
14 bytes

SmileBASIC, 12 bytes

?3*4;" bytes

(Probably works in a bunch of other BASIC dialects, too)

Alternatives:

?&HC;" bytes
?9+3;" bytes

SNOBOL4 (CSNOBOL4), 27 bytes

	OUTPUT =3 * 9 ' bytes'
END

Try it online!

prints with a trailing newline.

Groovy, 22 bytes

{print"${0x16} bytes"}

Try it online!

C# (.NET Core), 65 bytes

class P{static void Main(){System.Console.Write(0x41+" bytes");}}

Try it online!

Jotlin, 17 bytes

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

Uses the println builtin

Bash, 21 bytes

"Read your own source code" is clearly not the winner here, but no one else submitted one, so what the heck.

echo `wc -c<$0` bytes

Try it online!

J, 19 bytes

echo' bytes',~":_bj

Try it online!

Attache, 18 bytes

Print[!4-6,$bytes]

Try it online!

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

Octave, 23 bytes

printf('%i bytes',9+14)

Try it online!

And this:

disp(['','67$f}xiw'-4])

Try it online!

Octave, 22 bytes

disp([50 50 ' bytes'])

Try it online!

05AB1E, 6 bytes

₂¤“ÿ¡Ï

Try it online!

₂      # [26]        | Pushes 26 (many other alternatives).
 ¤     # [2, 6]      | Split out tail.
  “ÿ¡Ï # ['6 bytes'] | ÿ = "Interpolate top of stack.", ¡Ï = "bytes" (compressed)

Alternatives for ₂¤ include: 5>, ₁¤, 3·

><>, 13 bytes

#o<" bytes"nd

Try it online!

MATL, 12 bytes

6EV' bytes'h

Try it online!

Pushes 6, doubles with E, converts that to a string with V, and horzcats it with the string ' bytes' to get the proper spacing. Implicit output takes care of the rest.

MATL, 13 bytes

'57$f}xiw'4-c

Try it online!

This pushes the string '57$f}xiw' and subtracts 4, to get 13 bytes. This is converted to characters using c.

JavaScript, 19 bytes

Octal was invented to serve two purposes:

• setting file permissions in Linux
• answering this challenge

alert(023+' bytes')

Try it online!

R, 16 bytes

cat(4*4,"bytes")

Try it online!

Python 3, 25 24 18 bytes

print(6*3,'bytes')

Try it online!

dc, 14 11 bytes

[ bytes]Bnn

Try it online!

-3 bytes by @Cows quack

Pari/GP, 18 bytes

print(2*9" bytes")

Try it online!

SOGL V0.12, 8 bytes

┌`m39Σ³‘

Try it Here!

Stax, 5 bytes

╗↑╞ô╝

Run and debug it

Unpacked, it looks like this. Packed source mode makes this kind of trivial and uninteresting.

5p     print 5 with no line break
`5l@   print the compressed string " bytes"

If you don't want to use packed source mode, 6^p`5l@ works for 7 bytes.

Pyth, 10 bytes

+T" bytes"

Try it here

If you don't mind separating with a newline instead of a space, you can get it down to 8 bytes with

y4"bytes

Jelly, 7 bytes

“¢>¶ŒD»

Try it online!

Compressed strings.