text:
Output your Score!
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!

Does this need the [tag:quine] tag, or may the code self-inspect?

Pardon me for asking, but what is a trailing byte (I'm sorta new ).

@Dat, given the formatting of the word bytes I suspect the intention is that the count should include the bytes it takes to print the text: bytes

Are leading spaces in output acceptable?

If my code is 1 byte long, should I output 1 bytes or 1 byte? (keep in mind there are already 41 answers, although I don't think any are affected)

@X1M4L Also, I don't recommend code to be able to self-inspect, this would easily make a generalized quine challenge if not for that.

Can bytes be uppercase?

@JoKing well I didn’t address casing in the rules, but if somehow using capital letters makes your score lower, then by all means I’d love to see what you came up with. I say go for it!

@X1M4L i can imagine that in some programming languages (mostly very ancient ones) there are no lowercase characters in a character set. In this case however, it's just to make Brainfuck code more compact which seems fair.

Can the output be surrounded by quotes?

@iamnotmaynard im sorry but output is limited to numerical byte count, the word bytes, and white-space characters

As rafa11111 asked earlier: Are leading spaces acceptable?

@StewieGriffin - I you read the question only trailing whitespaces seems to be allowed.

Can bytes be in any case pattern, e.g. bYtEs?

@HelloGoodbye sure

JavaScript, 19 bytes
Octal was invented to serve two purposes:

setting file permissions in Linux
answering this challenge

alert(023+' bytes')

Try it online!

Does this count as a full program?

@ericw31415 This is a browser program, as defined in this meta answer.

+1 because finally clarifying me why octal is not completely useless!

+1 for answering this challenge

Perl 5, 16 bytes
There are many other ways to get 16 but this one is mine
say afpbytes^PPP

Try it online!

How does this work?

@cairdcoinheringaahing In perl you can leave out the quotes on strings if they looks like a literal and don't conflict with a keyword (and is very much deprecated but we don't care in golf), Binary operators & | ^ and ~ can also be applied to strings and work on them like on a list of ASCII values (if and only if both sides are strings). For | and ^ it works as if the shorte string is extended with \0. After that is a simple exercise to find combinations of letters that xor to the desired output,

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.)

Canvas, 8 bytes
８ bytes＋

Try it here!
A more interesting 20 byte solution:
bytecount.innerText＃

Try it here!

OK, that is pretty clever.

Notice that one of the restrictions is "Your source code can not include any of the digits from your byte count" so the first solution is not valid in this case =)

@Cyclonecode That "8" there isn't a regular ASCII 8 though - it's a full-width 8 character in this unicode version of the code, though really it's the byte 0xD5, which is completely unrelated to any 8s

brainfuck, 53 BYTES
+[[<+>->->++>----<<<]>-]>-.--.<<<+.<.<.-----.>+++.<-.

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

PHP, 14 bytes
<?=7*2?> bytes

How about putting the bytes part outside the ?>? Try it online!

@JoKing great 3 less bytes :)

Just fyi, it's probably best that you split up your answer into multiple answers if you cover more than one language.

Python 3, 25 24 18 bytes
print(6*3,'bytes')

Try it online!

But "4" is in "24".  Maybe "33-9"?

@recursive 3*8 should be fine, though

@recursive whoops, fixed it :P

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.

I've downvoted this answer, because I think that using packed mode, while a clever way of saving bytes, feels like cheating (which it isn't) at worst, and uncreative at best. Rather than go on a downvote spree of all Stax restricted-source answers, I'll leave this downvote to cover all such similar answers.

I certainly agree that it's uncreative.  But I think the fault lies with the concept of restricted-source, not the language.  This is actually the most direct way of producing "5 bytes" using Stax.

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!

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.

Wouldn't that violate the rule against unnecessary whitespace? Or maybe I don't understand?

@SteveBennett You're right. I've modified it so that the program doesn't have redundant characters (though it can be golfed pretty easily

431 bytes, Psll code: (out (_ 431) " ") (out _ "b") (out _ "y") (out _ "t") (out _ "e") (out _ "s")

@MarcinKonowalczyk There's a source restriction on this challenge so that you can't use numbers from the score (in your case 4,3 or 1)

though i managed to modify the format to work

@JoKing Aaa, yes. I apparently read straight past it.

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!

R, 16 bytes
cat(4*4,"bytes")

Try it online!

Isn't it 17 because of your missing space?

@PmanAce "Output should only be the byte count of your program and a trailing bytes". The program is 16 bytes.

cat by default adds a space between its inputs.

object.size outputs in the correct format (with bytes included by default). Annoyingly, the shortest I could find is 17: object.size(0)-39. TIO

@RobinRyder why is 0 56 bytes? that's the part that confuses me

@RobinRyder Hadley's book says a zero-length vector takes up 40 bytes, so that's 40, 8 bytes for a 64-bit number, and 8 more bytes which come from...somewhere.

All the byte counts in that reference are off by 8. On my machine, a zero-length is 48 bytes, not 40. Maybe Hadley's results are outdated?

Apparently, in Hadley's version, a 1-length vector is of length 48, so there must exist a version of R in which this 16-byte code works: object.size(0)/3.

@RobinRyder there must be! The first edition (which I linked) came out in September 2014 so it's a version 3.1.1 or earlier; the 2nd edition removes that particular section altogether.

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

Beat me to it! And the ; can usually be omitted!

Ahh but then it would be 14/15 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

Ah, didn't notice there was already a Whitespace answer.. Here is a shorter one (104 bytes).. Will delete mine again. Here is the same with added highlighting and explanation.

Oh, hmm. I guess the text is short enough that implementing the loop actually hurts more than just repeating the PrintChar.  (And I know, I can always drop the final NNN, but I really like not having errors.)

dc, 14 11 bytes
[ bytes]Bnn

Try it online!
-3 bytes by @Cows quack

[ bytes]Bnn shaves some bytes

@Cowsquack thanks!

@cowsquack duckies go MOO, I'd assume :P?

@MagicOctopusUrn Ducks, what are ducks? :P

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·

Too bad this doesn't work.

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!

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).

I've finally outgolfed this.  There might be room to get me back.

I've managed to get "76 bYTES" down to 78 bytes but I can't get it any further :(. If anyone can manage to remove that last pair of brackets, feel free to post it as your own answer

Haskell, 26 bytes
main=putStr$"\50\54 bytes"

Try it online!

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

Try it online!

Unnecessary whitespace is now forbidden, but you can use a $ instead.

@ØrjanJohansen Thanks for pointing out.

Octave, 22 bytes
disp([50 50 ' bytes'])

Try it online!

Applescript, 15 bytes
Yes, I’m going there.
9+6&”bytes”

But... Your source code can not include any of the digits from your byte count

@nicael Dang, you’re right. One second then...

Correct me if I'm wrong, but isn't ” a multibyte character (3 bytes in Unicode if I remember correctly), so this is more than 11 bytes?

@cairdcoinheringaahing ...Shoot. You’re right - “ is 2 bytes, upping this to 15.

does this not still print 11?

@DestructibleLemon Sigh... Edited. Again.

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!

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!

"& then force-feeding things to all the interns until we earn a diploma". Absolutely wonderful!

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!

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.

, 040 for 32 bytes

, 040 is against the (updated) rules but I added a trailing newline instead of the space. Thank you!

You could also use ,' ' to avoid any numerals at all!

@ErikF now that is clever. thanks :)

31 bytes

@Steadybox nice catch. I prefer the printable character solutions though.

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

Try it online!
And this:
disp(['','67$f}xiw'-4])

Try it online!

The first answers seems fine, but... how does the second one works? o.O

@rafa11111 Subtracting 4 from (the ASCII codes of) '67$f}xiw' gives the ASCII codes of '23 bytes'. Then, concatenating with the empty string ''  converts ASCII codes to chars

@Luis Mendo Pretty clever! Thanks for clarifying!

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.

