Create a program that prints the number of characters it has, in words

Question

Create a program which prints the amount of characters its source has in English words.

If your program is nine letters long it should print "nine".

Capitalization is ignored: in case you're printing "one" (somehow) you can print "one", "oNe", "ONE" or anything else.

Base ten is required.

Proper spacing is also required.

In the (unlikely but just for specification) case your program reaches one billion characters or more, use the American number scale. A billion here is 10^9 and a million is 10^6.

Do not use "one hundred and one": use "one hundred one".

Do not use the hyphen. Print forty four, not forty-four.

Test cases with a fake program:

10.(96 0s later)..01 prints one HuNdreD ONE -- okay: proper spacing, no "and"
10.(96 0s later)..01 prints one HuNdreDONE -- not okay: wrong spacing
10.(96 0s later)..01 prints one thousand two hundred two -- not okay: base 3 rather than base 10
10...(999999996 0s later) prints nine hundred ninety-nine million nine hundred ninety-nine thousand nine hundred ninety-six: not okay, wrong number and includes hyphens

Golfy challenge, as always: shortest code wins. You're free to post after the green tick has been given, though. This serves more for completeness for hard to program languages. Malbolge, anyone?

Answer 1

Poetic, 400 bytes

Type fourhundred chars? I say, I think I have an angle.
I say "Gosh, could I just go create some poem? Clearly it comes a long way, writing stuff I say."
I compose the entire written poem, and someone reads a tiny, tiny portion.
"Surely, it all is garbage," cried a big fat crybaby.
Would HE frankly notice how many long, tedious hours I took?
The crybaby whined a lot. I watched, then I ignored him.

Try it online!

