[Question]
  [
You are given two strings, each consisting of the English word for a number between **1** and **13**:
```
one, two, three, four, five, six, seven, eight, nine, ten, eleven, twelve, thirteen
```
Your program or function must find out whether it's possible to spell at least one other word from the same list without using any of the letters used in the two input words.
You can [follow this link](https://tio.run/##vVFNT8MwDL3zK3xzorWWJk4wFU67wrFCwCFr3TVTl1Rp9oFgv704K9MEPwAfLOfFfu/J3pi9Gapg@5g7X/M4NlCAMhmsNBQP8HkDUAqC3nEG8eAltYGlbvwuSLZ7qQd7lMR7dhmwXbcxA2fPA2ekm37igbvUHVsbIrNDGvrORoUZoF6IUOC4Cw5KGvyWVZX0X4moeichCB8TogzMxBxZV/PxuVGV@Cwgn2uhOI3/5NXvYhKCS6B4KmlrenEnHvHrjBjqTb10tbrTmjbeOoWoBcc3l18i9eEsv74pcM8mqvmt6NyU1PiwNFU7EadzJO1ZkUj@aKQVXvtXl/7rxORKNT/nfQR84QHhHvDJo/5NdErrTA4q7wbfMXV@rYRIL8Zv) to see a naive, ungolfed implementation along with the table of all possible I/O.
### Examples
* If the input is `['six', 'four']`, we can spell `'ten'`, `'eleven'` or `'twelve'` so the answer is **yes**.
* If the input is `['five', 'seven']`, we can only spell `'two'` but the answer is still **yes**.
* If the input is `['one', 'six']`, we cannot spell any other number so the expected answer is **no**.
### Rules
* You may take the words in any reasonable format. They can be in either lower case (`'one'`), upper case (`'ONE'`) or title case (`'One'`), but it must be consistent.
* You may be given twice the same word.
* The order of the words is not guaranteed (i.e. your code must support both `['four', 'six']` and `['six', 'four']`).
* You may return either truthy / falsy values (inverting the meaning is permitted) or two distinct and *consistent* values of your choice.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'").
  
[Answer]
# [J](http://jsoftware.com/), 19 bytes
Takes input as `six four`. As the input range is limited, I just deleted characters while the output stayed the same. :-) Reads like "if there is no `e` in the input, or if there are no `t` and `o` in the input, … then we can spell another number."
```
e.e`to`for`si-.~&><
```
[Try it online!](https://tio.run/##ZY4xD4IwEIX3/oqLA6UJFOOIQkxMnJzcTY6Yq60hNIEKTPx1bMFB43DD@@7evfecN5IrKHLgkMAWcj@phNP1cp5JEjqLyrbYmVROUXmYBaO7thDvlQDemRGUfbX8GyrTE3TUU/ODbeOpGTljVZHHXqEbLDrdEmH4gcHnc0ZcvEjmoR02JhwGWS/UDVT7M6dN64gawdQudCdZrf3YGuk8U8c44cCTm4jKLJug@qzSXO3@VvMb "J – Try It Online")
```
e.e`to`for`si-.~&><
                &>< boxing stuff
  e`to`for`si       for each e, to, for, si:
             -.~      delete from the input any character from the list
e.                  is the input still in the results, i.e. is there any 
                      case were no character got deleted?
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 15 bytes
```
“Œ}İs~#²ð»Ḳḟ@€i
```
[Try it online!](https://tio.run/##y0rNyan8//9Rw5yjk2qPbCiuUz606fCGQ7sf7tj0cMd8h0dNazJBkrWezg937TjWeLjlSFftof0nltY93Lno4c4Wf5NHjVuOTY6wfLh7i@XhiQ93LXi4ewmI3LG45tB@a7A5CgUJCt5AgxQOt4PIhzvbgEgFxCw2NFZw/w8A "Jelly – Try It Online")
Adaptation of [xash's J answer](https://codegolf.stackexchange.com/a/215990/66833). Returns a non-zero integer (truthy) for **yes** and `0` (falsey) for **no**. The footer generates all test cases and tests them (mapping truthy and falsey to `1` and `0` for readability)
My original answer was 38 bytes:
```
“}ICẸƁÄĊ}¿ȥ~ṢṄO4⁴ƓX9Ỵ9ÑẠỤẠḣ|¿;»ḲiⱮ€Q§Ạ
```
[Try it online!](https://tio.run/##y0rNyan8//9Rw5xaT@eHu3YcazzccqSr9tD@E0vrHu5c9HBni7/Jo8YtxyZHWD7cvcXy8MSHuxY83L0ERO5YXHNov/Wh3Q93bMp8tHHdo6Y1gYeWAyX@ux1uVwHyjk56uHPG///qxZkVCmn5pUXqOgrqaZllqQrFqWWpeSBefh6Qk1kBlgAqgLFBwkAMFwZpUgcA "Jelly – Try It Online")
Returns a falsey value if the answer is **yes** and a truthy value otherwise
Basic naive compression approach, ~~I'm sure there's a shorter answer out there that exploits some property that's shorter~~
Both input in the form `six four`
## How they work
```
“Œ}İs~#²ð»Ḳḟ@€i - Main link. Takes s on the left
“Œ}İs~#²ð»      - "e to for si"
          Ḳ     - ["e", "to", "for", "si"]
             €  - Over each k of these:
           ḟ@   -   Yield s with characters in k removed
              i - Index of s in this list or 0
```
And the 38 byte compression version:
```
“}ICẸƁÄĊ}¿ȥ~ṢṄO4⁴ƓX9Ỵ9ÑẠỤẠḣ|¿;»ḲiⱮ€Q§Ạ - Main link. Takes s on the left
“}ICẸƁÄĊ}¿ȥ~ṢṄO4⁴ƓX9Ỵ9ÑẠỤẠḣ|¿;»        - "one two ... twelve thirteen"
                               Ḳ       - Split on spaces
                                   Q   - s deduplicated
                                  €    - Over each number n:
                                 Ɱ     -   Over each character c in s:
                                i      -     Index of c in n else 0
                                    §  - Sums
                                     Ạ - Does not contain 0
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 23 bytes
```
G`t|o
G`f|o|r
G`s|i
G`e
```
[Try it online!](https://tio.run/##XZVBktswDATv@wo/YL/g81ZuecImVXTMKkRMyYo3B//dEWYGIOSLPbCAIQSy6bVtffnxfH58bo/x9vF5eYzHun/fHn3/bM/n@Xz69vvPuN36T2un8/ltLO39dOn3RnXr/yTavS2Urf@6bpRLX5S4Xfu6tT1l@xoygGIdJOsgUQc1665ri6WlffGQtGEgIwa0ok6zy/i7youS9dQsp0Y15Szey95Pwx9A7X2G8mWkvUhShkxJg@2r2T09wnx/J3pD0FAyMrxV5VB6AyFZwAAt5AOVoxmWS3p5SJQrQHloH1UmycqHQycqN5KCDzVs4ufYTLSHrTw2Zy/dckh5YBiUM0HBJmbkjZQIzcwYDZWQJypCHqqMdK4ijqMVsU5XLnVMtpdqbXltTW@yc/b9lbKR7OyvM@ZYR06VPyZ3NhmMlRyhkSz5WAgVJgISMQyQ6C@OpwmkTTizdYA0ClOYtfDioAkqp8wHhU2rpAYDAGxM1JwoQQeiiCuIIq57r0qY2Fph@AAXOYdEIRWzoUk5WaULkXOuXBAkKLeCcieKWcDTAQlLuuTTgzX6C1D71PCVZD4DeTOgu1gpOVYrtIaodd@QyFJAXwXwDcxLjtUK@YruntJXkEI6Nf2pYa@rYCZYyY5jlkwnzoXkCXECW1gtmE5CE87KZR2SzVs1LyG/F63eqxHxZrSyeRFgyla3LyLN2coGpnlNs0NVcsybjyjrFgTNcSMSaF2WZJoBsZYWz4zi/5aR/nLlV9PsUMXv/w "Retina 0.8.2 – Try It Online") Link includes all 169 possible inputs. Leaves the input unchanged if no numbers are possible, but outputs nothing if other numbers are possible. Explanation:
```
G`t|o
```
The input must contain `t` or `o` in order to prevent `two` from being possible; only `two` and `twelve` contain `w`, so if there's a `w` then `t` is already present.
```
G`f|o|r
```
The input must contain `f`, `o` or `r` in order to prevent `four` from being possible; only `four` contains `u`, so if there's a `u` then `f`, `o` and `r` are already present.
```
G`s|i
```
The input must contain `s` or `i` in order to prevent `six` from being possible; only `six` contains `x`, so if there's an `x` then `s` and `i` are already present.
```
G`e
```
The input must contain `e` in order to prevent `eleven` from being possible; only `eleven` and `twelve` contain `l`, only `five`, `seven`, `eleven` and `twelve` contain `v`, and only `one`, `seven`, `nine`, `ten`, `eleven` and `thirteen` contain `n`, so if there's an `l`, a `v` or an `n` then `e` is already present. Additionally, only `two`, `four` and `six` do not contain an `e`, so no other letters need to be tested.
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), ~~28~~ 24 bytes
```
{|/(x~x^)'$`e`to`for`si}
```
A port of [@xash's excellent J answer](https://codegolf.stackexchange.com/a/215990/98547).
[Try it online!](https://tio.run/##bYpRCoMwEESvsoRCFCzqb84iJRQ2zaIkELcq2Hr11FiwFpyPnX0z0159G6NR86vMpmW65fKiUbPXxgfd0zvWq6qk5BvURzht9vCbbGV9nP@gOm32c/CT5k/3xciizKiQAkRelKpRpNa3Ed4h8OiBbUAE458BDA0IPU3Q44AOkB6WwVEaJuy2lEfs1hlbCozoRPwA "K (oK) – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~35~~ 34 bytes
```
J“€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š—¿áÓÁÏ“#€SåO0å
```
> 
> You must compress,
> if not, be distressed.
> 
> 
> 
Inputs as lowercase.
[Try it online!](https://tio.run/##AWEAnv9vc2FiaWX//0rigJzigqzCteKAmuKAouKAnsOt4oCgw6zLhsOIxZLFocOvwr/FuMKvwqXFoOKAlMK/w6HDk8OBw4/igJwj4oKsU8OlTzDDpf//WyJzaXgiLCAiZm91ciJd "05AB1E – Try It Online")
# How?
```
J                                     # Join the two input numbers into a string
 “€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š—¿áÓÁÏ“           # Push the number words from "one" to "thirteen"
                            Så        # Are each character in the input?numbers? 1 if yes, 0 if not
                           €  O       # Sum the results for each word
                               0å     # Is there a 0 on a word?
                                      # (implicitly) Print the answer
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-x`](https://codegolf.meta.stackexchange.com/a/14339/), 14 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Adaptation of [xash's J solution](https://codegolf.stackexchange.com/a/215990/58974) so be sure to upvote them, too.
Input as a single lowercase delimited string, outputs a positive integer for true and `0` for false.
```
`èJ-n£`qÍ£¶kX
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LXg&code=YOiBSi1uo2BxzaO2a1g&input=InNpeCBmb3VyIg) or [try all possible pairs](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=YOiBSi1uo2BxzaO2a1g&footer=Tm1nViCuuPo4ILjDcFV4IGcpcSIgLT4g&input=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) (with `1` used for true)
[Answer]
# [Python 3](https://docs.python.org/3/), 67 bytes
```
lambda s:sum(max(c in p for c in s)for p in'e to for si'.split())<4
```
[Try it online!](https://tio.run/##lZbdTttAEIXv8xQrbmxLaUUKUiXU9EWAizRsGoslsewB0kY8e5qdOTM7DkSiWEjnrOfnQ7Ni3P2h9XZzdVjN7w5p8fTrYRGGm@H5qX5a7OplaDehC6ttH1gOTZbdUVYx0JZfDG31dehSS3XT/Lg@UBxomNe3F9tNDMffiykret2qWvdRT1fb515l@6KnQ7tTFV/iBjq2v9cEvWlL4RKQXDS9xmQFad32FPndkQNUWQkVK1BlDSqWQpWlULFCn6yVKmtQcbkSkFy0UUnLQpW7KxdrkIlWNnZKJwZ8bEAoWruyM0p2yinFfVgaZRVaYBhvZgAuS6EVCVg2YBUtqKyFVCRaslFONsCUqi4m@QxjRPOCeGyniFkCkaUiZqOIrIGYNRBZasNsDDEbReSqLib5jIIozQ3x2AKEWQkgK/BlDTyWQpelwLFCp6wVLWuQcbkSkFy0YUnLQpVjlIs1yEQrGzulEwM@NiAUrV3ZGSU75ZTiPiyNsgotMIyX64FXtPBCg1cceGGEV4zwQqOzOOUVB14U92FplGW8imG8uQJwWQqtSMCyAatoQWUtpCLRko1ysgGmVHUxyWcYI5qXf0d2AcjGT274VEZPZfBkYyc3dHIjpzJwsnGTHzb5UdPJoJO7mTAYdRrdTVgddvK3Ew7jTqP7CWsDT/6Gao9RZBpnlqGn01sqr2z1sNHtI8YWEFvbQeJ0DbHTTSTG1gvbso/Y2kqSHqPINM50uwlAbj2JtA0Fq0tKre0pHNiqUq/bCl4XllrbPjgoawsHtrm040l8Oq3gVphB4s@6byZx18UlxYd5PZvKc2mP@plT5958Pud9pI8pmbOz1T96c/kfOe/Vx/5zOWefZrJcx@Vj7MM81NXd87fv18tqGljNrqpmkj8daRrzV@Xftqv5s3EadCLNzSQcf3L2qqaGTde3G6pX1Z7ewpefYd@/hT2a3Mb5vL9/q5rDPw "Python 3 – Try It Online")
Uses [xash](https://codegolf.stackexchange.com/users/95594/xash)'s idea from his [J answer](https://codegolf.stackexchange.com/a/215990/9481).
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~130~~ ~~128~~ 102 bytes
Saved 2 bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!!!  
Saved a whopping 26 bytes thanks to [AZTECCO](https://codegolf.stackexchange.com/users/84844/aztecco)!!!
```
a,b,i;f(s,j)char*s,*j;{for(a=b=0,i=11;i--;i%3||(b+=!a,a=0))for(j=s;*j;)a+="e..to.forsi"[i]==*j++;b=b;}
```
[Try it online!](https://tio.run/##lZbRbtpAEEXf@xUOEpIBk0KjPlSu@1L1KxIejLME0y1EeJugJvx66e7Mndk1SaQ0FtK969mZQ2aT2WZ61zSnU10si7Zc5V2xGTXrej/uivGmfFrt9nldLatZ0VbzedlOp2U7vHp@zpeT6qIu6mo2GoWYTdWVPn5UT6qBubx0u0u/2rWD63ZRVePNZFIuq2V5PP2q220@yp4@ZP6H6mTOdK67XmRV9jTYbU3mP4OClHvciVrvjayudr/3ItsHWe3agyjzYLbQpr1bO@htGxPHAJtEu0djNaFbt3tn6J3nAFVQTEUKVEGDiiRTBclUpFAnaKEKGlSULgbYJFqpuGSkCtWFizTIWAsbOaFjAz4yIGQtVckpJTnh5ORpmO3tirTAUN7AAFySTMsSsGTAyppRSTMpS5QkI5xkgMlZkxib7lBGFI@IvpwgBglEkoIYjCCSBmLQQCQpBYNRxGAEkbImMTbdERG5uCL6EiAMigFJgS9o4JFkuiAZjhQqBS1oQYOM0sUAm0QrFpeMVCFGuEiDjLWwkRM6NuAjA0LWUpWcUpITTk6ehtnerkgLDOWlfOBlzbzQ4GUHXhjmZcO80KjMTnjZgRfJ0zDb26W8gqG8IQNwSTItS8CSAStrRiXNpCxRkoxwkgEmZ01ibLpDGVE8/jvSA@C0/S5pvoutd7HxTtvukqa7pOUuNtxpu13abJe22p012iYnEwattr2zCSvNtunphEO7be98wmrDbXpCpUYv0vZ3xqbb81PKr3T0kJHpw0YHEFmdQexkDJGTScRGxwvZOI/I6kjiGr1I29@ZzCYAJeOJpU4oWBlSYnVOYUFHlXiZVvAysMTq9MFCHFtY0MklFc/i7XmGZIQpJL7WsaSLS7v1f7uHe9M4c8s3l3nBz0wf8fNEvfXm/XteRqYxcef8zeyvvZn9x56X6nX/vj1vPvhN8xWxWZvmp9njknhz@PHp5vDlu/98HhRZ6q@kQ/72meWhTe321hz8tlkJ@dWfoD9mt8qlgaOPWBjrSplNJhQtN9Xktupz8Y2VAhalvg/VOv/24mKVu1F/3fh1PTDnG@/3PmSVD4ZdNv2WDW@zYXfjD2Tmiqwr9LubquoWSHv8cDz9bVa2vutO08d/ "C (gcc) – Try It Online")
Uses [xash](https://codegolf.stackexchange.com/users/95594/xash)'s idea from his [J answer](https://codegolf.stackexchange.com/a/215990/9481).
Inputs a string of two words separated by a space and returns a truthy value if it's possible to spell at least one other word from the given list without using any of the letters used in the two input words or a falsy value otherwise.
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, ~~83~~ ~~28~~ 26 bytes
*Credit to @NahuelFouilleul for saving 2 bytes*
```
$_=/e/&/t|o/&/[for]/&/i|s/
```
[Try it online!](https://tio.run/##DcYxCoAwDEDRvafoIG7SydGTiDilGChJSWLt4NmNXf77FaSs7tO5JUhzspdH98xyDPHV5K7YY@ZbQsYGUaEBBaZx2INdKAZA0R7@uBoyqS@1/A "Perl 5 – Try It Online")
Switched to @xash's method. This script inverts the output: `0` means that another number can be formed; `1` means that another number cannot be made.
[Answer]
# [Python 2](https://docs.python.org/2/), 56 bytes
```
lambda s:all(set(x)&set(s)for x in"e to for si".split())
```
[Try it online!](https://tio.run/##VY/BCsIwDIbP9ilCD9Iy8OBR2BtsTzA9dJi6Qm1HG7f59LPZQPGU5Oufj3R80xDDebX1dfXm2d8N5IvxXmUktegjl6xtTLCACxKBIvCUnTzl0TtSWq9NLWMoT3MEGhJiSbwSWDdhyS2QccIA6B4DQXAc5NFvlGb0JUaDS4QYvlIhxuQCKaskK1gotf7BXc6KP8xnlDwz0dZdV1llKgmy6vV2timfgObGbb@3@64QjBKj9iIOuy/p9QM "Python 2 – Try It Online")
Take inputs like `two four`, outputs negated. Checks whether the string has an `e`, and intersects the non-`e` numbers of `two`, `four`, and `six`.
[52 bytes in Python 3](https://tio.run/##VY/BCsIwDIbP9ilCD9I68OJN2BvoE0wPHaauUNvRRjcZPvtsHCjeki9/PpL@SV0Mu9nWp9mbW3sxkPfGezVtxtd62uSXjQlGcEEiUATuspPb3HtHSuv5UMsYymiIQF1CLIl7AuseWHIjZHxgAHTXjiA4DnLrP5QG9CVGnUuEGL5SIfrkAimrJCtYKLX@wUXOij/MZ5Q8M3Gsm6ayylQSZNXqz9mmPAGHM5ftUi67QjBKjI57sVp8Sc9v) using `{*x}` for `set(x)`.
[Answer]
# [Bash](https://www.gnu.org/software/bash/), ~~85~~ ~~74~~ ~~61~~ 53 bytes
Supply the input as an argument of the program. Output is via exit code.
```
[[ -z `for i in e to for si;{ grep -v [$i]<<<$1;}` ]]
```
[Try it online!](https://tio.run/##FccxDoAgDAXQq/yBlcGZ3oQ0QZOiXcBQw6Dx7DW@7W2rHe45I94otQ8otEFwdfwzTQ/2ISfiRA7KRBSW9BYwu3vVKTCZ0j4 "Bash – Try It Online")
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), ~~175~~ ~~164~~ 146 bytes
```
def f(x):w="oe two tre for fie si se eit ie te e twe tire".split();return[[(w:=[*filter(lambda a:c not in a,w)])for c in i]for i in x][-1][-1]!=[]
```
[Try it online!](https://tio.run/##XYzLCsIwEEX3fsWYVSJVEDdS6ZeELGo7wYGalMn04dfXRBeCiwvncubO@JJHDJfryNvWowevV1MvjYoIskQQRvCRwRNCIkgISAK5SKZ8kUOM6pTGgUSbG6NMHKzVS93Yg6dBkPXQPu99C23dQYh5HaCtFuNMedyVSq4gFVydPZ4/2TfWbSNTEO21VYlWVYHycWLljNn9jKcZi0o4Y/hzMXxVHmexvQE "Python 3.8 (pre-release) – Try It Online")
saved 8 bytes with the help of member [SunnyMoon](https://codegolf.stackexchange.com/users/98140/sunnymoon)
saved 18 bytes with the help of member [Neil](https://codegolf.stackexchange.com/users/17602/neil)
normal version of the code:
```
def f(x):
    w="oe two tre for fie si se eit ie te e twe tire".split()
    for i in x:
        for c in i:
            w = [*filter(lambda a:c not in a, w)]
    return w != []
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 19 bytes
```
⊙⪪”&↓εg⌕⁸¡⁼”a⬤ι¬№θλ
```
[Try it online!](https://tio.run/##FcoxCoAwDADA3VeEThHqC5yKuwi@IEjFQGi0RsHXR735lo3qoiTuU@VimMqD8y5sGDKZ0qqVTg4RAoU2QhJBjjCq4aDX948I0v5695XvDJZL490tLw "Charcoal – Try It Online") Port of my Retina answer, but I was able to output a Charcoal boolean, i.e. `-` for possible, nothing for impossible. Explanation:
```
  ”&↓εg⌕⁸¡⁼”        Compressed string `eatoaforasi`
 ⪪          a       Split on `a`
⊙                   Any substring satisfies
             ⬤ι     All characters of substring satisfy
               ¬№θλ Character not present in input
                    Implicitly print
```
[Answer]
# [Ruby 2.7](https://www.ruby-lang.org/) `-n`, 45 bytes
*+1 to the idea of [xash](https://codegolf.stackexchange.com/users/95594/xash) in his J's answer!*
```
p %w[e to for si].any?{$_.chars&_1.chars==[]}
```
[Try it online!](https://tio.run/##JYo7CoAwDED3niKDuukNxIMUEZWKWZLS1B/WqxsLDo/3hhe26VL1UB7WQWRYOIBg34x0dXeSVAzNvI5BKvndtrZ/VAXPvG7BLLg7ELc7Mky58DTxYMi87CMyidb0AQ "Ruby – Try It Online")
# [Ruby 2.7](https://www.ruby-lang.org/) + `gem install humanize`, 61 bytes
```
require'humanize'
f=->v{(1..13).any?{_1.humanize.count(v)<1}}
```
[![gem-install-humanize-demo](https://i.stack.imgur.com/sG0fy.png)](https://i.stack.imgur.com/sG0fy.png)
# [Ruby 2.7](https://www.ruby-lang.org/) `-n`, ~~104~~ 90 bytes
*Saved 10 bytes by removing duplicate chars from number names.*
```
p %w[one two thre four five six sevn eight nie ten elvn twelv thiren].any?{_1.count($_)<1}
```
[Try it online!](https://tio.run/##JY3BCgIxDETv/YocFPTggnfBDxERlawbkGRp03YX1183pnoaZph5E/NtNhthXU/CCFoFdIgIveQIPRWERBMkLAxIj0GByVvo7umRVhcfUEQ@d1eej68lLam7S2bdrC7bw/5t1giNF/48LMihnXkefodVPjIqCSfb8Rc "Ruby – Try It Online")
TIO uses an older version of Ruby, while in Ruby 2.7, we've numbered parameters, i.e., `_1`, which saves 2 bytes.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~39~~ 37 bytes
```
ị“½ĠWufṠ`ßṡƝ0:Ƒ’bȷ¤æ»
OUḅ96%191%⁵)ç/Ḃ
```
[Try it online!](https://tio.run/##AVoApf9qZWxsef//T1XhuIU5NiUxOTEl4oG1CuG7i@KAnMK9xKBXdWbhuaBgw5/huaHGnTA6xpHigJliyLfCpMOmwrsKw5HigqzDpy/huIL///8ib25lIiwgInNpeCI "Jelly – Try It Online")
*-2 bytes thanks to @xigoi*
Takes input as a list of two words in lowercase.
### How it works
Uses a lookup table for all pairs. Instead of a 13×13 lookup table, this uses a 10×10 table because a few number/words (1&3, 2&4, 7&9, 10&12) have the same table values, so I engineered a hash with very specific collisions using a [brute force script](https://tio.run/##xVRPb5swFL/zKd5aJTWJ12LI0iZSjutxOzS3CFUGnGKNGGSbtNG06z5AP@K@SGYbCE1Vqelhmg8WPP/@vOfHo9rpvBTRfn/@6apW8irh4oqJLVRN3FvLcgPrWqS6LAsFfFOVUoNkWZ0yr31TO@WdQ1oWBVe8FGoOZBhhCIcTDNfDGQYSDEnoGYxkupaipaOCbpKMwhPezZ9GO7wqZYZSf3wN61JCClyAiv1BFE4H5MupZBIds0NCPsB@ZT0hwYBEp5LD2Sv2dDYwZR/Y6A362NAnk9GIjxoRp8Cx02Ci3jBJNUNqNZ9/JrEf@/5gdm1E4c/vZzhB@ib6kPSkkyb/VXo2fVfaiZKZ6W3gVAPPy9gacqQwUAwJhsyfe2DWO17ZaVZ0kDQOXN1vacEzlFOV39vBwJBSxQ5uqi60ggX8NGNwwBgVp66stoX/cugN1WnOxcN9Rbm0pBWyh6sgbkRXYexjaGKki0V9bNrFbvrYrIsRe/XORpeaFka9YAIpplGb5KUppGYK@b7vYDZBe3c2x@PMmtrs4uuuxBWNYbE4vCVxD@o9xwvT7xddaDMx0cjzbJauaIe4KAXDoB9Ls@WSmed1WUuz8615VvzJbGzLBAbGH3KNQXBHcJGiOdGPrLBonXOpGRMX@N9JX9ZVxSTyW4vvlrG0FsvG4tZZ3DqLO2tx1wh9bSy@OYuli7QWy9Zi2Vl4sZeZ1M0V3dJCMc82yHVHUvHAkP2xRu13Z/pioX0PEsnoj0Nbs54VYhIEfg90Xe@PkzHBEB0hOhRvPqzj8XBNfAVuEzqMSjtzdiBezmcjd6mqgmt0huHMf0PHrkpyoVHWMbn/Jqq9qqWs2X7/Fw).
A 9×9 table is theoretically possible, but I doubt that it will save bytes due to a more complex hash function.
[Lookup table generator](https://tio.run/##vZM7b9swEMd3fYrbSMJnwo7zcm2lSIEMXdrRKFQNskzFVBVSoOg8kPizO0cqju0lYzUcpOPd738Pqi4ei650uvVDY1dqt6sgBV4gLAWkN/CaACzIw6xRCP7Jklk7Re@V3Tiy@pHeO/1MRj0qg6D0/dojGB0ToqfpT/yTakK0X2vnlTJMdm2jPWcITMxIyCm/cQYWsrMPipdBP5NSlrkkgHvpPbyAARUntVmp598VL6nOFIZjQYjt7j/VmjjVkVJ2jTBC6O0FwhnCFOEcYYwwQbiK9jJPGmv/bdqQQO3cOle88PFI5PKhaLlKb0YiSSrrgDfKg05HM9Dz8YTsYCDiBoK/td0tEUg403mYlq4oIYKzcJYLKK3x2mxUOP3k1YFXR169530Sf3wQ60gk9xEP3lKo@ILUEBYUIWA@jzkUuU22Cal1tlGysfcfdVAbcTI/Da2rU8R@3X7d2CE46xvLKUkTPInjHeEYz3CC53iBl3iF1zjNE7vxYcmwfxjdhy6Osgj3g71FzyI7Yhd5LttidWdWfCqErK02nDFBYeyvGe6fkMYGw8O3dKpVhQ@7miWdpE7uinLdy4TqQyWDNDC@VgyzPaQv9@kHQF8yD9M@ZeApdZnTFr4D@6M6Bt@A/bJMnMpsw18QLujxdkhGzHbv) after computing the hashes.
```
OUḅ96%191%⁵            # hash function
OUḅ96                    # character codepoints interpreted in reverse as a base 96 number
     %191%⁵              # mod 191 then mod 10
ị“½ĠWufṠ`ßṡƝ0:Ƒ’bȷ¤æ»  # lookup table
ị“½ĠWufṠ`ßṡƝ0:Ƒ’bȷ¤      # get the correct row from a list of 10 rows corresponding to the hash of the first word
                         # (base-250 compression then interpret as base 1000)
                   æ»    # bitshift by the amount corresponding to the hash of the second word
                   
Ñ€ç/Ḃ     # apply the lookup table and hash. For some reason I couldn't get ÑçÑḂ to work.
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~14~~ 12 bytes
*Edit: -2 bytes thanks to Razetime*
```
Λn⁰w¨toƒr¹∫e
```
[Try it online!](https://tio.run/##yygtzv6f@6ip8f@52XmPGjeUH1pRkn9sUtGhnY86Vqf@//8/Wqk4s0IhLb@0SElHKS2zLFWhOLUsNQ/Iyc8DsjMrlGIB "Husk – Try It Online")
Outputs falsy (`0`) if we can spell another letter without the input letters, truthy (non-zero) otherwise.
Uses approach of checking whether any of the input letters are present in `"to"`, `"for"`, `"is"` or `"e"`, as pioneered by [xash's answer](https://codegolf.stackexchange.com/a/215990/95126).
```
Λ               # are all these elements truthy?
 n              # are there intersecting elements of
  ⁰             # input
                # in each of
   w¨toƒr¹∫e    # "to","for","is","e"
```
[Answer]
# [Zsh](https://www.zsh.org/) `-Fe`, 30 bytes
```
for i (e to for si)grep [$i] f
```
[Try it online!](https://tio.run/##3VhNb9swDD3Hv4JIC6wFlvW@od2tQE@77DYMiFczsVBFMiQ66frnM5GUnHY/gUHiPEnUE5/14Qe/5fF8BT7GCeIRE/Teg3cBM7hQvtNM3Wl0HiFhP4D/BkPsutUVTCnuU38A6l8ktgRCn6GHXQn@DDnCKTlCoCg18NSt8HmMcO3hAR6FAg@z70tImkNwYQ8xwHM8HPowSAbl8oKwfcsjbB6xNA34hQvrWNrKb71lkj/43M8Z4efTj5Ia5vCJIM/TFBNBnMjFkCvRBrewiwmY4@tNtyrfVUZi8jPXO7jRdAvO7nafcIJf1@43PJ7LOG4fYkLINMSidAM0chL@L5Qiaz8hnPpA4LI04asjSblb3cLD3YDHuzB7X2@dK4H/RbWbs75/WMP1924oCs9VKVj6dCyITtGgqDEhWhO1i3MyN1M7d0RzorJ7tbenMh4xWBOFbj@SNVHBBXt7ikwtvrb8vK1NVR0FekuHenUULhHamauOfZ857yeirHk/FmXO@4koa96PRZnzfiLKmvdjUea8H4sy5/3kSLfm/WT5WfN@6iiMeT91FNa8n1gkW0apirJllJooZ2tPiShbRqmJMnWmV1G2jFIVZcsotSPdmEvX5WfKKLWZMmWUFkdhySh14iWMvXmpomy9eVFRxt68VFF89imUx7BCfngpoqXVXyL1cKm47slO5pwvisrdqkD7MawjMNQRGNHS6i@RbQTBbQSeAKaVf4llpKSMhJMBtSa/RFVCgQufnPuVSXDlEqxsAukS4N9FN04tNFZ1M8qkWJgU0iVAmWq1MtVCYxILIZ0FUauqXbVSeypuHanmTJeM6ZIvfcjWv9dVSy0d/1FZfaY0mlpaWtvhvNT8Aw "Zsh – Try It Online") (includes all combinations)
Takes [input from a file](https://codegolf.meta.stackexchange.com/a/2452 "although it's somewhat controversial") named `f`, outputs via [exit code](https://codegolf.meta.stackexchange.com/a/5330) (`0` = we can't spell a third word, `1` = we can).
The option `-F` disables globbing; without it, we would have to escape the square-brackets. `-e` makes `zsh` exit on the first command that fails - it's like a short-circuiting NOR over all the commands executed, similar to the approach in this great [J answer](https://codegolf.stackexchange.com/a/215990). Also takes inspiration from this [Bash answer](https://codegolf.stackexchange.com/a/216040).
[Answer]
# [Haskell](https://www.haskell.org/), 44 bytes
```
f a=any(not.any(`elem`a))$words"e to for si"
```
[Try it online!](https://tio.run/##NctBDoIwEAXQPaf4aVhAQG@AJ9CVS2OkidPQCB3SGUBPXyuJm/lvJn8GKy8ax5QcbGfDpwqsx1/2NNLU27ouN45PMQRlOI4Qb5KSKKSbF71qPAeUEDQNDA6nPLJk4A2Vg9RFMVkf0GGy8@WB/fNmOFCrG5t2l/h3Vt5bx0vMzIc/nV9zgVYK5p6@ "Haskell – Try It Online")
* Uses [xash](https://codegolf.stackexchange.com/users/95594/xash)'s idea from his [J answer](https://codegolf.stackexchange.com/a/215990/9481).
* Takes input as "one,two" and returns True for yes, False for not.
* I think it reads well as it is so no explanation.
[Answer]
# [R](https://www.r-project.org/), 87 bytes
```
function(x,u=utf8ToInt)all(sapply(c('to','for','si','e'),function(m)any(u(m)%in%u(x))))
```
[Try it online!](https://tio.run/##bY0xCsMwEAT7vMIYjE6gB6TxA9KnN8JIRKDcCenOyK9XLk0g4C1mi2HZOnaPvLUSct48Er9CXUcU3DkRQneyCsf7kx7I1ucMzZeST9jBMBlnIlVlS4pgrPsN39bjCaK9JFwEutV8v/6vYG6pT5GkzvZ2YWM6wtTCEfDaE6pOXeX4AA "R – Try It Online")
Reversed output: `TRUE` if we cannot spell another number without the input letters.
Started with the full vector `"one","two","three" ... "thirteen","fourteen"`, then removed the duplicate letters, then removed the only-in-one-number letters, then removed the letters in words that consistently had another letter. This brought the vector to `"oe","to","tre" ... "e","te","tire"`. At this point it was obvious that we can delete all numbers containing an "e" except `"e"` (which is what's left of `"eleven"`).
And then I realised that I'd just re-created [xash's answer](https://codegolf.stackexchange.com/a/215990/95126).
Well done, [xash](https://codegolf.stackexchange.com/users/95594/xash)!
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 14 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
“e€‡€ˆ€„“#€мQà
```
Port of [*@xash*' J answer](https://codegolf.stackexchange.com/a/215990/52210), so make sure to upvote him!
Also takes the input as a single (space-delimited) string.
[Try it online](https://tio.run/##yy9OTMpM/f//UcOc1EdNax41LASSp9vAzHlAQWUg68KewMML/v8vzqxQSMsvLQIA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfaXL/0cNc1IfNa151LAQSJ5uAzPnAQWVgawLewIPL/iv8z9aqTizQiEtv7RISUcpLbMsVaE4tSw1D8jJzwOyMytAwkBZMDMWAA).
**Explanation:**
```
 “e€‡€ˆ€„“       # Push dictionary string "e for is to"
          #      # Split it on spaces: ["e","for","is","to"]
           €м    # For each: remove all those characters from the (implicit) input
             Q   # Then check for each if they're still equal to the (implicit) input
              à  # And check if any of the four were truthy by taking the maximum
                 # (after which this result is output implicitly)
```
[See this 05AB1E tip of mine (section *How to use the dictionary?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `“e€‡€ˆ€„“` is `"e for is to"`.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~99~~ ~~95~~ 78 bytes
```
x=>y=>!'e to for si'.split` `.filter(m=>![...m].some(k=>(x+y).includes(k)))[0]
```
[Try it online!](https://tio.run/##ZY69TsQwEAZ7nmKp1tYFixopKa@9ghKQYuXWaDnHjrxO5Dx9iOFO4qf8RjPa/bCLlSHxlB9CPNPm2q203dp290iQI7iYQBiNTJ5zD71x7DMlNe7GeKW9Ge2kLm2nymHVhsPg5zOJuugfI6eZtH55fNuGGCR6Mj6@KzxaLwQj2SCwkjRQvesO8TWgvvvlP3Np9qfm9IRwAKdQuKBWWBFq@GMfeaEGhBYKN9/tqAZf8H9xCjXgctNj@LbrFdDbJw "JavaScript (Node.js) – Try It Online")
Uses xash's idea from his J answer.
Returns false for yes and true for no (counterintuitive I know, deal with it). Uses currying syntax - `(x)(y)`.
Explanation:
```
x=>                           //declare function
  y=>                         //declare function 2
    !                         // necessary for consistent result
    'e to for si'             //see xash's J answer
    .split` `                 // to array
    .filter(                  //keep value only if following true
      m=>                     //function with value m
        !                     //if following is false
        [...m]                //m into array of letters
        .some(                //replace each with
          k=>                 //function of k
            (x+y).includes(k) //if includes true (input contains one of word
        )                     
       )                      // array now has any items only if it contains something
   [0]                        //0th item, undefined if no answers, one of strings above if does, then negated by ! at top.
```
There's got to be a better way to do all the .includes.
# Regex (any)
```
^([^e]*|[^to]*|[^for]*|[^si]*)$
```
Just using @xash's trick again. Takes a single string.
# Javascript, 44 bytes (using regex)
```
x=>/^([^e]*|[^to]*|[^for]*|[^si]*)$/.test(x)
```
I mean it works, but I like the other one because it took more than 2 minutes. Takes a single string.
]