I may be wrong, but don't you have a 2 in your byte count and program?  3*4 should be fine though

@fyrepenguin Heh, right you are, of course. How silly of me.

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.

6EV' bytes'h is 12 (I was just about to post it)

although it's the same boring approach :P

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.

Forth (gforth), 14 13 bytes
$d . ." bytes

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.

Technically not a full program :)

@O.O.Balance Oops.. somehow read past that, thanks for the correction. There goes my score.. XD

v->3*5+"bytes"?

@Neil It contains a 5, so I'm afraid that's not going to work.

37*2 contains a 7, so it is not valid. Your alternative solution is fine though.

@O.O.Balance Oops.. not sure how I missed that. Removed it.

v->0xE+"bytes" or v->0xF+" bytes". Can't test but should work anyways. Nothing says the score and "bytes" must be separated.

@OlivierGrégoire Thanks. As for whether there need to be a space before bytes, as expected when I looked in the challenge edit it stated " bytes", so the space is mandatory. I edited the challenge description to  bytes and also added the rule explicitly to make it more clear the space between the number and bytes is mandatory. Thanks for the -1 with the hexadecimal number 0xF though.

enum H{H;{System.out.print(<octal or hex>+" bytes");System.exit(0);}} for both Java 5 and 6.

@OlivierGrégoire I know, I know. ;) When I posted the full program I was doubting to answer it as enum thinking about your tip-answer. Do you know any online compiler that still supports it? I prefer to have a link with test code for my answers..

Then I posted it

@OlivierGrégoire Oh, I was just done with my edit, lol.. Still looking for an online compiler for Java 5/6, though.. :(

Now You use 053 to write 43. That's not allowed. Fixed by switching to hexa, for 1 extra byte.

@OlivierGrégoire Ah oops.. >.> Third time I made that mistake, wth.. I'm glad it's weekend now.. sigh. Thanks!

Hexagony, 26 22 Bytes
B{3'/bs.<t>;ey;:!$@P0/

-4 Bytes @Jo King
Try it online!

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

Reuses every semicolon twice similar to
this answer.

It even uses one of the semi-colons 4 times!

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

Welcome to Code Golf, and nice first answer!

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

My Excel shows additional leading space. Is it allowed?

@pajonk That is the default nature VBA's Print and ? statement when handling number types, and is generally accepted to be valid for PPCG. That said, it may the space may be forcefully removed by converting to a string, and then operating upon that string, such as ?6+7&&" bytes for 13 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!

Suggest 063 for (int)'8', 067 for (int)'<' and 070 for (int)'='

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.

What calculator has a toString( function?

@kamoroso94 The TI-84 Plus CE. Source

><>, 13 bytes
#o<" bytes"nd

Try it online!

JavaScript, 16 15 bytes
x=>0xf+' bytes'

_=>5*3+' bytes'

@Neil Both the code and the byte-count contains a 5 in that case..

@KevinCruijssen Bah, I can't believe I overlooked that.

Submissions are required to be full programs "write a full program to output its own code golf score!"

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.

@manatwork OK, I hadn't seen that, here's a new version.

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]

Bash, 20 18 17 bytes
echo $[8+9] bytes

Try it online!
-2 bytes thanks to @manatwork.
-1 byte thanks to @boboquack.

echo $[20-2] bytes for 18 bytes?

@manatwork woah, I didn't know bash could do math like that

“The  old  format  $[expression]  is  deprecated  and will be removed in upcoming versions of bash.” — man bash. But in meantime we enjoy using it here in PPCG.

echo $[5#33] bytes also works for a score of 18.

Doesn’t 8+9 work for 17?

@boboquack Yes, it does. Nice.

Jstx, 4 bytes
♦─]P

Try it online!

m4, 15 bytes
As in the m4 POSIX macro processor.
eval(8+7) bytes

Vim, 12 10 bytes
i9<C-o><C-a> bytes

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!

Python 3, 18 bytes
print(9*2,'bytes')

Try it online!

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"

Python 2, 17 bytes
print 9+8,'bytes'

Output: 17 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!

C# (Mono C# Shell), 27 bytes
Console.Write(3*9+" bytes")

Try it online!

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.

88 bYTES is a little easier to generate by modifying the end slightly

Back at you ;). I'm pretty sure 77 or 76 bYTES is possible though, but I've only got that down to 80 bytes

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.

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.

Risky, 32 bytes
*+}*!*1!**/*1*1++*{*1*1!}*}*1+1+*+1**+1!***+{*{+***+1*1!***+!*/

Try it online!

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!

Can't test at the moment, but would it work if you use a numeric constant ending with 6 (e.g. kṄ = 4096) and omit the trailing backtick? (...or just use a different number from the length and increment to get the byte count?)

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

Google Sheets, 12 bytes
An anonymous worksheet function that takes no input and outputs to the calling cell
=3*4&" bytes

MSSQL, 26 24 bytes
print str(8*3) +' bytes'

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!

Welcome to the site! It looks like you have some extraneous whitespace. Could that be removed? Also, I don't know a whole lot about F#, but are you sure this is a full program? The original rules stated write a full program to output it's own score

@DJMcMayhem whoops, dropped that extra space. Also I do believe this is a full program. It compiles and runs just fine in Visual Studio without anything else, though I may misunderstand what that means.

Whoops, my bad. I assumed that F# was like C# where you need class declarations in a full program. Looks valid to me!

You can remove tre space before and after the string literal and replace 0x17 with 0x15 to get 21 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

Windows Command Line, 20 bytes
set/a4*5&echo  bytes

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

SQL, 18 bytes
SELECT 2*9,'bytes'

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.

J, 19 bytes
echo' bytes',~":_bj

Try it online!

C# (.NET Core), 65 bytes
class P{static void Main(){System.Console.Write(0x41+" bytes");}}

Try it online!

I'm afraid your code contains a 5.. Easily fixed by using 72-7, though.

Fixed! With a little bit of hex to make it look clever! =D

A bit silly and crooked: class Q{static void Main(){new System.Exception("sixty four");}} => 64 and the word bytes is in the exception when you drill down through it!

SNOBOL4 (CSNOBOL4), 27 bytes
	OUTPUT =3 * 9 ' bytes'
END

Try it online!
prints with a trailing newline.

Japt, 8 bytes
#+` ßs

char-code 8 concatenated with " bytes" compressed.
Try it online!

Identical to what I had, again. 2³ would also work.

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.

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.

Ruby, 18 bytes
puts"#{6*3} bytes"

Try it online!

brainfuck, 95 bytes
+[--------->+<]>.----.--[--->++<]>--.[->+++<]>++.[--->+<]>+++.-----.+++[->+++<]>.[--->+<]>----.

Try it online!
97 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.

CJam, 10 10 bytes
Ao" bytes"

Try it online!

+1 for the no-op space used just to pad the byte count. Too bad CJam doesn't have a predefined variable with the initial value 9.

...although I just realized that the challenge forbids "[u]nnecessary spaces and newlines". But you could still do e.g. " bytes"A\ or A" bytes"+ to comply with the rules as specified.

