[Question]
  [
**Challenge:**
The concept is simple enough: write a full program to output its own code golf score!
Output should only be the byte count of your program and a trailing  `bytes`.
**BUT WAIT**..... there is one restriction:
* Your source code can not include any of the digits from your byte count
* So if your score is `186 bytes`, your program can not contain the characters `1` , `6` , or `8`
**Example Output:** 
```
315 bytes
27 Bytes
49 BYTES
```
**Additional Rules:**
* Unnecessary characters, spaces, and newlines are forbidden in the source code, however trailing spaces and newlines are perfectly acceptable in output
* There should be a single space between the number and `bytes` in the output
* Letters are case insensitive
* No self inspection or reading the source code
* [standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are disallowed
* this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so
**Shortest code in bytes wins!**
  
[Answer]
# JavaScript, 19 bytes
Octal was invented to serve two purposes:
* setting file permissions in Linux
* answering this challenge
```
alert(023+' bytes')
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z@Yk1pUomCrkJyfV5yfk6qXk58OEdMwMDLWVldIqixJLVbX/P8fAA "JavaScript (Node.js) – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/), 16 bytes
There are many other ways to get `16` but this one is mine
```
say afpbytes^PPP
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVIhMa0gqbIktTguICDg//9/@QUlmfl5xf91fU31DA30DAE "Perl 5 – Try It Online")
[Answer]
# [7](https://esolangs.org/wiki/7), 23 characters, 9 bytes
```
54340045141332401057403
```
[Try it online!](https://tio.run/##BcEBEQAwDAIxSzCeq39lLLmtBIkaJw9ZPZTtAw "7 – 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:
```
5434004514133240105**7**403
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.)
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 8 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
８ bytes＋
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXVGRjE4JTIwYnl0ZXMldUZGMEI_,v=1)
A more interesting 20 byte solution:
```
bytecount.innerText＃
```
[Try it here!](https://dzaima.github.io/Canvas/?u=Ynl0ZWNvdW50LmlubmVyVGV4dCV1RkYwMw__,v=1)
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 53 BYTES
```
+[[<+>->->++>----<<<]>-]>-.--.<<<+.<.<.-----.>+++.<-.
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fOzraRttOFwi1gRQQ2NjYxNrpApGerq4ekKOtZwOEIBldPaAaIFdX7/9/AA "brainfuck – Try It Online")
Another submission with capitalised `bytes`. Found with the help of the excellent [BF-crunch](https://github.com/primo-ppcg/BF-Crunch) helper by primo.
[Answer]
# PHP, 14 bytes
```
<?=7*2?> bytes
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 5 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
╗↑╞ô╝
```
[Run and debug it](https://staxlang.xyz/#p=bb18c693bc&i=&a=1)
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.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~25~~ ~~24~~ 18 bytes
```
print(6*3,'bytes')
```
[Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69Ew0zLWEc9qbIktVhd8/9/AA "Python 3 – Try It Online")
[Answer]
# [PHP older than 7.2](https://secure.php.net/), 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!](https://tio.run/##S0oszvj/PymxONXMREE3RcHGxkYhwMXCMq3Y3NfY1Mg907TQ17/c1lahRqEgo@D/fwA "Bash – Try It Online")
[Answer]
# [Keg](https://esolangs.org/wiki/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!](https://tio.run/##y05N//@fLamyJLX4/38A)
[Answer]
# [Pyramid Scheme](https://github.com/ConorOBrien-Foxx/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!](https://tio.run/##jY7RCsIwDEXf8xV5FkropEX/JRRkDraHoUx98Otr07VVcIFdCD25TXN7fy@XebqaRz8O8xAjikKpTYZMBpGQUWGZEYturydrnIbyaURBY0g7VzM/1RiwElI/LqxxCpX9gjVrm@V3B94XHb4NkvfYEq31P@wY6MRrd@zKknRrO9vYn4sPqci5NpX1x1Ahxg8 "Pyramid Scheme – Try It Online")
Outputs `440 BytEs` by multiplying 8 by 55.
[Answer]
# [R](https://www.r-project.org/), 16 bytes
```
cat(4*4,"bytes")
```
[Try it online!](https://tio.run/##K/r/PzmxRMNEy0RHKamyJLVYSfP/fwA "R – Try It Online")
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), ~~14~~ 11 bytes
```
[ bytes]Bnn
```
[Try it online!](https://tio.run/##S0n@/z9aIamyJLU41ikv7/9/AA "dc – Try It Online")
-3 bytes by `@Cows quack`
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 6 bytes
```
₂¤“ÿ¡Ï
```
[Try it online!](https://tio.run/##MzBNTDJM/f//UVPToSWPGuYc3n9o4eH@//8B "05AB1E – 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·`
[Answer]
# 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!](https://tio.run/##S0oszvj/PzU5I18hoTxZQTfZRsUgQSGpsiS1@P9/AA "Bash – Try It Online")
[Answer]
# PHP + HTML, 16 bytes
```
&#49;&#54; 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):
```
&#49;&#54; bytes
```
[Answer]
# [Whitespace](https://web.archive.org/web/20150618184706/http://compsoc.dur.ac.uk/whitespace/tutorial.php), 112 bytes
Just because nobody's done it yet:
```
   			    
	
 	   
   	 	  		
   	   	 	
   	 	 	  
   	 		  	
   	    	 
   	     
  
	
   
 
	  
 
   
```
[Try it online!](https://tio.run/##PYzBCcAwDAPf0hRarZRA8ysk0PFdyyHxQ5zE4e/ps433uluEJACZIigDPZmAhVX3iiPY2ELGQZHrmU2iOlk1L@IH "Whitespace – 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
```
[Answer]
# [Brain-Flak](https://github.com/Flakheads/BrainHack), ~~100 BYTES~~ 80 bYTES
```
((((((()()()))[]{})))((({}){})(((({}){}))<([]([](([][][])([{}]()({{}}))))[])>)))
```
[Try it online!](https://tio.run/##SypKzMzLSEzO/v9fAwI0QVBTMzq2uhZIAQWANBBpwFmaNhrRsSAExCCoqRFdXRsL1FVdXQvSAtSqaQek/v//r@sIAA "Brain-Flak (BrainHack) – 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`).
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 22 bytes
```
disp([50 50 ' bytes'])
```
[Try it online!](https://tio.run/##y08uSSxL/f8/JbO4QCPa1EABiNQVkipLUovVYzX//wcA "Octave – Try It Online")
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 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!](https://tio.run/##K0otycxLNPz/n0shqbIktZhLy648QU9P@/9/AA "Retina – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 26 bytes
```
main=putStr$"\50\54 bytes"
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/PzcxM8@2oLQkuKRIRSnG1CDG1EQhqbIktVjp/38A "Haskell – Try It Online")
---
### 29 bytes
```
main=putStr$pred<$>"3:!czuft"
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/PzcxM8@2oLQkuKRIpaAoNcVGxU7J2Eoxuao0rUTp/38A "Haskell – Try It Online")
[Answer]
# Applescript, 15 bytes
Yes, I’m going there.
```
9+6&”bytes”
```
[Answer]
# [Poetic](https://mcaweb.matc.edu/winslojr/vicom128/final/tio/index.html), 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!](https://mcaweb.matc.edu/winslojr/vicom128/final/tio/index.html?LY9BbsMwDATvfsWeeorzhx77DFqiaiISZYhUAr8@kdxeSJC7mMWm2uA74/v@c4ed5lwgiBJvY3kTjvCKoztEsfdCaovgofU1dCqoyqhpIKrxcn28naK/f144m88rjZhwbtxWVtryoD6leaeMrZEMJk3LerSaxBFqOUhPNHqwzeBCZvJk5ErRZl4g28GxB7rwos5N7bZ8zTI6WYHXxByn6vuYNntQzlfbfz@6umS8GExNQaP3kWuh93uj@AE)
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!
[Answer]
# [MATL](https://github.com/lmendo/MATL), 13 bytes
```
'57$f}xiw'4-c
```
[Try it online!](https://tio.run/##y00syfn/X93UXCWttiKzXN1EN/n/fwA "MATL – Try It Online")
This pushes the string '57$f}xiw' and subtracts `4`, to get `13 bytes`. This is converted to characters using `c`.
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 23 bytes
```
printf('%i bytes',9+14)
```
[Try it online!](https://tio.run/##y08uSSxL/f@/oCgzryRNQ101UyGpsiS1WF3HUtvQRPP/fwA "Octave – Try It Online")
And this:
```
disp(['','67$f}xiw'-4])
```
[Try it online!](https://tio.run/##y08uSSxL/f8/JbO4QCNaXV1H3cxcJa22IrNcXdckVvP/fwA "Octave – Try It Online")
[Answer]
# 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.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 12 bytes
Full program which implicitly prints to STDOUT.
```
'bytes',⍨3×4
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKM97b96UmVJarG6zqPeFcaHp5uABP@nAQA "APL (Dyalog Unicode) – 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.
[Answer]
# 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](https://tio.run/##S9ZNT07@/z83MTNPQ7O6oCgzryRNQ0k1RSGpsiS1WEnHwMRA07qW6/9/AA).
Thanks to [NieDzejkob](https://codegolf.stackexchange.com/users/55934/niedzejkob) for golfing 1 byte.
Alternative with the same bytecount, thanks to [ErikF](https://codegolf.stackexchange.com/users/79060/erikf):
```
main(){printf("%d bytes",' ');}
```
Try it online [here](https://tio.run/##S9ZNT07@/z83MTNPQ7O6oCgzryRNQ0k1RSGpsiS1WElHXUFd07qW6/9/AA).
[Answer]
# 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](https://codegolf.meta.stackexchange.com/questions/4780/should-submissions-be-allowed-to-exit-with-an-error/4781#4781) (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](https://codegolf.stackexchange.com/a/140181/52210)).
# Java 8+, 74 bytes (full program)
```
interface M{static void main(String[]a){System.out.print(0112+" bytes");}}
```
[Try it online.](https://tio.run/##y0osS9TNSsn@/z8zryS1KC0xOVXBt7q4JLEkM1mhLD8zRSE3MTNPI7ikKDMvPTo2UbM6uLK4JDVXL7@0RK8AKFiiYWBoaKStpJBUWZJarKRpXVv7/z8A)
# Java 8+, ~~16~~ 15 bytes (lambda function)
```
v->0xF+" bytes"
```
-1 byte thanks to *@OliverGégoire*.
[Try it online.](https://tio.run/##LY0xC4MwEIX3/oqHU6Qo3aUdu9VF6FI6nDEtsTGKOUOl@NvTiMLdcO8@3teSp6xtPkEacg430vZ3ALRlNb5IKpTrCVQ8avuGFPdeN/BpEdMlbhzHxFqihMUZwWeX0/d6TFDPrFwSig0aptpEaGf9WtJFl9h6H09Quotmx6rL@4nzIb5Y2FwKOxmT7s4l/AE)
[Answer]
# [FerNANDo](http://esolangs.org/wiki/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!](https://tio.run/##S0stykvMS8n//99YwZjLkMtIwYjLQMFQAcgDkkAeUBTGNwLSBnB5AwUDMN8QyIeoBokAaS5DEP7/HwA "FerNANDo – Try It Online")
]