Can we spell a third number?

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

• Robin Ryder: May we take input as integers instead of strings?
• Arnauld: @RobinRyder No. I did consider that, but I think there are more possible approaches that way and it's still possible to come up with a shorter answer by turning the strings into 'some' numbers within your code.
• caird coinheringaahing: Can we take input as a single string e.g. six four?
• Arnauld: @cairdcoinheringaahing Yes, that's fine.
• Arnauld: @thedefault. Xash's solution actually works up to at least twenty, or even "twentynine" if we concatenate the words.

Answer 1

J, 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!

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?

• Arnauld: Nice answer! ;-)

Answer 2

Jelly, 15 bytes

"Œ}İs~#2ð»Ḳḟ@€i

Try it online!

Adaptation of xash's J answer. 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ẸƁÄĊ}¿ȥ~ṢṄO44ƓX9Ỵ9ÑẠỤẠḣ|¿;»ḲiⱮ€Q§Ạ

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~#2ð»Ḳḟ@€i - Main link. Takes s on the left
"Œ}İs~#2ð» - "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ẸƁÄĊ}¿ȥ~ṢṄO44ƓX9Ỵ9ÑẠỤẠḣ|¿;»ḲiⱮ€Q§Ạ - Main link. Takes s on the left
"}ICẸƁÄĊ}¿ȥ~ṢṄO44Ɠ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 3

Retina 0.8.2, 23 bytes

G`t|o
G`f|o|r
G`s|i
G`e

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.

• Silvio Mayolo: You followed the exact same chain of logic I used, just seven hours earlier than me. I don't think I can beat this Retina solution with this approach, so I'll just settle for upvoting yours.
• Neil: @SilvioMayolo It looks as if xash beat me to it anyway. (I didn't understand his program, so I didn't realise it at the time, but XCali ported it, so it must be the same.)

Answer 4

K (oK), (削除) 28 (削除ここまで) 24 bytes

{|/(x~x^)'$`e`to`for`si}

A port of @xash's excellent J answer.

Try it online!

Answer 5

05AB1E, (削除) 35 (削除ここまで) 34 bytes

J"€μ‚•„í†ìˆÈŒšï¿Ÿ ̄\Š—¿áÓÁÏ"#€SåO0å

You must compress, if not, be distressed.

Inputs as lowercase.

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

• Dominic van Essen: You'll save a byte by taking input as a single string already (see comments to question).
• Kevin Cruijssen: You can save a byte by changing #€S to S#.

Answer 6

Japt -x, 14 bytes

Adaptation of xash's J solution 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 or try all possible pairs (with 1 used for true)

Answer 7

Python 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!

Uses xash's idea from his J answer.

Answer 8

C (gcc), ^{(削除) 130 (削除ここまで) (削除) 128 (削除ここまで)} 102 bytes

Saved 2 bytes thanks to ceilingcat!!!
Saved a whopping 26 bytes thanks to 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!

Uses xash's idea from his J answer.

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.

• AZTECCO: You can get rid of one loop for 102 , I think still golfable
• Noodle9: @AZTECCO Very nice - thanks! :D
• EasyasPi: What is the purpose of the b=b;? I don't see it.
• Noodle9: @EasyasPi Because gcc uses the same register for assignment and return value, so this saves bytes over return b;.

Answer 9

Perl 5 -p, (削除) 83 (削除ここまで) (削除) 28 (削除ここまで) 26 bytes

Credit to @NahuelFouilleul for saving 2 bytes

$_=/e/&/t|o/&/[for]/&/i|s/

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.

• Nahuel Fouilleul: 26 bytes
• Neil: @NahuelFouilleul Might as well use f|o|r for consistency (I did that in my Retina answer).

Answer 10

Python 2, 56 bytes

lambda s:all(set(x)&set(s)for x in"e to for si".split())

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 using {*x} for set(x).

• Danis: 52 bytes

Answer 11

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!

Answer 12

Python 3.8 (pre-release), (削除) 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!

saved 8 bytes with the help of member SunnyMoon

saved 18 bytes with the help of member 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 != []

• SunnyMoon: You can improve this by removing duplicate characters, i.e one,two,thre,four,five,six,sevn,eight,nie,ten,elvn,twelv,thiren, I guess
• Neil: @SunnyMoon You can also remove u, x and g since they never appear in other words.
• Neil: @SunnyMoon Also the letters h, l, n and v only appear in words with e, and w only appears in words with t, so they don't make any difference.

Answer 13

Charcoal, 19 bytes

⊙⪪"&↓εg⌕8¡="a⬤ι¬Noθλ

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⌕8¡=" Compressed string `eatoaforasi`
 ⪪ a Split on `a`
⊙ Any substring satisfies
 ⬤ι All characters of substring satisfy
 ¬Noθλ Character not present in input
 Implicitly print

Answer 14

Ruby 2.7 -n, 45 bytes

+1 to the idea of xash in his J's answer!

p %w[e to for si].any?{$_.chars&_1.chars==[]}

Try it online!

Ruby 2.7 + gem install humanize, 61 bytes

require'humanize'
f=->v{(1..13).any?{_1.humanize.count(v)<1}}

gem-install-humanize-demo

Ruby 2.7 -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!

^{TIO uses an older version of Ruby, while in Ruby 2.7, we've numbered parameters, i.e., _1, which saves 2 bytes.}

Answer 15

Jelly, (削除) 39 (削除ここまで) 37 bytes

ị"1⁄2ĠWufṠ`ßṡƝ0:Ƒ’bȷ¤æ»
OUḅ96%191%5)ç/Ḃ

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 lookup table, this uses a ×ばつ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.

A ×ばつ9 table is theoretically possible, but I doubt that it will save bytes due to a more complex hash function.

Lookup table generator after computing the hashes.

OUḅ96%191%5 # hash function
OUḅ96 # character codepoints interpreted in reverse as a base 96 number
 %191%5 # mod 191 then mod 10
ị"1⁄2ĠWufṠ`ßṡƝ0:Ƒ’bȷ¤æ» # lookup table
ị"1⁄2Ġ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.

• caird coinheringaahing: ÑçÑ}Ḃ works, not that it saves any bytes
• Adamátor: Why not inline the hash function for 37 bytes?