@IlmariKaronen Ao" bytes" works.

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 :(

Swift 4, 19 18 bytes
Saved 1 byte thanks to Jo King.
print(9*2,"bytes")

Try it online!

Why not 9*2?-

@JoKing What an oversight... Thanks!

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

C#, 68 65 64 bytes
class P{static void Main(){System.Console.Write(8*8+" bytes");}}

Try it online!

Welcome to PPCG! Your program contains the digits 5 and 6 which you are printing, that's not allowed.

Fixed the program and thanks for the review @ØrjanJohansen

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.

You're good as that rule has fallen to the wayside

Ah. Thanks for letting me know.

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.

W d, 7 bytes
♣êæ█☺₧K

Explanation
Unpacked:
7 bytes"

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!

Javascript, 15 bytes
j=>0xf+' bytes'
Seems like the obvious answer.
Alternative:
j=>9+6+' bytes'

Golfscript, 12 bytes
6 6+" bytes"

Try it online!

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

PICO-8, 25 bytes
print(ord("」").." bytes")

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

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

Try it online!

><>, 13 bytes
dn'setyb '>o<

Try it online!

Vyxal ṡ, 5 bytes
4›`¨∞

Try it Online!
Explanation :
4     # push 4
 ›    # increment
  `¨∞ # push "Bytes"
      # flag `ṡ` => join with space
      # implicit output

dc, 14 bytes
7d+n[ bytes]p

Double it

Pyth, 11 bytes
+hT" bytes"

Try it online!

Why do you have h?  Doesn't that just add the eleventh byte that it's there to account for, and it can thus be removed safely?

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

Try it online!

C# (Visual C# Interactive Compiler), 20 bytes
Write(11+9+" bytes")

Try it online!

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.

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.

T-SQL, 32 bytes
print char(51)+char(50)+' bytes'

Best I could come up with.

Javascript,26 bytes
console.log(78/3+" bytes")

Try it online!

Python 2, 18 17 bytes
print 8+9,'bytes'

-1 byte thanks to @Wondercricket.
Try it online.

That trailing space is not in the output, I think it's still precisely what the rule is intended to forbid. However, you can use parentheses around 2*9 instead.

@ØrjanJohansen I changed it to 8+9 instead to save a byte. :)

SOGL V0.12, 8 bytes
┌`m39Σ³‘

Try it Here!

Pari/GP, 18 bytes
print(2*9" bytes")

Try it online!

SmileBASIC, 12 bytes
?3*4;" bytes

(Probably works in a bunch of other BASIC dialects, too)
Alternatives:
?&HC;" bytes
?9+3;" bytes

jamal, 14 characters
{@* 2 7} bytes

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

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 :)

Befunge-98 (FBBI), 12 bytes
"c.4k,@setyb

Try it online!
Thank you Jo King and Mistah Figgins for -3 bytes.

13 bytes

12 bytes

TeX, 16 bytes
^^q^^v bytes\bye

Ruby, 15 bytes
p"#{0xf} bytes"

Try it online!

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.

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:

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

Tcl, 23 bytes
puts [scan  %c]\ bytes

Try it online!

Tcl, 23 bytes
puts [expr 19+4]\ bytes

Try it online!

Ruby, 16 bytes
p "#{9+7} bytes"

Try it online!

k (oK), 16 bytes
Try it online!
($:4*4)," bytes"

String result of 4*4 and concatenate

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.

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

Python (REPL), 16 bytes
'%d bytes'%(8*2)

Output :
16 bytes

You could use f-strings like f'{7*2} bytes'

Or, if you insist on using an older version of Python, you could use raw string r'%d bytes'%14

vim, 12 bytes
a9 bytes<ESC>03<C-A>

<ESC> is 0x1b. <C-A> is 0x01
Try it online!

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

Byte count is calculated from the source code, not the RAM it takes up. So this should be 18 bytes.  But +1 for using an uncommon language; we need more variety around here.

Even with a tokenizing interpreter?

Yes.  If the size of the target language/object code/internal representation mattered, the score would change every time improvements were made to the implementation's optimizer.  And there would be a lot of situations where making the source code larger would make the target code smaller, and vice versa, since optimizers work better when they have a lot of explicit information about what assumptions are safe to make.

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.

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

+1 because it's funny

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!

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

Try It Online!
The unprintable character is the unit separator which value is 31.

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

Deadfish~, 59 bytes
iisioiiiioii{ii}icii{iii}iic{ii}iiicdddddc{d}dddddc{i}iiiic

Try it online!

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.

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

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.

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:

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)

Pxem, 11 bytes.

Filename: .n bytes.p

Escaped: \013.n bytes.p

Content: empty.

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

Nim, 17 bytes
echo 8+9," bytes"

Try it online!

Python 3, 34 bytes
print(f'{chr(51)}{chr(52)} bytes')

Try it online!

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.

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?

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!

Python 3, 22 19 bytes
print(22-3,'bytes')

Try it online!
Thanks to @twentysix for -3 bytes

0b10110 to 22-3 gives 19 bytes: print(22-3,'bytes')

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.

6+6+" bytes" would also work (exactly like my answer in another language)

@LinceAssassino Lol thanks, can't believe I missed something as simple as that.

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"

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.

Lexurgy, 15 bytes
a:
*=>15\ 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.

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.

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'

You mean August 2022

@steffan indeed I do. I'll fix that

The reason the ~3 isn't working is because the C implementation is out of date. You can use my interpreter here: https://knight-lang.netlify.app/ However, it's not quite correct as it outputs 22 bytes although it's 23 bytes. Should be easily fixable.

Also, as you can find out by reading the spec, each function can be shortened to just its first letter. So OUTPUT is just O, but it would work the same if you did OSADKJKA or whatever.

So here's 17 bytes: O++''+9 8' bytes'. Try it online!

Thank's all; I've reduced it to 17 bytes.

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

Oh wait this is 54 bytes in Headass, i'll add it later

RProgN 2, 12 bytes
34*" 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!

uBASIC, 14 bytes
An anonymous ubasic answer.
0?2*7;" bytes"

Try it online!

MY-BASIC, 18 bytes
An anonymous MY-BASIC answer that outputs to STDOUT.
Print 9+9," 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!

Red, 19 bytes
prin[22 - 3 'bytes]

Try it online!

jshell, 12 bytes
9+3+" bytes"

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

For whatever reason, JShell requires TCP sockets to start up. For security reasons, those aren't available in TIO's sandbox.

Neim, 10 bytes
μ( bytes)B

μ represents 10.
Try it online!

Bash, 17 Bytes
echo $[8+9] bytes

output:
17 bytes

Vim, 13 Bytes
i<Ctrl-r>=7+6<Enter> bytes

FALSE, 11 bytes
'\u000B." bytes"

\u000B should be replaced by the corresponding character.

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

Haxe, 20 bytes
trace(4*5+' 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!

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'.

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 " "

V, 13 bytes
a20 bytes<esc>^7<C-x>

<esc> is \x1B and <C-x> is \x18.
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.

Jotlin, 17 bytes
P("${8+9} bytes")

Uses the println builtin

Attache, 18 bytes
Print[!4-6,$bytes]

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

Groovy, 22 bytes
{print"${0x16} bytes"}

Try it online!

AWK, 19 14 bytes
$0=2*7" bytes"

Try it online!

I don't get the point in using the x variable. Why not $0=2*7" bytes" for 14 bytes?

Well obviously it's because I didn't think of it.  :p

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

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

The source code is not allowed to include any of the digits of the byte count. 20*2 contains a zero.

For only two lines, no @echo off to optimize

Thanks l4m2, I have shortened the answer and corrected my mistake.

Save two bytes: @set/ar=33-4.

Swift, 22 bytes
print("\(18+4) 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

Pip, 10 bytes
t." bytes"

Try it online!
Conveniently, there's a preset variable for the number 10.

JavaScript, 20 bytes
alert(5*4+" bytes");

Unnecessary characters, spaces, and newlines are forbidden in the source code

@l4m2 Fixed now.

Clojure, 24 bytes
(println(+ 17 7)"bytes")

Try it online!

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

Lua, 21 bytes
print(3*7 ..' bytes')

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

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

15 bytes

Excel, 13 bytes
=4+9&" bytes"

Using CONCATENATE for 28 bytes:
=CONCATENATE(4*6+4," bytes")

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

Yeah, but now you have no space between the number and the bytes

LOWER, 93 bytes
ₔ₉₃ₔₓ₃₂ₔₓ₉₈ₔₓ₁₂₁ₔₓ₁₁₆ₔₓ₁₀₁ₔₓ₁₁₅

Try it online!
This is all Unicode characters, so no 9s or 3s here.

JavaScript (Node.js), 22 bytes
alert(`${8+14} bytes`)

ok. will do that.

@Cowsquack : There done. Thanks for the info

OK? I see what the point is. It must outputting that on its own. Ok will update that.

Nice, this works fine now :)

@Cowsquack: Thanks you for all the help.

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!

See this and this standard loophole. I do not think that your answer is valid.

@JonathanFrech fixed

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

Nothing crazy here.

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

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.

What is that flag lol

@thejonymyster It doesn't matter what the contents of the flag is, but the code itself is counting the length of the flags (I think).

@Steffan That's correct. Note that Zsh already has the options 569X enabled by default, so by adding BCDEFGHIJ the length of the options reaches 13.

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

Malbolge, 106 bytes
D'`_ML"n<YkFEVwwe@PsON;:ml[kG4ECe#z@x,_^)\[Zvotm3qSi/gfed*hgfH%]baZ_^W{UZSRWVUNrR4PINGLEiIBG@dDCB$@?>=<5YF

