[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]
# [Poetic](https://mcaweb.matc.edu/winslojr/vicom128/final/tio/index.html), 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!](https://mcaweb.matc.edu/winslojr/vicom128/final/tio/index.html?LZBNboUwDIT3nMJijbgCi6pqu@6TujbEJCkhRvkp4vSvE1opSmRnNN/Yj@sQWrUmV6NJYmhxnPJEH5T5GvAU5@OG1/GPEEccG2Ts7n/q3zS7gRatwUDzXXMhq7Qk4SKUdRc6VPaJXoJwChf5AvEumZiCRktng5zJF48il7quf@SxBwHKQ7MggpDE4pPc0iLxdh2QxdwQjUJAmmYLJ1i2G6JUvMax6z9rkoA28BwC@UyW08xWhh5hPcZmmr2llZEvXTPP19h93VO9v9KaOG4IH7X4RcjpSTvDv00AlBivNaNdU24LU92m7oHM/050YoU3ImgZoTi5LE7M0AaLqL2N2lbv/D4@nzObXw)
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]
# [Google Translate](https://translate.google.com/) (3 bytes)
```
‰∏Ä
```
[Try it online!](https://translate.google.com/?text=%E4%B8%80)
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](https://translate.google.com/) (3 bytes)
```
tre
```
[Try it online!](https://translate.google.com/?text=tre)
It's Italian for "*three*".
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 40 bytes
```
+[+++++>++<]>.+++++++++.+++.++.+++++.+++
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fO1obBOy0tW1i7fS0YUAPgvXgnP//AQ "brainfuck ‚Äì 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]
# [MathGolf](https://github.com/maxbergmark/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!](https://tio.run/##y00syUjPz0n7///R1JXx//8DAA "MathGolf ‚Äì Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 15 bytes
```
exit("fifteen")
```
...prints to STDERR.
**[Try it online!](https://tio.run/##K6gsycjPM/7/P7Uis0RDPS0zrSQ1NU9d8/9/AA "Python 3 ‚Äì Try It Online")** (see the "debug" panel)
[Answer]
# [COW](https://bigzaphod.github.io/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!](https://tio.run/##S84v///fN99fUZELSCqgsDB52EVwi@KXwSXr60u8ftJUkaYSp@p8Baxi/mAM1pGPRyVhe/KhYZBPff9QVzfchHwydaOEmj@ch8D5WMRwYUi4UeSjfKTUBzdV8f9/AA "COW ‚Äì Try It Online")
Prints `EIGHT HUNDRED`
[Answer]
# 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]
# [PHP](https://php.net/), 4 bytes
```
four
```
[Try it online!](https://tio.run/##K8go@P8/Lb@06P9/AA "PHP ‚Äì Try It Online")
---
# [PHP](https://php.net/), 9 bytes
```
<?= nine;
```
[Try it online!](https://tio.run/##K8go@P/fxt5WIS8zL9X6/38A "PHP ‚Äì Try It Online")
[Answer]
# Malbolge, 40 bytes
```
(CB%#9]~}5:3Wyw/4-Qrqq.'&Jkj(h~%|Bd.-==;
```
[Answer]
# [Labyrinth](https://github.com/m-ender/labyrinth), 10 bytes
```
84.69.78.@
```
**[Try it online!](https://tio.run/##y0lMqizKzCvJ@P/fwkTPzFLP3ELP4f9/AA "Labyrinth ‚Äì 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]
# [Piet](https://github.com/cincodenada/bertnase_npiet), 90 codels
[![enter image description here](https://i.stack.imgur.com/7I3fq.png)](https://i.stack.imgur.com/7I3fq.png)
[Try it online!](https://tio.run/##hZJNSwMxEIbv/or3KIoh3x8ehGyStb0sYgteFLyIFDwIFk/qX68z2922nhzCMsySJ@/MO@@bl@1uJ6e4RkxwErbBBsgKmaEyf6WcT4VNsBHWwmlA3A23Yorlot6f7UmKWMc76SQnVoTUx0pL8AHNEOtPvIqJpYnVThCujBIsrIKz0BHOwFXEhqhYYJF71uOy5vX56onziWWIZSRLKAZ9RN9DZ5iG0o11BeOhiZVRLZRnNCQDLm6EFP6KstXEssSiQezfVwqZNBZWwQ2OTVEld0z0VJdIHbA4X83tCf920OWIFUhFQXUIhhukm3TICt1B9ugVOoVgYQyS5xw/QnwshRguCbc1B5YnVvYIHtYgFIQeocIEKOo3IUV0Fbmgd0g0LM9QiM/yJb7DPPztxArso4YigxoqTY0uBESP0nj8pM4F@MR/6Zcf3Tz4mIeHjRDPs67ILAVVeAmSg5bcCyuS7ONxReTor2P6yAL1th4XrA0TK/HsLTKp0PxspFX8N6roSMxu9ws "Piet ‚Äì 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]
# [Emoji](https://esolangs.org/wiki/Emoji), 18 bytes
```
‚õΩeighteenüöò‚û°
```
[Try it online!](https://tio.run/##S83Nz8r8///R7L2pmekZJampeR/mz5rxaN7C//8B "Emoji ‚Äì Try It Online")
---
# [Emoji](https://esolangs.org/wiki/Emoji), 8 chars
```
‚õΩeightüöò‚û°
```
[Try it online!](https://tio.run/##S83Nz8r8///R7L2pmekZJR/mz5rxaN7C//8B "Emoji ‚Äì Try It Online")
[Answer]
# [Piet](https://www.dangermouse.net/esoteric/piet.html) + [ascii-piet](https://github.com/dloscutoff/ascii-piet), 40 bytes (3√ó14=42 codels)
```
ttllldabknmEmqusbeeeeeute_rbacqtuljvff ?
```
[Try Piet online!](https://piet.bubbler.one/#eJxNTEEKwzAM-4vOCsRt0zX5SulhdBkUuq2Q7TT69yk5zRZCtmR_sb5uGWmePT3H1tbRxAMjLzSjiaOwcNY0MLCvbl3_Iei-qkmxrvn6ERT3skZO1KO-IdbQQpR8IME5B2LfHtLmVZpyWZHu171kYnsen7c8nD-a3ycB)
![](https://github.com/Bubbler-4/svg-stuff-and-tools/raw/27967a267a6089516184efccc12f182afdd73a58/images/CodeGolfSE/194480-2.svg)
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](https://www.dangermouse.net/esoteric/piet.html) + [ascii-piet](https://github.com/dloscutoff/ascii-piet), 50 bytes (4√ó13=52 codels)
```
ttttliametf M tt iillldedMnjlvjcfll i Mkmuuljcbjjj
```
[Try Piet online!](https://piet.bubbler.one/#eJwtjNEOgjAUQ__lPnfJrsqQ_crCg8GZkKCSoE-Gf7cF1qVdt3P3s-F9r5ZLidiV4BFOd3jL7md4x9ajMEWoRu20yU8C5WJaXHVH90azG7EPHL8o0FDpgC5MSUDX97ClzpYthGCwaXzy7JGLrS6D5cdtWipsfM3fD99s_QNFMSv_)
![](https://github.com/Bubbler-4/svg-stuff-and-tools/raw/cec86b3ba829e541ef0525c4bed6dace09626a04/images/CodeGolfSE/194480.svg)
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]
# [Hexagony](https://github.com/m-ender/hexagony), 6 bytes, 17 cycles
```
s;i>x@
```
[Try it online!](https://tio.run/##y0itSEzPz6v8/7/YOtOuwuH/fwA "Hexagony ‚Äì 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](https://github.com/m-ender/hexagony), 6 bytes, 18 cycles
```
x>i;s@
```
[Try it online!](https://tio.run/##y0itSEzPz6v8/7/CLtO62OH/fwA "Hexagony ‚Äì Try It Online")
Inspired by [boboquack's 9-byte solution](https://codegolf.stackexchange.com/a/194788/78410). 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]
# [SOGL V0.12](https://github.com/dzaima/SOGLOnline), 3 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
Well, SOGL has a string compression library that seems to compress "three" to 3 bytes.
```
@0‚Äò
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=QDAldTIwMTg_,v=0.12)
[Answer]
# Brainf\*\*\*, 90 bytes
```
+[+[>>+<+<-]>]>[>+>+>+>+>+>+<<<<<<-]>.>-----.>.>---------.>++++++.>+++++++++++.<+><><><><>
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fO1o72s5O20bbRjfWLtYu2k4bAW3AACiuZ6cLAnowBoSjDQYwGsKx0bazgcL//wE "brainfuck ‚Äì Try It Online")
[Answer]
# [Lost](https://github.com/Wheatwizard/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](https://tio.run/##y8kvLvn/v8wGAuwggMtO1V6pJCOzqETfS0nb4f///7qOAA) or [verify that it's deterministic](https://tio.run/##y8kvLvn/v8wGAuwggMtO1V6pJCOzqETfS0nb4f///7qO/3XDAA).
### 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]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
‚Äú‚±Æ9¬ª
```
**[Try it online!](https://tio.run/##y0rNyan8//9Rw5xHG9dZHtr9/z8A "Jelly ‚Äì Try It Online")**
[Answer]
## JavaScript, ~~16~~ 10 bytes
-6 each from Night2's suggestion in the comments
[Try it online!](https://tio.run/##y0osSyxOLsosKNEts/j/v6AoM68koSQ1L@H/fwA) (`alert` doesn't work in TIO, so I'm using `print`)
```
alert`ten`
```
---
## Javascript, ~~26~~ 20 bytes
[Try it online!](https://tio.run/##y0osSyxOLsosKNEts/j/Pzk/rzg/J1UvJz89oaQ8Na@kMuH/fwA)
```
console.log`twenty`;
```
[Answer]
# [Keg](https://github.com/JonoCode9374/Keg), 3 bytes
-1 from Jono2906 for reminding me the string compression
2 can play the 3 byte game! 
```
‚Äò0‚ÖÄ
```
[TIO](https://tio.run/##y05N////UcMMg0etDf//AwA)
## 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!](https://tio.run/##y05N//8/Lb@06P9/AA "Keg ‚Äì Try It Online")
## Explanation
```
four#   Push 4 onto the stack
#Implicit Print
```
[Answer]
# Shakespeare Programming Language, 800 bytes
[Try it online!](https://tio.run/##jVFLDoIwEL3KHEAblsadJi7cGVgZ46LUESvlEyhRTo9TCUIBgSbTTOfz@t5Mnqqq2jgO7EuN@ZoO3KVSmLHdk79X7FSIcMV2QsNxyzyBMRrncog1ZmBKgMc3MFVX89qekwJkDvqBkBcRJHfbE4WP5HLwZfA1wTX0X3QzL0UeEkzJBoglBayWZcWpDOYLF6DplxTY3L8Mn@TfkO3a@Fc92KFWFyOMfBo@paao1khfwu3c@3xpJgS/YDL9xsZqAFuKi4IrNbc386mlZamwzg7@kKq3YKuaJjUqoA1U1Qc)
(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]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 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!](https://tio.run/##Sy7WTc4vSv3/PzknsbhYIaC6uCSxJDNZoSw/M0XBNzEzT0OzOriyuCQ1V885P684PydVL7wosyRVQ6k4s6KkUiEtv7RISdO6tvb/fwA "C# (.NET Core) ‚Äì Try It Online")
[Answer]
# 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]
# [Taxi](https://bigzaphod.github.io/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!](https://tio.run/##XcyxCsIwFIXhvU9x6OJWaN06C47t5hzam3ix5Ibkhtanj1EQxOEsP5xPzcGltJMn3LNfI61IfOgTVnJswQm7YWXvYBS3yErxlHChINo1V4HKXx139Ig4Y8OArWtmXh45wCCYlMg7inDy9upzlqSYrOWFvthPGv1HGur6KpXyAg "Taxi ‚Äì 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]
# [vemf](https://selaere.github.io/vemf/doc/docs.html), ~~6~~ 5 bytes
```
"five
```
Outputs `five`. [try it online](https://selaere.github.io/vemf/wasm/index.html?code=ImZpdmU&fmt=0)
[Answer]
# [Python 3](https://docs.python.org/3/), 16 bytes
```
print("sixteen")
```
[Try it online!](https://tio.run/##K6gsycjPM/7/v6AoM69EQ6k4s6IkNTVPSfP/fwA "Python 3 ‚Äì Try It Online")
Also works in [Proton](https://tio.run/##KyjKL8nP@/@/oCgzr0RDqTizoiQ1NU9J8/9/AA).
[Answer]
# [ink](https://github.com/inkle/ink), 4 bytes
```
Four
```
[Try it online!](https://tio.run/##y8zL/v/fLb@06P9/AA "ink ‚Äì Try It Online")
Predictably enough, it prints `Four`
[Answer]
## Batch, 10 bytes
```
@ echo ten
```
If you think the extra space after the `@` is ugly, the next possible answer is:
```
@echo twelve
```
[Answer]
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/tree/fb4a2ce2bce6660e1a680a74dd61b72c945e6c3b), 3 bytes
```
‚Äú‚Äû√≠
```
[Try it online!](https://tio.run/##MzBNTDJM/f//UcOcRw3zDq/9/x8A "05AB1E (legacy) ‚Äì Try It Online")
Using dictionary 
[Answer]
# [Bash](https://www.gnu.org/software/bash/), ~~15~~ 9 bytes
```
echo nine
```
[Try it online!](https://tio.run/##S0oszvj/PzU5I18hLzMv9f9/AA "Bash ‚Äì Try It Online")
Thanks to:  
- @Night2 for saving me 6 bytes
]