text:
Line up for golf!
Alice, Bob, Carol, Dave, and Eve are going out for a nice game of golf and need your help to decide in what order they will play.
Your program will input some statements, which are defined as a condition, and then one or more optional logical boolean operators followed by another condition. (That's [Condition]([Logical][Condition])* in regexp notation.) A logical boolean operator is "and" or "or." You may chose either and or or to have higher precedence, as long as it is consistent.
A condition is a name, followed by the word "is," followed optionally by the word "not," followed by one of these:

in front of
behind
n spaces in front of
n spaces behind
next to
nth
nth to last

An example of a valid condition is "Alice is not next to Bob".
Associativity is from left to right, except for "not," which only applies to a single statement. This means that "x or y and z or not a" means "((x or y) and z) or a," where x could be "Alice is 1st" or "Alice is behind Bob" or "Alice is not 2nd to last."
Your output must be the order in which the players line up, separated by commas, from front to back of the line.
Here's the full specification in regexp notation:
[Statement] = [FullCondition]([Logical][FullCondition])*
[FullCondition] = [Name] is [Condition]
[Condition] = (not)? (in front of|behind|[Number] space(s)? (in front of|behind)|next to|[Ordinal]|[Ordinal] to last)
[Logical] = and|or
[Number] = 1|2|3|4...
[Ordinal] = 1st|2nd|3rd|4th...

Standard methods of input and output. Input should be as a string, and output can be as a string or list.
And finally, here are some sample inputs and outputs.
Input:
The players are Alice, Bob, and Carol.
Alice is 2nd.
Bob is in front of Alice.

Output:
Bob, Alice, Carol

Input:
The players are Alice, Bob, and Carol.
Alice is 1 space in front of Bob. // remember to handle pluralization correctly!
Carol is 1st to last.

Output:
Alice, Bob, Carol

Input:
The players are Alice, Bob, and Carol.
Alice is in front of Bob.

Output:
Alice, Bob, Carol
Carol, Alice, Bob // multiple outputs may be required

Input:
The players are Alice, Bob, and Carol.
Alice is in front of Bob.
Bob is in front of Alice.

Output:
// nothing

Input:
The players are Alice, Bob, and Carol.
Alice is not in front of Bob and Carol is not 2nd or Bob is 1st.

Output:
Carol, Bob, Alice
Bob, Alice, Carol
Bob, Carol, Alice

This is code-golf, so the shortest code in bytes will win!
A great many thanks to @Doorknob for posting this in the Secret Santa's Sandbox. Again, thank you.

This was one I was going to take over but you really should repost it in sand box as it may need work

I worded it wrong. I looked at taking it over and never posted anything on it :P I instead posted a different one. But it may be finished.

Are lists a valid output format? So for example {{Alice, Bob, Carol}, {Carol, Alice, Bob}} for the third test case, and {{Alice, Bob, Carol}} for the second?

@GregMartin Yes, I'll edit.

Commonly in mathematics, and is taken to have higher precedence than or. (and is multiplication in the boolean algebra, while or is sort of addition.) Can the solver choose which convention (this, or left-associativity) they'll consistently use?

@GregMartin Yes. Consistently.

This seems another challenge for Prolog!

Your regexp seems to allow statements like "Alice is next to Bob or behind Carol and Bob is 2nd to last or not 2 spaces in front of Carol" (note the omission of the subject's name in two of the four condition clauses). Is this intentional? And if so, does this example conflict with left-associativity, with which "Bob is 2nd to last" is supposed to be bound more tightly to "Alice is next to Bob or behind Carol" than to "not 2 spaces in front of Carol"? (And if so, more test cases please!)

@GregMartin ((((Alice is next to Bob) or [Alice is] behind Carol) and Bob is 2nd to last) or [Alice is] not 2 spaces in front of Carol). Left associativity is the rule here. This does not contradict the last test case because (Alice is not in front of Bob) and [Alice is] Carol does not make sense, which would make the entire parenthesis-enclosed version ((Alice is not in front of Bob) and (Carol is not 2nd)) or (Bob is 1st), and everything works out. Left-associativity is not conflicted, and this is intentional. Does that answer your question?

I truly don't see how your parsing of my example makes sense. How can the subject "Alice" be more tightly bound to "not 2 spaces in front of Carol" than "Bob", with all those nested parentheses in the way? I don't think either left-associativity or a common-sense reading supports that parsing. Perhaps, since you don't have any relevant test cases anyway, you can just change the spec to [Statement] = [FullCondition]([Logical][FullCondition])*.

@GregMartin Yeah, I see my mistake, sorry. But thank you for the new regexp, I think it makes more sense for this challenge. I will edit it in.

oh good, I thought maybe I was going crazy....

Can we assume something about the names? Are they always a subset of {Alice, Bob, Carol, Dave, Eve} or do we have to handle others?

@Pietu1998 Yes, it is okay.

@Arnauld This is not okay, but I do not expect it to be to hard to fix. Sorry.

Does next to equal 1 space behind or also 1 space in front of?

@Titus Yes, it does. next to = ((1 space behind) or (1 space in front of)).

JavaScript (ES6), 554 499 ... 463 bytes
Takes input as an array of strings and returns an array of arrays of strings. Parsing rule: and has higher precedence than or.
Below is a slightly formatted version. The compact version is included in the snippet.
([P,...C])=>
  [...Array(m=9349)]
  .map(_=>p[a=P.match(/[A-E]\w+/g).sort(_=>(k=k*2%m)&1)]?0:p[a]=a,p={},k=1)
  .filter(s=>
    s&&eval(
      C.join`and `.match(/.+?(or |and |$)/g)
      .map(s=>
        (
          c=s.match(/([A-E]\w+|\d|no|la|fr|be|x|p|or|an)/g),
          S=n=>`s.indexOf('${c[p+n]}')`,
          E=`]=='${c[0]}'`,
          c[p=1]=='no'?(p++,'!(s['):'(s['
        )+
        (
          (x=+c[p])&&p++,
          {
            la:'s.length-'+x+E,
            fr:F=S(1)+-1+E,
            be:B=S(1)+'+1'+E,
            x:F+'||s['+B,
            p:S(2)+(c[p+1]>'f'?-x:'+'+x)+E
          }[c[p]]||--x+E
        )+
        (c.pop()>'o'?')||':')&&')
      ).join``+1
    )
  )

How it works
1. Initialization
The input array is split into:

P = first line, describing the players
C = array containing all other lines

We first extract the names of all players from P:
P.match(/[A-E]\w+/g)

We compute all permutations of the names, using several iterations of sort():
sort(_ => (k = k*2 % 9349) & 1)

The prime 9349 was (empirically) chosen in such a way that all permutations are guaranteed to be found, given enough iterations of the sort, for up to 5 players.
2. Filtering
The main part of the function consists of filtering these permutations to keep only the ones that match all conditions in C.
We join the different condition lines with and and split the resulting string on or and and to get an array of conditions.
Each condition is parsed to isolate the relevant tokens:
Token          | RegExp part
---------------+------------
Name of player | [A-E]\w+
Digit          | \d
'not'          | no
'last'         | la
'in front of'  | fr
'behind'       | be
'next to'      | x
'spaces'       | p
'or'           | or
'and'          | an

Each condition is translated into JS code:
Condition                     | JS code
------------------------------+-------------------------------------------------------------
'X is Nth'                    | s[N - 1] == 'X'
'X is Nth to last'            | s[s.length - N] == 'X'
'X is in front of Y'          | s[s.indexOf('Y') - 1] == 'X'
'X is behind Y'               | s[s.indexOf('Y') + 1] == 'X'
'X is next to Y'              | s[s.indexOf('Y') - 1] == 'X' || s[s.indexOf('Y') + 1] == 'X'
'X is N spaces in front of Y' | s[s.indexOf('Y') - N] == 'X'
'X is N spaces behind Y'      | s[s.indexOf('Y') + N] == 'X'

Finally, all codes are joined with || and && operators and the resulting string is eval()'d.
For example, below are the translations of the test cases as JS code:
(s[1]=='Alice')&&(s[s.indexOf('Alice')-1]=='Bob')&&1
(s[s.indexOf('Bob')-1]=='Alice')&&(s[s.length-1]=='Carol')&&1
(s[s.indexOf('Bob')-1]=='Alice')&&1
(s[s.indexOf('Bob')-1]=='Alice')&&(s[s.indexOf('Alice')-1]=='Bob')&&1
!(s[s.indexOf('Bob')-1]=='Alice')&&!(s[1]=='Carol')||(s[0]=='Bob')&&1

Test cases

let f =

([P,...C])=>[...Array(m=9349)].map(_=>p[a=P.match(/[A-E]\w+/g).sort(_=>(k=k*2%m)&1)]?0:p[a]=a,p={},k=1).filter(s=>s&&eval(C.join`and `.match(/.+?(or |and |$)/g).map(s=>(c=s.match(/([A-E]\w+|\d|no|la|fr|be|x|p|or|an)/g),S=n=>`s.indexOf('${c[p+n]}')`,E=`]=='${c[0]}'`,c[p=1]=='no'?(p++,'!(s['):'(s[')+((x=+c[p])&&p++,{la:'s.length-'+x+E,fr:F=S(1)+-1+E,be:B=S(1)+'+1'+E,x:F+'||s['+B,p:S(2)+(c[p+1]>'f'?-x:'+'+x)+E}[c[p]]||--x+E)+(c.pop()>'o'?')||':')&&')).join``+1))

console.log(JSON.stringify(f([
  'The players are Alice, Bob and Carol.',
  'Alice is 2nd.',
  'Bob is in front of Alice.'
])));

console.log(JSON.stringify(f([
  'The players are Alice, Bob, and Carol.',
  'Alice is 1 space in front of Bob.',
  'Carol is 1st to last.'
])));

console.log(JSON.stringify(f([
  'The players are Alice, Bob, and Carol.',
  'Alice is in front of Bob.'
])));

console.log(JSON.stringify(f([
  'The players are Alice, Bob, and Carol.',
  'Alice is in front of Bob.',
  'Bob is in front of Alice.'
])));

console.log(JSON.stringify(f([
  'The players are Alice, Bob, and Carol.',
  'Alice is not in front of Bob and Carol is not 2nd or Bob is 1st.'
])));

Python 3, 527 524 511 bytes
import re,itertools as I
S=re.sub
p=re.findall(r"\w+(?=[,.])",input())
l=[]
try:
 while 1:
  c=[["not "*("not "in c)+S(" .+o (.+)",r" in[\1+1,\1-1]",S(" .+f","+1==",S(" .+d","-1==",S(r" .+(\d+).+",r"+1==\1",S(r" .+(\d+).+st",r"==len(p)-\1",S(r" .+(\d+).+f",r"+\1==",S(r" .+(\d+) .+d",r"-\1==",c[:-1]))))))),c][len(c)<7]for c in re.split("(or|and) ",input())]
  while c[1:]:c[:3]=["("+" ".join(c[:3])+")"]
  l+=[c[0]]
except:print([P for P in I.permutations(p)if eval("and ".join(l),dict(zip(P,range(len(p)))))])

Try it online!
Outputs an array of valid permutations. Expects the names to only contain A-Za-z0-9_ (Alice through Eve are obviously valid).

PHP, way too long (790 744 725 697 678 669 bytes)
foreach(file(F)as$i=>$s)if($i){$g("#(.*)( and | or |\.)#U",$s,$w,2);foreach($w as $q){preg_match("#^(\w+)(.*?)(\w+)$#",$q[1],$m);$n=$u[-3+$p=($o=strpos)($u=$m[2],p)];$d.="!"[!$o($u,no)]."(".strtr(!$o($u,x)?A.($o($u,f)?$p?"==B-$n":"<B":($o($u,b)?$p?"==B+$n":">B":"==".preg_replace("#.*(\d).*#",($k=$o($u,a))?"$z-$1":"$1",$k?$u:$m[3]))):"(A-B)**2<2",[A=>$m[1],B=>$m[3]]).")$q[2]";}$d=!$x.="&"[!$x]."($d)";}else{($g=preg_match_all)("#(\w+)[.,]#",$s,$m);$z=count($y=$m[1]);}for(;$j++<10**$z;)if(count_chars($p="$j",3)==join(range(1,$i=$z))){for($c=$x;$i--;)$c=strtr($c,["."=>"","not"=>"",$y[$p[$i]-1]=>$i+1]);for(;eval("return$c;")&++$i<$z;)echo$y[$p[$i]-1],"
,"[$i<$z-1];}

takes input from file F, no trailing newline; and before or. Run with -nr or test it online.
breakdown
foreach(file(F)as$i=>$s)if($i)              # loop through input lines
{
    $g("#(.*)( and | or |\.)#U",$s,$w,2);       # split statement to conditions
    foreach($w as $q)
    {
        preg_match("#^(\w+)(.*?)(\w+)$#",$q[1],$m); # 1. copy names to $m[1],$m[3]
        $n=$u[-3+$p=($o=strpos)($u=$m[2],p)];       # 2. remove names, 3. find N in "N spaces"
        $d.="!"[!$o($u,no)]."(".                    # 4. negate, 6. concatenate
            strtr(                                  # 5. translate condition:
            !$o($u,x)
            ?A.($o($u,f)?$p?"==B-$n":"<B"               # (N spaces) in front of
            :($o($u,b)?$p?"==B+$n":">B"                 # (N spaces) behind
            :"==".preg_replace("#.*(\d).*#",            # N-th
                ($k=$o($u,a))?"$z-$1":"$1"                  # ... (to last)
                ,$k?$u:$m[3])
            ))
            :"(A-B)**2<2"                               # next to
        ,[A=>$m[1],B=>$m[3]])
        .")$q[2]";
    }
    $d=!$x.="&"[!$x]."($d)";                    # concatenate statements, clear statement
}else                                           # first line: import names to $y, count to $z
{($g=preg_match_all)("#(\w+)[.,]#",$s,$m);$z=count($y=$m[1]);}
                                            # loop through combinations
for(;$j++<10**$z;)if(count_chars($p="$j",3)==join(range(1,$i=$z))){
    for($c=$x;$i--;)                            # remove dot and "not", replace names
        $c=strtr($c,["."=>"","not"=>"",$y[$p[$i]-1]=>$i+1]);
                                                # all conditions met? print combination!
    for(;eval("return$c;")&++$i<$z;)echo$y[$p[$i]-1],"\n,"[$i<$z-1];
}


text:
Predict the Bomb's Landing Point!
Introduction
It was just a normal day, here at your military base. Suddenly, you looked up to see a bomb falling down from the sky! You need to create a program to predict where it will fall, and tell you the location.
Challenge
You will be given a bomb in the form of Start-X Start-Y X-velocity Y-velocity. You can assume that they will all be positive integers. 0 is a valid input only for Start-x and Start-y. The bomb starts with x Start-x, and y Start-y. Each "frame" (no graphical output required), the bomb will move x-velocity units right, then y-velocity units down. Continue doing this until the bomb reaches y of 0 or below. Then, output what it's x was when it hit the ground.
Test Cases
1
Input:0 10 2 2
Output:10
2
Input:5 4 3 2
Output:11
3
Input:11,8,7,3
Output:32
This is code-golf, so shortest answer in bytes wins!

Once you do out the math, it looks like the formula leaves little to golf.

@xnor Maybe the ceiling function could be golfed. But I can't see anywhere else.

You can assume that they will all be positive integers 0 is not a positive integer. Can you clarify if 0 is a valid input or not?

Looks like 0 is valid input from test case #1

0 is a valid input only for start-x and start-y. editing now.

Since this is such a trivial question, please do not upvote answers in obvious or golfing languages.

"Normal day", "military base" being in your "military base" isnt "normal". also, If you make a military base you might as well make it an explosion-proof bunker.

05AB1E, 9 bytes
¹³²(I÷(*+

Try online

JavaScript, 29 28 bytes
Thanks @user5090812 for golfing off 1 byte
(a,b,x,y)=>a+x*((b+y-1)/y|0)

Try it online!
If it did not have to move x then y but was instead falling in a straight line it would be 18 bytes
(a,b,x,y)=>a+x*b/y

You could do (a,b,x,y)=>a+x*(b/y|0+1) and save 5 bytes

@powelles If I do that I will end up overshooting for exact values.

Weird. I expected x|0+1 to perform the same as Math.ceil and didn't actually test it.

@powelles if you have 1|0+1 you end up with 2. With Math.ceil you will get 1

I mistakenly made the assumption that ceiling could be implemented as floor+1.

There is a way to emulate ceiling with integer math, but in this case it saves only 1 byte: (a,b,x,y)=>a+x*((b+y-1)/y|0)

TI-Basic, 21 bytes
Input :Prompt A,B:X+A+Aint(Y/B-E~9

If the ceiling function did not have to be implemented, it would be more straightforward at 13 bytes:
Input :Prompt A,B:X+AY/B

Don't you need to prompt for x and y as well?

@fəˈnɛtɪk In TI-83/84 BASIC, providing no arguments to Input is equivalent to Prompt X,Y, taking location from the graph screen. It's usually more of a savings when only one or two values are needed, although it saves 1 byte in this situation as well.

Python, 45 28 Bytes
lambda a,b,x,y:a+x*-(-b//y)

Try it online!

The import has to be scored. meta post

@mbomb007 Still, with the import is 45 bytes

Why not use your own ceil function? lambda a,b,x,y:a+x*int(b/y+.5)

@DJMcMayhem Just made one 2 bytes shorter than yours

a--b//y*x seems to work.

If you use Python 2, I think you can eliminate the // and just put /.

Combining ØrjanJohansen's suggestions and my suggestion: lambda a,b,x,y:a--b/y*x in Python 2 for 23 bytes.

@DJMcMayhem wouldn't that do a round? a ceil is (b+y-1)/y

You could use a-x*(...) to save 1 byte

Scheme 40 36 Bytes
λ(x y u v)(+ x(* u(ceiling(/ y v))))

Does scheme require all of those spaces between identifiers and parentheses

Actually I can get rid of some of them...thanks

Haskell, 21 bytes
(a#b)x y=a-x*div(-b)y

The trivial answer: defines an operator that takes 4 arguments and then uses the formula.
Could probably be golfed more.
EDIT: Yep, Ørjan Johansen points out we can use a-x*div b(-y), which brings us to 22 bytes. Try it online!
At this point, the code is really more other people than mine, so I'm going to mark this answer community wiki. Feel free to golf this further if you want :)

Ouch, importing Data.Ratio ... try a-x*div(-b)y.

C#, 46 bytes
(a,b,c,d)=>a+c*(int)Math.Ceiling((double)b/d);

Ruby, 21 bytes
->x,y,v,w{x-v*(y/-w)}

Java 7, 66 bytes
int f(int a,int b,int x,int y){return a+x*(int)Math.ceil(1f*b/y);}

source: Stack Exchange

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

sort: votes


text:
Large Numbers in BF
Background
The language BrainF*** (or simply BF), is an extremely minimal programming language. We're going to strip it back even further by eliminating IO operations; only the sub-langage defined by the operations +-<>[], henceforth referred to as BF-subset, shall be used. The BF variant considered has a tape extending infinitely to the left and right, and cells which can take on any integer value without overflowing, and which are initialized to 0.
For those unfamiliar with BF, this explanation is adapted from the esolangs BF page.
A BF-subset program is a sequence of commands. The commands are executed sequentially, with some exceptions: an instruction pointer begins at the first command, and each command it points to is executed, after which it normally moves forward to the next command. The program terminates when the instruction pointer moves past the last command.
>   increment the data pointer (to point to the next cell to the right).
<   decrement the data pointer (to point to the next cell to the left).
+   increment (increase by one) the byte at the data pointer.
-   decrement (decrease by one) the byte at the data pointer.
[   if the byte at the data pointer is zero, then instead of moving the instruction pointer forward to the next command, jump it forward to the command after the matching ] command.
]   if the byte at the data pointer is nonzero, then instead of moving the instruction pointer forward to the next command, jump it back to the command after the matching [ command.

The Task
If a BF-subset program terminates, its score is defined as the final value of the cell which the program halts at, otherwise 0. Your challenge is to write a program to generate BF-subset programs of each length between 1 and 20 inclusive, such that the total score is maximized.
The winner of the contest will be the entrant with the highest total score; in case of a tie, the shortest program takes the title. Your program must be fast enough for you to run it to completion.
Example Output and Scores
+                   01
++                  02
+++                 03
++++                04
+++++               05
++++++              06
+++++++             07
++++++++            08
+++++++++           09
++++++++++          10
+++++++++++         11
++++++++++++        12
+++++++++++++       13
++++++++++++++      14
+++++++++++++++     15
++++++++++++++++    16
+++++++++++++++++   17
++++++++++++++++++  18
+++++++++++++++++++ 19
+++++++++++++++++++ 20

Here, the total score is 210.
Edit: Changed the maximum length from 17 to 20.

How can we test our submissions? Also, given that I expect these values to grow astronomically, I suspect that only the length-17 entry to matter in principle.

Isn't this basically meta-golf of something like output Graham's number?

@xnor For short lengths, the values actually stay quite small.

@user1502040 That's fair, I see the really astronomical programs seem to take about twice that many characters. I do have a concern that if someone finds an exceptionally good solution, the only limit will be running it to completion even when the result is mathematically known. So I'd suggest ditching that rule.

Isn't the score actually 105?

Also your program for 20 is too short.

Err, Is - a vald program? Technically, the output would be 255.

Although I like this challenge, I think with a limit of 20 all possible solutions have already been crunched to death. The shortest I could find that doesn't appear on the constants page is 22 bytes for 160: ->>>>+[>+[-<+++>]<<+]> (well, it does now, I've just added it).

309
+                    01
++                   02
+++                  03
++++                 04
+++++                05
++++++               06
+++++++              07
++++++++             08
+++++++++            09
++++++++++           10
+++++++++++          11
++++++++++++         12
+++++++++++++        13
++++[->++++<]>       16
+++++[->++++<]>      20
+++++[->+++++<]>     25
++++++[->+++++<]>    30
++++++[->++++++<]>   36
+++++++[->++++++<]>  42
+++++++[->+++++++<]> 49

Do these all match the best-known values from the constants page?

@xnor Not sure, right now I'm checking through it. EDIT: Yeah, looks like they do, but I might have made a mistake.

@orlp But loops only run while the cell has a nonzero value

@ASCII-only I misread the answer, I removed my downvote.

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


text:
King of the Hill: Bank Heist
Example run added 4/11
Rules Clarification 4/8: All submissions will be competing in one giant free-for-all tournament consisting of as many matches as my computer can perform in 48 hours.
Anyone who's spent any time watching streams on Twitch is aware of the prevalence of DeepBot, and is perhaps even familiar with its Bank Heist betting game. This King of the Hill tournament is directly inspired by that game. Don't worry, though. I think I've thrown enough extra kinks into this version to keep things interesting.
A quick example
#####GAME 13: 16 players######

Round 1:
gunHeCK bet 0.
PassivePanga bet 69.
SnitcherKing bet 1.
Lurker bet 0.
OC'sRandomTpyos bet 1.
MonisAddiction bet 69.
RaysFive01K bet 28.
LimeadeSneaktar bet 1.
KaylorrCriterion bet 0.
HardHatUmar bet 0.
HeCKuSumer bet 185.

Round 2
HeCKuSumer decided to !guncheck.
LimeadeSneaktar decided to double cross.
MonisAddiction decided to all in.
OC'sRandomTpyos decided to acquire intel.
RaysFive01K decided to deposit.
SnitcherKing decided to finger.
PassivePanga decided to !guncheck.

Results
PassivePanga failed. :(
SnitcherKing failed. :(
OC'sRandomTpyos was successful, and may gain ¥0
MonisAddiction failed. :(
RaysFive01K was successful, and may gain ¥0
LimeadeSneaktar was successful, and may gain ¥1
HeCKuSumer failed. :(

Results:
0. KaylorrCriterion: 3600
1. Lurker: 3600
2. gunHeCK: 3600
3. SnitcherKing: 3586
4. PassivePanga: 2634
5. LimeadeSneaktar: 2496
6. HeCKuSumer: 1909
7. HardHatUmar: 490
8. RaysFive01K: 255
9. OC'sRandomTpyos: 170
10. MonisAddiction: 0

(In this round, 7 players joined the heist, but the dice only rolled right for 3 of them. Of those, only LimeadeSneaktar brought any home--having stolen it from OcsRandomTpyos. RaysFive01K won significantly more, but deposited it all at the bank before leaving. At this point, the players who did not heist are doing well, living off their day jobs.)

#####GAME 14: 231 players######

Round 1:
Lurker bet 0.
HeCKuSumer bet 190.
KaylorrCriterion bet 0.
HardHatUmar bet 0.
MonisAddiction bet 0.
OC'sRandomTpyos bet 1.
gunHeCK bet 0.
LimeadeSneaktar bet 1.
RaysFive01K bet 25.
PassivePanga bet 69.
SnitcherKing bet 1.

Round 2
PassivePanga decided to !guncheck.
OC'sRandomTpyos decided to buy guard.
HeCKuSumer decided to !guncheck.
SnitcherKing decided to finger.
RaysFive01K decided to deposit.
LimeadeSneaktar decided to double cross.

Results
HeCKuSumer failed. :(
OC'sRandomTpyos failed. :(
LimeadeSneaktar failed. :(
RaysFive01K failed. :(
PassivePanga failed. :(
SnitcherKing failed. :(

Results:
0. KaylorrCriterion: 3840
1. Lurker: 3840
2. gunHeCK: 3840
3. SnitcherKing: 3825
4. PassivePanga: 2805
5. LimeadeSneaktar: 2495
6. HeCKuSumer: 1959
7. HardHatUmar: 490
8. MonisAddiction: 240
9. RaysFive01K: 229
10. OC'sRandomTpyos: 161

Six players heisted--but should have been paying more attention to the rabble and backed out, because the probabilities dropped too low to win, and all failed.

#####GAME 15: 300 players######

Round 1:
OC'sRandomTpyos bet 1.
Lurker bet 0.
SnitcherKing bet 1.
MonisAddiction bet 69.
LimeadeSneaktar bet 1.
gunHeCK bet 0.
HardHatUmar bet 0.
RaysFive01K bet 22.
KaylorrCriterion bet 0.
HeCKuSumer bet 195.
PassivePanga bet 69.

Round 2
HeCKuSumer decided to !guncheck.
OC'sRandomTpyos decided to buy guard.
MonisAddiction decided to all in.
PassivePanga decided to !guncheck.
LimeadeSneaktar decided to double cross.
RaysFive01K decided to deposit.
SnitcherKing decided to finger.

Results
OC'sRandomTpyos failed. :(
SnitcherKing failed. :(
MonisAddiction was successful, and may gain ¥0
LimeadeSneaktar failed. :(
RaysFive01K failed. :(
HeCKuSumer failed. :(
PassivePanga failed. :(

And here, the probabilities dropped too low to win again--except for MonisAddiction, who went all in, and therefore avoided the probability modification incurred by the rabble backing out. No winnings are listed here, because a player who wins going all in immediately adds all winnings to its holdings without any possible modification by other players' actions.

Game Rules
Tournament/Game Structure

The tournament will consist of a number of games chosen uniformly at random between 1000 and 1100, in which every serious submission will be competing simultaneously in a free-for-all.
Every player starts the first game with 240 credits and each subsequent game with the number of credits it had at the end of the previous game.
Each game proceeds in 2 rounds, and in each round, players are called in an order determined uniformly at random to make one decision:

In the first round, a player may pay any integer number of credits between 0 and its current credit holdings to stake participation in a bank heist.
In the second round, each player that elected to participate in the heist by wagering at least one credit (hereafter referred to as "heisters") may decide to let its bet ride (and, while doing so, possibly perform some other action), opt out of the heist, or go all-in. (These options are further described below.)

Based on the number of heisters and the total number of credits they paid, one of five banks is selected on which to stage a heist. This selection affects the individual probability of victory and the odds by which the payout is determined. (The banks are described below.)
Each heister that did not opt out will, with the bank's (modified) probability, win its stake multiplied by the bank's (modified) betting odds (rounded down), or else lose its stake. Note that each player's success or failure is determined individually--some will succeed where others fail.
All players, whether they participated or not, succeeded or failed, then receive a paycheck (with exceptions described below).
Note that it is impossible to permanently leave the game. At worst, a player may have to wait a game to receive its next paycheck.
After all 1000-1100 games, the player with the greatest number of credits will be declared the winner of that tournament.
The tournament will be repeated an unspecified number of times (as many as can be computed in 48 hours) and the player earnings across all tournaments summed in order to determine the overall winner of this contest.

The Second Betting Round

Any player who has wagered a positive stake in the first round may participate in the second round.
In this round, a player may:

reply with the string "back out" to cancel its bet. This will set its wager to zero for the current heist and also slightly decrease the probability the players remaining in the heist will succeed. By taking this option, a player forgoes the 240 credit paycheck that follows the heist as punishment for putting the remaining heisters at risk. (The remaining heisters will succeed with a probability equal to the bank's probability times the fraction of heisters that did not "back out".)
reply with the string "all in" to blow its entire credit holdings--and take out a payday loan on its next 240 credit paycheck--to buy all the best gear and intel for a heist and go in alone, guns blazing, without relying on anyone. Such a player's victory probability cannot be affected by other heisters dropping out of the heist, nor can its winnings be stolen by double-crossers. Winning payouts will be determined as if its bet were its entire credit holdings plus 240, while loss will set its holdings to zero.
Reply with any other string (including the empty string) in order to stick with the previous bet and go through with the heist as normal. (Recommended reply: "!guncheck"). Certain replies will have additional side effects:

A reply of "change jobs" will cause the player to quit its job. Beginning this round, at the end of each round, the player will have a 5% chance to get hired in a new position. If this succeeds, the player is hired and immediately receives its first paycheck. Each new job is guaranteed to pay exactly 5% more than the last (rounded down). This action will succeed whether or not the heist succeeds.
A reply of "acquire intel" will, if the heist succeeds, cause the player to spend all of its winnings from that heist to get an extra 0.00001 per credit thus spent on the odds for the bank that was heisted for that player only. This odds modification is permanent. As an example, if a player chooses this action when heisting bank 1 and wins 6969 credits in a heist, bank 1's odds for that player will be permanently increased by 0.06969 and the player will receive nothing from that heist.
A reply of "buy guard" will cause the player to buy off one of the security guards at the bank being heisted. In exchange for a permanent reduction of 1 credit on that player's paycheck (the guard's regular bribe), the player will receive a "permanent" increased victory probability at that bank (due to the guard "forgetting to mention" that player to the cops when asked). The probability will increase by exactly 1% of the difference between the player's current victory probability at that bank and 100%. This action will succeed even if the heist fails. NOTE: If at any time, a player has not enough credits to pay all of its guard bribes, it immediately and "permanently" loses as many probability bonuses as the number of bribes that could not be paid, selected uniformly at random from all bribes registered.
A reply of "deposit" will, if the heist succeeds, leave a player's entire winnings in an account at the bank heisted. The credits will not be accessible for any purpose nor be counted towards a player's score until withdrawn. This account will pay interest at a rate of 0.14% per game.
A reply of "withdraw" will, if the heist succeeds, add to a player's winnings the entire contents of its account at the bank heisted. The account will be zeroed as a result. Note that these additional winnings can be stolen by double-crossers.
A reply of "double cross" will do one of two things:

If the number of heisters who played "double cross" is at most 1/10th (rounded down) of the total number of non-rabble heisters who decided to go through with the heist (or exactly one if there are less than 10 such players), the player will receive additional winnings equal to the total winnings of all non-double-crossers divided by the number of double-crossers (rounded down). All non-double-crossers in this case receive 0 credits from the heist. In other words, the double-crossers steal everyone else's credits and divide it evenly amongst themselves.
If the number of heisters who played "double cross" exceeds the threshold, the player will receive no winnings (if its heist was successful), have its paycheck cut in half, and be fired from its job. (See "change jobs".) All non-double-crossers (including rabble) in this case will receive a bonus payment of the total winnings of all double-crossers divided by the total number of non-double-crossers. In other words, the conspiracy got too big to keep a secret, the conspirators were rooted out and excluded from the heist, and everyone divided up their stakes for punishment--and their reputation for dirty dealing lost them their jobs as well.

A reply of "finger" (as in "fingering a double-crossing scoundrel rat") will, if the heist succeeds, give the player eight opportunities (drawing uniformly with replacement from the set of non-rabble heisters) to identify a double-crosser which has not already been so identified.

Each double-crosser identified this way will immediately pay the fingerer 25% of its current credit holdings (rounded down) in lieu of being shot, lose its job and have its paycheck cut in half (because the boss won't tolerate bad behavior), and lose 5% of its probability of victory at the bank being heisted (as other heisters are extra suspicious in the future and likely to throw it under the bus if things get hairy). Double-crossers identified this way do not affect whether the double-cross was successful for other double-crossers, but they do not receive any of the stolen credits from the double-cross, and said stolen credits will be redistributed back to the non-double-crossers.
If no double-crossers are identified this way, the snitch will get stitches for wasting everyone's time--and also pay half its winnings from the current heist, take a 5% cut on its paycheck (boss cuts the tattletale's hours), and lose 5% of its betting odds at the current bank (as other heisters are less likely to be generous/fair with their winnings in the future). The half of its winnings thus lost will be distributed to the unfingered double-crossers if the double-crossers succeeded, or the non-double-crossers (including rabble) if the double-crossers failed.

The Banks
The bank is selected using the index numheisters + int(totalamountbet/100000), where numheisters is the number of players which wagered a positive stake in round 1 and totalamountbet is the sum of the stakes of all of those players. In other words, a hundred thousand credits is as good as 1 additional heister. Based on this index one of the following banks will be chosen, the bank with the highest threshold that the index meets or exceeds:
Bank             Index Threshold   Victory Prob.  Bet Odds
----             ---------------   -------------  --------
0:Municipal                    0           0.540      0.80
1:City                        20           0.488      1.10
2:State                       40           0.425      1.30
3:National                    60           0.387      1.65
4:Federal Reserve             80           0.324      1.95

Note that as a tournament continues, the probability of reaching the highest bank level will increase, as the amount each player can bet trends upwards. Note also that these are only initial odds and probabilities, before they have been modified by any "acquire intel" or "buy a guard" actions. With the initial probabilities and odds, only the City and National banks have expected winnings exceeding expected losses.
The Rabble

The tournament also contains 500 other players, called the "rabble", who participate as regular players in heists but are not scored in the end. These serve to make each game different and somewhat less predictable, and make it possible to reach the riskier/more rewarding banks even with only a few "real" players.
Each game will include some subset of rabble to participate chosen uniformly at random over all subsets of rabble.
All rabble use the following strategy:

Randomly choose to bet with probability equal to the probability of succeeding at the bank that would be selected based on the decisions of the players who have already made their decision this round.
If betting a nonzero amount, choose the largest of the following amounts that would not exceed its current holdings: 69, 420, 6969, 80085.
In the second round, "back out" with probability equal to 5% plus 50% of the proportion of bettors that have already backed out, otherwise heist as normal. (Note that this means early players in the second round that back out can have huge cascading effects among the rabble--pay attention and be ready for the heist to collapse before it even starts.)

Inputs and Outputs
In both rounds, programs will be given the following information, in exactly this order, as command line arguments. Unless otherwise stated, all values are integers containing no decimal.

The current game number (zero-indexed)
The round number of the current game (1 or 2)
The number of players in the current game (including rabble).
The number of players that have already taken their turns this round.
The number of heisters that have committed a positive stake so far. (In the second round, this will actually be the total number of heisters who bought in in the first round.)
The total number of credits invested so far. (In the second round, this will actually be the total number of credits invested in the first round--in particular, it does not include more than the initial stakes of "all in" heisters and does include the stakes of "back out" heisters.)
The number of heisters who have confirmed in the second round (i.e. did not "back out"). This will be zero during the first round.
The (zero-indexed) number of the bank to be heisted (during the first round, the bank that would be heisted if no one else bet)
The number of credits currently available to the player.
The number of credits the player bet in the first round. (This is always zero in the first round.)
The number of credits the player will receive in its paycheck at the end of each game.
1 if the player is currently receiving a paycheck, 0 if the player is unemployed
Player's rank on the leaderboard (not including rabble) as of the end of the previous game, 1-indexed. (Defined as 1+the number of players with strictly more credits at that time. E.g. during the first game, all players have rank 1.)
The mean number of credits held by all players (not including rabble) (represented as a decimal number)
The mean absolute deviation in the number of credits held by all players (not including rabble) (represented as a decimal number)
The maximum number of credits held by any player (i.e. the number of credits held by a rank 1 player, not including rabble)
The number of credits the player has stored in bank 0 account
Bank 1 account
Bank 2 account
Bank 3 account
Bank 4 account
The player's individual probability of victory at bank 0
Bank 1 probability
Bank 2 probability
Bank 3 probability
Bank 4 probability
The player's individual payout odds upon a successful heist at bank 0
Bank 1 odds
Bank 2 odds
Bank 3 odds
Bank 4 odds

In the first round of a game, a player program must print to stdout an integer between 0 and the total number of credits in that player's account. Any bet amount greater than the available credit balance is taken to be a max bet. Any other output (or error condition) will be interpreted as a zero bet.
In the second round of a game, a player program must print to stdout a string as described in the section "The Second Betting Round" above. An error condition here is taken to be the default action: go through with the heist as normal.
Controller
The tournament will be run using this controller. Bot examples there as well. Still being tested. More code to come. Feel free to submit bug fixes (on github). Will be updated if any rules change as well.
To run a single tournament on your own machine, add a line to competitors.txt and then use:
python bankheist.py 1000

Contest Rules

Players may submit any number of player programs in any freely available language the programs of which may receive command line arguments.
Submissions must include fairly explicit instructions for how to compile programs and run them on my PC, including names of tools needed and exact commands to be issued. Submission must include at least one command which executes the program and may have command line arguments appended directly to it.
Submissions must also have a unique name to identify them (which contains no spaces).
Programs must run in a reasonably short amount of time. (I'm not setting an upper bound on what constitutes reasonable. Rather, I will simply advise the creator any entry that seems to have an outsize execution time to speed it up.)
Programs may not read or write to files. Nor may they use any other method of storing information between runs. The point of this challenge is to make complex decisions on the basis of limited/summarized information.
Any and all of these rules are subject to change at any time if necessary. A message will be added at the top of this post indicating any such changes.
This contest ends no sooner than one week after the last user submits posts his or her first submission. Modifications of existing submissions are allowed at any time up until the contest ends. I'll do my best to keep the current deadline updated in a message at the top of this post.
This contest ends no sooner than one week after the last time the rules were changed, if any. I will do my best to leave comments for any users affected by any rule changes.
You better bet I'll be participating in this contest myself. ;)

Comments are not for extended discussion; this conversation has been moved to chat.

Maybe because i am not familiar with twitch or the heist game but there is a lot of rules that may best be demonstrated with a small worked example(s). At the moment it seems not very approachable.

King of the Hill? I haven't heard that name in years.

Some "bad" examples of programs.
These are some bots I've written to test the controller. Mostly, they just do the minimum necessary thing to test one specific type of action. Depending on the level of participation in this KotH, anywhere from a few to all of these will be included in the final tournament, since a lot of the strategy in the game will come from dealing with the behaviors of lots of different bots.
I include them all here mostly as "usage" examples.
Lurker
Never bet. If you're not beating this, rethink your strategy.
print 0

PassivePanga
Always bet 69.
import sys

round = int(sys.argv[2])
myyattas = int(sys.argv[9])
if round == 1:
    if myyattas > 69:
        print "69"
    else:
        print "0"
else:
    print "!guncheck"

KaylorrCriterion
Make a Kelly bet if and only if the Kelly Criterion is met. As this rarely happens with doing some "acquire intel" and "buy guard" first, this generally gets the same result as Lurker.
import sys
import ast
game,round,numplayers,alreadyplayed,numbet,yattasbet,numready,bankid,myyattas,mybet,mypayment,hired,myrank,mu_yattas,sigma_yattas,max_yattas = map(ast.literal_eval,sys.argv[1:17])
bankholdings = map(int,sys.argv[17:22])
bankprobs = map(float,sys.argv[22:27])
bankodds = map(float,sys.argv[27:32])

def get_bank(bettors,credits):
    selector = min(4,int(bettors+int(credits/100000.)/20))
    return bankprobs[selector],bankodds[selector]

if round == 1:
    if alreadyplayed < 0.37*numplayers or numbet==0:
        print 0
        #sys.stderr.write("1: %d,%d\n"%(alreadyplayed,numbet))
    else:
        ratiosofar = numbet/float(alreadyplayed)
        bettors = ratiosofar * numplayers
        ratesofar = yattasbet/float(numbet)
        credits = bettors*ratesofar
        p,b = get_bank(bettors,credits)
        f = (p*(b+1)-1)/b
        print max(int(f*myyattas),0)
        #sys.stderr.write("2: %d,%d\n"%(p,b))
else:
    if alreadyplayed < 0.37*numbet or numbet==0:
        print "!guncheck"
    else:
        p,b = get_bank(numbet,yattasbet)
        realp = p*numready/float(alreadyplayed)
        f = (realp*(b+1)-(1-240./(myyattas+240.)))/b
        print "!guncheck" if f>0 else "back out"

gunHeCK
Make a Kelly bet if and only if the number of heisters seen so far indicate that the bet will meet the Kelly criterion (but don't back out if wrong). Typically does worse than Lurker
import sys
import ast
game,round,numplayers,alreadyplayed,numbet,yattasbet,numready,bankid,myyattas,mybet,mypayment,hired,myrank,mu_yattas,sigma_yattas,max_yattas = map(ast.literal_eval,sys.argv[1:17])
bankholdings = map(int,sys.argv[17:22])
bankprobs = map(float,sys.argv[22:27])
bankodds = map(float,sys.argv[27:32])

def get_bank(bettors,credits):
    selector = min(4,int(bettors+int(credits/100000.)/20))
    return bankprobs[selector],bankodds[selector]

if round == 1:
    if alreadyplayed < 0.37*numplayers or numbet==0:
        print 0
        #sys.stderr.write("1: %d,%d\n"%(alreadyplayed,numbet))
    else:
        ratiosofar = numbet/float(alreadyplayed)
        bettors = ratiosofar * numplayers
        ratesofar = yattasbet/float(numbet)
        credits = bettors*ratesofar
        p,b = get_bank(bettors,credits)
        f = (p*(b+1)-1)/b
        print max(int(f*myyattas),0)
        #sys.stderr.write("2: %d,%d\n"%(p,b))
else:
    print "!gunHeCK"

Moni'sAddiction
Go "all in" unless already winning.
import sys
import random

round = int(sys.argv[2])
myrank = int(sys.argv[13])
mybet = int(sys.argv[10])

if round == 1:
    if random.random()<0.1:
        print 1
    else:
        print 69
else:
    if myrank>1:
        print "all in"
    else:
        if mybet==1:
            print "back out"
        else:
            print "!guncheck"

HeCKuSumer
Always bet a small constant fraction of holdings.
import sys

round = int(sys.argv[2])
myyattas = int(sys.argv[9])

if round==1:
    print int(0.1*myyattas)
else:
    print "!guncheck"

OC'sRandomTpyos
Change jobs a lot in early tournament. Spend all that money improving probabilities and odds. Then spend the last few games going all in. This would probably do a lot better without the going all in unless already in a top spot.
import sys
import ast
import random

game,round,numplayers,alreadyplayed,numbet,yattasbet,numready,bankid,myyattas,mybet,mypayment,hired,myrank,mu_yattas,sigma_yattas,max_yattas = map(ast.literal_eval,sys.argv[1:17])
bankholdings = map(int,sys.argv[17:22])
bankprobs = map(float,sys.argv[22:27])
bankodds = map(float,sys.argv[27:32])

if round == 1:
    if game<800 or myrank>3:
        print 1
    else:
        print myyattas/4
else:
    if game<800:
        if hired:
            print "change jobs"
        else:
            print random.choice(["acquire intel","buy guard"])
    else:
        if myrank>3:
            print "all in"
        else:
            print "!guncheck"

HardHatUmar
Changes jobs whenever possible for most of the tournament. Avoids betting more than the minimum necessary. Does decently well, but not great.
import sys

game = int(sys.argv[1])
round = int(sys.argv[2])
hired = int(sys.argv[12])

if round==1:
    if game < 900 and hired:
        print 1
    else:
        print 0
else:
    print "change jobs"

LimeadeSneaktar
Change jobs whenever possible during the first part of the tournament. Spend every other game double crossing. Does decently well even against SnitcherKing. Will probably fare more poorly once many other bots are double crossing and fingering. If not--the rules may need changing.
import sys
import ast

game,round,numplayers,alreadyplayed,numbet,yattasbet,numready,bankid,myyattas,mybet,mypayment,hired,myrank,mu_yattas,sigma_yattas,max_yattas = map(ast.literal_eval,sys.argv[1:17])
bankholdings = map(int,sys.argv[17:22])
bankprobs = map(float,sys.argv[22:27])
bankodds = map(float,sys.argv[27:32])

if round==1:
    print 1
else:
    if hired and game<900:
        print "change jobs"
    else:
        print "double cross"

SnitcherKing
Always bet the minimum, and always finger. Does pretty well in small tournaments that include LimeadeSneaktar.
import sys

round = int(sys.argv[2])

if round == 1:
    print 1
else:
    print "finger"

RaysFive01K
A bit more complicated--and therefore actually pretty good. Most of its advantage comes from depositing all winnings in early tournament (protecting them from double crossers) while driving up its win probabilities (and changing jobs to pay for all those guards and heists), then withdrawing them all at the end of the game (once they have earned serious interest and the probability of failing to withdraw is sufficiently low--though here losses to double crossers is a serious risk). This will definitely be in the tournament, and may or may not be a serious contender.
import sys
import ast
import random
game,round,numplayers,alreadyplayed,numbet,yattasbet,numready,bankid,myyattas,mybet,mypayment,hired,myrank,mu_yattas,sigma_yattas,max_yattas = map(ast.literal_eval,sys.argv[1:17])

bankholdings = map(int,sys.argv[17:22])
bankprobs = map(float,sys.argv[22:27])
bankodds = map(float,sys.argv[27:32])

if round ==1:
    if game < 900:
        print myyattas/10
    else:
        print 1
else:
    if game < 500 and hired:
        print random.choice(["change jobs","finger","buy guard"])
    elif game < 900:
        print "deposit"
    elif bankholdings[bankid]>0:
        print "withdraw"
    else:
        if alreadyplayed/float(numplayers)<0.5:
            print "finger"
        else:
            print "back out"

I approve of these nameings <insert Twitch & Panga memes>

Lone John
import sys
import ast

game,round,numplayers,alreadyplayed,numbet,creditsbet,numready,bankid,mycredits,mybet,mypayment,hired,myrank,mu_credits,sigma_credits,max_credits = map(ast.literal_eval,sys.argv[1:17])

bankholdings = map(int,sys.argv[17:22])
bankprobs = map(float,sys.argv[22:27])
bankodds = map(float,sys.argv[27:32])

if round == 1:
    if mycredits > 100 or hired:
        print(int(mycredits)/2)
    else:
        print(0)
else:
    if bankprobs[int(bankid)] > 0.6:
        print("all in")
    elif int(mypayment) > 50 :
        print("buy guard")
    elif int(mycredits) > 200 and int(game) < 900 and hired == "1":
        print("change jobs")
    elif bankprobs[int(bankid)] * (float(numready)+1)/(float(alreadyplayed)+1) < 0.30:
        print "withdraw"
    else:
        print "!guncheck"

Bribes guards until he has the probability to win, then goes all in. Alone.
Changes jobs when he needs more money to bribe guards.

what is this player called?

@quintopia ops! I forgot I got all the way to posting it! Name and explination added.

Nice. Just as a tip, you don't need to do all those typecasts. Everything is already the right type from being eval'd right off the bat. Which means that the condition hired == "1" will always be false and it will never change jobs.

I just ran it in a single round against all the others I made. Came in last place. Bad luck :(


text:
Cook me a hot dog!
Sometimes I find myself wanting a hot dog (don't we all) and so I make one. Now to make a hot dog, it is very simple.
1) Put the hot dogs into boiling water
2) Wait for a certain amount of time (detailed below)
3) Eat the hot dog once the time has elapsed.
You may have noticed that I said

certain time (detailed below)

and so I will detail.
Many different brands have many different recommendations for how long we should cook the hot dogs, but I have found it best to cook them for exactly 4 minutes and 27 seconds (don't ask). I have tried many different timers, but have found that a program that continuously outputs is the best way to attract my attention.
YOUR TASK
You have to make a program that will output the message Not ready yet for exactly 4 minutes and 27 seconds. After this time has elasped, you should output Eat your hot dog until the end of time. Please don't take any input.
HOW TO WIN
You must write the shortest code in bytes to win because this is a code-golf

Very closely related.

Quite close to Legen… wait for it… also.

The only difference is that this challenge requires the program to wait for a specific amount of time

should it print continuously for 4:27 or just once and wait?

@DeadPossum until the end of time

Must we output "Not ready yet" continuously over and over again until the interval finishes (Not ready yet\nNot ready yet\n...) or can we just output it once and change the output once the 4m 27s is over?

Elvis has left the building… Could a moderator jump in and edit the question to add a clear implementation of “After this time has elasped, you should output Eat your hot dog until the end of time.”? Given there is nothing specified about output frequency, some solution just bend the rules and output the 2nd message a single time. I can't see anything good for the challenge in that.

Oops, my answer has been reminding me to eat my hot dog for the last two days...

Possible duplicate of Is it Christmas?

Dang it. I had a ti-basic answer and was going to answer

Scratch, 93 78 bytes

Code:
when gf clicked
say[Not ready yet
wait until<(timer)>[267
say[Eat your hot dog

Generated by https://scratchblocks.github.io/, which seems to be the standard for Scratch scoring.
Fairly self explanatory. When the program starts, say "Not ready yet" until the timer (which is counted in seconds) is greater than 267. Then starts an infinite loop where it says Eat your hot dog.
It is continuous output, because the say block runs forever unless you say [] or say something else.

There is no need for the forever, saving 8 bytes. That takes it to 85 bytes. It is also shorter in Hñähñu (Mezquital Otomi), instead of English, by another 8 bytes (without the forever), taking it to just 77 bytes.

http://scratchblocks.github.io/#?lang=ote&script=Ngu%20gi%20%E2%9A%91%20tom%E2%80%99i%0Ayopi%3C(timer)%3E%5B555%0Ama%5BNot%20ready%20yet%0Aend%0Ama%5BEat%20your%20hot%20dog

@Tim thanks, but the green flag doesn't seem to work.

Actually that comes from the official translation by the website, so it's a bug that it renders wrong.

@Tim The green flag block probably hasn't been implemented yet (although the translation still translates it). Also, there is no Hñähñu language in official Scratch.

Bash + coreutils, 50
timeout 267 yes Not ready yet
yes Eat your hot dog

Explanation
Fairly self-explanatory I think, but just in case:

The yes coreutil continuously repeatedly outputs any parameters passed to it on the command line
The timeout coreutil takes a numeric timeout parameter followed by a command.  The command is run, then killed after the specified timeout.

Operation Flashpoint scripting language, 67 bytes
#l
s="Not ready yet"
?_time>267:s="Eat your hot dog"
hint s
goto"l"

Save as "hotdog.sqs" (or whatever) in the mission folder and call with [] exec "hotdog.sqs".
Explanation:
#l                                  // Label for the "goto"
s="Not ready yet"
?_time>267:s="Eat your hot dog"     // "?:" means "if () then" in a script.
                                    // "_time" is a local variable that is automatically
                                    // created and updated in every script. Its value
                                    // is the time in seconds since the script started.

hint s                              // Outputs the text in a text box.

~.1                                 // Sleeps for a tenth of a second.
                                    // The script seems to work without sleeping too,
                                    // so I didn't include this in the golfed version.
                                    // Looping in a script without sleeping is always
                                    // a bad idea, though. It sometimes crashes the game.

goto"l"                             // Go back to the beginning of the loop.
                                    // This is the only way to create a loop if you don't
                                    // want to halt the game (and the time calculation)
                                    // until the loop finishes.

I have tried many different timers, but have found that a program that continuously outputs is the best way to attract my attention.

This solution should be especially good with attracting your attention, since the hint command plays a clinging sound effect every time it's called, which sounds very annoying when the simultaneous sounds get clipped in a tight loop.

Powershell, 85 71 59 bytes
1..276|%{Sleep 1;'Not ready yet'};for(){'Eat your hot dog'}

There's probably a much better way, so criticism welcome! This is my first golf attempt :)
EDIT Down a whole 14 bytes thanks to AdmBorkBork! And definitely a technique to remember!
EDIT 2 Another 12 bytes gone thanks to Matt. Not calling write twice also removed 2 spaces, very helpful!

Welcome to PPCG! Nice to see another PowerSheller around. An easy golf is to run a loop a fixed number of times 1..276|%{} instead of a for loop with an increment. Check out some other tips on that page, too!

Strings are sent to std out be default. No need to specify with the write-output cmdlet.

JavaScript ES6, 76 bytes
$=>setInterval("console.log(--_>0?`Not ready yet`:`Eat your hot dog`)",_=517)

Explanation
This prints something to the console every 517 milliseconds. At first, it prints 'Not ready yet' and decreases the counter. After 517 iterations (= 517 * 517 = 267289 ms), it starts printing 'Eat your hot dog'.
Test

f=
  $=>setInterval("console.log(--_>0?`Not ready yet`:`Eat your hot dog`)",_=517);
(setInterval("console.log('DONE NOW')",267000)&&f())();

can't you just do settimeout and save a byte?

setTimeout only executes the function once. The challenge is to continuously output a string, so setTimeout would be invalid.

(--_? works instead of (--_>0?  (-2)

Unfortunately, it doesn't _ will be decremented every time something is printed, so it will also go below zero. All negative integers are truthy, so those would print 'Not ready yet' as well (which is not what we want).

GameMaker' scripting language variant used in Nuclear Throne Together mod, 68 bytes
t=0while 1{trace(t++<8010?"Not ready yet":"Eat your hot dog")wait 1}

Explanation

GML's parser is deliciously forgiving. Semicolons and parentheses are optional, and the compiler is not at all concerned about your spacing outside the basic rules (0while parses as 0,while and thus is ok)
Variables leak into the executing context unless declared via var (same as with JS).
GML variant used in NTT introduces a wait operator, which pushes the executing "micro-thread" to a list for the specified number of frames, resuming afterwards. Coroutines, basically.
The game is clocked at 30fps, so 4m27s == 267s == 8010 frames.
trace() outputs the given string into the chat.

If you have the videogame+mod installed, you can save that as some test.mod.gml, and do /loadmod test to execute it, flooding the chat with "status reports":

I am not exactly sure what is going on here, but I approve.

TI-Basic, 75 bytes
For(A,1,267
Disp "Not ready yet
Wait 1
End
While 1
Disp "Eat your hot dog
End

Explanation
For(A,1,267             # 9 bytes, for 267 times...
Disp "Not ready yet     # 26 bytes, display message
Wait 1                  # 3 bytes, and wait one second
End                     # 2 bytes, ...end
While 1                 # 3 bytes, after that, continuously...
Disp "Eat your hot dog  # 31 bytes, output second message
End                     # 1 byte, ...end

Python 2, 92 bytes
from time import*
t=time()
while 1:print"Not ready yet"if time()-t<267else"Eat your hot dog"

Try it online!

while 1:print'ENaott  yroeuard yh oyte td o g'[time()-t<267::2] for 90 bytes

@ovs while 1:print['Eat your hot dog','Not ready yet'][time()-t<267] would also be 90 (while being clearer and not printing the extra white space).

C#, 174 172 147 bytes
Saved 25 bytes by "borrowing" some ideas from raznagul's C# answer and merging them with the sum of first n numbers trick!
Saved 2 bytes by using the sum of first n numbers trick for a loss of precision of 185 milliseconds.
class P{static void Main(){for(int i=1;;){System.Console.WriteLine(i++<731?"Not ready yet":"Eat your hot dog");System.Threading.Thread.Sleep(i);}}}

Ungolfed program:
class P
{
    static void Main()
    {
        for (int i=1;;)
        {
            System.Console.WriteLine( i++ < 731 ? "Not ready yet" : "Eat your hot dog");
            System.Threading.Thread.Sleep(i);
        }
    }
}

Explanation:
Since the total time to wait is hardcoded at 267 seconds, one can consider this number as a telescopic sum of the first n natural numbers, n * (n + 1) / 2, which must equal 267000 milliseconds.
This is equivalent to n^2 + n - 534000 = 0.
By solving this second order equation, n1 = 730.2532073142067, n2 = -n1. Of course, only the positive solution is accepted and can be approximated as 730.
The total time can be calculated as 730 * (730 + 1) / 2 = 266815 milliseconds. The imprecision is 185 milliseconds, imperceptible to humans.
The code will now make the main (and only) thread sleeps for 1 millisecond, 2 milliseconds and so on up to 730, so the total sleep period is ~267 seconds.
Update:
The program's logic can be simplified further - basically it needs to continuously display a message and wait a specified time until switching to the second message.
The message can be change by using a ternary operator to check the passing of the specified time (~267 seconds).
The timing aspect is controlled by using an increasing counter and pausing the execution thread.
However, since the counter variable continues increasing indefinitely without any conditions to check its value, one can expect an integer overflow at some point, when the message reverts to Not ready yet.
A condition can be added to detect and mitigate the issue by assigning a positive value greater than 730 when the overflow occurs - like i=i<1?731:i inside the for loop. Sadly, it comes at the cost of 11 additional bytes:
class P{static void Main(){for(int i=1;;i=i<1?731:i){System.Console.Write(i++<731?"\nNot ready yet":"\nEat your hot dog");System.Threading.Thread.Sleep(i);}}}

The key here is using the counter value in milliseconds to greatly delay the moment of overflow.
The time until overflow can be calculated according to the sum(1..n) formula, where n = the maximum 32-bit signed integer value in C# (and the .NET framework) or 2^31 - 1 = 2147483647:
2 147 483 647 * 2 147 483 648 / 2 = 2,305843008 x 10^18 milliseconds = 2,305843008 x 10^15 seconds = 26 687 997 779 days = ~73 067 755 years
After 73 million years, it might not matter if a glitch in the system appears - the hot dog, the hungry OP and maybe the human race itself are long gone.

Previous version (172 bytes):
namespace System{class P{static void Main(){for(int i=1;i<731;){Console.Write("\nNot ready yet");Threading.Thread.Sleep(i++);}for(;;)Console.Write("\nEat your hot dog");}}}

Ungolfed program:
namespace System
{
    class P
    {
        static void Main()
        {
            for (int i = 1; i < 731; )
            {
                Console.Write("\nNot ready yet");
                Threading.Thread.Sleep(i++);
            }
            for ( ; ; )
                Console.Write("\nEat your hot dog");
        }
    }
}

Previous version (174 bytes):
namespace System{class P{static void Main(){for(int i=0;i++<267e3;){Console.Write("\nNot ready yet");Threading.Thread.Sleep(1);}for(;;)Console.Write("\nEat your hot dog");}}}

Ungolfed program:
namespace System
{
    class P
    {
        static void Main()
        {
            for (int i=0; i++ < 267e3; )
            {
                Console.Write("\nNot ready yet");
                Threading.Thread.Sleep(1);
            }
            for ( ; ; )
                Console.Write("\nEat your hot dog");
        }
    }
}

Alternatively, the program may display Not ready yet only once, wait until the specified time is over and then output Eat your hot dog by overwriting the previous message while being quite a few bytes shorter:
C#, 145 bytes
namespace System{class P{static void Main(){Console.Write("Not ready yet");Threading.Thread.Sleep(267000);Console.Write("\rEat your hot dog");}}}

Ungolfed program:
namespace System
{
    class P
    {
        static void Main()
        {
            Console.Write("Not ready yet");
            Threading.Thread.Sleep(267000);
            Console.Write("\rEat your hot dog");
        }
    }
}

That's great. I'd give you +1, if I hadn't already. ;)

C# 144 bytes
()=>{for(int i=0;;){var s="\nEat your hot dog";if(i<267e3){i++;s="\nNot ready yet";}System.Console.Write(s);System.Threading.Thread.Sleep(1);}};

Ungolfed full program:
class P
{
    static void Main()
    {
        System.Action a = () =>
            {
                for (int i = 0; ;)
                {
                    var s = "\nEat your hot dog";
                    if (i < 267e3)
                    {
                        i++;
                        s = "\nNot ready yet";
                    }
                    System.Console.Write(s);
                    System.Threading.Thread.Sleep(1);
                }
            };

        a();
    }
}

Unfortunately I could not use the ?:-operator as I have not found a way to stop incrementing i without the if.

Try something like if(i++<267e3) to save a few bytes.

@adrianmp: That wouldn't work, as that would still increment i every millisecond. And once int.MaxValue is reached the program would either crash or start printing Not ready yet again.

I've managed to pull this off by greatly delaying the overflow (or even mitigating it at the cost of a few bytes). I've "borrowed" some ideas from your answer. Thanks!

Batch, 99 97 bytes
@for /l %%t in (1,1,267)do @echo Not ready yet&timeout>nul 1
:l
@echo Eat your hot dog
@goto l

Batch has no date arithmetic so as a simple 267 second timeout isn't permitted the best I can do is 267 one-second timeouts. Edit: Removed unnecessary /t.

05AB1E, 43 29 28 bytes (Thanks to Adnan)
267F…€–Žä‡«ªw,}[“Eat€ž…ß‹·“,

Does not work online, since it times out. Offline it will work.
267F: Loop 267 times
…€–Žä‡«ª: First string with dictionary
w,: Wait one second and print
}[: End if loop and start infinite loop
“Eat€ž…ß‹·“: Second string with dictionary
,: Print

Thanks, my client saw that this code was short and works offline - now he wants me to write his website using this language. . .

It works online, but just not on the interpreter that is given online. You can see for yourself here

I know. It was a joke :D.

It's best to just answer the normal way :D

“NotŽä‡«“ can be replaced by …€–Žä‡«ª

Ruby, 80 71 67 Bytes
Edit: Thanks to manatwork for shaving off 13 whole bytes
267.times{puts"Not ready yet"
sleep 1}
loop{puts"Eat your hot dog"}

Why not 267.times{…}?

Wow, thanks. I feel dumb now.

Looks like you are counting with CR/LF line separators. As Ruby allows LF only, we used to count that only. And there is no need for the line break after the {. That would result 67 bytes.

I'm a beginner at Ruby, and a total noob at code golfing, so thanks for all the help!

In case you missed it, there is a collection of Tips for golfing in Ruby to help beginners.

Python, 115 bytes
My first time trying something like this. I am also a beginner so here it goes in Python 3 for 115 bytes:
import time
for i in range(267):
    time.sleep(1)
    print("Not ready yet")
while 1:
    print("Eat your hotdog")

Welcome to the site! The aim of code golf is to write the shortest code possible in your language. There are a few things that can be improved and it couldn't hurt to look at the current Python winner for some tips!

Remove the time.sleep(1) - saves a few bytes

@praszyk, then the for will finish looping over range(267) much faster than 4 minutes 27 seconds and the solution becomes invalid. ☹

On the basis that the OP wants hotdogs continuously, until the end of time -
 which I understand from the phrase:

After this time has elasped, you should output Eat your hot dog until the end of time.

This is my answer:
C++, 187 188 224 167 bytes
Whitespace removed (167 bytes):
#include<stdio.h>
#include<windows.h>
int main(){for(;;){for(int x=0;x<267;x++){Sleep(1000);printf("Not ready yet");}Sleep(1000);printf("Eat your hot dog");}return 0;}

readable form (224 bytes):
#include <stdio.h>
#include <windows.h>

int main() {
  for( ; ; ){
    for(int x=0; x < 267; x++){
      Sleep(1000);
      printf("Not ready yet");
    }
    Sleep(1000);
    printf("Eat your hot dog");
  }
  return 0;
}

If, on the other hand, OP enjoys his hot dogs in moderation, then this is my answer:
Whitespace removed (158 bytes):
#include<stdio.h>
#include<windows.h>
int main(){for(int x=0;x<267;x++){Sleep(1000);printf("Not ready yet");}Sleep(1000);printf("Eat your hot dog");return 0;}

readable form (198 bytes):
#include <stdio.h>
#include <windows.h>

int main() {
  for(int x=0; x < 267; x++){
    Sleep(1000);
    printf("Not ready yet");
  }
  Sleep(1000);
  printf("Eat your hot dog");
  return 0;
}

What's delay?

OK that's an old function. Replaced with Sleep(1000)

You can get rid of a bunch of whitespace to save bytes. Also, I count 224 bytes, not 188.

@HyperNeutrino you're right - I counted line endings but not leading whitespace. Edited accordingly (sorry I'm new at this!)

@Quentin delay() is a function that I hoped could be lifted straight from Arduino... turns out that I can't! It did exist back in the day as part of the dos.h library, I understand.

You can get 169 bytes just by removing whitespace

@HyperNeutrino thanks! Edited accordingly

JavaScript Blocks Editor for micro:bit, 90 Bytes

The code:
basic.showString("Not ready yet")
basic.pause(254000)
basic.showString("Eat your hot dog")

You can try it here.
Got inspired by the Scratch answer to solve the task with my micro:bit. The only Problem is that the pause-block starts after outputting the first string so i needed to reduce the pause by 13s.
Note: The old Microsoft Block Editor for micro:bit is shorter to create but produces more code so is in fact longer.

Excel VBA 122 94 bytes
Sub p()
e=Now+#0:4:27#
Do
[a1]=IIf(Now<e,"Not ready yet","Eat your hot dog")
Loop
End Sub

Thanks Taylor Scott

You can cut down this solution quite a bit, CDate("00:04:28") can be condensed to #0:4:27#, you can replace your While ... Wend loop with a Do .. Loop Loop and you can replace your if clause with an iif clause

@TaylorScott Yes thanks :)

@TaylorScott is there any alternative for msgbox ?

@TaylorScott also iif clause is not working with msgbox I am not sure why  and #0:4:27# autoformats to a date not time you are free to edit the answer if you want

Actually because VBA does not have any STDIN or STDOUT, there are a lot of options available to you, such as the VBE immediates window and to cells in excel, you can see more about this  at https://codegolf.stackexchange.com/a/107216/61846

You would need to format it to something like Msgbox IIf(Now<d,"Not ready yet","Eat your hot dog") the #0:4:27# clause autoformats to a date, but as VBA is an autoformatting language, you can use this to your advantage as it works functionally identically to cDate("00:04:27")

Excel VBA, 82 Bytes
Anonymous VBE immediates window function that takes no input and outputs whether or not you should eat your hot dog to cell [A1].
d=Now+#0:4:27#:Do:[A1]=IIf(Now<d,"Not ready yet","Eat your hot dog"):DoEvents:Loop

Interesting I didn't knew you can run the program directly from Immediate window

PERL, 76 bytes
$|++;
for(1..247){print'Not ready yet';sleep 1};print "Eat your hot dog";for(;;){}

I count 82 bytes.

PHP 88 bytes
<?$t=0;do{$t++;echo "Not ready yet";sleep(1);} while ($t<267);echo "Eat your hotdog";?>

“After this time has elasped, you should output Eat your hot dog until the end of time.” So you have to repeat the 2nd message too. That will add to its length, but fortunately there is place to shorten it: for($t=267;$t--;sleep(1))echo"Not ready yet";for(;;)echo"Eat your hotdog";. By the way, running code with php -r is accepted, so no need for the PHP tags (especially not the closing one, which is considered bad habit in that case: “The closing ?> tag MUST be omitted from files containing only PHP” – PSR-2).

@manatwork untested: for($t=267;;sleep(1))echo $t-->0?"Not ready yet":"Eat your hotdog";

Interesting one, @diynevala. According to the documentation, “If PHP encounters a number beyond the bounds of the integer type, it will be interpreted as a float instead. Also, an operation which results in a number beyond the bounds of the integer type will return a float instead.” – Integer overflow, so that condition should work correctly until the end of time.

@manatwork Also sleeps for 1 second between outputs even after 267 seconds.

REXX, 82 bytes
do forever
if time(e)<267 then say 'Not ready yet'
else say 'Eat your hot dog'
end

Java 7, 152 bytes
void c(){for(long s=System.nanoTime(),e=s+(long)267e9;s<e;s=System.nanoTime())System.out.println("Not ready yet");System.out.print("Eat your hot dog");}

Explanation:
void c(){                                 // Method
  for(                                    //  Loop
      long s=System.nanoTime(),           //    Current time in nanoseconds as start
      e=s+(long)267e9;                    //    End time (267 seconds later)
      s<e;                                //    Loop as long as we haven't reached the end time
      s=System.nanoTime())                //    After every iteration get the new current time in nanoseconds
    System.out.println("Not ready yet");  //   Print "Not ready yet" as long as we loop
                                          //  End of loop (implicit / single-line body)
  System.out.print("Eat your hot dog");   //  Print "Eat your hot dog"
}                                         // End of method

PHP, 68 bytes
for($t=268;$t--;sleep(1))echo$t?"Not ready yet←":"Eat your hot dog";

continuous output; ← is ASCII 10 = LF. Run with -r.
one-time output, 50 bytes
Not ready yet<?sleep(267);echo"←Eat your hot dog";

where ← is ASCII 13 = CR. Save to file or use piping to run.

RBX.Lua, 69 bytes
for i=1,267 do print"Not ready yet"Wait(1)end;print"Eat your hot dog"

RBX.Lua is the language used on ROBLOX.com. It is a modified version of Lua 5.1 that features a built-in 'Wait' function. The above code is pretty self-explanatory, below is a more readable version:
for i = 1, 267 do
    print("Not ready yet");
    Wait(1);
end

print("Eat your hot dog");

The code outputs "Not ready yet" continuously into STDOUT, for 267 seconds (4 minutes 27 seconds) before outputting "Eat your hot dog".

Javascript, 83 Bytes
d=Date.now()
while(1)alert(Date.now()-d<267000?"Not ready yet":"Eat your hot dog"))

Alertz for everyone!

You can change 267000 to 267e3 and save a byte.

From the question: "You have to make a program". This is not a program or a function, but a snippet.

This is a program.

You can save a few bytes by using new Date in place of Date.now(), and another few by using for(d=new Date;;)alert...

@ETHproductions That actually introduces a bug, where it will eat the hotdog twice in the year.

alert() halts the program until the user closes and the challenge bans input

@dandavis it is not "input", it is an accepted form of output.

well, unless you continuously click "OK", you'll burn your dogs with this timer...

@dandavis actually, you can click OK once if you time it right and it will work.

C - 130 bytes
It could be slightly shorter (128bytes), but I thought it neater to overwrite "Not ready yet"
#include<stdio.h>
#include<unistd.h>
int main(){printf("Not ready yet");fflush(stdout);sleep(267);printf("\rEat your hot dog\n");}

Welcome on the site! You can omit #include<unistd.h> (it will emit a warning but still compile). Doing as you do (overwriting the previous message) is your right, but since the challenge doesn't really ask for it, I'd suggest not to do it. It would allow you to do int main(){puts("Not ready yet");sleep(267);puts("Eat your hot dog");} (with no includes, they aren't needed) - but no obligation to do it of course.

Python 2.7, 90 88 bytes
import time;exec"print'Not ready yet';time.sleep(1);"*267;while 1:print"Eat your hotdog"

I don't get why someone -1'd my answer. can some1 explain? :(

VBA,126 Bytes
sub hd()
Debug.print "Not ready Yet"
application.wait(now+timevalue(00:04:27))
Debug.print "Eat your hot dog"
end sub

Doesn't do what the challenge asked for.

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


text:
Composition of permutations – the group product
Given two permutations in disjoint cycle form, output their product/composition in disjoint cycle form.

To find the composition, convert the disjoint cycles to permutations in two-line notation. Each number in a disjoint part of a cycle is mapped to the number following it in the same part. It wraps around. So 1 -> 5, 5 -> 1, 2 -> 4, 4 -> 2. If a number is not found, 3 -> 3, it is mapped to itself. The first disjoint cycle could also be written (1 5)(2 4)(3). These mappings are converted to two lines, like so (note that the order of P and Q are reversed):

[T]he product of two permutations is obtained by rearranging the columns of the second (leftmost) permutation so that its first row is identical with the second row of the first (rightmost) permutation. The product can then be written as the first row of the first permutation over the second row of the modified second permutation.

Wikipedia article

Rules:

Input will be given as a list of lists or similar format
You may not take something like (1 5)(2 4) as [5, 4, 3, 2, 1], already in two-line form (mapping index to value)
Not all numbers have to occur in each group, so you could have (1 5)·(1 2), resulting in (2 5 1).
Your output should be able to be used as your input.
You do not need to support input with an empty cycle (1 5)·(). That would instead be given as (1 5)·(1) or something equivalent.
Since cycles wrap around, the order doesn't matter as long as the result is correct.
You can start at zero or one. It doesn't matter, because the results are the same.
The numbers can be larger than 9.
You may not include the same number more than once in the output. So [[1],[1]] is not allowed.
Note that this operation is not commutative! I put Q before P, because that's what Wikipedia did. You can choose any order, but specify which if it's different.
Shortest code wins
Built-ins are allowed, but if you use one, show a solution without using it as well.

Examples:
Not all equivalent output possibilities are shown
Input
Output

[[1, 5], [2, 4]], [[1, 2, 4, 3]]
[[1, 4, 3, 5]] (or [[4, 3, 5, 1]] or ...)

[[1, 5]], [[1, 2]]
[[2, 5, 1]]

[[10, 2, 3]], [[2]]
[[3, 10, 2]]

[[1]], [[3]]
[[]] (or [[1]] or something equivalent)

[[10,2,3,15],[1,7],[5,6],[14,4,13,11,12]], [[5,6,7,9,14],[2,8,3,10],[1,11]]
[[12, 14, 6, 1], [8, 15, 10, 3, 2], [13, 11, 7, 9, 4]]

(arguments in reverse order from above gives a different answer)
[[5,6,7,9,14],[2,8,3,10],[1,11]], [[10,2,3,15],[1,7],[5,6],[14,4,13,11,12]]
[[9, 14, 4, 13, 1], [10, 8, 3, 15, 2], [7, 11, 12, 5]]

To me, these are permutations, not permutation groups. A permutation group is a collection, closed under this composition operation, of a bunch of individual permutations.

@GregMartin Fixed terminology

J, 7 bytes
C.@C.@,

Try it online!

Your output should be able to be used as your input.

@mbomb007 The output is usable as input. Each list of cycles has to be a 0-indexed array of boxed arrays.

Or is this J's default print behavior? I just want to make sure the function can be chained.

@mbomb007 Yes that's just the visual representation of it. It has to be 0-indexed, but I have it listed as 1-indexed and the convert them to 0-index before they are stored in the variables to be passed to the function. Then after, I convert it back from 0-indexed to 1-indexed before outputting it.

Haskell, 157 148 bytes
EDIT:

-9 bytes: That could indeed be golfed more. Removed redundant parentheses around p++q. Swapped argument order of g. Got rid of d by starting iterate with p x, after which takeWhile no longer tied with fst + span. Made iterate infix.

Doing this while I'm late... probably can golf some more.
It was simpler, and seemed to be allowed, so the output includes single-element cycles.
q#p=g(p++q>>=id)$f q.f p
f p a=last$a:[y|c<-p,(x,y)<-zip(0:c)(c++c),x==a]
g(x:l)p|c<-x:fst(span(/=x)$p`iterate`p x)=c:g[x|x<-l,x`notElem`c]p
g[]p=[]

Try it online!
How it works:

# is the main function. q#p takes two lists of lists of numbers, and returns a similar list. The tests seem to have Q before P so I used the same order.
f p converts the permutation p from disjoint cycle form to a function, after which f q and f p can be composed with the usual composition operator ..

The list comprehension iterates through the cycles c, searching for a and finding its successor. If the comprehension finds nothing, a is just returned.
zip(0:c)(c++c) is a list of pairs of elements of c and their successors. Since the question lets us "start at one" we can use 0 as a dummy value; it's cheaper to prepend that to zip's first argument than to use tail on the second.

g l p takes a list l of elements, and a permutation function p, and returns the list of cycles touching the elements.

Here c is the cycle containing the first element x of the list, the other elements of c are found by iterating from p x until x is found again. When recursing to find the remaining cycles, all elements of c are first removed with a list comprehension.

Thanks for noting that order matters when computing the result. I'd forgotten to add an example or comment about it. That has been rectified.

Mathematica, 15 bytes
##⊙Cycles@{}&

Yes Virginia, there is a builtin.... Mathematica supports a permutation data type already in disjoint cycle notation: this pure function takes as input any number of arguments in the form Cycles[{{1, 5}, {2, 4}}] and outputs the product permutation, again in Cycles[] form. It uses the opposite ordering convention as the OP, so for example,
##⊙Cycles@{}&[Cycles[{{1, 2, 4, 3}}], Cycles[{{1, 5}, {2, 4}}]]

returns Cycles[{{1, 4, 3, 5}}]. The ⊙ symbol I used above should really be the 3-byte private-use Unicode symbol U+F3DE to work in Mathematica. Note that Mathematica has a named builtin for this operation, PermutationProduct, but that's three bytes longer.

Python, 220 bytes
a,b=eval(input())
p,o=a+b,[]
for i in range(1,1+max(map(max,p))):
 if not any(i in t for t in o):
  u,m=(i,),i
  while 1:
   for t in p[::-1]:
    if m in t:m=t[(t.index(m)+1)%len(t)]
   if m==i:o+=[u];break
   u+=(m,)
o

Welcome to the site.  I see quite a few ways you could shorten this.  Consider checking out the tips page for python.

Python 3.8, 187 bytes
q,p=eval(input())
g=lambda p,i:[*(c[c.index(i)-1]for c in p if i in c),i][0]
h=lambda*c:(x:=g(p,g(q,c[0])))in c and(*c[(m:=c.index(min(c))):],*c[:m])or h(x,*c)
exit({*map(h,sum(p|q,()))})

Try it online! or Check all test cases!
Input: q and p in that order, each is a set of tuples, from STDIN.
Output: The product permutation Q·P as a set of tuples, to STDERR.
Explanation
The function g finds which number maps to the number i in the permutation p (aka g is the inverse permutation of p).
g=lambda p,i:
[                   # creates a list
  *(                # containing the following
    c[c.index(i)-1] #   the number before i in cycle c
    for c in p      #   for all cycles in permutation
    if i in c       #   if i is in that cycle
  )                 #
  ,i                # adds i to the end of that list
                    #   (in case i is not in any cycle)
][0]                # returns the first element of the list

The function h takes in a number, and returns the cycle in Q·P that contains that number. The returned cycle will be a tuple, formatted in a way such that the smallest element is at index 0.
h=lambda*c:                   # input: an incomplete cycle c, as a list
(x:=g(p,g(q,c[0])))           # finds the number x before the first number in c
in c                          # if x is also in c (aka the cycle is complete)
and                           # then returns the following:
(                             #   c as a tuple with min element at index 0
  *c[(m:=c.index(min(c))):],  #   (c, from the min element to the end)
  *c[:m]                      #   (c, from start to the min element)
)
or                            # else (cycle is incomplete) returns the following
h(x,*c)                       #   recursive result when after prepending x to c

By applying h to all numbers, we can get all cycles in Q·P. To prevent duplicate cycles in our result, we simply put all cycles in a set. This works since similar cycles returned by h will be formatted to the same tuple (with the smallest element at index 0).
We only needs to consider the numbers appearing in P or Q, as all other numbers will map to themselves.
exit(              # returns through STDERR
  {                # create a set from the followings
    *map(h,        #   map function h to
      sum(p|q,())  #   all numbers in P or Q
    )
  }
)