Try it online!
Created with zb3 malbolge tools

05AB1E, 15 bytes
30 2/ò" bytes"J

Try it online!

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.

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.

YASEPL, 16 bytes
=a$**^~>" bytes"

ibe, 28 bytes
dheoslresluuslopslotslupslor

J-uby, 28 bytes
I know more succinct solutions are possible but this one amused me.
:join&:succ*[?1,?7," byter"]

Attempt This Online!


text:
Electronic Piggy Bank
A piggy bank is a container used to collect coins in. For this challenge use the four US coins: quarter, dime, nickel, and penny.
Challenge
Your challenge is to create an electronic piggy bank. Write a program (or function) that when run (or called), outputs (or returns) the count of each coin you have, as well as the total amount the coins amount to.
Input
A string, array, etc...(your choice) of the coins into your piggy bank(case insensitive).
 Q - Quarter(Value of 25)
 D - Dime(Value of 10)
 N - Nickel(Value of 5)
 P - Penny(Value of 1)

Output
The count of coins from the input and the total amount, separated by the non-integer delimiter of your choice. (The order in which you output the coin totals does not matter, but the total coin value(sum) must be the last element)
Examples
 Input          ->       Output

 P              ->       1,0,0,0,1 or 0,0,0,1,1 or 0,0,1,0,1 or 1,1
 N              ->       0,1,0,0,5
 D              ->       0,0,1,0,10
 Q              ->       0,0,0,1,25
 QQQQ           ->       0,0,0,4,100
 QNDPQNDPQNDP   ->       3,3,3,3,123
 PPPPPPPPPP     ->       10,0,0,0,10
 PNNDNNQPDNPQND ->       3,6,3,2,113

Rules
Standard loopholes are not allowed.
This is code-golf, so the shortest code in bytes for each language wins!

Can we take input in lowercase?

@Shaggy Yes you can

Can we output a list, rather than a delimited string?

@Mnemonic Of course, a list will be separated by each element.

The order of the coins in the total. May we give it in the order of appearance in the input?

@Adam Yes. I rephrased it, please feel free to edit if you feel you can word it better.

So if the order may be inferred from the input, may we omit 0s? It will still be clear which letters the each number refers to.

@Adám Yes you can omit the 0's

May we choose symbols other than QDNP?

@EriktheOutgolfer No you must use either QDNP or qdnp as the input

Is this output format too far off? 19 byte answer that I'm not sure is valid: Try it online!

@MagicOctopusUrn Not at all! As long as I can determine the count of the each coin plus the total it is fine for me! Awesome answer!

I feel like there should be a [money] tag.

Can the input list be empty (no coins) and if so what should the output be. In particular, may the sum be empty instead of 0 ?

If only part of the challenge were to actually draw an ASCII piggy bank around the output.

@TonHospel the list cannot be empty, so don't worry about that scenario

Python 2, 73 bytes
-3 bytes thanks to @Rod
C=map(input().count,'QDNP')
print C+[sum(map(int.__mul__,C,[25,10,5,1]))]

Try it online!

You can replace a*b for a,b in zip(C,[25,10,5,1]) with map(int.__mul__,C,[25,10,5,1]) to save few bytes

R, 70 69 bytes
function(n)c(x<-table(factor(n,c("P","N","Q","D"))),x%*%c(1,5,25,10))

Try it online!
Takes input as a vector of individual characters. Converts them to factors and tabulates them, then computes the values with a dot product.
For ease of testing purposes, I've added a way to convert from test cases above to the input that the function is expecting.
This barely beats out storing the coin names as vector names, which means that the approach below would be likely be golfier if we had more coin types:
R, 71 70 bytes
function(n)c(x<-table(factor(n,names(v<-c(P=1,N=5,Q=25,D=10)))),x%*%v)

Try it online!

Python 2, 63 bytes
a,b,c,d=map(input().count,'PNDQ')
print a,b,c,d,a+b*5+c*10+d*25

Try it online!

Python 2, 63 bytes
l=map(input().count,'PNDQ')
a,b,c,d=l
print l+[a+b*5+c*10+d*25]

Try it online!

APL (Dyalog Unicode), 28 27 bytes
1 5 10 25(⊢,+.×)'PNDQ'+.=¨⊂

Try it online!
Tacit function. Takes input as a vector in the format ,'<input>'.
Thanks to ngn for one byte!
How?
1 5 10 25(⊢,+.×)'PNDQ'+.=¨⊂ ⍝ Main function, tacit.
                          ⊂ ⍝ Enclose
                         ¨  ⍝ Each character of the input
                      +.=   ⍝ Sum the number of matched characters
                'PNDQ'      ⍝ From this string
1 5 10 25(  +.×)            ⍝ Multiply the values with the left argument, then sum them.
          ⊢,                ⍝ And append to the original vector of coins.

1⊥∘.=∘'PNDQ' -> 'PNDQ'+.=¨⊂

Excel (Polish language version), 150 bytes
The input is in A1. The formulas are in cells B1-F1:
cell  formula
------------------------------
B1    =DŁ(A1)-DŁ(PODSTAW(A1;"Q";""))
C1    =DŁ(A1)-DŁ(PODSTAW(A1;"D";""))
D1    =DŁ(A1)-DŁ(PODSTAW(A1;"N";""))
E1    =DŁ(A1)-DŁ(PODSTAW(A1;"P";""))
F1    =B1*25+C1*10+D1*10+E1

resulting in output of number of quarters, dimes, nickels, pennys and the sum in cells B1, C1, D1, E1 and F1 respectively.
English language version (162 bytes):
cell  formula
------------------------------
B1    =LEN(A1)-LEN(SUBSTITUTE(A1;"Q";""))
C1    =LEN(A1)-LEN(SUBSTITUTE(A1;"D";""))
D1    =LEN(A1)-LEN(SUBSTITUTE(A1;"N";""))
E1    =LEN(A1)-LEN(SUBSTITUTE(A1;"P";""))
F1    =B1*25+C1*10+D1*10+E1

Japt, 25 22 bytes
Saved 3 bytes thanks to @Shaggy
`p˜q`¬£èX
pUí*38#éìH)x
Test it online! Takes input in lowercase
Explanation
`p˜q`¬         Split the compressed string "pndq" into chars, giving ["p", "n", "d", "q"].
      £        Map each char X to
       èX      the number of occurrences of X in the input.
<newline>      Set variable U to the resulting array.
 Uí*           Multiply each item in U by the corresponding item in
    38#é         38233
        ìH       converted to base-32, giving [1, 5, 10, 25].
           x   Take the sum.
p              Append this to the end of U.
               Implicit: output result of last expression

Trying to figure out a way to golf away the comma, not having much luck so far.

Got it!

And save another byte by taking input in lowercase.

Knocked another byte off

@Shaggy Impressive, thanks!