Prints Four HunDrED. (I tried to make it print some number in the 300s, but I can't seem to do so in under 400 bytes.)

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

Answer 2

Google Translate (3 bytes)

一

Try it online!

It's the Chinese character for "one" (matching the number of characters in the source code), though the score's due to the character itself being 3 bytes.

---

Google Translate (3 bytes)

tre

Try it online!

It's Italian for "three".

Answer 3

brainfuck, 40 bytes

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

Try it online!

The last three characters don't actually do anything useful, but it's easier to output forty than thirty seven.

The ascii code for f is 102, which is 2/5 of 255, found by the initial loop. After that, all the characters in the output just happen to be in ascending alphabetical order.

Answer 4

MathGolf, 2 bytes

Well, MathGolf has a string compression library that seems to compress "two" to 1 byte. You need a command to decompress this.

╩_

Try it online!

Answer 5

Python 3, 15 bytes

exit("fifteen")

...prints to STDERR.

Try it online! (see the "debug" panel)

Answer 6

COW, 800 bytes

MoO!!
MoO MoO!!
MoO MoO MoO!!
MoO MoO MoO MoO!!
MoO MoO MoO MoO MoO!!
MoO MoO MoO MoO MoO MoO!!
MoO MoO MoO MoO MoO MoO MoO!!
MoO MoO MoO MoO MMM MoO MoO MoO!!
MoO MoO MoO MoO MoO MoO MoO MoO MoO!!
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO!!
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO!!
MoO MoO MoO MoO Moo MoO MoO MoO MoO Moo MOo MOo!!
Moo MoO Moo MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO!!
MoO MoO Moo MMM Moo MoO MoO MoO MoO MoO MoO MoO MoO MoO!!
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO!!
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO!!
Moo MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MOo MOo!!
MOo MOo MOo MOo MOo Moo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo Moo MMM!!
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MMM MoO Moo MOo Moo!

Try it online!

Prints EIGHT HUNDRED

Answer 7

CSS, 30 bytes

body::after{content:'thirty';}

---

CSS (Google Chrome only), 26 bytes

This should be saved in an empty file between <style> and </style> tag, doesn't work on FireFox or Stack Exchange's code snippets. Tested on Windows Chrome 77.

:after{content:'twenty six

Answer 8

PHP, 4 bytes

four

Try it online!

---

PHP, 9 bytes

<?= nine;

Try it online!

Answer 9

Malbolge, 40 bytes

(CB%#9]~}5:3Wyw/4-Qrqq.'&Jkj(h~%|Bd.-==;

Answer 10

Labyrinth, 10 bytes

84.69.78.@

Try it online!

How?

  - initially the main stack contains infinite zeros    [0,0,0,...]
8 - multiply the top of the stack by ten and add eight  [8,0,0,...]
4 - multiply the top of the stack by ten and add four   [84,0,0,...]
. - pop, mod 256, print character                       T
6 - multiply the top of the stack by ten and add six    [6,0,0,...]
9 - multiply the top of the stack by ten and add nine   [69,0,0,...]
. - pop, mod 256, print character                       E
7 - multiply the top of the stack by ten and add seven  [7,0,0,...]
8 - multiply the top of the stack by ten and add eight  [78,0,0,...]
. - pop, mod 256, print character                       N
@ - exit

Answer 11

Piet, 90 codels

Try it online!

In pseudo-code:

The characters are pushed onto stack. To save space, their ASCII values minus 100 are stored. When the string is built, a loop pops, adds 100 to, and prints each character to STDOUT.

    ; Place sentinel 0 on stack
    push 1
    not

    ; Place 21 (y) on stack
    push 7
    push 3
    mul

    ; Place 16 (t) on stack
    push 4
    dup
    mul

    ; Place 1, 10, 5, 10 (e, n, i, n) on stack
    push 1
    push 10
    push 5
    push 10

    ; Check if top of stack is non-zero
    ; Place a 1 if it is, a 0 otherwise
    dup
    not
    not

write_loop:
    ; Turn DP (Direction Pointer) as many steps
    ; clock-wise as value on top of stack
    ; If we had a zero on stack, we continue into
    ; the yellow area and get trapped, ending execution
    pointer

    ; If not, we continue
    ; Add 100 to top of stack
    push 5
    push 4
    push 5
    mul
    mul
    add

    ; Pop and print character
    outc

    ; Turn DP one step to the right
    push 1
    pointer

    dup
    not
    not

    ; Check if top of stack is non-zero
    ; Place a 1 if it is, a 0 otherwise
    dup
    not
    not

    ; We're now back at beginning of the writing loop, sort of like a jmp write_loop

Answer 12

Emoji, 18 bytes

⛽eighteen🚘➡

Try it online!

---

Emoji, 8 chars

⛽eight🚘➡

Try it online!

Answer 13

Piet + ascii-piet, 40 bytes (3×14=42 codels)

ttllldabknmEmqusbeeeeeute_rbacqtuljvff ?

Try Piet online!

Prints FORTY. A fantastic use case of a white trap :) Also I like the fact that the program is packed so perfectly.

How it works

A classic 3-row layout with a 1 DP+ at the left edge.

Commands        Stack
2 3 dup dup *   [2 3 9]
dup dup 1 - *   [2 3 9 72]
2 -             [2 3 9 70]   Setup the stack so that repeatedly adding and
                             printing gives FORT
dup outC + dup outC +
dup 1 DP+ outC + dup outC
                [84]   Print FORT, turning right at R2C1
>               [84]   No-op (stack underflow) to take care of the crossing
5 + outC        []     Finally print Y

---

Piet + ascii-piet, 50 bytes (4×13=52 codels)

ttttliametf M tt iillldedMnjlvjcfll i Mkmuuljcbjjj

Try Piet online!

Prints fifty. Not sure if I can do 40, but I guess pretty much unlikely.

How it works

The execution path: First row -> (turn right) -> 3rd-to-last column -> (turn right) -> last row in reverse -> (turn right twice) -> 3rd row -> transfer to 2nd row at the red 5 block -> end.

...>>>>>>>v X
 .. ....>>+>X
>>>>>>>.. v X
^<<<<<<<<..

Commands:

Commands          Stack
6 dup 3 * 1 - *   [102]   Push 102 ('f')
dup outC          [102]   Print 'f'
dup 3 + outC      [102]   Print 'i' (= 'f' + 3)
dup outC          [102]   Print 'f'
2 dup dup +       [102 2 4]
dup * - -         [116]   Add 14 to 'f' (= 't')
dup outC          [116]   Print 't'
5 inC + outC      []      Add 5 and print 'y'
                          (inC is ignored; it is to reuse the crossing purple cell)

Answer 14

Hexagony, 6 bytes, 17 cycles

s;i>x@

Try it online!

Now the letters six are in more natural order, and the program finishes one cycle faster.

How it works

For more thorough explanation, see the previous answer below.

 A B
C > D
 E .
Execution path: ABC>CBAD>ADB.>.CE
                ^^  ^^    ^^    ^
                s;  i;    x;    @

---

Hexagony, 6 bytes, 18 cycles

x>i;s@

Try it online!

Inspired by boboquack's 9-byte solution. The following quote was a big hint:

I'm slightly disappointed that I couldn't get six to work (that would be pushing it with three characters, one output, one redirection and one termination).

How it works (or, How I got to this solution)

A 6-byte program is laid out on a hexagon of side length 2, and the 7th instruction is necessarily a no-op:

 ? ?
? ? ?
 ? .

Since I needed at least one mirror, I tried out various mirrors placed at various places, until I found this:

 A >
B C D
 E .

Assuming the current memory is always positive (and there are no branches/mirrors/IP changers among ABCDE), the IP follows the path

A>ADCB>.CAD>DAC.BE

The cell C is run exactly three times, and the cells right before C are D, B, and A respectively. And the cell E is first run after three runs of C. This is exactly what we want: write one of s, i, or x on the memory and print it, and then terminate!

Now back to the actual source code:

 x >
i ; s
 @ .

And the execution path, linearized, with significant instructions emphasized:

x>xs;i>.;xs>sx;.i@
   ^^^  ^    ^^  ^
   ^^              Print 's'
     ^  ^          Print 'i'
             ^^    Print 'x'
                 ^ Terminate

Answer 15

SOGL V0.12, 3 bytes

Well, SOGL has a string compression library that seems to compress "three" to 3 bytes.

@0‘

Try it Here!

Answer 16

Brainf***, 90 bytes

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

Try it online!

Answer 17

Lost, 30 bytes

v<<<<<<<>>>>>>>
>%?"thirt/J"+@

Contains the unprintable character ESC with unicode value 27 after the ^ on the second line. Thanks to @JoKing getting rid of the unprintable (for the same byte-count).

Try it online or verify that it's deterministic.

Explanation:

Explanation of the language in general:

Lost is a 2D path-walking language. Most 2D path-walking languages start at the top-left position and travel towards the right by default. Lost is unique however, in that both the start position AND starting direction it travels in is completely random. So making the program deterministic, meaning it will have the same output regardless of where it starts or travels, can be quite tricky.

A Lost program of 2 rows and 5 characters per row can have 40 possible program flows. It can start on any one of the 10 characters in the program, and it can start traveling up/north, down/south, left/west, or right/east.

In Lost you therefore want to lead everything to a starting position, so it'll follow the designed path you want it to. In addition, you'll usually have to clean the stack when it starts somewhere in the middle.

Explanation of the program:

All arrows, including the reflect / in the string, will lead the path towards the leading > on the second line. From there the program flow is as follows:

• >: travel in an east/right direction
• %: Put the safety 'off'. In a Lost program, an @ will terminate the program, but only when the safety is 'off'. When the program starts, the safety is always 'on' by default, otherwise a program flow starting at the exit character @ would immediately terminate without doing anything. The % will turn this safety 'off', so when we now encounter an @ the program will terminate (if the safety is still 'on', the @ will be a no-op instead).
• ?: Clean the top value on the stack. In some program flows it's highly likely we have a partial string on the stack, so we use this to wipe the stack clean of that potential string.
• ": Start a string, which means it will push the integer code-points of the characters used.
• thirt/J: Push the code-points for these characters, being 116 104 105 114 116 47 74 respectively
• ": We're done pushing code-points of this string
• +: Add the top two values together: (47+74=) 121
• @: Terminate the program if the safety is 'off' (which it is at this point). After which all the values on the stack will be output implicitly. Using the -A program argument flag, these code-points will be output as characters instead.

Two things to note:

The top part could also have been v<<<<<<<<<<<<<< instead. Lost will wrap around to the other side when moving in a direction. So using v<<<<<<<>>>>>>> could be a slightly shorter path, and since it's the same byte-count anyway, why not use it. :)
Also, the first line contains an additional trailing > to make the byte-count from 29 to 30.

Answer 18

Jelly, 4 bytes

“Ɱ9»

Try it online!

Answer 19

JavaScript, 16 10 bytes

-6 each from Night2's suggestion in the comments

Try it online! (alert doesn't work in TIO, so I'm using print)

alert`ten`

---

Javascript, 26 20 bytes

Try it online!

console.log`twenty`;

Answer 20

Keg, 3 bytes

-1 from Jono2906 for reminding me the string compression

2 can play the 3 byte game!

‘0⅀

TIO

Old answer, 4 bytes

You can't get shorter than 4. (Without using string compression of course.) 4 is the smallest English word that is the same length as the number it represents.

Just some good old-fashioned Ascii/auto-pushing Keg golfing!

four

Try it online!

Explanation

four#   Push 4 onto the stack
#Implicit Print

Answer 21

Shakespeare Programming Language, 800 bytes

Try it online!

(Whitespace added for readability)

800 Bytes---- filler.Ajax,.Puck,.Act I:.
Scene I:.[Enter Ajax and Puck]Ajax:
You is the sum ofthe sum ofthe cube ofa big big cat a big big cat a cat.Speak thy.
You is the sum ofyou a big big cat.Speak thy.
You is the sum ofyou a big pig.Speak thy.
You is the sum ofyou a cat.Speak thy.
You is the sum ofyou twice twice the sum ofa big cat a cat.Speak thy.
You big big big big big cat.Speak thy.
You is twice the sum ofyou a big big cat.Remember you.Speak thy.
You is the sum oftwice you the cube ofthe sum ofa big pig a pig.Speak thy.
You is the sum ofyou the sum ofa big big big pig a cat.Speak thy.
Recall.You is the sum ofyou a big big pig.Remember you.Remember you.Speak thy.
You is the sum ofyou twice the sum ofa big big big cat a pig.Speak thy.
Recall.You is the sum ofyou a cat.Speak thy.
Recall.Speak thy.

Prints EIGHT HunDRED. The math to get from one letter to another was very complicated and there was little room for error. This is probably improvable in terms of code, but 700 is most likely impossible. Little improvement saving 2 bytes in the actual code because I missed out on optimizing 2*(4+2) to 2*2*(2+1) for some reason.

Answer 22

C# (.NET Core), 64 bytes

class P{static void Main(){System.Console.Write("sixty four");}}

I had to see what a non-competitive language would score.

Try it online!

Answer 23

Excel, 4 bytes

four

Uninteresting answer, not using a formula.

---

Excel, 5 bytes

'five

Using a formula, requires at least 3 extra bytes (=, ", ").

Excel, 6 bytes

="six"

Excel, 12 bytes

="tw"&"elve"
=T("twelve")

Excel, 14 bytes

=T("fourteen")

Excel, 16 bytes

=IF(1,"sixteen")

Excel, 18 bytes and upwards

=TRIM(" % ")

Insert required text, padded with required whitespace.

Answer 24

Taxi, 164 160 bytes

"One hundred sixty" is waiting at Writer's Depot.
Go to Writer's Depot: w 1 r 3 l 2 l.
Pickup a passenger going to Post Office.
Go to Post Office:n 1 r 2 r 1 l.

Try it online!

This also throws an error because I don't return the taxi to the garage so my boss fires me. It's not a requirement to not throw errors, though, so I guess I'm fired.

Answer 25

vemf, 6 5 bytes

"five

Outputs five. try it online

Answer 26

Python 3, 16 bytes

print("sixteen")

Try it online!

Also works in Proton.

Answer 27

ink, 4 bytes

Four

Try it online!

Predictably enough, it prints Four

Answer 28

Batch, 10 bytes

@ echo ten

If you think the extra space after the @ is ugly, the next possible answer is:

@echo twelve

Answer 29

05AB1E (legacy), 3 bytes

“„í

Try it online!

Using dictionary

Answer 30

Bash, 15 9 bytes

echo nine

Try it online!

Thanks to:
- @Night2 for saving me 6 bytes