[Question]
  [
Print or return the following string:
```
zottffssentettffssenttttttttttttttttttttffffffffffffffffffffsssssssssssssssssssseeeeeeeeeennnnnnnnnno
```
This is the first letter of each of the numbers **z**ero, **o**ne, **t**wo, all the way up to **o**ne hundred.
Standard I/O rules apply, but the output must be exactly as shown above, optionally with a single trailing newline. No other variation in output is permitted. This is code golf, shortest code in bytes wins.
---
Note this has also been cross-posted to [Anarchy Golf](http://golf.shinh.org/p.rb?zottffssentettffssen) (by me)
  
[Answer]
# [Python](https://www.python.org), 58 bytes
```
a='ttffssen'
print(f"zo{a}te{a+''.join(x*10for x in a)}o")
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72soLIkIz9vwYKlpSVpuhY3rRJt1UtK0tKKi1Pz1LkKijLzSjTSlKryqxNrS1KrE7XV1fWy8jPzNCq0DA3S8osUKhQy8xQSNWvzlTShJuRBNAH1wMwpSYWzsIA0LKAYC0iFgzw4gNsKcz8A)
[Answer]
# x86-64 machine code, 41 bytes
```
66 B8 7A 6F 66 AB 48 B8 74 74 66 66 73 73 65 6E 48 AB AA C6 07 65 AE 48 AB 6A 0A 59 F3 AA 48 C1 E8 08 75 F5 B0 6F 66 AB C3
```
[Try it online!](https://tio.run/##TZFLT8MwEITP8a8Ygqo4EKryFOqDA4gjEqo4gNoeXMdujFI72ClNW/jrBIfwuuxqd0bfjrT8aMF5XTO3BMU4pKS7yM2c5ZBE9oOleQWrEkTbCG@ITDQcXpLAlcatSdCdb0qBXnV2mfh67YUuc1wphGUppXNCh633pW1z8sW7fnq4xf3DGBObqplni8jrnDV667b9oFi5DMe9AQpTwPKKBFYU@Ka4zMI2sfzJZ72FbcEsT5qIv/msKEkcIh6QV6NSSMozZg/g/ILsK83zVSowdGWqTDe7IkTpEkumNI3JjgSNGVa4VV5Ozo9PZgMSSNrOHhAU1tslDTsuTPC3/hOm@o7xTGkBblLRDxu1uVBhhF6CjR9Tg92PHZ3eyaNHbUaUrrRTCy1SfAWOZTypDg9n8eAd60zlAnSDPQ@pbk7/JwHtKDQvcfFUe1Llxfe6/uAyZwtXHy0vznzxjx55v8g/AQ "C (gcc) – Try It Online")
Following the standard calling convention for Unix-like systems (from the System V AMD64 ABI), this takes in RDI a memory address at which to place the result, as a null-terminated byte string.
In assembly:
```
f:  mov ax, 'z' | 'o'<<8    # Put these two bytes in AX.
    stosw                   # Write them to the string, advancing the pointer.
    .byte 0x48, 0xB8        # Place the following eight bytes in RAX.
    .ascii "ttffssen"
    stosq                   # Write them to the string, advancing the pointer.
    stosb                   # Write the first byte 't' again, advancing the pointer.
    mov BYTE PTR [rdi], 'e' # Place the byte 'e' at the current output address.
    scasb                   # Advance RDI over the 'e' while comparing with AL.
    stosq                   # Write "ttffssen" again, advancing the pointer.
r:  push 10; pop rcx        # Set RCX to 10.
    rep stosb               # Write AL to the string 10 times, advancing the pointer.
    shr rax, 8              # Shift RAX right by 8 bits; AL (its low byte)
                            #  will be each of "ttffssen" in order.
    jnz r                   # Jump back, to repeat, if the result is nonzero.
    mov al, 'o'             # Set AL to 'o'.
    stosw                   # Write 'o' and a null byte, advancing the pointer.
    ret                     # Return.
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 7 bytes
```
₁ʀ∆ċvhṅ
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLigoHKgOKIhsSLdmjhuYUiLCIiLCIiXQ==)
```
₁ʀ∆ċvhṅ
₁ʀ      # Range [0, 100]
  ∆ċ    # Nth cardinal of each
    vh  # First char of each
      ṅ # Join together
```
# [Vyxal](https://github.com/Vyxal/Vyxal) `sMH`, 4 bytes
```
ƛ∆ċh
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJzTUgiLCIiLCLGm+KIhsSLaCIsIiIsIiJd)
(thanks to lyxal)
sMH, why are there flags for everything
```
H flag  # Preset stack to 100
ƛ       # Map over 100
M flag  # Make that 100 be a range [0, 100] instead of [1, 100]
 ∆ċ     # Convert to cardinal
   h    # Get the first character
s flag  # Join together
```
[Answer]
# [Factor](https://factorcode.org) + `math.text.english`, 39 bytes
```
[ 100 [0,b] [ number>text first ] map ]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70sLTG5JL9owU2r0GBPP3crhezUorzUHIXi1MLS1Lzk1GKF3MSSDL2S1IoSvdS89JzM4gyISFFiXjpQNjNfwXppaUmarsVN9WgFQwMDhWgDnaRYhWiFvNLcpNQiO5BOhbTMouIShVigzgKFWIjyVcmJOTkK5UWZJakQgQULIDQA)
[Answer]
# JavaScript (ES6), 57 bytes
Builds the output recursively from right to left.
```
f=(k=8)=>k>0?f(k-.1)+`${s}o`[~~k]:`zo${s="ttffssen"}te`+s
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zVYj29ZC09Yu287APk0jW1fPUFM7QaW6uDY/IbquLjvWKqEqH8i1VSopSUsrLk7NU6otSU3QLv6fk1qikFpRkJpckpqiYKugVJUPU1GSCmdhAWlYQDEWkAoHeXCQr2TNBbK3KLUYaGWahqY1V3J@XnF@TqpeTn66BlBYByJni3CavYL6@x39j@ZMAZLqClYK6o/m9qhrWv8HAA "JavaScript (Node.js) – Try It Online")
### Note
Because of floating point errors, we don't reach exactly `k = 0` on the last iteration. That's why we have to use the test `k > 0 ?` instead of just `k ?`.
This is still 1 byte shorter than the following integer version:
**58 bytes**
```
f=(k=81)=>k--?f(k)+`${s}o`[k/10|0]:`zo${s="ttffssen"}te`+s
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zVYj29bCUNPWLltX1z5NI1tTO0Glurg2PyE6W9/QoMYg1iqhKh8oYqtUUpKWVlycmqdUW5KaoF38Pye1RCG1oiA1uSQ1RcFWQakqH6aiJBXOwgLSsIBiLCAVDvLgIF/Jmgtkb1FqMdDKNA1Na67k/Lzi/JxUvZz8dA2gsA5EzhbhNHsF9fc7@h/NmQIk1RWsFNQfze1R17T@DwA "JavaScript (Node.js) – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 49 48 41 bytes
```
IntegerName@#~StringPart~1&~Array~100<>""
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2Zl@98zryQ1PbXILzE31UG5LrikKDMvPSCxqKTOUK3OsagosbLO0MDAxk5J6X8AUKrEIe0/AA "Wolfram Language (Mathematica) – Try It Online")
*-1 thanks to Steffan*
*-7 thanks to att!*
My Wolfram is rusty and was never great, so probably golfable, but it seemed like the right tool.
TIO shows an error because it can't connect to the internet, but it's still prints the correct answer.
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 145 bytes
```
--[----->+>+>+>+>+>+>+>+<<<<<<<<]++++++++[->++>+>>>++>++>>+<<<<<<<<]>++++.>+.+++++..>.>.>---.>---.>-.>.<<+.->.[<]>------[.>]<[<]>[..........>]<+.
```
[Try it online!](https://tio.run/##VU1RCoBQCDuQuBPILiLvo4Iggj6Czm/6eBVt4JgbOp/TdqzXskeouhYof9pAkwHPSiXskvpVWDko6EWAxbz5jLRmAiU8y/2dOtisrONFbgQRNw "brainfuck – Try It Online")
**Commented code**
```
--[----->+>+>+>+>+>+>+>+<<<<<<<<]    Set cell 0 to 254 and loop 102 times filling cells 1 to 8 with ascii f
++++++++[->++>+>>>++>++>>+<<<<<<<<]  Set cell 0 to 8 and loop 8 times boosting certain cells to give vnffvvfn 
>++++.                               Move to cell 1; boost and output z
>+.+++++..                           Move to cell 2; boost and output ott
>.>.>---.>---.>-.>.                  From cells 3 to 8 output ffssen modifying values as necessary
<<+.->.                              Move to cell 6; temporarily modify to output t; move to cell 7 to output e
[<]>------                           Move to cell 1 and modify from z to t; cells now contain ttffssen
[.>]                                 Move through ttffssen outputing each character once (12 to 19) until empty cell reached
<[<]>                                Move back to cell 1
[..........>]                        Move through ttffssen outputting each character 10 times (20 to 99) 
<+.                                  Move to cell 8; modify value to o and output 
```
[Answer]
# [Python 3](https://docs.python.org/3/), 68 bytes
```
print('zottffssentettffssen'+'t'*20+'f'*20+'s'*20+'e'*10+'n'*10+'o')
```
[Try it online!](https://tio.run/##NcY7DoBACAXA4zzdbfycCaINbOQ1enk0IVYz4@bhtmeO6zROeJxUjRCj/EMH0balQ4soBG39sMIxZ74 "Python 3 – Try It Online")
I'm sure this isn't optimal. Idk.
[Answer]
# [sed](https://www.gnu.org/software/sed/), 59 bytes
```
s/^/ttffssen/
s/./&&&&&&&&&&/g
s/.*/zottffssentettffssen&o/
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m724ODVlwYKlpSVpuhY3rYv14_RLStLSiotT8_S5ivX19NXgQD8dJKClX5UPU1GSCmOp5etDjICatGAhF4QBAA)
[Answer]
# [R](https://www.r-project.org/) + [`english`](https://cran.r-project.org/web/packages/english/index.html), 48 50
*Edited per Dominic van Essen's comment*
```
cat(substr(english::as.english(0:100),1,1),sep="")
```
Similar to [chunes' answer](https://codegolf.stackexchange.com/a/252595/87572), this solution uses a library / package to handle integer-to-English mapping, then parses and collapses the resulting vector.
[Answer]
# [Arturo](https://github.com/arturo-lang/arturo), ~~110~~ ~~65~~ 63 bytes
* **-45 bytes**, -2 bytes thanks to Krenium
```
s:"ttffssen"print~{zo|s|te|s||join map split s=>[repeat&10]|o}
```
Readable version:
```
s: "ttffssen"
print ~{zo|s|te|s||join map split s => [repeat&10]|o}
```
[Try it Online!](http://arturo-lang.io/playground?pmwgLs)
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 29 bytes
```
s["zo"J"ttffssen""te"Js*LTJ\o
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72koLIkY8GCpaUlaboWe4ujlarylbyUSkrS0oqLU_OUlEpSlbyKtXxCvGLyIWqgSmFaAA)
A near literal translation of [97.100.97.109](https://codegolf.stackexchange.com/users/113573/97-100-97-109)'s [Python solution](https://codegolf.stackexchange.com/a/252599/78186).
[Answer]
# [Ruby](https://www.ruby-lang.org/), 54 bytes
```
puts"zo#{a="ttffssen"}te#{a+a.chars.map{|c|c*10}*''}o"
```
[Try it online!](https://tio.run/##KypNqvz/v6C0pFipKl@5OtFWqaQkLa24ODVPqbYkFSignaiXnJFYVKyXm1hQXZNck6xlaFCrpa5em6/0/39VPkx1SSqchQWkYQHFWEAqHOTBQT4A "Ruby – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 53 bytes
Identical to my (and **[@xnor's](https://codegolf.stackexchange.com/users/20260/xnor)**, presumably) Python solution to the **[cross-post](http://golf.shinh.org/p.rb?zottffssentettffssen)** on Anarchy Golf.
```
s='ttffssen'
print'zo%ste'%s+s+(('o'+s*10)*8)[-8::-8]
```
[Try it online!](https://tio.run/##bcs9CoAwDEDh3XuU9IeCOpWCJxHHFF2aYrLo5eNkp37TW1575KS6qvIGIqUwY4Wp3VcVeMmwIBgOHKwFgsB@mZ1Pbo8p55gO1Zf@S7DXQBngAexqRx8 "Python 2 – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/), 40 bytes
```
say+zo,$_=ttffssen,te.$_.s/./$&x10/gre.o
```
[Try it online!](https://tio.run/##K0gtyjH9X1qcqlBmqmdoYK1QnFipoFSVX1KSllZcnJpXkgpnYQFpWEAxFpAKB3lwkK9k/R9omXZVvo5KvC3MFp2SVD2VeL1ifT19FbUKQwP99KJUvfz//wE "Perl 5 – Try It Online")
[Answer]
# [C (clang)](http://clang.llvm.org/), ~~106~~ \$\cdots\$ ~~77~~ 75 bytes
```
f(i){for(i=0;i<101;i++)putchar("zottffssentettffssen"[i>99?:i<20?i:i/10]);}
```
[Try it online!](https://tio.run/##bY/dCsIwDIXvfYpQEFrncFO82ObPhfgUzotRWw1qN9aKw7FXt1Y2RWEfBBKSnORwn18ydbRWUmS1zEuKyyDBRRiECXoeK26Gn7KSkkdujJRaC2XEJyM7XEXROsbFNFhjjJMw2LOksagMXDNUlEE9AMdbYgSiKgQ34gBL6JUzPcgedA/ii/qSk6S9nittuh/4SfCzKHd790RN0mo7Tato42JOxvBbz0jTbhelsyMp8TtWQFjbkZT9j6Rq21mMYahT5SQ/nt1kY59cXrKjtv79BQ "C (clang) – Try It Online")
*Saved a whopping ~~22~~ ~~28~~ 30 bytes thanks to [jdt](https://codegolf.stackexchange.com/users/41374/jdt)!!!*  
*Saved a byte thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!!!*
[Answer]
# [Lua](https://www.lua.org/), 68 bytes
```
a='ttffssen'print('zo'..a..'te'..a..a:gsub('.',('%1'):rep(10))..'o')
```
[Try it online!](https://tio.run/##JcoxCoAwDAXQ08hPQIJdCx4mQiuCtKVNFy8fBbc3vHuqu@4wy3mMVND6VYzwVIioCCz90HiOeRAEK2EJ4NhTo7Axf6mC3V8 "Lua – Try It Online")
[Answer]
# Bash 5.2, ~~45~~ 43 bytes
*-2 bytes thanks to Sisyphus*
```
ttffssen
echo zo$_\te$_${_//?/&&&&&&&&&&}o
```
Uses the **[brand new](http://git.savannah.gnu.org/cgit/bash.git/tree/NEWS?h=bash-5.2#n86)** (set-by-default) shell option `patsub_replacement`!
Look forward to seeing this in many a future Bash golf.
ATO is still on 5.1 at the time of writing, so if you want to try it out yourself, the easiest way is with `alpine:edge`:
```
#!/bin/sh
podman run --rm -i alpine:edge << 'EOF'
apk add bash >/dev/null
bash -c 'ttffssen;echo zo$_\te$_${_//?/&&&&&&&&&&}o'
EOF
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~29~~ 26 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
`zottffÑA`
+h`` +¢®pAÃ+'o
```
[Test it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=YHpvdHRmZtFBYAoraGCSYCAroq5wQcMrJ28)
Note that there is an unprintable character between the ```` on line 2
```
`zottffÑA`     # U = "zottffssen"
               # Start building the output with U implicitly
 h``           # Replace the first 2 characters of U with "te"
+              # Add that to the output
      ¢        # Remove the first 2 characters of U
       ®  Ã    # For each remaining character
        pA     #  Duplicate it 10 times
     +         # Add that to the output
           +'o # Add "o" to the output
               # Print implicitly
```
I also tried [another version](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=YHR0ZmbRQWAKInpvIitVK2CSYCtVK3BBIPM4IKwrJ28) which does "U repeated 10 times, grouped by index % 8, then joined" for the 20-99 portion, but it didn't golf as well
[Answer]
# Excel, ~~77~~ 71 bytes
Saved 6 bytes thanks to [JvdV](https://codegolf.stackexchange.com/questions/252593/zottffssentettffssen/252739?noredirect=1#comment562329_252739)
```
=LET(a,"ttffssen",CONCAT("zo",a&"te"&a,REPT(MID(a,ROW(1:8),1),10),"o"))
```
This is only slightly more efficient than just typing the 101 characters manually.
* `LET(a,"ttffssen"` stores the string `ttffssen` for later repeated use.
* `CONCAT("zo",a&"te"&a` combines strings to make the first part. This is only 2 bytes more efficient than hard-coding it.
* `MID(a,ROW(1:8),1)` turns the 8 character string into an array of 8 characters.
* `REPT(MID(~),10)` repeats each of those characters 10 times. These last two lines are the big byte-saver I missed the first time. Storing the string as `a` is not efficient by itself but it *is* if you later re-use it in the `REPT()` function.
* `CONCAT(~,~,~,"o")` add the last letter to the rest of the bits.
---
Original 77 byte version:
```
="zottffssentettffssen"&CONCAT(REPT({"t","f","s","e","n"},5*{4,4,4,2,2}))&"o"
```
---
This **78 byte** alternative looked like it'd be shorter since each character is repeated the same number of times (allowing you to replace an array with a single integer) but it's only a close second:
```
="zottffssentettffssen"&CONCAT(REPT({"t","f","s"},20))&"eeeeeeeeeennnnnnnnnno"
```
---
This **79 byte** alternative was an attempt at compressing that array of characters but the savings where offset by the bytes required to convert them to strings:
```
="zottffssentettffssen"&CONCAT(REPT(CHAR(101+{15,1,14,0,9}),5*{4,4,4,2,2}))&"o"
```
[Answer]
# [Tcl](http://tcl.tk/), ~~301~~ 57 bytes
saved bytes thanks to the comment of @Sisyphus
Golfed version provided by me, [try it online!](https://tio.run/##bcsxDoAgDEbhq/whxE0vRBjUFBdCjS0J4fI4GDvxTW95euYx7qqCzkFI0aCakgiVqORbeOiSemDdc8YG37CYyN/pOv@PktVEmpAJMsWwGy8)
```
puts zo[set x ttffssen]te$x[regsub -all . $x &&&&&&&&&&]o
```
Original ungolfed version
```
set a "ttffssen"
proc repeat_string {str count} {
    set result ""
    for {set i 0} {$i < $count} {incr i} {
        append result $str
    }
    return $result
}
proc generate_string {a} {
    set result ""
    foreach char [split $a ""] {
        append result [repeat_string $char 10]
    }
    return $result
}
puts "zo${a}te${a}[generate_string $a]o"
puts "zottffssentettffssenttttttttttttttttttttffffffffffffffffffffsssssssssssssssssssseeeeeeeeeennnnnnnnnno"
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 23 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
.•p≠²δK•ÐST×JŠ"zoÿteÿÿo
```
Port of [*@97.100.97.109*'s Python answer](https://codegolf.stackexchange.com/a/252599/52210), so make sure to upvote him/her as well!
[Try it online.](https://tio.run/##yy9OTMpM/f9f71HDooJHnQsObTq3xRvIPjwhOOTwdK@jC5Sq8g/vL0k9vP/w/vz//wE)
**Explanation:**
```
.•p≠²δK•           # Push compressed string "ttffssen"
 Ð                 # Triplicate it
  S                # Convert the top copy to a list of characters
   T×              # Repeat each character 10 times as string
     J             # Join these back together to a single string
      Š            # Triple-swap so the other two strings are on top
       "zoÿteÿÿo  "# Push string "zoÿteÿÿo", where the `ÿ` are automatically filled with
                   # the three strings
                   # (after which the result is output implicitly)
```
[See this 05AB1E tip of mine (section *How to compress strings not part of the dictionary?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `.•p≠²δK•` is `"ttffssen"`.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 44 bytes
```
zo_te_20$*t20$*f20$*s10$*e10$*no
_
ttffssen
```
[Try it online!](https://tio.run/##K0otycxL/P@fqyo/viQ13shARasERKSBiGJDIJEKIvLyueK5SkrS0oqLU/P@/wcA "Retina 0.8.2 – Try It Online") Link is to verbose version of code. Explanation: Mostly run-length compression via `$*`, with a final substitution to save a further 3 bytes.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 22 bytes
```
≔ttffssenθzoθteθＦθ×ιχo
```
[Try it online!](https://tio.run/##S85ILErOT8z5/9@xuDgzPU9DqaQkLa24ODVPSUehUNOaK6AoM69EQ6kqXwnOQRIuSUUVTssvUgAyFCAiIZm5qcUamToKhgaaCD0gk/7//69blgMA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
≔ttffssenθ
```
Save the first letters of two/twelve/twenty, three/thirteen/thirty, four(teen)/forty, five/fifteen/fifty, six(teen/ty), seven(teen/ty), eight(een/y) and nine(teen/ty) in a variable.
```
zo
```
Output the first letters of zero and one.
```
θ
```
Output the first letters of two to nine.
```
te
```
Output the first letters of ten and eleven.
```
θ
```
Output the first letters of twelve to nineteen.
```
Ｆθ
```
Loop over the first letters of twenty to ninety.
```
×ιχ
```
Output each letter repeated ten times.
```
o
```
Output the first letter of one [hundred].
[Answer]
# [simply](https://github.com/ismael-miguel/simply), 64 bytes
Just uses the same method as plenty of answers.
```
out"zo"$A="ttffssen""te"$A;each$A as$v;for$_ in0..9out$v;out'o'
```
Outputs the expected string, without any trailing whitespace.
# Ungolfed
Extremely verbose, almost looking like pseudo-code:
```
Set $initials to the value "ttffssen".
Show the values "zo", $initials, "te", $initials.
Loop through $initials as $letter.
Begin.
    Loop from 0 to 9 as $i.
    Begin.
        Show the contents of $letter.
    End.
End.
Show the value "o".
```
More code-y looking:
```
$initials = "ttffssen";
echo "zo", $initials, "te", $initials;
each $initials as $letter {
    for $i in 0..9 {
        echo $letter;
    }
}
echo "o";
```
All versions do exactly the same.
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), ~~19~~ 18 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
╢├╕◄ε╕f♣+∙╢►@♂m*'o
```
[Try it online.](https://tio.run/##y00syUjPz0n7///R1EWPpsx5NHXqo@kt57YC6bRHMxdrP@qYCZKYtsvh0cymXC31/P//AQ)
**Explanation:**
```
╢├        # Push compressed "zo"
╕◄ε       # Push compressed "ttff"
   ╕f♣    # Push compressed "ssen"
      +   # Append the top two together: "ttffssen"
       ∙  # Triplicate it
╢►        # Push compressed "te"
  @       # Triple-swap the top three values (a,b,c to c,a,b)
 m        # Map over the characters of the top "ttffssen":
♂ *       #  Repeat the character 10 times
'o       '# Push character "o"
          # (after which the entire stack is joined and output implicitly as result)
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 56 bytes
```
"zo$(($a='ttffssen'))te$a$(-join($a|% T*y|%{"$_"*10}))o"
```
[Try it online!](https://tio.run/##bY/BCsIwEETvfsWybElSKOi14kn6B9411C0qpWmbiFrrt0erNSL0nZadYWe2Nhdu7YHL0hNfa84d72EFojPOFYW1XDkO0wTFBHYCDlQBI5ZAecv6nbnz2BmSkvRKfBOFUo5Jk0xO5li9pD6CTXzrozvSFuPF/KGUQY/Z2DwFkuENhTNcf66nMAhj1LDPmrMu/9yQcAM/i38C "PowerShell – Try It Online")
```
"zo                                                    " # start s new string with "zo"
   $(               )                                    # evaluate the subexpression $(...), which ...
     ($a='ttffssen')                                     # ... sets $a to "ttffssen", and outputs it straight back into the string (because of the additional brackets)
                     te                                  # literal "te"
                       $a                                # insert $a ("ttffssen")
                         $(                          )   # insert the results of another subexpression $(...)
                                 $a|% T*y                # pipe $a to % (alias for ForEach-Object) and call the member ToCharArray()
                                         |%{       }     # pipe the single characters to % and process them in the scriptblock {...}; loop variable is $_
                                            "$_"*10      # turn the char back into a string, and "multiply" it with 10
                           -join(                   )    # join those 10-char-long strings together
                                                      o  # Add the final "one hundred"
```
Output is implicit.
[Answer]
# [Java (JDK)](http://jdk.java.net/), 92 bytes
Interesting challenge!
```
()->{var s="ottffssente";for(int i=0;i<90;)s+=++i==9?"":s.charAt(i<9?i:i/10%9);return"z"+s;}
```
[Try it online!](https://tio.run/##dZHBToQwEIbv@xSTSUxoyCIeoVbifT15NB4qlN2uLGCnEN0NR28@gr7cvgiWyOKa4H@aTmf@/0u7la1cbrPnvm6eCp1CWkgiuJO6hMNiAaBLq0wuUwUr1wCne2t0uYbcY9ydu2GIrLRudwUFiN5jy5tDKw2QwMraPCdSzgR5XhnP2YEWIdfXUcgZ@cL3tRBRghhTkG6kubWeu0t0rC@vwouIcaNsY0rco0@86/kQN6KOqW2lM9g5YO@H7OERpFkT@4urXmuVWpWBANyfYU3VjPIZ0YzUpHJShfw83ihyyUUwvprrv5FVu6BqbFC7CVuU3gnx/wnn4iOgPxSBemlkQb9bCR4/3zHG49cHstPfdP03 "Java (JDK) – Try It Online")
---
I'm really glad that it was possible to beat the trivial solution :') (**95 bytes**) :
```
()->"zottffssentettffssen"+"t".repeat(20)+"f".repeat(20)+"s".repeat(20)+"eeeeeeeeeennnnnnnnnno"
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 22 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
`zo{=`ttffÑA`}{+mpA}o
```
[Test it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=YHpvez1gdHRmZtFBYH2SeyttcEF9bw)
```
`zo{=`ttffÑA`}\x92{+mpA}o
`zo                     o     :Compressed string, starting with "zo" and ending with "o"
   {                          :Interpolate
    =                         :  Assign to variable U
     `ttffÑA`                 :  Compressed string "ttffssen"
             }                :End interpolation
              \x92            :Compressed "te"
                  {    }      :Interpolate
                   +          :  Append to U
                    m         :  Map each character in U
                     p        :    Repeat
                      A       :    Ten times
```
[Answer]
# Oracle SQL, 97 bytes
```
select 'z'||listagg(substr(to_char(to_date(level,'J'),'jsp'),1,1))from"DUAL"connect by level<=100
```
Or, a bit more readable:
```
select
   'z' ||
   listagg(
      substr(
         to_char(to_date(level, 'J'), 'jsp')
         ,1,1)
      )
from
  "DUAL"
connect by
   level<=100;
```
]