Can the chefs go?

Question

On the TV cooking show Guy's Grocery Games, the chefs cannot begin shopping until Guy Fieri, the show's host, says "Three, two, one, go!" However, the words do not have to be all together. He often "hides" the words in things like this (based on a real example, but not quoting verbatim):

There are three of you here; after this round there will be two; but only one of you will go shop for up to $20,000.

(At the end of the show, the winning chef must find either five or ten items, depending on the episode, from the store; the number of items found determines how much money they win.)

Fairly regularly, he succeeds in confusing the chefs and they don't go. Often, they realize after a few seconds that they can go and frantically run down the aisles trying to make up for the lost time; other times, they don't realize it until the judges start shouting "Go! Go! Go!"

Can you do better?

Write a program that determines

1. Whether the input string allows the chefs to go, and
2. If so, at what point in the string they may go.

The chefs may go if the string contains three, followed by zero or more other characters, followed by two, followed by zero or more other characters, followed by one, followed by zero or more other characters, followed by go. Matching is case-insensitive.

The point at which the chefs may go is the zero-based index of the o in go.

Because ThreeTwoOneGo is 13 characters, this number will always be at least 12. If the chefs can go, return the point at which they can go. If they cannot, return no value, any falsy value, or any number of your choice less than or equal to 11. This number does not need to be consistent; it's okay if it varies randomly and/or with the input, as long as it is consistently less than or equal to 11.

Answer 1

R, 51 bytes

regexpr("three.*two.*one.*g\\Ko",scan(,""),,T)[1]-1

Thanks to Bbrk24 for pointing out that \K (you have to use an extra backslash in R) sets where the match is considered to start.

R has a lot of built in regex functions, and this one handily tells you where the first match starts (-1 if there is no match). It's 1-indexed though, so we have to take 1 off (and hence, if the chefs can't go, -2 is returned, but that's less than 11 so we're good).

We need to specify perl=TRUE to use the \K feature. It's cheapest to specify that positionally rather than use pe=T.

Depending on conventions for how the input is available, the scan(,"") could turn into a variable (e.g. x) or function (\(x)) saving 8 or 4 bytes respectively.

Answer 2

Perl 5 + -p, 34 bytes

Returns 0 on invalid inputs. Performs a match against the input, using the result to decrement the last position of the match, via @+, by 1 (on successful matches, otherwise 0).

$_=-/three.*?two.*?one.*?go/i+"@+"

Try it online!

Answer 3

JavaScript (ES11), 40 bytes

-6 bytes thanks to InSync

Returns -1 for invalid inputs.

s=>s.search(/(?<=three.*two.*one.*g)o/i)

Attempt This Online!

Method

Using a lookbehind assertion, we look for the position of the first "o" in the input string which is preceded by the pattern "three.*two.*one.*g".

Answer 4

Retina, 25 bytes

I^iw0`three.*two.*one.*go

Try it online!

The regex is pretty straightforward, all the magic comes from the configuration flags at the beginning:

• I: find the position of the matches
• ^: use the position of the last character instead of the first
• i: case insensitive
• w: do this for all possible ways (even overlapping) of matching this regex
• 0: return only the first one

In practice, w0 will make sure that we return the earliest possible complete match, and is shorter than any other option based on lazy matching (.*?)

Answer 5

Vyxal 3, 24 bytes

ʀ"ỌṚUmn»\6”Ṃ".*?"j∥ẋMṪL+

Try it Online! | Literate mode equivalent (doesn't work)

Explanation:

ʀ"ỌṚUmn»\6”Ṃ".*?"j∥ẋMṪL+­⁡​‎⁠‎⁡⁠⁢‏⁠‎⁡⁠⁣‏⁠‎⁡⁠⁤‏⁠‎⁡⁠⁢⁡‏⁠‎⁡⁠⁢⁢‏⁠‎⁡⁠⁢⁣‏⁠‎⁡⁠⁢⁤‏⁠‎⁡⁠⁣⁡‏⁠‎⁡⁠⁣⁢‏⁠‎⁡⁠⁣⁣‏⁠‎⁡⁠⁣⁤‏⁠‎⁡⁠⁤⁡‏⁠‎⁡⁠⁤⁢‏⁠‎⁡⁠⁤⁣‏⁠‎⁡⁠⁤⁤‏⁠‎⁡⁠⁢⁡⁡‏⁠‎⁡⁠⁢⁡⁢‏‏​⁡⁠⁡‌⁢​‎‎⁡⁠⁡‏⁠‎⁡⁠⁢⁡⁣‏⁠‎⁡⁠⁢⁡⁤‏⁠‎⁡⁠⁢⁢⁡‏‏​⁡⁠⁡‌⁣​‎‎⁡⁠⁢⁢⁢‏⁠‎⁡⁠⁢⁢⁣‏⁠‎⁡⁠⁢⁢⁤‏‏​⁡⁠⁡‌­
 "ỌṚUmn»\6”Ṃ".*?"j        # ‎⁡Split "ỌṚUmn»\6” ("three two one go") on spaces and join by ".*?"
ʀ                 ∥ẋM     # ‎⁢Parallel apply regex search and regex match to lowercased input
                     ṪL+  # ‎⁣Add length - 1 to index
💎

Created with the help of Luminespire.

Answer 6

Jelly, 24 bytes

“Ç<*tẉ{cIE»Ḳṫw¥ƒŒlL’ȧạ¥L

Try it online!

A monadic link taking a string and returning an integer.

Thanks to @JonathanAllan for pointing out the case-insensitive requirement!

Explanation

“Ç<*tẉ{cIE»Ḳ              | Compressed string "three two one go" split at spaces
            ṫw¥ƒŒl        | Reduce, starting with the main link argument lower-cased, then for each of the strings above, find the first position in the current string and take the tail starting from there
                   L      | Length
                    ’     | Decrease by 1
                     ȧạ¥L | And with absolute difference from this and the length of the original string

Answer 7

Retina 0.8.2, 36 bytes

i1M!`.*?three.*?two.*?one.*?g(?=o)
.