Jelly, 19 bytes
ċÐ€“PNDQ”µæ.“¢¦½ı‘ṭ

Try it online!
How it works
ċÐ€“PNDQ”µæ.“¢¦½ı‘ṭ    Main link. Arguments: s (string)
 Ð€“PNDQ”              For each char in "PNDQ":
ċ                        Count the occurrences of the char in s.
                       Collect the results in an array. Call this a.
         µ             Start a new monadic chain. Argument: a
          æ.           Take the dot product of a with
            “¢¦½ı‘       [1, 5, 10, 25].
                  ṭ    Tack this onto the end of a.

MATL, 22 20 bytes
!'PNDQ'=Xst[l5X25]*s

Try it online! Or verify all test cases.
Explanation with example
Consider input 'PNNDNNQPDNPQND' as an example. The stack contents are shown upside down, i.e. the top element appears below.
!        % Implicit input: string (row vector of chars). Transpose into a
         % column vector of chars
         % STACK: ['P';
                   'N';
                   'N';
                   'D';
                   'N';
                   'N';
                   'Q';
                   'P';
                   'D';
                   'N';
                   'P';
                   'Q';
                   'N';
                   'D']
'PNDQ'   % Push this string (row vector of chars)
         % STACK: ['P';
                   'N';
                   'N';
                   'D';
                   'N';
                   'N';
                   'Q';
                   'P';
                   'D';
                   'N';
                   'P';
                   'Q';
                   'N';
                   'D'],
                  'PNDQ'
=        % Implicit input. Test for equality, element-wise with broadcast
         % STACK: [1 0 0 0;
                   0 1 0 0;
                   0 1 0 0;
                   0 0 1 0;
                   0 1 0 0;
                   0 1 0 0;
                   0 0 0 1;
                   1 0 0 0;
                   0 0 1 0;
                   0 1 0 0;
                   1 0 0 0;
                   0 0 0 1;
                   0 1 0 0;
                   0 0 1 0]
Xs       % Sum of each column
         % STACK: [3 6 3 2]
t        % Duplicate
         % STACK: [3 6 3 2],
                  [3 6 3 2]
[l5X25]  % Push array [1 5 10 25]
         % STACK: [3 6 3 2],
                  [3 6 3 2],
                  [1 5 10 25]
*        % Multiply, element-wise
         % STACK: [3 6 3 2],
                  [3 30 30 50]
s        % Sum
         % STACK: [3 6 3 2],
                  113
         % Implicitly display

!'PNDQ'=Xst[l5X25]!Y* is 21 bytes. although I admit I haven't tested it.

@Giuseppe Thanks, but the challenge says "the non-integer delimiter of your choice", so I assume only one delimiter is allowed

I hadn't noticed that. Ah well.

I think the 21 byte solution is OK... OP commented something to that effect

@Giuseppe Great! Down to 20 bytes then. Thanks for the heads-up

APL+WIN, 33 27 bytes
5 bytes saved thanks to Adam
Prompts for screen input of coin string.
n,+/1 5 10 25×n←+⌿⎕∘.='PNDQ'

Save 5 bytes: n,+/1 5 10 25×n←+⌿⎕∘.='PNDQ'

@ngn Thanks. Old age is getting the better of me :(

JavaScript (ES6), 63 61 bytes
Saved 2 bytes thanks to Shaggy
Takes input as an array of characters. Outputs P,N,D,Q,total.
Inspired by ovs' Python answer.
a=>eval(a.join`++,`+`++,[P,N,D,Q,P+N*5+D*10+Q*25]`,P=N=D=Q=0)

Try it online!

Original answer, 73 bytes
Takes input as an array of characters. Outputs Q,D,N,P,total.
a=>a.map(c=>o[o[4]+='521'[i='QDNP'.search(c)]*5||1,i]++,o=[0,0,0,0,0])&&o

Try it online!

Very nicely done! You can knock 2 bytes off by shuffling some stuff around.

J, 29 bytes
1 5 10 25(],1#.*)1#.'PNDQ'=/]

Try it online!
Explanation:
'PNDQ'=/] creates an equality table
   'PNDQ' =/ 'PNNDNNQPDNPQND'
1 0 0 0 0 0 0 1 0 0 1 0 0 0
0 1 1 0 1 1 0 0 0 1 0 0 1 0
0 0 0 1 0 0 0 0 1 0 0 0 0 1
0 0 0 0 0 0 1 0 0 0 0 1 0 0

1#. finds the sum of each row of the table, thus the number of occurences of each value
   1#. 'PNDQ' =/ 'PNNDNNQPDNPQND'
3 6 3 2

1#.* finds the dot product of its left and right argument
    1 5 10 25(1#.*)3 6 3 2
113

], appends the dot product to the list of values
   1 5 10 25(],1#.*)1#.'PNDQ'=/] 'PNNDNNQPDNPQND'
3 6 3 2 113

05AB1E, 30 26 22 21 19 bytes
X5T25)s.•50†•S¢=*O=

Try it online!

X                   # Push 1.
 5                  # Push 5.
  T                 # Push 10.
   25               # Push 25.
     )s             # Wrap stack to array, swap with input.
       .•50†•       # Push 'pndq'.
             S      # Push ['p','n','d','q'] (split).
              ¢     # Count (vectorized).
               =    # Print counts, without popping.
                *   # Multiply counts by [1,2,10,25]
                 O  # Sum.
                  = # Print.

Dump:
Full program: X5T25)s.•50†•S¢=*O=
current >> X  ||  stack: []
current >> 5  ||  stack: [1]
current >> T  ||  stack: [1, '5']
current >> 2  ||  stack: [1, '5', 10]
current >> )  ||  stack: [1, '5', 10, '25']
current >> s  ||  stack: [[1, '5', 10, '25']]
current >> .  ||  stack: [[1, '5', 10, '25'], 'pnndnnqpdnpq']
current >> S  ||  stack: [[1, '5', 10, '25'], 'pnndnnqpdnpq', 'pndq']
current >> ¢  ||  stack: [[1, '5', 10, '25'], 'pnndnnqpdnpq', ['p', 'n', 'd', 'q']]
current >> =  ||  stack: [[1, '5', 10, '25'], [3, 5, 2, 2]]
[3, 5, 2, 2]
current >> *  ||  stack: [[1, '5', 10, '25'], [3, 5, 2, 2]]
current >> O  ||  stack: [[3, 25, 20, 50]]
current >> =  ||  stack: [98]
98
stack > [98]

Printed Output:
[3, 25, 20, 50]\n98 or [P, N, D, Q]\n<Sum>

Because something was printed, the ending stack is ignored.

C# (.NET Core), 163 136 bytes
Thanks to @raznagul for saving alot of bytes there!
n=>{var m="";int c=0,i=0,k=0;for(var v=new[]{1,5,10,25};i<4;m+=k+",",c+=k*v[i++],k=0)foreach(var x in n)k+=x=="PNDQ"[i]?1:0;return m+c;}

Try it online!

Old version:
n=>{var v=new[]{1,5,10,25};string l="PNDQ",m="";int c=0,i,j,k;for(i=0;i<4;i++){for(j=0,k=0;j<n.Length;j++)k+=n[j]==l[i]?1:0;m+=k+",";c+=k*v[i];k=0;}m+=c;return m;}

Try it online!

I've managed to golf your soultion down to 136 bytes. To many changes to list.

@raznagul Great solution! May I ask why you switched the input to a generic list instead of an array? AFAIK you can iterate over the characters of a string without using a list.

That is a remnant from an earlier version, so I could use n.Count instead of n.Length. As that was dropped entirely you can use string now.

Vyxal, 18 bytes
«∨λð«fvO:»TM»₄τÞ•J

