text:
Output integer given a digital clock style input
Input
    _  _     _  _  _  _  _  _
  | _| _||_||_ |_   ||_||_|| |
  ||_  _|  | _||_|  ||_| _||_|

output
1234567890

Rules
Code golf - shortest code wins.
Input will be given as a 3-line string with each line separated by a newline, or as 3 separate strings. Each line is guaranteed to be a multiple of 3 characters long with no additional whitespace, and all lines will be the same length.
Each digit is represented as a 3x3 block of characters as above. Note that the 1 digit has two leading spaces in order to fill the 3x3 block.

I think your formatting failed?

oh yeah it failed

I edited it. Please help cause i don't know how to go about it

Reverse challenge. Additionally, all challenges on this site require a winning criterion, for example [tag:code-golf]

I suggest (at least in the future) to post your challenges in the sandbox first: https://codegolf.meta.stackexchange.com/questions/2140/sandbox-for-proposed-challenges

Welcome to PPCG. This has potential to be a very good challenge, however there are a number of issues. As others have mentioned,  it needs a winning criterion (I would suggest codegolf meaning shortest code wins. Can we assume all digits will be 3 characters wide? At the current time the 1 is narrower than the others. I've checked and I see that in your original source you had 2 leading spaces on the 1, so I'll go ahead and edit these back in. You also haven't specified the output for 0 so I will edit that in also. Feel free to roll back my edits if you disagree.

Closely related.

(However, the above challenge is harder and got only 1 answer.)

which one is the answer?

Abel, as you haven't objected to my edits, I'm going to remove my name from them and nominate this question for re-opening.

It is way too early to accept an answer. Unlike other sites of the SE network, it is recommended here to wait at least a week or 2. Accepting no answer at all is also perfectly fine.

That's far, far too soon to be accepting a solution. Moreso seeing as it's the only solution, so far.

Sorry man. that was my first question ever. thanks for saying this, I learned.

Related (has a second input for variable width/height); closely related / possible dupe? (difference is that the digits 1, 3, and 7 aren't three characters wide; apart from that it's the same).

Can we take the input as a 2D list of characters?

May we output a list of the digits rather than an integer (some answers already do)?

...and if not are we allowed to print the leading zeros which might be given in an input?

JavaScript (ES6),  105  104 bytes
Takes input as an array of 3 strings. Returns an array of digit characters.
a=>a.map(s=>s.match(/.../g).map(([a,b,c],n)=>'3789465021'[(o[n]=~~o[n]+[++a|7*++b^44*++c])%13]),o=[])[2]

Try it online!
How?
Finding a concise way to process the input
A common trick to turn an input string into an identifier is to use parseInt(). But it only works with alphanumeric strings and is therefore pointless here. Other than that, JS is not very good at processing ASCII codes in few bytes, so we'd better find another trick.
We can notice that each digit in this font can still be uniquely identified if we replace each character with a binary value: \$1\$ for space, \$0\$ for not space:
  0  |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
  _  |     |  _  |  _  |     |  _  |  _  |  _  |  _  |  _
 | | |   | |  _| |  _| | |_| | |_  | |_  |   | | |_| | |_|
 |_| |   | | |_  |  _| |   | |  _| | |_| |   | | |_| |  _|
-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
 101 | 111 | 101 | 101 | 111 | 101 | 101 | 101 | 101 | 101
 010 | 110 | 100 | 100 | 000 | 001 | 001 | 110 | 000 | 000
 000 | 110 | 001 | 100 | 110 | 100 | 000 | 110 | 000 | 100

That looks like a good golfing start: it means that we can abuse the fact that a space is coerced to \$0\$ and can be turned into a \$1\$ by applying the pre-increment operator to it, while it will result in NaN for the other characters.
Hence the idea to implement something along these lines:
s.match(/.../g)        // split each line into groups of 3 characters
.map(([a, b, c], n) => // for each group (a, b, c) of characters at position n:
  ???                  //   do some bitwise magic with ++a, ++b and ++c
                       //   and use it to update an identifier for the n-th digit
)                      // end of map()

Bitwise magic
After some experiments and brute-forcing, it turned out that a pretty short and efficient formula is:
o[n] = ~~o[n] + [++a | 7 * ++b ^ 44 * ++c]

Step-by-step example:

The 1st line of a "0" is " _ ". Therefore, we have ++a -> 1, ++b -> NaN and ++c -> 1.
So, ++a | 7 * ++b ^ 44 * ++c evaluates to 1 | 7 * NaN ^ 44 * 1, which is \$45\$.
Because o[n] is initially undefined, ~~o[n] evaluates to \$0\$. And because \$45\$ is coerced to a string, o[n] is updated to "045".
The 2nd line of a "0" is "| |". This time, we have ++a -> NaN, ++b -> 1 and ++c -> NaN. The bitwise expression evaluates to \$7\$ and o[n] is updated to "457". (Note that the leading 0 is thrown away by ~~o[n].)
The 3rd line of a "0" is "|_|", leading to ++a -> NaN, ++b -> NaN and ++c -> NaN. The bitwise expression evaluates to \$0\$ and the final value of o[n] is "4570".

Minimal perfect hash function
Of course, the parameters of the bitwise formula were not chosen at random (well ... at least no completely): by coercing the final identifier of a digit back to an integer and applying a modulo \$13\$, we get a unique value in \$[0..9]\$.
The following table summarizes the results for all digits:
  digit |   0   |   1   |   2   |   3   |   4   |   5   |   6   |   7   |   8   |   9
--------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
     ID |  4570 |  4377 | 45144 |  4511 |  4307 | 45441 | 45440 |  4577 |  4500 |  4501
--------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
 mod 13 |   7   |   9   |   8   |   0   |   4   |   6   |   5   |   1   |   2   |   3

Hence the 10-byte lookup table: '3789465021'.

J, 55 bytes
(0 3,:3 3)(6 7 8 11 4 2 13 14 5 9 i.15|[:#.@,' '&=);.3]

Try it online!
J has a primitive ;.3 called Subarrays that let's you process a multi-dimensional "sliding window".  Here we have a 3x3 window moving 3 steps to the right each time, which grabs exactly 1 digit.
We convert each 3x3 matrix to a boolean mask ' '&=, flatten it ,, and convert that binary number to decimal #..  After a little experimenting, I found that modding it by 15 15| returned a unique list of small numbers, and we just find the index within that.
More brute forcing could likely find an even more efficient encoding.

05AB1E, 25 bytes
€S3δôøðQε˜JC15%•#/ι®ˆ¼•sè

Input as a list of lines, output as a list of digits. If we could take the input as a 2D list of characters, the first 2 bytes can be removed.
Try it online.
Explanation:
€S                        # Convert each line in the (implicit) input-list of strings to
                          # an inner list of characters
   δ                      # Convert each inner list of characters to:
  3 ô                     #  Split it into blocks of size 3
     ø                    # Zip/transpose; swapping rows/columns
      ðQ                  # Check which characters are spaces (1 if truthy; 0 if falsey)
        ε                 # Map each 3x3 block to:
         ˜                #  Flatten it to a single list
          J               #  Join it together to a single string
           C              #  Convert it from binary to an integer
            15%           #  Take modulo-15
               •#/ι®ˆ¼•   #  Push compressed integer 105048012903067
                       s  #  Swap to take the earlier integer
                        è #  And (0-based) index it into this to get the resulting digit
                          # (after the map, the result is output implicitly)

See this 05AB1E tip of mine (section How to compress large integers?) to understand why •#/ι®ˆ¼• is 105048012903067 (NOTE: the leading 1 and all the 0s except for the 3rd (7th digit) are fillers.

Python 3, 105 bytes
f=lambda p,q,r:p and'5498136207'[int(''.join(map(str,p[:2]+q[:3]+r[:2])))%49%11]+f(p[3:],q[3:],r[3:])or''

Try it online!
Takes input as three bytestrings. It considers the following sections in a digit, which gives a unique combination:
 _     12
|_  => 345
 _|    67

In this order, the base-10 ascii values for each character are converted into a string, concatenated, and converted back into an integer. In the example above this would be '32'+'95'+'124'+'95'+'32'+'32'+'95' => 329512495323295. This integer is reduced with a double modulo %49%11. This results in a unique value from 0 to 9 for each digit, hence the string map '5498136207'.

Charcoal, 57 bytes
Ｅ³ＳＦ÷Ｌθ³«Ｊ⊕×³ι¹⊞υ÷⌕”{“→✂⌕Ｑ¤αA？=¹⧴Ｚb⁻e⁵ηπ⪫Q¡”⁺ＫＫ⪫ＫＭω⁹»⎚⪫υω

Try it online! Link is to verbose version of code. Explanation:
Ｅ³Ｓ

Copy the three lines of input to the canvas.
Ｆ÷Ｌθ³«

Loop over the digits...
Ｊ⊕×³ι¹

... jump to the middle of the digit...
⊞υ÷⌕”{“→✂⌕Ｑ¤αA？=¹⧴Ｚb⁻e⁵ηπ⪫Q¡”⁺ＫＫ⪫ＫＭω⁹

... and concatenate the nine characters of the digit and look it up in a compressed string, dividing the index by 9.
»⎚⪫υω

Clear the canvas and output the detected digits.

PHP, 104 102 bytes
-2 bytes thanks to Arnauld
for(;!$i||$d&&print'6930274581'[crc32($d)%63%10];$i++)for($d=0;$a=$argv[++$$i];$d.=substr($a,$i*3,3));

Try it online!
Takes input as 3 separate strings.
How?
I create a single line string for each digit with a leading "0" (10 in total for each digit), this is basically 3 lines of 3 characters for each digit concatenated to each other without new lines and a "0" at start of them. For string of each digit I get the cyclic redundancy checksum polynomial of 32-bit lengths (crc32) and then do a mod 63 and mod 10 on it to get unique values for each digit. Then using the unique values and a mapping I simply output the actual digit. Look at the table below for a visual demonstration:
| Digit | Single line string | CRC32      | %63 | %10 |
|-------|--------------------|------------|-----|-----|
| 0     | "0 _ | ||_|"       | 4018184249 |  23 |   3 |
| 1     | "0     |  |"       |  750606692 |  59 |   9 |
| 2     | "0 _  _||_ "       | 2375221876 |  34 |   4 |
| 3     | "0 _  _| _|"       | 2330511487 |  52 |   2 |
| 4     | "0   |_|  |"       |  745793270 |  26 |   6 |
| 5     | "0 _ |_  _|"       | 1887416553 |  57 |   7 |
| 6     | "0 _ |_ |_|"       |  366569277 |  60 |   0 |
| 7     | "0 _   |  |"       | 1506663000 |  45 |   5 |
| 8     | "0 _ |_||_|"       | 2483214119 |   8 |   8 |
| 9     | "0 _ |_| _|"       | 4054057203 |  21 |   1 |

Commented
for(;                     // outer loop, iterates on digits
  !$i||                   // this allows the first iteration of loop to happen
  $d&&                    // $d is the single line string of each digit
                          //   continue the loop as long as $d is not empty
  print                   // and if $d is not empty, print
    '6930274581'          //   a character from mapping string
    [crc32($d)%63%10];    //   at index of CRC32 of the digit's single line string % 63 % 10
  $i++                    // increment $i by one, $i indicates which digit we are reading now
)
  for(                    // inner loop to get single line string of each digit
                          //   this loop iterates 3 times as we have 3 separate inputs
    $d=0;                 // set $d to "0" on start of each loop
    $a=$argv[++$$i];      // set $a to appropriate input (input 1 or 2 or 3)
    $d.=substr($a,$i*3,3) // concatenate a sub string of current digit from $a to $d
  );

102 bytes by initializing $d to 0 and using another hash function.

@Arnauld, thanks, I have to create a brute force tool later as your idea opens up so many possibilities. I can set $d to any character (a-z, A-Z, 0-9, _) and then if I can find some mods that return 1-10 (without 0), I can save another byte by using _0123456789 instead of '0123456789'.

Oh, never mind!!! I have to add a space before _ and $d must be equal to falsy, so no bytes will be saved. Idiot me!

Jelly, 26 bytes
s€3=⁶ZF€Ḅ%15“pŻḣṾ:’b⁴¤iⱮ’Ḍ

Try it online!
A monadic link taking a list of three Jelly strings and returning an integer. Converts each input into a binary list where 1 is space and 0 anything else, converts back from binary, takes mod 15 (lowest divisor that yields unique output for each digit) and then looks these up in a list of 10 values to extract the relevant digit. Finally converts from a list of decimal digits to an integer.

Jelly, 21 bytes
20 if a list of digits is acceptable -- remove trailing Ḍ
...or if we may print with any leading zeros -- remove trailing Ḍ and replace the D with a Ṿ
ZOḅ3/ḅ⁹%129ị“ȯṂṾ;’D¤Ḍ

A monadic Link accepting a list of the three lines which yields an integer.
Try it online!
How?
Magic...
ZOḅ3/ḅ⁹%129ị“ȯṂṾ;’D¤Ḍ - Link: list of lists of characters
Z                     - transpose
 O                    - to ordinals
   3/                 - three-wise reduce using:
  ḅ                   -   (left list) from base (right) (vectorises)
      ⁹               - literal 256
     ḅ                - (left list) from base (256)
        129           - literal 129
       %              - (left) modulo (129) (vectorises)
                   ¤  - nilad followed by link(s) as a nilad:
            “ȯṂṾ;’    -   base 250 integer = 3792546810
                  D   -   to digits = [3,7,9,2,5,4,6,8,1,0]
           ị          - (left) index into (right) 1-indexed & modular (vectorises)

Huh?...
After ZO we have a list of columns of 32s, 95s, and 124s where there were spaces, underscores, and pipes, respectively. For example:
 _  _
 _||_   -> [[32,32,32],[95,95,95],[32,124,124],[32,124,124],[95,95,95],[32,32,124]]
 _||_|

The three-wise reduce using base conversion with vectorisation effectively takes each group of three lists (i.e. an input-digit), first converting the left-most to each base defined by the middle list and then converts that resulting list to each base defined by the right-most list:
[32,32,32]ḅ95 = 32×95²+32×95+32 = 291872
->
[32,32,32]ḅ[95,95,95] = [291872,291872,291872]

[291872,291872,291872]ḅ32 = 291872×32²+291872×32+291872 = 308508704
and
[291872,291872,291872]ḅ124 = 291872×124²+291872×124+291872 = 4524307872
->
[291872,291872,291872]ḅ[32,124,124] = [308508704,4524307872,4524307872]

similarly
([32,124,124]ḅ[95,95,95])ḅ[32,32,124] = [317844128,317844128,4661212704]

so  applying ZOḅ3/ we have:
 _  _
 _||_   -> [[308508704,4524307872,4524307872],[317844128,317844128,4661212704]]
 _||_|

This gives a unique triples for each input-digit which we convert to unique integers by conversion from base 256 (ḅ⁹) and modulo by 129 (%129) to find unique integers which remain unique if modulo-ed by ten.
   ZOḅ3/                              ḅ⁹              %129  (implicit %10 of ị)
0  [309401120,4628496048,4628496048]  21466435284656  110   0
1  [ 35751968, 524305824, 524305824]   2477787571616  119   9
2  [308605948,4525733964, 308605948]  21383695908860  104   4
3  [308508704,4524307872,4524307872]  21381173548448   41   1
4  [ 47306784, 602657424, 602657424]   3255180354192    6   6
5  [317746884, 317746884,4659786612]  20909862778740   15   5
6  [317844128, 317844128,4661212704]  20916262082080   97   7
7  [299993120,4492051872,4492051872]  20814806443424   92   2
8  [317844128,4661212704,4661212704]  22028164437536    8   8
9  [317746884,4659786612,4659786612]  22021424949108   93   3

(256 was chosen because it is a short literal in Jelly, ḅ14%67 is the same length and also works but the lookup integer, 5987203416, takes an extra base 250 digit - “¡⁴,>ʠ’.)
 _  _      ZOḅ3/ḅ⁹                            %129       (implicit %10 of ị)
 _||_   -> [21381173548448,20916262082080] -> [41,97] -> [1,7]
 _||_|

and the 1st and seventh elements of “ȯṂṾ;’D = [3,7,9,2,5,4,6,8,1,0]
...are three and six -> [3,6]


text:
Surjection from one string to two strings
This is the inverse of negative seven's question.
Write a program or function which, given any single, possibly-empty string of printable ASCII (codes \$[32,126]\$) outputs or returns two strings of printable ASCII.
For any two ordered, possibly empty strings \$s_1\$ and \$s_2\$, there must be third string \$s_0\$, which input to your program, outputs \$s_1\$ and \$s_2\$.

In other words, if \$\mathbb S\$ is the set of all ASCII strings (including the empty string):
\$f\$ is well-defined on \$\mathbb S\$: \$(\forall s\in\mathbb S)(f(s)\in\mathbb S\times\mathbb S)\$
\$f\$ is a surjection to \$\mathbb S\times\mathbb S\$: \$(\forall s_1,s_2\in\mathbb S)(\exists s_0\in\mathbb S)(f(s_0)=(s_1,s_2))\$
Test cases:
For each of these strings (surrounding «quotes» excluded), your output should be two strings:
«»
«hello world»
«'one' 'two' 'three' 'four'»
«"one" "two" "three" "four"»
«["one", "two", "three"]»
«; exit()»

For each of these pairs of strings, there must be at least one string you can provide to your program such that that pair is output (surrounding «quotes» excluded):
 s_1     |  s_2
---------|----------
«hello » | «world»
«hell»   | «o world»
«hello»  | « world»
« »      | «»
«»       | « »
«»       | « !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~»
«\r\n»   | «\r\n»

As always, you are encouraged to add test cases pertinent to your method.
Rules:

Input must be a single string/character array/byte array consisting of only ASCII characters.
Output is  ordered; \$(a,b)\neq(b,a)\$. Output can be any ordered structure in your language, or printed with a newline (LF or CR LF) separator and optional trailing newline.
I/O must be consistent. If one case handles input as an argument and outputs to stdout with a trailing newline, all cases must handle input as an argument and output to stdout with a trailing newline.
Standard loopholes are forbidden.
This is code-golf, so shorter programs are better!

As a reminder, this is only a surjection, not a bijection: Your program/function will likely map many different strings to the same output.

Python 2, 42 bytes
lambda s:(s.split("1"+len(s)/2*"0")*2)[:2]

Try it online!
The inverse is:
def F(a,b):
    return a+"1"+len(a+b)*"0"+b

A tempting idea for the inverse is to encode the pair of input strings by putting some separator string in between them. That way, we can extract the pair by splitting on this separator. The issue is that the separator may appear in the inputs string.
We get around this by making the separator longer than the total length of both strings. We use 1 followed by a number of 0's equal to the number of characters in both strings. For example,
abc, defgh -> abc100000000defgh

Note that no matter how many 0's and 1's are in the two inputs, there's no way to get another copy of the separator to appear.
We can recover the separator from the combined string by using a number of zeroes equal to half its length rounded down. I had wanted to compute this as 10**_, but Python's repr appends an annoying L to large numbers, which messes it up.
We need to the submission function still give two outputs when the input string doesn't contain the required separator. In this case, splitting just gives the original string, but we copy it twice to be compliant.

Python 2, 35 bytes (not working)
lambda s:s.split(s[:len(s)/3])[-2:]

Try it online!
This would work except it gives an error for the empty string. The idea is to have the inverse encode a,b -> sep + a + sep + b, where the separator sep has the same length as a+b so we can extract it as the first third of the string. A similar idea of putting the separator interspersed runs into the same issue.

Python 2, 43 bytes
lambda s:[s[i::2].lstrip()[1:]for i in 0,1]

Try it online!
The idea for encoding is to intersperse the two input strings with alternating characters. The problem there is that they may have different lengths. So, we pad them to the same length by prepending each one with some number of leading spaces then | (any non-space char will do). For example, abcd, ef goes to
|abcd
  |ef

This can be undone for each string by stripping off all leading spaces then removing the first character. Note that any spaces or | in the actual strings are left unharmed.
Python 3.8 (pre-release), 44 bytes
lambda s:(s[(i:=s.find('_'))+1:2*i],s[2*i:])

Try it online!
Inverse:
F=lambda a,b:(len(a)+1)*"?"+"_"+a+b

For instance, F("ab","cdef") = ???_abcdef. The number of symbols before the _ tells us where to split the remainder -- it's one more than the length of the first string.
We need the submission not to error when there's no _, but this works out because Python's string find uses -1 for missing, which still gives valid slices.

Your 35 byte solution that "Doesn't work" just has an off by one error. Your separator strings are of length 1+|a|+|b|, which is equal to |s|/3+1, since |s|=3|a|+3|b|+2. So if you change that solution to lambda s:s.split(s[:len(s)/3+1])[-2:], just adding a +1, it works fine, for 37 bytes. (Unless I'm missing something?) Try it online!

@isaacg Nice find, that does work. And [1:] for [-2:] saves another byte -- I believe the split is always exactly 3 elements. You can post an answer for the bounty.

On more thought, I realised this still doesn't work - f(F('','')) is fixed, but f('') still errors. It'll take more work to fix that. I'll keep looking.

I couldn't find any way to fix the empty string problem in under 6 bytes, making it not an improvement: Try it online!

Haskell, 38 bytes
f(' ':a:b)=(a:)<$>f b
f s=(drop 1s,"")

Try it online!
Not using built-in parsing.

21 bytes (doesn't quite work)
last.(("",""):).reads

Try it online!
(As pointed out by @benrg, this produces unprintable characters outside the valid range on some inputs like "\1" that decode to escape characters.)
The inverse is
g(a,b)=show a++b

This puts the first string in quotes, escaping any characters as needed, and appends the second string. This is undone by reads, which looks for a prefix that's a string representation of the correct type (here, string), reads it, and puts it in a pair with the remainder.
To make the function total, if this fails, we just return two empty strings. Note that reads only does lexing, not evaluation, so it won't mess up on weird inputs.
If we may output a singleton list of a two-string pair, we can save 3 bytes:
18 bytes
max[("","")].reads

Try it online!

Unfortunately the reads solutions don't work because, for instance, the input "\"\\12345\"" contains only printable ASCII but the output contains a non-ASCII character. It's a shame because they're nicely golfed.

@benrg Good find. I had tried testing with backslashes but hadn't though about escapes like that.

Python 2, 53 52 bytes
lambda s:(s.split('_x'+s.count('x')/2*'x')+[''])[:2]

Try it online!

Excellent! Thanks for providing an inverse function as well.

@GammaFunction: The inverse function was the Motivator!

How do I produce the pair "First_String", "Second_String"?

05AB1E, 8 7 bytes
g2÷°¡2∍

-1 byte thanks to @Grimy.
Try it online or verify all test cases.
Inverse (4 bytes):
Jg°ý

Try it online or verify all test cases.
Port of @xnor's first Python 2 approach, so make sure to upvote him as well!!
Explanation:
g        # Get the length of the (implicit) input-string
 2÷      # Integer-divide it by 2
   °     # Take 10 to the power this
    ¡    # And split the (implicit) input-string by this integer
     2∍  # Extend this list to (or keep it at) size 2
         # (after which this pair is output implicitly as result)

J        # Join the strings in the (implicit) input-list together to a single string
 g       # Get the length of this
  °      # Take 10 the power this
   ý     # And join the strings of the (implicit) input-list with this as delimiter
         # (after which the resulting string is output implicitly as result)

What a horrific language! +1

Þ2£ -> 2∍ (:

@Grimmy Now that I see it I don't understand why I used Þ like that in the first place, haha. First time I use it, even though I've used ∍ at least two dozen times. Thanks!

Retina 0.8.2, 33 bytes
^(("[^"]*")*),?
$1¶
%`^"|"("?)
$1

Try it online! Link includes test cases. Takes as input the output from my Charcoal answer to @negativeseven's question and outputs the two strings on separate lines. Explanation:
^(("[^"]*")*),?
$1¶

My Charcoal answer always outputs a number of quote-surrounded strings followed by a comma. Find that comma and split the strings there. If there's no comma, the split happens after the quote-surrounded strings, if any.
%`^"|"("?)
$1

Decode each string by deleting the first quote, one quote of each pair, and the last quote. (Assuming this is an encoded string, of course... otherwise this just deletes arbitrary quotes.)

Ruby, 81 bytes
->s{s.match(/^(\d+)\.(.*)/m){|m|l=m[1].to_i;[m[2][0,l],m[2][l..-1]||'']}||['',s]}

Try it online!
I don't golf much in Ruby so this can surely be shortened -- tips appreciated.
Idea is to to provide a meta-prefix <number>.rest of string which will split "rest of string" at number.  Strings without the meta-prefix just return ["", <original string>]

Retina 0.8.2, 17 bytes
^(.*)(.*)\1\1
$2¶

Try it online!
This parses the string as \$xs_1xxs_2\$ for the longest possible \$x\$ due to the greedy nature of regexes.  We may choose \$x = 10^{\max \{|s_1|, |s_2|\}}\$ to ensure the desired parse.

Haskell, 67 bytes
p""=["",""]
p(' ':c)="":p c
p('#':b:c)|h:t<-p c=(b:h):t
p c=p$'#':c

Try it online!

This isn't a surjection since A##b c d and similar inputs yield three strings as output. You might also want to provide an explanation on how to produce any desired output.

i can produce any two strings with one string: escape all their blanks with a hash and join them with a blank before feeding the joint.  that is surjective.  and i "read return two strings" as return two strings or more, implicit take 2.

Zsh, 37 bytes
a=("${(@Q)${(z)1}}")
<<<$a[1]'
'$a[2]

Try it online!

(z) splits a string according to shell grammar
(Q) removes quotes
(@) prevents array joining in quotes
" " are needed to preserve empty elements

Finally we print the first two strings with a quoted newline between them.

source: Stack Exchange

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

sort: votes


text:
How wavy is an array?
A wave of power \$k\$ is an infinite array that looks like \$1,2,\dots,k,k-1,\dots,1,\dots,k,\dots,1,\dots\$, and so on.
For example, a wave of power 3 starts with \$1,2,3,2,1,2,3,2,1,...\$, and repeats indefinitely. A wave of power 1 is an infinite array of ones. They happen to be beautifully expressed as $$w_k[t] = k - |(t - 1)\bmod(2k - 2) - k + 1|\text{, 1-indexed}$$
In this challenge, all waves are trimmed to their first \$n\$ elements, where \$n\$ is the length of the input array.
A decomposition of an array into waves is an array of coefficients of length \$n\$ such that the original array equals the sum of the waves multiplied by their corresponding coefficients. Formally, if the original array is \$A\$, the decomposition is an array \$B\$  such that for any \$i\$  (\$1 \le i \le n\$) the following equality holds:
$$A[i] = \sum_{j=1}^\infty B[j] \cdot w_j[i]\text{, 1-indexed}$$
The waviness of an array is the index of the last non-zero value in its decomposition into waves.
The task is, given a positive integer array of length \$n\$, to calculate its waviness. Note that the decomposition can still include non-integer and negative numbers.
Test cases
All test cases below are 1-indexed. Your solution may use 0-indexing instead.
[1, 1, 1] -> 1                 (decomposition: [1, 0, 0])
[1, 2, 1] -> 2                 (decomposition: [0, 1, 0])
[1, 2, 3] -> 3                 (decomposition: [0, 0, 1])
[1, 1, 2] -> 3                 (decomposition: [1, -0.5, 0.5])
[1, 3, 3, 3, 1] -> 3           (decomposition: [-1, 1, 1, 0, 0])
[1, 2, 2, 4] -> 4              (decomposition: [0, 0.5, -0.5, 1]
[4, 6, 9, 1, 4, 3, 5] -> 7     (decomposition: [2, -0.5, 5, -5, 6.5, -1, -3]
[4, 6, 9, 1, 4, 3, 5, 7] -> 8  (decomposition: [2, -0.5, 5, -5, 6.5, -1, -10.5, 7.5])

This is tagged code-golf an uncommon justification, so the shortest answer wins.

Deleted sandbox post

APL (Dyalog Unicode), 34 33 27 bytes
⊢{⊢/⍋0≠⍺⌹⍉↑(1+⍵⍴⍳,⊢-⍳)¨⍳⍵}≢

Try it online!
Lots of golfing thanks to ngn.
How it works
g←⊢{⊢/⍋0≠⍺⌹⍉↑(1+⍵⍴⍳,⊢-⍳)¨⍳⍵}≢  Accept a vector V of length N
  ⊢{                       }≢  Call the inner function with ⍺=V, ⍵=N
                         ⍳⍵    Make 0..N-1
             (    ⍳,⊢-⍳)¨      For each i of above, make 0..i-1,i..1 and
              1+⍵⍴               repeat/truncate to length N and +1
         ⍺⌹⍉↑                  Reform above as matrix and solve equations
       0≠                      Test nonzero on each item (nonzero→1, zero→0)
    ⊢/⍋                        Find the last index of 1

APL (Dyalog Unicode), 34 33 bytes
⍴-0(⊥⍨=)⊢⌹∘⍉∘↑1+⍴⍴¨(⊢,1+⌽)∘⍳¨∘⍳∘⍴

Try it online!
Uses ⎕IO←0 and an alternative way to generate the matrix W.
g←⍴-0(⊥⍨=)⊢⌹∘⍉∘↑1+⍴⍴¨(⊢,1+⌽)∘⍳¨∘⍳∘⍴  Accept a vector of length n
                                ⍳∘⍴  Make a vector 0..n-1
                     (⊢,1+⌽)∘⍳¨      For each k of above, chain 0..k-1 and k..1
                  ⍴⍴¨                  and repeat or truncate to length n
                                     The first row has 0 elements, repeat gives n zeros
                1+                   Increment all elements
  ⍴-0(⊥⍨=)⊢⌹∘⍉∘↑                     The rest is the same as the previous answer

APL (Dyalog Unicode), 34 bytes
⍴-0(⊥⍨=)⊢⌹∘⍉∘↑⍴⍴¨(⊢,1↓¯1↓⌽)∘⍳¨∘⍳∘⍴

Try it online!
A monadic train that accepts a numeric vector.
How it works
g←⍴-0(⊥⍨=)⊢⌹∘⍉∘↑⍴⍴¨(⊢,1↓¯1↓⌽)∘⍳¨∘⍳∘⍴  Accept a vector of length n
                                 ⍳∘⍴  Make a vector 1..n
                   (⊢,1↓¯1↓⌽)∘⍳¨      For each k of the above, generate one unit of wave of power k (1..k..2)
                ⍴⍴¨                   Repeat or truncate each row to length n (result is nested vector)
             ⍉∘↑                      Convert nested vector to matrix, and transpose it
          ⊢⌹                          Solve the linear equation
    0(⊥⍨=)                            Count trailing zeros
  ⍴-                                  Subtract from n

Basically, this solution uses the same W matrix as Arnauld's submission, solves the linear equation, and then finds the index of the last nonzero entry using the good old "count trailing ones" ⊥⍨.

I know 33 is without it, but you might want to remove g← from the leading one.

JavaScript (ES6),  172 171  169 bytes
The output is 0-indexed.
a=>a.map((_,i)=>(D=m=>+m||m.reduce((s,[v],i)=>s+(i&1?-v:v)*D(m.map(([,...r])=>r).filter(_=>i--)),0))(a.map((v,y)=>a.map((_,x)=>x-i?x-~-Math.abs(y%(2*x)-x):v)))&&(j=i))|j

Try it online!
How?
This is essentially an implementation of Cramer's rule, except that the denominator is not computed.
Given the input vector of length \$n\$, we define \$W_n\$ as the matrix holding the waves, stored column-wise.
Example:
$$W_5=\begin{pmatrix}
1&1&1&1&1\\
1&2&2&2&2\\
1&1&3&3&3\\
1&2&2&4&4\\
1&1&1&3&5\end{pmatrix}$$
We compute all values \$v_i=\det(M_i)\$ with \$0\le i<n\$, where \$M_i\$ is the matrix formed by replacing the \$i\$-th column of \$W_n\$ with the input vector.
Example:
For the 5th test case and \$i=3\$, this gives:
$$v_3=\det(M_3)=\begin{vmatrix}
1&1&1&\color{red}1&1\\
1&2&2&\color{red}3&2\\
1&1&3&\color{red}3&3\\
1&2&2&\color{red}3&4\\
1&1&1&\color{red}1&5\end{vmatrix}=0$$
We return the highest index \$j\$ such that \$v_j\neq0\$.
Commented
The helper function \$D\$ uses Laplace expansion to compute the determinant:
D = m =>                     // m[] = matrix
  +m ||                      // if the matrix is a singleton, return it
  m.reduce((s, [v], i) =>    // otherwise, for each value v at (0, i):
    s                        //   take the previous sum s
    + (i & 1 ? -v : v)       //   based on the parity of i, add either v or -v
    * D(                     //   multiplied by the result of a recursive call:
      m.map(([, ...r]) => r) //     pass m[] with the 1st column removed
      .filter(_ => i--)      //     and the i-th row removed
    ),                       //   end of recursive call
    0                        //   start with sum = 0
  )                          // end of reduce()

The matrix \$M_i\$ is computed with:
a.map((v, y) =>         // for each value v at position y in the input vector a[]:
  a.map((_, x) =>       //   for each value at position x in the input vector a[]:
    x - i ?             //     if this is not the i-th column:
      x -               //       compute the wave of power x+1 at position y:
      ~-Math.abs(       //         x - (|y mod (2*x) - x| - 1)
        y % (2 * x) - x //         (where y mod 0 is coerced to 0)
      )                 //
    :                   //     else:
      v                 //       append the value a[y] of the input vector
  )                     //   end of inner map()
)                       // end of outer map()

MATLAB, 111 bytes
function w=f(A)
n=length(A)
W=ones(n,1)
for k=2:n
W(1:n,k)=k-abs(mod(0:n-1,2*k-2)-k+1)
end
w=max(find(W\A))
end

I'm new to this, do MATLAB answers have to be in a function, or can we assume A is set implicitly?
The code is straight-forward. The sum in the OP can be replaced with a simple matrix multiplication, A = W*B. The code computes B = inv(W)*A and finds the index of the last non-zero entry in B. mod(x,0) isn't well-defined, so the first row has to be set manually.

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


text:
Create a program that prints the number of characters it has, in words
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?

Proper spacing is also required. Does this mean no trailing spaces in the output?

To solve it in Unary, is there a list of larger units?

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.

Clearly it comes a long way, writing stuff I say. Beautiful poem, have a +1.

@A_ Thanks, it's always fun to create coherent sentences based on pre-determined word lengths.

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

You can add a &tl=en at the end of your URLs to force it to show in English. My Google translate was set to English to Persian from a previous translation and after opening your links, it was showing the resulting numbers in Persian :P Here is also a 2 chars version, converting Persian دو to English Two.

...also (Latin-ised) Hindi "do".

and albanian dy

to is Norwegian and Danish for two (and we also say tre for three). Google translate doesn't autodetect that one, though.

cinco, that means five in Spanish

insert obligatory "google translate isnt a programming language" complaint

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.

Whoops, I don't know why I was trying to use different cells for each letter... Nice

@HiddenBabel Thanks. forty turned out really well. I think for NINETY the optimum would be one cell for NNTY and one cell for IE

So I guess you already looked for thirty with one cell for trty and one for hi? I can't find a singular loop that will set both of them close by.

Indeed, forty is the only number whose letters are in ascending alphabetical order.

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!

Now we're looking for a language where there's a 1-char command that prints one, or where the empty program prints zero. That's going to be interesting.

@Nat MathGolf can use Code Page 437, in which ╩ is one byte (0xCA)

@Nat MathGolf has a built-in dictionary, the first 256 words of which can be accessed using ╩ followed by one byte. The word at index 95 (the code point for _) is "two", so "two" is pushed to the stack and implicitly printed when the program exits. (I think, I haven't used MathGolf)

Python 3, 15 bytes
exit("fifteen")

...prints to STDERR.
Try it online! (see the "debug" panel)

I had print('sixteen'), you win :)

print'ten', in Python 2?

@JuanCa yes

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

I think ONE THOUSAND is expected.

@A_ EIGHT HUNDRED then! Mooooo!

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

Never would have thought of this one: +1

PHP, 4 bytes
four

Try it online!

PHP, 9 bytes
<?= nine;

Try it online!

Your first example also works with cat.  (The unix command, not the animal.)

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

Is it possible to add a code break-down, or if you can't say how it works then how it was produced?

There exists a certain Malbolge generator. It is very useful in generating short Malbolge code. :)

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

As an IP address range this answer geolocates to the United Kingdom with Vodafone wireless broadband.

@PurpleP Ha ha awesome.

@PurpleP First thing I thought of when seeing this answer (IP address, not UK Vodafone)

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

How many bytes is this?

@JoKing Depends on the fileformat for the image, which is why Piet is generally counted in codels.

Yes, but this is [tag:code-golf], so it is measured in bytes

@JoKing That is curious. I have not seen that comment on any other Piet answers.

Emoji, 18 bytes
⛽eighteen➡

Try it online!

Emoji, 8 chars
⛽eight➡

Try it online!

⛽➡  ...gasoline makes the car go?

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)

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

SOGL V0.12, 3 bytes
Well, SOGL has a string compression library that seems to compress "three" to 3 bytes.
@0‘

Try it Here!

Gratz, unless a language exists which prints zero, nowt, or nought with an empty program this is probably as good as it'll get.

...I stand corrected!

Brainf***, 90 bytes
+[+[>>+<+<-]>]>[>+>+>+>+>+>+<<<<<<-]>.>-----.>.>---------.>++++++.>+++++++++++.<+><><><><>

Try it online!

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.

This is a nice find!

@ouflak Thanks, although I must admit it's very similar as the Hello World! answer in Lost. It took a while before I realized I could use an unprintable to output thirty, though. Otherwise I would have had to settle with forty with a bunch more no-op trailing >.

You can do /J to avoid the unprintable if you like

@JoKing Ah, I tried some combinations with both addition and subtraction of the arrow, but forgot about the reflects / and \. Thanks, that indeed looks better. :)

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`;

@Night2 The JS print function is used for printers, not console output, I think.

@Night2 Ah, makes sense. I'll update the TIO, but keep it as alert on here since it's more recognizable (sort of)

Where can I find some explanation regarding the syntax used here? I've never seen this before (ommiting the brackets), but it indeed works with any function. What's it called?

@TomášZato They're called tagged templates. I found some info on them here, in the Tagged templates section

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

Ah, didn't see your answer when I posted mine. Good job!

Jelly, 4 bytes
“Ɱ9»

Try it online!

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!

sixty?

Would be nine if lambdas were allowed.

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.

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.

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.

Yeah, that's all and well.

vemf, 6 5 bytes
"five

Outputs five. try it online

Welcome to Code Golf! Looks like an interesting language.

Python 3, 16 bytes
print("sixteen")

Try it online!
Also works in Proton.

I think you just beat me to this. Same code works in both Python 3 and Lua.

ink, 4 bytes
Four

Try it online!
Predictably enough, it prints Four

Turing Machine Code, 60 50 bytes
0 _ f r 1
1 _ i r 2
2 _ f r 3
3 _ t r 4
4 _ y r 50

Try it online!
As an added bonus, if that counts for anything, it has the number in the code as well.
Edit: Found a shorter solution which still contains the number of bytes in the code.

It doesn't count but nice stuff.

Batch, 10 bytes
@ echo ten

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

Why not just echo nine?

@Night2 Because that echos the command echo nine as well as its output.

But running directly from command prompt, doesn't do that (unless it doesn't count as Batch).

@Night2 No, that would be a snippet, or a REPL, or something along those lines.

05AB1E (legacy), 3 bytes
“„í

Try it online!
Using dictionary

Works with ' instead of “ too. Also why legacy?

@Makonede yes it seems to work but honestly Idk osabie I wrote this following the docs, I was sure it has a dictionary. One of the most interesting esoteric languages for sure.. Maybe I 'll try to learn in the future!

Bash,  15  9 bytes
echo nine

Try it online!
Thanks to:
- @Night2 for saving me 6 bytes

9 bytes. By the way you can click on  icon in https://tio.run and copy/paste "Code Golf submission (Stack Exchange)" section here to have auto generated answer with correct formatting.

@Night2 Thank your for the improvment and the tip :)

Hexagony, 9 bytes
n;i;@;e\\

Try it online!
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).
Not How it works
This Hexagony program looks almost like normal code!
n;i;@;e\\
n;i;       Pushes n and prints it, then pushes i and prints it
    @;     Retrieves the bottom of the stack (n) and prints it
      e\\  Pushes e and terminates the program, printing implicitly

How it works

Input starts on the blue path, storing the value n then printing it with ;. It picks up the value i, then jumps to the third line where it hits a mirror. This takes it to the diagonal path, reentering the value i then printing it with ;.
From the bottom left corner, since the current value of i is truthy, it jumps to the red stream starting in the top-left corner, taking n then printing it with ;. The two mirrors redirect it and then it jumps to the e. Finally, it jumps from the middle of the bottom edge to the middle of the top edge, printing the e with ; and terminating with @.

Thanks to Timwi for their HexagonyColorer.

TI-Basic, 5 bytes
"FIVE

Also works with "SEVEN".

One that's shorter (but not really) "Six

GolfScript, 6 bytes
Push six. Implicit print.
 'six'

Try it online!

Lua, 10 bytes
print"ten"

Also works in many BASIC dialects that don't have a ? shortcut for PRINT

Japt, 4 bytes
`fr

Test it here

Backhand, 6 bytes
"s"xiH

Try it online!
Outputs "six".

Whitespace, 151 60 bytes
[S S S T    T   S N
_Push_6_Y][S S S T  N
_Push_1_T][S S S T  S T N
_Push_5_X][S S T    T   S T S N
_Push_-10_I][S S S S S N
_Push_0_S_(with_two_additional_no-op_spaces)[N
S S N
_Create_Label_LOOP][S S S T S T S S T   T   N
_Push_constant_83][T    S S S _Add_top_two][T   N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.
Try it online (with raw spaces, tabs and new-lines only).
Whopping -91 bytes thanks to @JoKing by using an < instead of == check in my Java program below and adding no-ops.
Shortest program generated with this Java program, which uses the printing approach of this Whitespace tip to output in full uppercase.

R, 7 6 bytes
 "six" #space before the text

Previously:
"seven"

Also works in PHP without the opening PHP tag. In fact, with PHP you could have simply four

Ruby, 6 bytes
Ruby has an extremely convenient builtin p that prints the string.
p'six'

Try it online!

Are the quotes allowed?

Red, 10 bytes
print 'ten

Try it online!

Japt, 5 bytes
"five

Try it online!

Welcome to Japt :) I'll be reopening my bounty (with slightly lower rep) for new users on Monday or Tuesday if you'd like to try for it. I'll count any solutions you post between now and then towards it, including this one. You're welcome to my solution, if you'd like; didn't see yours before posting.

Thank you @Shaggy ! I'll try it for sure even if I'm scared by the characters used since I do everything from a phone.. Btw I was sure there was some compression available in Japt, my bad I didn't checked.

This also works in TI-Basic (with all caps) "FIVE

Zsh, 6 bytes
<<<six

Try it online!

C (gcc), 25 20 bytes
f(){puts("twenty");}

Try it online!

"twenty" works

@12Me21 I am a fool.

APL (Dyalog Unicode), 12 9 6 bytes
Took me a little searching and I don't like requiring the extra spaces, but such are the vagaries of English numbers.
Edit: -3 bytes thanks to Night2. -3 bytes thanks to ngn.
⊢'six'

Try it online! And a slightly different version to get it to work on Try it online!

is ⎕← required? dyalog prints results by default. if not: ⊢'six'

@ngn Not in TIO https://tio.run/##SyzI0U2pTMzJT////1HXIvXizAr1//8B

but. or. generally, in kolmogorov complexity challenges we don't add ⎕←.

@ngn In that case, I've added both.

R, 10 bytes
cat("ten")

Try it online!
Prints ten. This simple answer is much shorter than all the other options I could think of.
If a bit of fluff around the answer is allowed, we can go with
R, 6 bytes
"six";

Try it online!
which prints [1] "six".
If a lot of fluff is allowed, we could even go with
R, 4 bytes
four

Try it online!
which prints to STDERR Error: object 'four' not found.

Brain-Flak, 80 bytes
((((((((()()()())))((({({}){}}()){}){}()))[[]])())[][][])[]){({}<>)<>}<>........

Try it online!
The code to push eighty is 72 bytes and we add an extra 8 bytes to bring it to the correct amount.
Brain-Flak, 80 bytes
(((())()()()())((([]())())[][][])){({}(([]([]<>[])[]{}()){}){})<>}<>............

Try it online!
This version pushes EIGHTY and requires 12 bytes of padding.

Commodore BASIC (TheC64/Mini, C64/128, VIC-20, PET, C16/+4) 25 tokenised and BASIC bytes
 0 print"seventeen

I could use the abbreviated ? but when listed the program will show the full print keyword. In any case it would make no difference to the byte count as ? and print use the same number of BASIC tokens.

Perl 5, 9 bytes
say"nine"

Try it online!

cat, 4 bytes
four

There are plenty of literal "four" answers already, but not one written in cat yet.

Also works in Text

VTFF, 1524 600 bytes
-924 bytes thanks to Jo King
New answer:

Readable version:
VVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVFVFVFVVVVVVVVVVVVFVFVFVVVFVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVV

For info on how the lang works, I can't be bothered to rewrite it all, so see the old answer:

Those bytes can be seen in the source code of this answer. They could be earlier, but they're apparently gone now. Alternatively, here it is with Vertical Tab characters replaced with Vs and Form Feeds replaced with Fs:
VVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVFVVV

Try it out here by putting the string "ONE THOUSAND FIVE HUNDRED TWENTY FOUR" in "Generate", then copying the output of that into "Interpret".
Explanation: VTFF is a language I found by hitting Random page on the Esolangs wiki a lot. The only characters are the vertical tab (0x0b) and form feed (0x0c), hereafter referred to as just V and F. Each block of V characters separated by F characters represents a number in unary. 32 is then added to that number and it is then converted into a character. This repeats until a string is built. That string is then sent to a JS eval statement, the output of which is the output of the program. Because the positions of out characters on the Unicode code table matter, capital letters are preferable to lowercase ones, because their unary representations are 32 bytes shorter. That said, if it ended up being 32 or 64 low I was happy to sprinkle in some lowercases if need be, but thankfully that didn't turn out to be the case. I obtained this with 15 minutes or so of manual brute forcing, where it quickly became clear that the 1500s would be easiest. If you automated the process, I imagine you could dip into the 1400s. Maybe there's even a really lucky one where you don't need all four digits. "FIVE HUNDRED" comes out at a frustrating 499 characters, for example.
Bonus fact: if you did this in binary VTFF (an imaginary language I just made up where it's just VTFF encoded in binary), you could get this down to just "FOURTY" bytes.

Would binary work for "FORTY" as well? :P

By adding some excess code, you can get this to "six"  +  " HUNDRED"

@JoKing Awesome, I changed it. I might give this another shot later today to see if there's something yet more clever to be done. Five hundred feels so close!

Red, 10 bytes
prin "ten"

Try it online!

Zsh, 6 bytes
<<<six

Try it online!

...You could just use six, ya know...

@EasyasPi lol oops

Vyxal, 3 bytes
`∧ḭ

Try it Online!
Pushes "three" as a dictionary-compressed string and implicitly outputs.

05AB1E, 5 bytes
"five

Try it online!

Welcome to Code Golf! Nice first answer.

Cascade, 9 bytes
"
n
i
n
e

Try it online!
Don't know why I didn't think of this earlier.

Rattle, 5 bytes
five|

Try it Online!
This is pretty simple - it takes "five" as a variable then outputs it implicitly

Factor, 9 bytes
[I nineI]
Attempt This Online!

Wolfram Language/Mathematica, Multiple Solutions, Bytes vary
four
"seven"
Print@"fifteen"
Echo@"fifteen";
Text[+"sixteen"]
FromCharacterCode@{70,105,102,116,121,32,70,73,118,101}
All of these work and are quite trivial, except for the last one, which actually took a bit of thought.

Minecraft Command Blocks, 11 bytes
w @a eleven

Whispers eleven to every player

If @ whispers to you:  is not allowed
tellraw @a "twenty four"

outputs just twenty four and is 24 bytes.

Go, 45 40 bytes, to STDERR
package main
func main(){print("forty")}

Attempt This Online!

-5 bytes for using forty, by @The Thonnu

Go, 59 bytes, to STDOUT
package main
import."fmt"
func main(){
Print("fifty nine")}

Attempt This Online!
An extra character is needed here (in this case a newline on line 3) because if it is not, then the byte count cycles between fifty eight (59 bytes) and fifty nine (58 bytes).

40 on first answer (STDERR)

For functions (not sure if allowed): 30 and 41

Befunge-98 (PyFunge), 9 bytes
"NINE,,@#

Try it online!
Explanation
"            Start stringmode
 NINE,,@#    Push "NINE,,@#", wrap to left
"            End stringmode
 N           Reflect (no fingerprint loaded)
"            Start stringmode, wrap to right
 NINE,,@#    Push "#@,,ENIN"
"            End stringmode, wrap to right
       @#    Jump over halt
     ,,      Print "NI"
    E        Reflect
     ,,      Print "NE"
       @     Halt

Slightly different (maybe nicer) solution
"Nine@,k3

Instead of bouncing back and forth over ,,, this just iterates it with 3k,. Also allows the subjectively nicer "Nine" instead of "NINE".

Forth (gforth), 16 bytes
S" sixteen" TELL

Try it online!
I tried doing ." <number>" but that didn't line up with anything under 20. I guess I could have padded with whitespace or a 0 DROP or something but that feels like cheating. Also this should work with any sane forth, not just gforth.

"any sane forth" Are there insane forths?

Python 2, 10 bytes
print'ten'

Try it online!

Lua, 16 bytes
print('sixteen')

Try it online!

Retina 0.8.2, 5 bytes

five

Try it online! Simply substitutes the empty input with the word five, which is the first word to have one fewer letter than its value.

BASIC, 6 bytes
?"SIX"

(Specifically tested in SmileBASIC: should work in most dialects, though ? is often expanded to PRINT, I think it's usually still stored as one byte)

Cascade, 9 bytes
"
n
i
n
e

Try it online!

Scheme, 5 bytes
This works in any Scheme implementation, but Chicken Scheme is what I used.
'five
EDIT: Alternative 4-byte solution
four outputs this:
Error: unbound variable: four
I think this counts, but if you don't like errors, the above solution is for you.

bit**, 30 bytes
#116/#104/#105/#114/#116/#121/

Try it online!

Inform 7, 21 bytes
To q:say 21 in words.

This creates a function which takes no arguments and returns nothing, which prints the word "twenty-one".
Some boilerplate showing how to call the function:
X is a room.
When play begins: q.

Unfortunately, hardcoding the string tends to put me at a number of characters that's harder to print.

Does this output a hyphen? If so, that's against spec unfortunately.

C (gcc), 29 bytes
main(){puts("twenty nine");;}

It's an actual program...
Try it online!

Python, 20 bytes
print("twenty")#lol.

hey! that's python code length is actually 20 characters. I know, It's cheating but the comment is still a text.
print("twenty")

prints the number. (15 chars)
#lol.

a useless comment. (5 chars)
so 5+15=20 and 20 is twenty, right?

Please include the byte count in your submission. There's no reason to think that comments are cheating. As a hint, can you think of a smaller number that has a longer word, but fits without the comments?

Welcome to CGCC, I have updated your answer to include bytes count in the title and look better. If you like, you can use https://tio.run to provide an online working example of your code too. It also allows you to copy an auto generated answer with all the formatting ready to be posted. When you are done with your code, you can click on  icon and copy "Code Golf submission (Stack Exchange)" section here to post as an answer.

print("sixteen")

Some answers with "production" (i.e. non-golfing) languages still not mentioned here:
C++ (clang), 55 bytes
#include<iostream>
int main(){std::cout<<"fifty five";}

Try it online!
Scala, 23 bytes
println("twenty three")

Try it online!
Haskell, 27 24 bytes
main=putStr"twenty four"

Try it online!

For Haskell you could do main=putStr"twenty four"

@SaraJ Thanks! Fixed.

For all of these you can remove the digits part and just leave the fifty/twenty

this is years old, but the C++ answer can be easily golfed down to print fifty, and the Scala answer seems to throw an error in TIO

Gaia, 5 bytes
five”

Just a string literal that gets implicitly output.
Try it online!

Tcl, 9 bytes
puts nine

prints
nine

Try it online!
Tcl, a lot more bytes (not finished yet) currently 42
this will read the source code counts the characters and convert the number into an actual number word.
content of c.tcl:
puts [string length [read [open c.tcl r]]]

prints:
% 42

Runic Enchantments, 6 bytes
"Six"@

Try it online!
This ended up being both much shorter and much less interesting than I anticipated. 3 bytes are required for syntax, making it impossible to go lower.

W, 5 bytes
five"

Implicitly prepends a quote. In order to specify your input, find prog.py and do this:
read = []

prog = 'five"'

Wren, 26 bytes
Just a method that outputs a string literal.
System.write("twenty six")

Try it online!

The number of quotes in your first program is definitely not odd...

W automatically "prepends" a quote z.

Ah, that makes sense. Interesting!

Husk, 3 bytes
¨◊ė

Try it online!

PowerShell, 6 bytes
Note the space before the first quotation mark.
 "six"

Try it online!

Ruby, 9 bytes
puts:nine

Try it online!
Longer than the other answer, but does not output extra characters

Ceylon (Web IDE), 18 bytes
The Ceylon Web IDE allows to omit all the boilerplate which makes up a normal program, so we can use just the actual print statement:
print("eighteen");

Try it online!
Ceylon (with run function), 30 bytes
void run() { print("thirty");}

Try it online!

Java 8 (full program), 75 70 bytes
interface M{static void main(String[]a){System.out.print("seventy");}}

-5 bytes thanks to @CommandMaster.
Try it online.
Java 8 (lambda function), 9 bytes
v->"nine"

Try it online.
Java 5/6 (full program), 40 bytes
enum M{A;{System.out.print("forty");}}//

No online compiler, because I don't know any for Java 5 or 6..
The trailing // are no-ops, but outputting forty is shorter.

Can't you output seventy in the first solution?

@CommandMaster Lol, I indeed can.. :/ Thanks!

T-SQL, 10 bytes
print'ten'

I guess is correct, right?
:)

What kind of SQL is this? I'm not aware of such a command/query, but I know you can do SELECT'fifteen'.

@Night2 It's Microsoft SQL Server. And yes, but that's 5 bytes more :P

you should probably make this T-SQL as the language

@MickyT Thank you!

Cubix, 20 bytes
/o;."uytnewT.p^@!<..

Try it online!
This wraps onto the cube as follows
    / o
    ; .
" u y t n e w T
. p ^ @ ! < . .
    . .
    . .

Watch it run

"uytnewT open string and start pushing uytnewT onto the stack
"u close the string and u-turn onto the lower line
p bring the bottom of the stack to the top
<! beginning of the print loop and test for 0

@ halt if tested 0
^y;/oe redirect up, no-op, pop TOS, reflect right, output character, no-op and then onto the beginning of the print loop

Erlang, 5 bytes
five.

Enter this code at interpreter prompt.

dc, 6 bytes
[six]P

prints:
six

Hexadecimal Stacking Pseudo-Assembly Language, 80 bytes
200079400000200074400000200068400000
200067400000200069400000200045400000
140000

Try it online!

Malbolge, 30 bytes
('B;_#!~[|:9zVw/.uQrOqon&Jl6"'

Try it online!
Created with ZB3's Malbolge Tools

Underload, 6 bytes
Try it online!
(six)S
Explanation
(six)  Puts the text "six" onto the stack.
S      Prints it.

Charcoal, 4 bytes
four

Try it online
The program just implicitly prints the string literal.

International Phonetic Esoteric Language, 8 bytes
"eight"o

Pushes and prints the string "eight".

Pip, 6 bytes
"six";

Try it online!
; is a comment.

Also a polyglot in R, and this exact 'program' was even already submitted in R

And, as a bonus, the other answer in R is also a polyglot in Pip

I've been trying to find easy challenges for R, but all of them somehow have an R solution

I don't think that should stop you from having a go.  I wish there were more challenges with more-than-one answer in R (or any other language).  It's really fun & instructive to see the different approaches.  Obviously, one of them will always be the shortest, but that isn't a problem.  I usually try to deliberately avoid looking at any other R answers if there already are any, and post my own answer if it ends-up different from whatever is already there, even if it's longer (and usually one of the other R golfers then makes it shorter for me anyway...).

For instance, this recent challenge got 4 independent (and all different) R answers...

MAWP, 30 bytes
99W3M!;98W!;1M;2A!;2M!;11MM3M;

Try it!
prints in capitals.

naz, 30 bytes
9a9m3a1o9s3s1o1a1o9a1o2a1o5a1o

Outputs THIRTY.

StupidStackLanguage, 55 30 bytes
avvdqvdmdfwwddfifvvdfiifvfaaaa

Try it online!
I found this by generating a list of numbers 1 - 100 as words, and then mapping said array with my StupidStackLanguage printing algorithm to generate an array of number printing programs. I then padded each program in the array with meaningless a characters until the number of characters it had equalled it's position in the array. Then, I just found the first program which had the same length as the number it printed.

Pxem, Filename: 6 bytes + Content: 0 bytes = 6 bytes.

Filename: six.px
Content is empty.

Sorry for a boring post.
Try it online!

This challenge states to output the number of characters in your program, not your score (filename+program). So you have to add a byte: zero.px

BRASCA, 5 bytes
`five

Try it!
Explanation
`five      - Push "five" on the stack, char by char
<implicit> - Print the stack, reversed

Japt, 4 bytes
Lucked out that the string compression found anything to compress in one of the smaller numbers.
`f r
`    // Decompress compressed string
 f r // Compressed string literal for "four"

Try it here.

Duocentehexaquinquagesimal, 39 32 bytes
ÖtΛ‰[WåÙUYr™{—*l”î)‘RçÊí¹©ÓûŽUQ‹

Try it online!

Knight, 6 bytes
O"six"

Try it online!
Not much to explain; O is shorthand for OUTPUT.

8086 DOS .COM file, 16 bytes
Hexdump:
0CD5:0100  B4 09 BA 08 01 CD 21 C3-73 69 78 74 65 65 6E 24 ......!.sixteen$

Assembly source:
        // NASM syntax with C comments because no SE highlighting
        [org 0x100]
        section .text
        global start
start:
        // int 21:09: write $-terminated string in ds:dx
        mov     ah, 0x09
        mov     dx, str
        int     0x21
        // exit
        ret
str:
        db      "sixteen$"

8086 DOS .COM file, dirty exit, 10 bytes
This one prints "ten" and then does whatever, likely in the form of a crash.
0CD5:0100  B4 09 BA 07 01 CD 21 74-65 6E                   ......!ten

        // NASM syntax with C comments because no SE highlighting
        [org 0x100]
        section .text
        global start
start:
        // int 21:09: write $-terminated string in ds:dx
        // but it prints even if it isn't $-terminated so why bother?
        // It's real mode, it'll find a $ eventually™
        mov     ah, 0x09
        mov     dx, str
        int     0x21
        // exit
        // jk
str:    // not $ terminated
        db      "ten"

Vyxal, 3 bytes
`∧ḭ

Try it Online!
Dictionary compression FTW!!!

Barrel, 4 bytes
four

Implicitly prints the unknown instructions "four". However, this could potentially be voided by later modifications, so here's a safe 5-byter that uses a string:
'five

AWK, 20 bytes
BEGIN{print"twenty"}

Try it online!

Emmental, 30 bytes
#84.#72.#73.#82.#84.#89.######

Try it online!

tinylisp, 6 bytes
Very simple solution, (q quotes the name after it to prevent it from being evaluated, the parentheses are implicitly closed at the end of the line, and the result of the top-level statement is implicitly outputted,
(q six

Try it online!

EEL - 78 Bytes
=83 !>=69 !>=86 !>=69 !>=78 !>=84 !>=89 !>=32 !>=69 !>=73 !>=71 !>=72 !>=84

Explanation
EEL (Easy Esoteric Lang) is an esoteric programming language created by me, easy to manage, hence the name. Below is a brief description of the language.
.-EEL is based on a vector of bytes initialized to zero, on which basic arithmetic operations can be performed, whose length is equal to 64Kb.
.-EEL allows the reading and writing of one byte at a time in the form of an ASCII character in the standard input and output respectively.
.-EEL has a brief help section which can be viewed from the interpreter.
.-EEL is extremely sensitive, so a wrong input byte can cause a wrong output.
.-EEL does not have an error/exception handling system, so it may crash unexpectedly if a fatal error such as division by zero occurs.
Defined operations:
=000 -> Copy the value of number 000 to the current byte.
+000 -> Add to the current byte, the value of number 000.
-000 -> Subtract to the current byte, the value of number 000.
*000 -> Multiply to the current byte, the value of number 000.
/000 -> Divide to the current byte, the value of number 000 (cannot be zero).
%000 -> Calculate the modulo of the current byte and the value of number 000 (cannot be zero).
> -> Go to the next byte of the vector.
< -> Go to the previous byte of the vector.
? -> Read a ASCII character from STDIN and assign it to current byte.
! -> Write to current byte in STDOUT as an ASCII character.
: -> Open/close the space for comments.
. -> Exit the program.
$ -> Reference to current byte.
NOTES:
The 000 number can be s current byte reference operator ($).
The 000 number (x) must be an integer number, such 0 < x <= 255.
There must be a space character u+0020 after each number 000.
Try the EEL interpreter!

Thunno, \$ 5\log_{256}(96)\approx \$ 4.12 bytes
"five

Attempt This Online!
Pretty simple.

Z80Golf, 10 bytes
00000000: 3e74 ff3e 65ff 3e6e ff76                 >t.>e.>n.v

Try it online!
  ld a, 't'
  rst 38h
  ld a, 'e'
  rst 38h
  ld a, 'n'
  rst 38h
  halt

Nim, 10 bytes
echo "ten"

Attempt This Online!

Aheui (esotope), 52 bytes
발밦밞발밞다받받밞밞따댜먛뻐더희xxxx

Try it online!
Contains 20 chars (16 hangul and 4 unused ascii) and prints TWenty. 19 seems to be out of reach. NINTeen barely fits, but the correct spelling of 19 is "nineteen".
밞바밣밞다밦발바발타밞밞따받탸먛뻐더희

Try it online!

Aheui (esotope), 40 bytes, solves for bytes instead
발박받밞밝발박따땨먛뻐더희

Try it online!
Prints FORTY. The strictly increasing nature of FORTY is useful again.
Each Hangul character costs 3 bytes, so 40 bytes can fit 13 chars and a newline. Luckily FORTY can be printed in exactly 13 chars (4 for charcode differences, 5 for the value 70, 3 for "dup; print; add" loop, and 1 for halt).
발박받밞    Push 5, 2, 3, 9
밝발박따따  Push 70 (7 * 5 * 2)
빠맣다      Loop: dup; print as char; add
            Break when add fails
희          Halt

Because the challenge says "Create a program which prints the amount of characters its source has in English words." and not "bytes", shouldn't this print "fourteen"?

@TheThonnu Good point. Added a solution for characters.

Julia 1.0, 15 bytes
print(:fifteen)

Try it online!

><>, 9 bytes
"ooooENIN

Try it online!
Prints NINE and halts with error (E is not a valid command).

Zalgo, 54 bytes
t̝̐̄̇h̝̐̈̆i̝̐̉̆r̝̐̂̇t̝̐̄̇y̝̐̉̇

Escaped with each cluster per line:
t\u031d\u0310\u0304\u0307
h\u031d\u0310\u0308\u0306
i\u031d\u0310\u0309\u0306
r\u031d\u0310\u0302\u0307
t\u031d\u0310\u0304\u0307
y\u031d\u0310\u0309\u0307

Prints thirty. Pushing a constant and printing takes 4 characters, and the first number whose length in English is strictly smaller than 1/4 of its value is 30. For stylistic reasons, each grapheme cluster in this code prints its root character (e.g. t̝̐̄̇ prints t). Python code used to generate the source.

Zalgo, 25 bytes, 1 grapheme cluster
I̝̝̝̐̏̆̐̎̆̐̅̆

Escaped:
I\u031d\u031d\u031d\u0310\u030f\u0306\u0310\u030e\u0306\u0310\u0305\u0306

Prints one. Validity of this answer depends on the definition of "character" in this challenge. Python code used to generate the source.

Stax, 5 bytes
äφ╓Dr

Run and debug it
Just unpacks to "five", which is then implicitly output

MSM, 11 9 6 bytes
xsi/..

The 3 letters are pushed on the stack, / swaps s and i to get the correct (reverse) order and the two 3 dots concatenate them to a single string. There are variants such as '.xis. or ?..xis.
Try it online!
Edit: -3 bytes thanks to @Night2

Pepe, 50 bytes
reeEEeeEEereeEEeEeeEreeEEeeEEereeEEEeEeereeEEEEeeE

Try it online!

C# (Visual C# Interactive Compiler), 18 bytes
Write("eighteen ")

Try it online!

SWI-Prolog, 15 bytes
write(fifteen).

Try it online!

Ten: write(ten)?

Apparently that works in the online version :)
But in the terminal versions, we have to close it with a dot.

You can always limit your answer to a specific version. This is code golf, doesn't matter if the answer is not cross-compatible.

Pyth, 5 bytes
"five

Try it online!
I don't think it's possible to get shorter than this. The overhead for compressed strings is 4 bytes already, so it's impossible to also get a 4-byte message in it.

rusty_deque, 12 bytes
"twelve"~ol~

Vyxal, 3 bytes
3∆ċ

Try it Online!
Simply push the number 3 and convert it to words.

FerNANDo, 80 bytes
1 1
01
10 01
0 1 1 0 01 10 0 10
0 1 1 01 10 01 0 10
0 1 1 01 01 10 10 1
01 01
01

Try it online!
Loops twice, printing "eig" on the first loop and "hty" on the second. Coincidentally, using the two-character names 01 and 10 increased the code to exactly the right length.

><> (Fish), 9 bytes
"enin">o<

Try it
Finishes with an error.
><> (Fish), 10 bytes
"net"ooo ;

Try it

Code Beautify Number to Word Converter, 1 Byte
If you input this:
1

You get one.

...This isn't really a programming language though

@JoKing I know, but google translate isn't either!

Thunno 2, 3 bytes
‘ċŀ

Attempt This Online!
Compressed string literal.

StackCell, 10 bytes
"net":[;:]
Explanation:

"net": Push the letters 'n', 'e', and 't' to the stack
:: Duplicate the top element of the stack ('t')
[: Consume the top element of the stack, and if zero jump to the next ] in the source
;: Consume and print the top element of the stack ('t' on the first iteration, then 'e', then 'n')
:: Duplicate the top element of the stack ('e' on the first iteration, 'n' on the second iteration, and 0 on the third iteration)
]: Consume the top element of the stack, and if non-zero jump to the previous [ in the source