Try it online! Link includes test cases. Outputs 0 for disallowed inputs. Explanation:

i1M!`.*?three.*?two.*?one.*?g(?=o)

Keep only the text up to the g of go (or delete the text entirely if it doesn't contain the words in the right order).

.

Count the number of characters remaining.

Answer 8

Scala 3, 77 bytes

s=>new Regex("(?i)(?<=three.*two.*one.*g)o").findFirstMatchIn(s).map(_.start)

Attempt This Online!

Answer 9

05AB1E, 39 37 bytes

lηÅΔηU“„í‚•€µ‚œ“#εXsδÅ¿ƶ0K}.«âε˜D{Q}à

What a mess.. Once again I hate that 05AB1E lacks a builtin to get all matching indices, instead of only the first.. The ηU and εXsδÅ¿ƶ0K} are all to do that manually.. -_-

Will output -1 if it's invalid.

Try it online or verify a few test cases.

Explanation:

l                # Convert the (implicit) input-string to lowercase
 η               # Convert it to a list of prefixes
  ÅΔ             # Get the index of the first prefix that's truthy for
                 # (or -1 if none are):
    η            #  Get the prefixes of the current prefix
     U           #  Pop and store it in variable `X`
    “„í‚•€µ‚œ“   #  Push dictionary string "three two one go"
     #           #  Split it on spaces
      ε          #  Map over all four words:
       X         #   Push the earlier list of prefixes of the prefix
        s        #   Swap so the current word is at the top again
         δ       #   Map over each prefix, using the word as argument:
          Å¿     #    Check whether the prefix ends with the word as substring
            ƶ    #   Multiply each check by its 1-based index
             0K  #   Remove all 0s
      }.«        #  After the map: reduce this list of lists by:
         â       #   Taking the cartesian product of two lists
          ε      #  Map over each combination of values:
           ˜     #   Flatten it to a single list
            D{Q  #   Check if the four indices are in increasing order:
            D    #    Duplicate the list
             {   #    Sort the copy
              Q  #    Check if both lists are still the same
          }à     #  After the map: check if any was truthy
                 # (after which the found index is output implicitly as result)

See this 05AB1E tip of mine (section How to use the dictionary?) to understand why “„í‚•€µ‚œ“ is "three two one go".

Answer 10

Charcoal, 42 bytes

≔θηＦ⪪”↶⌊¶z₂1γmι.Jχ” ≔✂η⌕↧ηιＬη¹η¿⊖ＬηＩ⁻Ｌθ⊖Ｌη

Try it online! Link is to verbose version of code. Does not output anything for disallowed inputs. Explanation:

≔θη

Make a copy of the input string.

Ｆ⪪”....” 

Loop over the four relevant words.

≔✂η⌕↧ηιＬη¹η

Slice the string so that it starts at that word. (But if the word is not present, the Find returns -1, which causes the Slice to return the last character.)

¿⊖Ｌη

If the string still contains at least two characters (which means it begins go), then...

Ｉ⁻Ｌθ⊖Ｌη

Output 1 more than the number of characters removed.

Answer 11

Python 3, 93 77 bytes

I'm new to regex, so open to golfs. Returns an integer for truthy and a None object for falsy.

lambda n:((x:=re.search("three.*?two.*?one.*?go",n,2))and~-x.end())
import re

Answer 12

Uiua 0.6.1, 38 bytes

-1⧻⊢⊢regex"(?is).*three.*two.*one.*go"

Try it yourself

Answer 13

C (gcc): 119 113 bytes

main(c,v)char**v;{char*s="go\0.one\0two\0three",*p=*++v;for(c=4;c--;)p+=strcasestr(p,s+4*c)-(int)p;exit(++p-*v);}

Edit: Thanks to everyone helping in improving the answer! :D

1. As always a minor improvement was made thanks to @ceilingcat (124 -> 122 bytes).
2. Thanks to @Command Master for getting rid of the prototype (119 -> 113 bytes).

C (gcc -m32): 105 bytes

main(c,v)char**v;{char*s="go\0.one\0two\0three",*p=*++v;for(c=4;c--;)p=strcasestr(p,s+4*c);exit(++p-*v);}

The prototype feels like a huge waste of bytes. Unfortunately, I could not figure out how to work around that. :/

Edit: Using the -m32 flag you can get rid of the prototype entirely (explained in the comments below). Thanks to @Command Master for suggesting this trick. :)

Try it online

Explanation:

main(c,v)char**v;{
    // 's' contains the keywords that are padded with '.' so the pointer can
    // be moved by a fixed value to go to the next keyword.
    //
    // 'p' contains the index of each keyword (eventually the index of 'go').
    // If no match is found 'p' will be NULL and cause a segmentation fault.
    // which indicates that the input does not allow the chefs to go.
    // The sequence is stored in reverse as it saves more space.
    char*s="go\0.one\0two\0three",*p=*++v;

    for(c=4;c--;)
        // The haystack is 'p' instead of v[1] since this discards any characters
        // before the last match which prevent false positives like:
        // "two...three..one..go..."
        //
        // Adds the needle's offset from 'p' to 'p', the casting tricks the
        // compiler to get around the issue of having the declare the prototype
        // of strcasestr().
        p+=strcasestr(p,s+4*c)-(int)p;

    // 'p' has to be incremented as it contains the index of 'g' of 'go'.
    exit(++p-*v);
}

Answer 14

JavaScript (Node.js), 51 bytes

s=>(z=/three.*two.*one.*?go/gi).test(s)*z.lastIndex

Attempt This Online!

This outputs 0 for no match, or the index.

The RegExp.lastIndex property (which only works for RegExes that have the g flag enabled) gives the index of the end of the previous match.

Answer 15

Swift, 156 bytes

Short version:

func c(_ s:String)->Int{let s=s.lowercased();return s.ranges(of: /three.*two.*one.*go/).first.map({s.distance(from:s.startIndex,to:$0.upperBound)-1}) ?? 0}

Verbose version:

func c2_(_ s: String) -> Int {
    let s = s.lowercased()
    return s.ranges(of: /three.*two.*one.*go/).first.map({
        s.distance(from: s.startIndex, to: $0.upperBound) - 1
    }) ?? 0
}

Answer 16

Gema, 38 characters

*\Cthree*two*one*g\Po*=@column@end
*=0

Sample run:

bash-5.2$ gema '*\Cthree*two*one*g\Po*=@column@end;*=0' <<< 'There are three of you here; after this round there will be two; but only one of you will go shop for up to $20,000.'
91

Try it online! / Try all test collected cases online!

Answer 17

TypeScript’s type system, 213 203 bytes

//@ts-ignore
type F<S,A=0,Z=any,B=Lowercase<S>>=B extends`${Z}three${Z}two${Z}one${Z}go${infer D}`?F<B extends`${infer B}go${D}`?B:0,[1]>:A extends 0?0:S extends`${Z}${infer R}`?F<R,[...A,1]>:A["length"]

Try it at the TS playground

Answer 18

Pip, 30 bytes

a~-`three.*?two.*?one.*?go`D$)

Outputs an index, or nothing if the chefs cannot go. Attempt This Online!

Explanation

   `three.*?two.*?one.*?go`     ; Regex, with non-greedy quantifiers
  -                             ; Make it case-insensitive
a~                              ; Find the first match in the program argument
                            $)  ; Get the index of the end of that match
                           D    ; Decrement

Answer 19

Python 3.8 (pre-release), 85 bytes

lambda s:([0]<sorted(x:=[*map(s.lower().find,('three','two','one','go'))])==x)*-~x[3]

Try it online!

Solution without regex

Answer 20

Bash, 77 bytes

IFS=: read l m<<<`grep -bioP three.*?two.*?one.*?go<<<$1`
echo $((${#m}+l-1))

Attempt This Online! (test cases shamelessly stolen from @manatwork's answer)

Bash + bc, 73 bytes

IFS=: read l m<<<`grep -bioP three.*?two.*?one.*?go<<<$1`
bc<<<${#m}+$l-1

ATO does not ship bc, so no link, sorry.

Use as script or bash function, with input string as first argument.
Outputs -1 if the chefs can't go.

Explanation:

                 grep -                         <<<$1   # in the first argument, match
                            three.* two.* one.* go      # the words anywhere
                         o                              # output only the match
                       b                                # and the index of the start of the match (format is hardcoded "index:match")
                          P        ?     ?     ?        # find words lazily, so the first instance allows the chefs to go
                        i                               # case-insensitive

IFS=:                                                   # set the Internal Field Separator to ':'
      read l m<<<`                                    ` # store output of grep in variables l and m, split input on IFS (implicit)
echo $((${#m}+l-1))                                     # output value of (length of match) + (index of start of match) -1