Try it Online!
«∨λð«fvO:»TM»₄τÞ•J
«∨λð«               # Compressed string "pndq"
     f              # Convert to list of characters
      vO            # For each, how many times does it appear in the input?
        :           # Duplicate it
         »TM»       # Compressed integer 21241
             ₄τ     # To base-26 as list: [1, 5, 10, 25]
               Þ•   # Dot product of this and the other list
                 J  # Append this to the list

Java (OpenJDK 8), 148 bytes
c->{int q=0,d=0,n=0,p=0;for(char w:c){if(w=='Q')q++;if(w=='D')d++;if(w=='N')n++;if(w=='P')p++;}return ""+q+","+d+","+n+","+p+","+(q*25+d*10+n*5+p);}

Try it online!
Well it's only one byte shorter than the other Java submission, but hey- shorter is shorter :D
Explanation:
int q=0,d=0,n=0,p=0;    //Initialize too many integers
for(char w:c){    //Loop through each coin
  if(w=='Q')q++;if(w=='D')d++;if(w=='N')n++;if(w=='P')p++;    //Increment the correct coin
}return ""+q+","+d+","+n+","+p+","+(q*25+d*10+n*5+p);    //Return each coin count and the total monetary value

143 bytes

Gol><>, 47 bytes
5R0TiE!vD;
5+@P@@t>b%m$.
a+$P$t
PrPrt
9s+r$P$rt

Try it online!
The output format is [P Q N D Value].
How it works
5R0TiE!vD;
       >b%m$.

5R0            Repeat command '0' (push 0) 5 times
   T           Set teleport location for later
    i          Input a char
     E         Pop if the last input was EOF; skip next otherwise

               If the last is EOF, the following is run:
      ! D;     Skip 'v', print the contents of the stack from bottom to top, then exit

               Otherwise the following is run:
       v
       >b%m$.  Take the top (input) modulo 11, and jump to (-1, input % 11)
               P%11 = 3, N%11 = 1, D%11 = 2, Q%11 = 4

5+@P@@t        Runs if the input is N
5+             Add 5 to top
  @            Rotate top 3 (the 3rd comes to the top)
   P           Increment the top
  @P@@         Increment the 3rd from top
      t        Teleport to the last 'T'

a+$P$t         Runs if the input is D
a+             Add 10 to top
  $            Swap top two
  $P$          Increment the 2nd from top
     t         Teleport to the last 'T'

PrPrt          Runs if the input is P
P              Increment the top
 r             Reverse the stack
 rPr           Increment the bottom
    t          Teleport to the last 'T'

9s+r$P$rt      Runs if the input is Q
9s+            Add 25 to the top ('s': add 16 to the top)
   r$P$r       Increment the 2nd from bottom
        t      Teleport to the last 'T'

Perl 5 -p, 47 bytes
#!/usr/bin/perl -p
P1N5D10Q25=~s:\D:$\-=-$'*($n=s/$&//g);say$n:egr

Try it online!

Pyth, 23 27 26 bytes
+Jm/Qd"PNDQ"s.b*NYJ[h05T25

Saved a byte thanks to @RK. Outputs as [P, N, D, Q, value].
Try it here
Explanation
+Jm/Qd"PNDQ"s.b*NYJ[h05T25
 Jm/Qd"PNDQ"                Save the count of each coin (in PNDQ order) as J.
                   [h05T25  [1, 5, 10, 25].
             .b   J       For each pair of count and value...
               *NY          ... take the product...
            s               ... and get the sum.
+                          Stick that onto the list of counts.

You can condense the definition of J and the first usage of J to get +Jm/Qd"PNDQ"s.b*NYJ[h05T25

Perl 5 -pF, 59 bytes
for$i(P,N,D,Q){say s:$i:$\+={P,1,Q,25,D,10,N,5}->{$&}:eg}}{

Try it online!

Ruby, 66 bytes
->s{t=0;{P:1,N:5,D:10,Q:25}.map{|c,v|t+=v*m=s.count(c.to_s);m}<<t}

Try it online!
Not great.

05AB1E, 19 bytes
"PNDQ"S¢D•Ωт•₂в*O)˜

Try it online!
Explanation
"PNDQ"                # push this string
      S               # split to list of chars
       ¢              # count the occurrences of each in input
        D             # duplicate
         •Ωт•         # push 21241
             ₂в       # convert to a list of base 26 digits
               *      # element-wise multiplication
                O     # sum
                 )˜   # wrap in a flattened list

C (clang), 112 bytes
f(char *i){int c,d,v[5]={0};for(;c=*i++;v[d=(c|c/2)&3]++,v[4]+="AYJE"[d]-64);for(c=0;c<5;printf("%d,",v[c++]));}

Try it online!
Output seq is now of P,Q,D,N,total-value
Works with both lower-case and upper-case inputs.
Explanation:
"AYJE" or {64+1,64+25,64+10,64+5} is. 64+value-of-coin.
d=(c|c/2)&3 (used as index) has value 1,2,3,0 for q,d,n,p inputs respectively, in both upper and lower case.

106 bytes

Eliminating c=0 was good catch. Thanks.

Kustom, 146 bytes (sort of)
It's hard to find challenges where this language works lol
$tc(count,gv(i),P)$
$tc(count,gv(i),N)$
$tc(count,gv(i),D)$
$tc(count,gv(i),Q)$
$gv(P)$,$gv(N)$,$gv(D)$,$gv(Q)$,$gv(P)+gv(N)*5+gv(D)*10+gv(Q)*25$

This is technically not one script, instead each line except the last is a global value, counting one byte extra for the name of each global ("i", "P", "N", "D", and "Q").

SmileBASIC, 70 bytes
INPUT C$P=N+D+Q
WHILE""<C$INC VAR(POP(C$))WEND?P,N,D,Q,P+N*5+D*10+Q*25

Example:
? PNDNDNDQP
2   3   3   1   72

Explanation:
INPUT COINS$
P=N+D+Q 'create variables
WHILE COINS$>"" 'loop until the coin list is empty
 'pop a character from the coin list
 'and increment the variable with that name
 INC VAR(POP(COINS$))
WEND
PRINT P,N,D,Q,P+N*5+D*10+Q*25

C, 149 bytes
f(char*s){int a[81]={},b[]={1,5,10,25},c=0;char*t,*v="PNDQ";for(t=s;*t;a[*t++]++);for(t=v;*t;printf("%d,",a[*t++]))c+=a[*t]*b[t-v];printf("%d\n",c);}

Try it online!
C doesn't have associative arrays, so I fake it (very inefficiently, memory-wise!) and then loop through again with a lookup array to add up the coins. It won't calculate foreign currency, though :-)

133 bytes

C# (.NET Core), 156 bytes
s=>{Func<char,int>f=i=>{return s.Split(i).Length-1;};var a=new[]{f('P'),f('N'),f('D'),f('Q')};return$"{string.Join(",",a)},{a[0]+a[1]*5+a[2]*10+a[3]*25}";};

Java (OpenJDK 8), 149 bytes
a->{int[]c={0,0,0,0,0};for(String g:a){if(g=="P")c[0]+=1;if(g=="N")c[1]+=5;if(g=="D")c[2]+=10;if(g=="Q")c[3]+=25;}c[4]=c[0]+c[1]+c[2]+c[3];return c;}

Try it online!

144 bytes

Retina, 50 bytes
P
P_
N
N5*
D
D10*
Q
Q25*
^
PNDQ_
O`.
(.)(\1*)
$.2¶

Try it online! Outputs in the order D, N, P, Q, total. Explanation:
P
P_
N
N5*
D
D10*
Q
Q25*

Calculate the total by inserting _s corresponding to the value of each coin.
^
PNDQ_

Insert an extra copy of each character so there is at least one of each to match.
O`.

Sort the characters into order.
(.)(\1*)
$.2¶

Count the number of each character after the first.

Julia, 45 bytes
!s=(t=count.(["DNPQ"...],s);[t;[10 5 1 25]t])
Attempt This Online!

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Egg hunting in Collatz style
Inspired by The Great API Easter Egg Hunt!
Summary
Your task is to search for a predetermined integer in the "Collatz space" (to be explained later) using the fewest step possible.
Introduction
This challenge is based on the famous Collatz conjecture that hopefully everyone here at least heard of. Here is a recap taken from Print the Super Collatz numbers.

The Collatz
Sequence (also
called the 3x + 1 problem) is where you start with any positive
integer, for this example we will use 10, and apply this set of steps
to it:
if n is even:
    Divide it by 2
if n is odd:
    Multiply it by 3 and add 1
repeat until n = 1

The Collatz distance C(m,n) between the two numbers m and n, for the purpose of this challenge, is the distance between two numbers in the Collatz graph(Credits to @tsh for telling me about this concept), which is defined as follows: (using 21 and 13 as examples):
Write down the Collatz sequence for m (in this case, 21):
21, 64, 32, 16, 8, 4, 2, 1

Write down the Collatz sequence for n(in this case, 13):
13, 40, 20, 10, 5, 16, 8, 4, 2, 1

Now count how many numbers appear only in one of the sequences. This is defined as the Collatz distance between m and n. In this case, 8, namely,
21, 64, 32, 13, 40, 20, 10, 5

So we have Collatz distance between 21 and 13 as C(21,13)=8.
C(m,n) have the following nice properties:
C(m,n)=C(n,m)
C(m,n)=0 iff. m=n

Hopefully the definition of C(m,n) is now clear. Let's start doing egg hunting in the Collatz space!
At the beginning of the game, a controller decides the position of an easter egg, which is expressed by its one-dimensional coordinate: An integer in the interval [p,q] (in other words, an integer between p and q, both ends inclusive).
The position of the egg remains constant throughout the game. We'll denote this coordinate as r.
You can now make an initial guess a0, and it will be recorded by the controller. This is your 0th round. If you are so lucky that you got it right at the first place (i.e. a0=r), the game ends, and your score is 0(The lower the score, the better). Otherwise, you enter the 1st round and you make a new guess a1, this goes on until you got it right, i.e. an=r, and your score will be n.
For each round after the 0th, the controller gives you one of the following feedbacks so that you can make a better guess based on the information given. Lets assume you are currently at the nth round and hence your guess is an

"You found it!" if an=r, in which case the game ends and you score n.
"You are closer :)" if C(an,r)<C(an-1,r)
"You are circling around the egg" if C(an,r)=C(an-1,r)
"You are farther away :(" if C(an,r)>C(an-1,r)

To save some bytes, I will call the responses as "Right", "Closer", "Same", "Farther", in the order presented above.
Here is an example game with p=1,q=15.

a0=10
a1=11, response: "Closer"
a2=13, response: "Farther"
a3=4, response: "Farther"
a4=3, response: "Closer"
a5=5, response: "Same"
a6=7, response: "Right"

Score: 6.
Challenge
Design a deterministic strategy to play the game for p=51, q=562 with the best score.
Answers should describe the algorithms in detail. You can attach any code that helps to elucidate the algorithm. This is not codegolf so you are encouraged to write legible code.
Answers should include the worst score they may achieve for all possible cases of r, and the one with lowest worst score wins. In the case of tie, the algorithms that has a better average score for all possible rs (which should also be included in the answers) win. There are no further tie breakers and we may have multiple winners in the end.
Specs

To reiterate, r lies in the interval [51,562].
Default loopholes apply.

Bounty (Added after the first answer is posted)
I may personally offer a bounty to an answer where all the guesses are made within the range [51,562] while still having a reasonably low worst score.

Do you have a controller?

Not one that is like the one in the original question.

C(m, n) is the distance of m, n on the Collatz graph.

I came up with the concept myself and didn't know Collatz graph. Thank you for telling me that. I will include the information in the question.

Ruby, 196
This was way harder that I initially thought. I had to handle a lot of obscure cases and ended up with a lot of ugly code. But is was a lot of fun! :)
Strategy
Every Collatz Sequence ends up with a sequence of powers of 2 (ex: [16, 8, 4, 2, 1]). As soon as a power of 2 is encountered, we divide by 2 until we reach 1. Let's call the first power of 2 in a sequence closest pow2 (as this is also the closest power of 2 to our number using Collatz Distance). For the given range (51-562), all the possible closest pow2 numbers are: [16, 64, 128, 256, 512, 1024]
Short version
The algorithm performs:

a binary search to figure out the closest power of 2 to the current number
a linear search to figure out every previous element in the sequence until the target number is discovered.

Detailed version
Given a game with the target number r, the strategy is the following:

Use binary search to figure out the power of 2 that is closest to r in as few steps as possible.
If the closest power of 2 that was found is the solution, stop. Otherwise continue to 3.
Since the power of 2 that was found is the first power of 2 occurring in the sequence, if follows that that value was reached by doing a (* 3 + 1) operation. (If it came after a /2 operation, then the previous number would also have been a power of 2). Compute the previous number in the sequence by doing the reverse operation (-1 and then /3)
If that number is the target, stop. Otherwise continue to 5.
Given the current number known from the sequence, it is needed to go back and discover the previous number in the sequence. It is not known whether the current number was arrived at by a (/2) or (*3 +1) operation, so the algorithm tries them both and sees which one yields a number that is closer (as Collatz Distance) from the target.
If the newly discovered number is the right one, stop.
Using the newly discovered number, go back to step 5.

The results
Running the algorithm for all the numbers in the 51-562 range takes around a second on a normal PC and the total score is 38665.
The code
Try it online!
require 'set'

# Utility methods
def collatz(n)
  [].tap do |results|
    crt = n
    while true
      results << crt
      break if crt == 1
      crt = crt.even? ? crt / 2 : crt * 3 + 1
    end
  end
end

def collatz_dist(m, n)
  cm = collatz(m).reverse
  cn = collatz(n).reverse
  common_length = cm.zip(cn).count{ |x, y| x == y }
  cm.size + cn.size - common_length * 2
end

GuessResult = Struct.new :response, :score
# Class that can "play" a game, responding
# :right, :closer, :farther or :same when
# presented with a guess
class Game

  def initialize(target_value)
    @r = target_value
    @score = -1
    @dist = nil
    @won = false
  end
  attr_reader :score

  def guess(n)
    # just a logging decorator over the real method
    result = internal_guess(n)
    p [n, result] if LOGGING
    result
  end

  private

  def internal_guess(n)
    raise 'Game already won!' if @won
    @score += 1
    dist = collatz_dist(n, @r)
    if n == @r
      @won = true
      return GuessResult.new(:right, @score)
    end
    response = nil
    if @dist
      response = [:same, :closer, :farther][@dist <=> dist]
    end
    @dist = dist
    GuessResult.new(response)
  end

end

# Main solver code

def solve(game)
  pow2, won = find_closest_power_of_2(game)
  puts "Closest pow2: #{pow2}" if LOGGING

  return pow2 if won
  # Since this is the first power of 2 in the series, it follows that
  # this element must have been arrived at by doing *3+1...
  prev = (pow2 - 1) / 3
  guess = game.guess(prev)
  return prev if guess.response == :right

  solve_backward(game, prev, 300)
end

def solve_backward(game, n, left)
  return 0 if left == 0
  puts "***      Arrived at  ** #{n} **" if LOGGING
  # try to see whether this point was reached by dividing by 2
  double = n * 2
  guess = game.guess(double)
  return double if guess.response == :right

  if guess.response == :farther && (n - 1) % 3 == 0
    # try to see whether this point was reached by *3+1
    third = (n-1) / 3
    guess = game.guess(third)
    return third if guess.response == :right
    if guess.response == :closer
      return solve_backward(game, third, left-1)
    else
      game.guess(n) # reset to n...
    end
  end
  return solve_backward(game, double, left-1)
end

