How-to leverage two unique orderings for a list to produce a single unique ordering for that list?

Question

The goal: Two people agree on an arbitrary ordering of a list of times. They pre-select some information. Then they reveal just enough information to uncover one item at a time.

e.g.: Bob selects "C A B" Jane selects "A C B"

Is there a way to leverage both these to deterministically produce an unique ordering? e.g. the result may be "B C A" but if Jane's selection were "C A B" instead the result would change as well.

All items in the list are unique. We want to reveal one item at a time. So when want to display the first item, Bob says 'C' and Jane says 'A'... now we know the first selection was 'B'. We do not yet know Jane's other two selections.

The use case we are trying to address: two players will establish a random order and then share it to produce a new arbitrary order that neither player alone could have anticipated.

Answer 1

You haven't said that the resulting order should respect any properties of Bob's and Jane's input. Then it's easy. Create a Latin square that lists all six possible orderings in each row and each column. Label the rows with Bob's ordering and the columns with Jane's. Look up the "determined" combined order at the intersection of that row and column.

Essentially all this does is produce a number between $1$ and $6$ given two inputs in that range, with the requirement that changing either input must change the output. The fact that the integers label orderings is irrelevant.

Edit in response to the additional requiremnt. Yes. The following table does the job. That algorithm is to select the first letter from the first two input letters using the only Latin square of size $3$. Then the two second choices determine the second output as shown - matching diagonals in the $2 \times 2$ blocks. The third output is the remaining letter.

      ABC  ACB  BAC  BCA  CAB  CBA
------------------------------------
ABC | ABC  ACB  BC   BA   CA   CB
ACB | ACB  ABC  BA   BC   CB   CA 
BAC | BC   BA   C    C    A    A
BCA | B    B    C    C    A    A
CAB | C    C    A    A    B    B
CBA | C

You should be able to finish it. Easy to code, either as a table or with logic.

Second Edit

In fact, you can select a permutation of any size this way. The recursive argument is straightforward. Use the first two inputs with any Latin square of the appropriate size to choose the first of $n$ outputs. Then there are $n-1$ values left for each of the two inputs and for the output, so recursion gives you the next output. The base case is the one remaining output.

If the game is to be repeated you can even vary the Latin square randomly at each stage, so knowing the result of past iterations can't help you predict what will happen next.