Answer 16

Husk, (削除) 14 (削除ここまで) 12 bytes

Edit: -2 bytes thanks to Razetime

Λn0w ̈toƒr1∫e

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.

Λ # are all these elements truthy?
 n # are there intersecting elements of
 0 # input
 # in each of
 w ̈toƒr1∫e # "to","for","is","e"

• Razetime: You can use Λ here: Try it online!
• Razetime: -2 bytes with n: Try it online!
• Dominic van Essen: @Razetime - Thanks & thanks! Really nice! I was hoping that it would be possible for Husk to be the shortest answer (at least so far), but just needed those extra tips!

Answer 17

Zsh -Fe, 30 bytes

for i (e to for si)grep [$i] f

Try it online! (includes all combinations)

Takes input from a file named f, outputs via exit code (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. Also takes inspiration from this Bash answer.

Answer 18

Haskell, 44 bytes

f a=any(not.any(`elem`a))$words"e to for si"

Try it online!

• Uses xash's idea from his J answer.
• 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 19

R, 87 bytes

function(x,u=utf8ToInt)all(sapply(c('to','for','si','e'),function(m)any(u(m)%in%u(x))))

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.

Well done, xash!

• Neil: I'd also re-created xash's answer, but I didn't realise until I read XCali's port, as I was sadly unable to understand xash's explanation. (On the other hand I needed no explanation to read XCali's code.)

Answer 20

05AB1E, 14 bytes

"e€‡€ˆ€„"#€мQà

Port of @xash' J answer, so make sure to upvote him!

Also takes the input as a single (space-delimited) string.

Try it online or verify all test cases.

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?) to understand why "e€‡€ˆ€„" is "e for is to".

Answer 21

JavaScript (Node.js), (削除) 99 (削除ここまで) (削除) 95 (削除ここまで) 78 bytes

x=>y=>!'e to for si'.split` `.filter(m=>![...m].some(k=>(x+y).includes(k)))[0]

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.