# Every Collatz Sequence ends with a sequence of powers of 2.
# Let's call the first occurring power of 2 in such a sequence
# POW2
#
# Let's iterate through the whole range and find the POW2_CANDIDATES
#
RANGE = [*51..562]
POWERS = Set.new([*0..15].map{ |n| 2 ** n })

POW2_CANDIDATES =
  RANGE.map{ |n| collatz(n).find{ |x| POWERS.include? x} }.uniq.sort
# Turns out that the candidates are [16, 64, 128, 256, 512, 1024]

def find_closest_power_of_2(game)
  min = old_guess = 0
  max = new_guess = POW2_CANDIDATES.size - 1
  guess = game.guess(POW2_CANDIDATES[old_guess])
  return POW2_CANDIDATES[old_guess], true if guess.response == :right
  guess = game.guess(POW2_CANDIDATES[new_guess])
  return POW2_CANDIDATES[new_guess], true if guess.response == :right
  pow2 = nil

  while pow2.nil?

    avg = (old_guess + new_guess) / 2.0

    case guess.response
    when :same
      # at equal distance from the two ends
      pow2 = POW2_CANDIDATES[avg.floor]
      # still need to test if this is correct
      guess = game.guess(pow2)
      return pow2, guess.response == :right
    when :closer
      if old_guess < new_guess
        min = avg.ceil
      else
        max = avg.floor
      end
    when :farther
      if old_guess < new_guess
        max = avg.floor
      else
        min = avg.ceil
      end
    end

    old_guess = new_guess
    new_guess = (min + max) / 2
    new_guess = new_guess + 1 if new_guess == old_guess
    # so we get next result relative to the closer one
    # game.guess(POW2_CANDIDATES[old_guess]) if guess.response == :farther
    guess = game.guess(POW2_CANDIDATES[new_guess])

    if guess.response == :right
      pow2 = POW2_CANDIDATES[new_guess]
      break
    end

    if min == max
      pow2 = POW2_CANDIDATES[min]
      break
    end

  end

  [pow2, guess.response == :right]

end

LOGGING = false

total_score = 0
51.upto(562) do |n|
  game = Game.new(n)
  result = solve(game)
  raise "Incorrect result for #{n} !!!" unless result == n
  total_score += game.score
end
puts "Total score: #{total_score}"

Impressive. There is a minor point: I believe one of the comments should not say "perfect square".

@WeijunZhou You are right. Fixed!

You should probably include the worst score for all cases, which is 196.

worst score: 11, sum score: 3986
All the guesses are in range [51,562].
My algorithm:

First time guess 512, and maintain a set of possible results vals, initially the set contains all numbers in range [51,562].
At each step, do the following:

Find the value of next guess guess in range [51,562] such that, when the values in vals (excluding guess itself) is partitioned into 3 sets corresponding to the possible outcomes Closer, Same, and Farther, the maximum size of those 3 sets is minimum.
If there are multiple possible values of guess satisfy the above, choose the smallest.
Guess the value guess.
If the answer is "Right", done (exit the program).
Remove all values in the set vals such that they cannot possibly give that result.

My reference implementation written in C++ and Bash runs in about 7.6 seconds on my machine and give the worst score/sum score as described in the title.
Trying all possible first guess values will take about 1.5 hours on my machine. I may consider doing that.

(P/S: Non-code submissions are allowed. If you don't trust my score, just implement it yourself and see)

But if you really want to see it working without reimplementing it for some reasons, Try it online!

Wait a minute why can't I just let my program to output a decision tree and score it :| it would be much faster ...

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Make Arrays/Lists start at one
Introduction
For as long as programmers have been programming and as long as English teachers have been teaching, there's a controversy over the datasets called Arrays and Lists (or hashes).
Arrays have almost always had their first index at 0. Which, for the programmer, is understandable because of math. But along the way, as more and more languages have appeared, and more and more people start to program, they can't wrap their mind around the array.
They know it's a table of indexes with values assigned to each index, but they don't know why it starts at 0, because 0 typically means nothing. 0 is a quantitative value that we don't see (or can, but mostly in context).
Task
It's simple: Make your arrays/list/hashes/whatever start at one
This doesn't require special tinkering to the compiler/interpreter. Make a user's array have their expected values at position 1.
Loopholes aren't allowed.
Examples
A basic example (written in Pseudo):
list = [1,2,3]
lis = [null]
value = 1
Loop list Through 3 Times as Index_Value
    lis[value] = Index_Value
    value += 1
print(lis) // or return lis, doesn't matter

Rules

No standard loopholes allowed
Languages that have arrays/lists/hashes that start at one OR are configurable to have settable index numbers.
Input will be given, you may expect a array. However, if the array requires certain types, assume the array is filled with integers. Basically, test for [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] (I do encourage any answers that aren't for competition)
Output must be the fixed array. If the fixed array is assigned to value a, then a[1] == 1
Anything can be in the a[0] index, the user will not care. Though, preferably, BUT NOT REQUIRED, the value should be null or some other comparable value.

This is code-golf, so the shortest answer in bytes wins.

So... a function that takes an array and prepends 0/null?

There seems to be some "close-as-unclear-without-comment" recently. Anyway -- 1 "Languages that have arrays/lists/hashes that start at one OR are configurable to have settable index numbers." What do you want to say? That's a noun, not a sentence. 2 Assuming language features is obviously unclear. Not every programming languages have array or index.

I can't see anything in the question which would rule out a 0-byte answer in any language which has arrays.

Haskell, 4 bytes
(0:)

Try it online!
Just prepends 0.
data List a = Cons a (List a) | Emp
    deriving (Eq)

instance Show a => Show (List a) where
    show Emp            = "[]"
    show (Cons x Emp)   = "[" ++ show x ++ "]"
    show (Cons x xs)    = "[" ++ show x ++ ", " ++ tail (show xs)

len              :: Integral b => List a -> b
len Emp           = 0
len (Cons x xs)   = succ $ len xs

pre              :: a -> List a -> List a
pre               = Cons

app              :: a -> List a -> List a
app x Emp         = pre x Emp
app x (Cons y ys) = pre y $ app x ys

(!)              :: Integral b => List a -> b -> a
Emp ! i           = error "index too large"
(Cons x xs) ! 1   = x
(Cons x xs) ! i   = xs ! (pred i)

Try it online!

C Macro, 17 bytes
#define F(t)(t-1)

Inform 7, 97 bytes
This challenge seems like one that Inform 7 could actually accomplish, despite its enormous verbosity!
To decide what list of numbers is f (L - a list of numbers): add 0 at entry 1 in L; decide on L.

Prepends a zero.

Java (OpenJDK 8), 67 bytes
a->{int c[]=new int[a.length+1],i=1;for(int u:a)c[i++]=u;return c;}

Try it online!
This was a fun little challenge in Java since Java arrays are static in size, but it seems like this is significantly less challenging in every language that can just slap a zero on for the first- excuse me, zeroth element
Explanation:
int i=1,c[]=new int[a.length+i];    ////Initialize counter and declare new array with length: 1 + input array length
for(int u:a)    //Loop through each element in input array
  c[i++]=u;    //Increment counter after shifting each element up one spot in the output array
return c;    //return new array starting at index 1

Credit:
-3 bytes thanks to Kevin Cruijssen!

-3 bytes by combining int and int[]: a->{int c[]=new int[a.length+1],i=1;for(int u:a)c[i++]=u;return c;}

Too bad System.arraycopy is so verbose.. Try it online, 74 bytes.

Python 3, 14 bytes
lambda s:[0]+s

Puts a zero at the start of the list. None would be a better null value but it's three bytes longer.

JavaScript, 10 bytes
a=>[,...a]

a[0] is a hole after fix

And any holes in the input are filled with undefined :P

Perl 5 -p, 6 bytes
#!/usr/bin/perl -p
s//0 /

Try it online!
Prepends 0
The controversy mostly exist because people confuse counting and naming :-)