Construa um par de espiões que jogarão pedras no rio

20

Recentemente, no recém-lançado Puzzling.SE , havia um problema sobre espiões jogando pedras em um rio que era realmente bastante desafiador:

Dois espiões devem passar entre si dois números secretos (um número por espião), despercebidos pelos inimigos. Eles concordaram em um método para fazer isso usando apenas 26 pedras indistinguíveis com antecedência.

Eles se encontram em um rio, onde há uma pilha de 26 pedras. Começando com o primeiro espião, eles se revezam jogando um grupo de pedras no rio: o primeiro espião lança um número de pedras, depois o segundo, depois o primeiro novamente ...

Cada espião deve jogar pelo menos uma pedra no seu turno, até que todas as pedras acabem.

Eles observam todos os arremessos e divergem quando não há mais pedras. Eles mantêm silêncio o tempo todo e nenhuma informação é trocada, exceto o número de pedras jogadas a cada turno.

Como eles podem trocar os números com sucesso se os números podem ser de 1 a M?

Sua tarefa é criar um par de programas spy1e spy2isso pode resolver esse problema da maneira mais alta possível M.

Seus programas levarão um número 1para o escolhido Mcomo entrada. Em seguida, spy1produzirá um número que representa o número de pedras que ele joga no rio, que será introduzido no spy2qual também produzirá um número para o qual será inserido spy1, e assim por diante até que os números produzidos sejam somados 26. No final do lançamento, cada programa produzirá o número que acredita que o outro programa tinha, que deve corresponder ao número que foi realmente inserido no outro programa.

Seu programa deve funcionar para todos os possíveis pares ordenados de números em (i, j)que ambos ie jpodem variar de 1até M.

O programa que trabalha para o maior Mserá o vencedor, com a primeira resposta a ser publicada quebrando o empate. Além disso, concederei uma recompensa de +100 reputação à primeira solução comprovada para o trabalho M >= 2286e +300 à primeira solução comprovadamente trabalhada M >= 2535.

Joe Z.
fonte
Solução significa algoritmo, ou um programa, que gera um conjunto de dissisões para cada (i, j)?
klm123
Não é um programa, mas dois. Eles devem se comunicar de forma independente, como no seu problema.
Joe Z.
3
Como os programas precisarão compartilhar sua árvore de decisão, podemos torná-lo um programa que exige argumentos para dizer qual é o espião?
Peter Taylor
Contanto que você possa garantir que cada espião se comunique independentemente e não haja informações extras trocadas entre eles.
Joe Z.
Independentemente, verifiquei que 2535 é o máximo teórico da informação para esse problema. Eu acredito fortemente agora que nenhum programa pode fazer melhor.
N1:

Respostas:

8

C #, M = 2535

Isso implementa * o sistema que eu descrevi matematicamente no tópico que provocou esse concurso. Eu reivindico o bônus de 300 representantes. O programa autoteste se você o executa sem argumentos de linha de comando ou --testcomo argumento de linha de comando; para o espião 1, corra com --spy1, e para o espião 2 com --spy2. Em cada caso, pega o número que devo comunicar a partir de stdin e, em seguida, lança através de stdin e stdout.

* Na verdade, encontrei uma otimização que faz uma enorme diferença (de alguns minutos para gerar a árvore de decisão a menos de um segundo); a árvore que gera é fundamentalmente a mesma, mas ainda estou trabalhando em uma prova disso. Se você deseja uma implementação direta do sistema que eu descrevi em outro lugar, consulte a revisão 2 , embora possa querer suportar o log extra Maine as melhores comunicações entre threads TestSpyIO.

Se você deseja um caso de teste concluído em menos de um minuto, altere Npara 16e Mpara 87.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;

namespace CodeGolf
{
    internal class Puzzle625
    {
        public static void Main(string[] args)
        {
            const int N = 26;
            const int M = 2535;

            var root = BuildDecisionTree(N);

            if (args.Length == 0 || args[0] == "--test")
            {
                DateTime startUtc = DateTime.UtcNow;
                Console.WriteLine("Built decision tree in {0}", DateTime.UtcNow - startUtc);
                startUtc = DateTime.UtcNow;

                int ok = 0;
                int fail = 0;
                for (int i = 1; i <= M; i++)
                {
                    for (int j = 1; j <= M; j++)
                    {
                        if (Test(i, j, root)) ok++;
                        else fail++;
                    }
                    double projectedTimeMillis = (DateTime.UtcNow - startUtc).TotalMilliseconds * M / i;
                    Console.WriteLine("Interim result: ok = {0}, fail = {1}, projected test time {2}", ok, fail, TimeSpan.FromMilliseconds(projectedTimeMillis));
                }
                Console.WriteLine("All tested: ok = {0}, fail = {1}, in {2}", ok, fail, DateTime.UtcNow - startUtc);
                Console.ReadKey();
            }
            else if (args[0] == "--spy1")
            {
                new Spy(new ConsoleIO(), root, true).Run();
            }
            else if (args[0] == "--spy2")
            {
                new Spy(new ConsoleIO(), root, false).Run();
            }
            else
            {
                Console.WriteLine("Usage: Puzzle625.exe [--test|--spy1|--spy2]");
            }
        }

        private static bool Test(int i, int j, Node root)
        {
            TestSpyIO io1 = new TestSpyIO("Spy 1");
            TestSpyIO io2 = new TestSpyIO("Spy 2");
            io1.Partner = io2;
            io2.Partner = io1;

            // HACK! Prime the input
            io2.Output(i);
            io1.Output(j);

            Spy spy1 = new Spy(io1, root, true);
            Spy spy2 = new Spy(io2, root, false);

            Thread th1 = new Thread(spy1.Run);
            Thread th2 = new Thread(spy2.Run);
            th1.Start();
            th2.Start();

            th1.Join();
            th2.Join();

            // Check buffer contents. Spy 2 should output spy 1's value, so it's lurking in io1, and vice versa.
            return io1.Input() == i && io2.Input() == j;
        }

        private static Node BuildDecisionTree(int numStones)
        {
            NodeValue[] trees = new NodeValue[] { NodeValue.Trivial };
            for (int k = 2; k <= numStones; k++)
            {
                int[] prev = trees.Select(nv => nv.Y).ToArray();
                List<int> row = new List<int>(prev);
                int cap = prev.Length;
                for (int i = 1; i <= prev[0]; i++)
                {
                    while (prev[cap - 1] < i) cap--;
                    row.Add(cap);
                }

                int[] next = row.OrderByDescending(x => x).ToArray();
                NodeValue[] nextTrees = new NodeValue[next.Length];
                nextTrees[0] = trees.Last().Reverse();
                for (int i = 1; i < next.Length; i++)
                {
                    int cp = next[i] - 1;
                    nextTrees[i] = trees[cp].Combine(trees[i - prev[cp]]);
                }

                trees = nextTrees;
            }

            NodeValue best = trees.MaxElement(v => Math.Min(v.X, v.Y));
            return BuildDecisionTree(numStones, best, new Dictionary<Pair<int, NodeValue>, Node>());
        }

        private static Node BuildDecisionTree(int numStones, NodeValue val, IDictionary<Pair<int, NodeValue>, Node> cache)
        {
            // Base cases
            // NB We might get passed val null with 0 stones, so we hack around that
            if (numStones == 0) return new Node(NodeValue.Trivial, new Node[0]);

            // Cache
            Pair<int, NodeValue> key = new Pair<int, NodeValue>(numStones, val);
            Node node;
            if (cache.TryGetValue(key, out node)) return node;

            // The pair-of-nodes construction is based on a bijection between
            //     $\prod_{i<k} T_i \cup \{(\infty, 0)\}$
            // and
            //     $(T_{k-1} \cup \{(\infty, 0)\}) \times \prod_{i<k-1} T_i \cup \{(\infty, 0)\}$

            // val.Left represents the element of $T_{k-1} \cup \{(\infty, 0)\}$ (using null for the $(\infty, 0)$)
            // and val.Right represents $\prod_{i<k-1} T_i \cup \{(\infty, 0)\}$ by bijection with $T_{k-1} \cup \{(\infty, 0)\}$.
            // so val.Right.Left represents the element of $T_{k-2}$ and so on.
            // The element of $T_{k-i}$ corresponds to throwing $i$ stones.
            Node[] children = new Node[numStones];
            NodeValue current = val;
            for (int i = 0; i < numStones && current != null; i++)
            {
                children[i] = BuildDecisionTree(numStones - (i + 1), current.Left, cache);
                current = current.Right;
            }
            node = new Node(val, children);

            // Cache
            cache[key] = node;
            return node;
        }

        class Pair<TFirst, TSecond>
        {
            public readonly TFirst X;
            public readonly TSecond Y;

            public Pair(TFirst x, TSecond y)
            {
                this.X = x;
                this.Y = y;
            }

            public override string ToString()
            {
                return string.Format("({0}, {1})", X, Y);
            }

            public override bool Equals(object obj)
            {
                Pair<TFirst, TSecond> other = obj as Pair<TFirst, TSecond>;
                return other != null && object.Equals(other.X, this.X) && object.Equals(other.Y, this.Y);
            }

            public override int GetHashCode()
            {
                return X.GetHashCode() + 37 * Y.GetHashCode();
            }
        }

        class NodeValue : Pair<int, int>
        {
            public readonly NodeValue Left;
            public readonly NodeValue Right;

            public static NodeValue Trivial = new NodeValue(1, 1, null, null);

            private NodeValue(int x, int y, NodeValue left, NodeValue right) : base(x, y)
            {
                this.Left = left;
                this.Right = right;
            }

            public NodeValue Reverse()
            {
                return new NodeValue(Y, X, this, null);
            }

            public NodeValue Combine(NodeValue other)
            {
                return new NodeValue(other.X + Y, Math.Min(other.Y, X), this, other);
            }
        }

        class Node
        {
            public readonly NodeValue Value;
            private readonly Node[] _Children;

            public Node this[int n]
            {
                get { return _Children[n]; }
            }

            public int RemainingStones
            {
                get { return _Children.Length; }
            }

            public Node(NodeValue value, IEnumerable<Node> children)
            {
                this.Value = value;
                this._Children = children.ToArray();
            }
        }

        interface SpyIO
        {
            int Input();
            void Output(int i);
        }

        // TODO The inter-thread communication here can almost certainly be much better
        class TestSpyIO : SpyIO
        {
            private object _Lock = new object();
            private int? _Buffer;
            public TestSpyIO Partner;
            public readonly string Name;

            internal TestSpyIO(string name)
            {
                this.Name = name;
            }

            public int Input()
            {
                lock (_Lock)
                {
                    while (!_Buffer.HasValue) Monitor.Wait(_Lock);

                    int rv = _Buffer.Value;
                    _Buffer = null;
                    Monitor.PulseAll(_Lock);
                    return rv;
                }
            }

            public void Output(int i)
            {
                lock (Partner._Lock)
                {
                    while (Partner._Buffer.HasValue) Monitor.Wait(Partner._Lock);
                    Partner._Buffer = i;
                    Monitor.PulseAll(Partner._Lock);
                }
            }
        }

        class ConsoleIO : SpyIO
        {
            public int Input()
            {
                return Convert.ToInt32(Console.ReadLine());
            }

            public void Output(int i)
            {
                Console.WriteLine("{0}", i);
            }
        }

        class Spy
        {
            private readonly SpyIO _IO;
            private Node _Node;
            private bool _MyTurn;

            internal Spy(SpyIO io, Node root, bool isSpy1)
            {
                this._IO = io;
                this._Node = root;
                this._MyTurn = isSpy1;
            }

            internal void Run()
            {
                int myValue = _IO.Input() - 1;
                int hisValue = 1;

                bool myTurn = _MyTurn;
                Node n = _Node;
                while (n.RemainingStones > 0)
                {
                    if (myTurn)
                    {
                        if (myValue >= n.Value.X) throw new Exception("Internal error");
                        for (int i = 0; i < n.RemainingStones; i++)
                        {
                            // n[i] allows me to represent n[i].Y values: 0 to n[i].Y - 1
                            if (myValue < n[i].Value.Y)
                            {
                                _IO.Output(i + 1);
                                n = n[i];
                                break;
                            }
                            else myValue -= n[i].Value.Y;
                        }
                    }
                    else
                    {
                        int thrown = _IO.Input();
                        for (int i = 0; i < thrown - 1; i++)
                        {
                            hisValue += n[i].Value.Y;
                        }
                        n = n[thrown - 1];
                    }

                    myTurn = !myTurn;
                }

                _IO.Output(hisValue);
            }
        }
    }

    static class LinqExt
    {
        // I'm not sure why this isn't built into Linq.
        public static TElement MaxElement<TElement>(this IEnumerable<TElement> e, Func<TElement, int> f)
        {
            int bestValue = int.MinValue;
            TElement best = default(TElement);
            foreach (var elt in e)
            {
                int value = f(elt);
                if (value > bestValue)
                {
                    bestValue = value;
                    best = elt;
                }
            }
            return best;
        }
    }
}

Instruções para usuários do Linux

Você precisará mono-csccompilar (em sistemas baseados no Debian, está no mono-develpacote) e monoexecutar ( mono-runtimepacote). Então os encantamentos são

mono-csc -out:codegolf31673.exe codegolf31673.cs
mono codegolf31673.exe --test

etc.

Peter Taylor
fonte
2
Isso é c #? Não sei como executar isso no Linux.
Joe Z.
Todo esse tempo eu pensei que estava fazendo algo errado. Como se vê, a construção da árvore de decisão leva apenas 30 minutos ... Para o registro, isso funciona no Fedora 20: 1. yum install mono-core(como root). 2. dmcs Puzzle625.cs3.mono Puzzle625.exe --test
Dennis
@ Dennis, acho que o JIT de Mono não é tão bom quanto o da Microsoft. Tenho algumas idéias para otimização, mas ainda não terminei de testá-las.
Peter Taylor
Os repositórios do Fedora fornecem a versão 2.10.8, que tem mais de dois anos. Talvez as versões mais recentes sejam mais rápidas. Estou curioso: quanto tempo leva com a Microsoft?
Dennis
2
De 30 minutos a 39 microssegundos. É o que chamo de otimização!
Dennis
1

Programa Python Tester

Eu acho que seria útil ter um programa de teste que possa verificar se sua implementação está funcionando. Ambos os scripts abaixo funcionam com o Python 2 ou o Python 3.

Programa testador ( tester.py):

import sys
import shlex
from subprocess import Popen, PIPE

def writen(p, n):
    p.stdin.write(str(n)+'\n')
    p.stdin.flush()

def readn(p):
    return int(p.stdout.readline().strip())

MAXSTONES = 26

def test_one(spy1cmd, spy2cmd, n1, n2):
    p1 = Popen(spy1cmd, stdout=PIPE, stdin=PIPE, universal_newlines=True)
    p2 = Popen(spy2cmd, stdout=PIPE, stdin=PIPE, universal_newlines=True)

    nstones = MAXSTONES

    writen(p1, n1)
    writen(p2, n2)

    p1turn = True
    while nstones > 0:
        if p1turn:
            s = readn(p1)
            writen(p2, s)
        else:
            s = readn(p2)
            writen(p1, s)
        if s <= 0 or s > nstones:
            print("Spy %d output an illegal number of stones: %d" % ([2,1][p1turn], s))
            return False
        p1turn = not p1turn
        nstones -= s

    n1guess = readn(p2)
    n2guess = readn(p1)

    if n1guess != n1:
        print("Spy 2 output wrong answer: expected %d, got %d" % (n1, n1guess))
        return False
    elif n2guess != n2:
        print("Spy 1 output wrong answer: expected %d, got %d" % (n2, n2guess))
        return False

    p1.kill()
    p2.kill()

    return True

def testrand(spy1, spy2, M):
    import random
    spy1cmd = shlex.split(spy1)
    spy2cmd = shlex.split(spy2)

    n = 0
    while 1:
        i = random.randrange(1, M+1)
        j = random.randrange(1, M+1)
        test_one(spy1cmd, spy2cmd, i, j)
        n += 1
        if n % 100 == 0:
            print("Ran %d tests" % n)

def test(spy1, spy2, M):
    spy1cmd = shlex.split(spy1)
    spy2cmd = shlex.split(spy2)
    for i in range(1, M+1):
        print("Testing %d..." % i)
        for j in range(1, M+1):
            if not test_one(spy1cmd, spy2cmd, i, j):
                print("Spies failed the test.")
                return
    print("Spies passed the test.")

if __name__ == '__main__':
    if len(sys.argv) != 4:
        print("Usage: %s <M> <spy1> <spy2>: test programs <spy1> and <spy2> with limit M" % sys.argv[0])
        exit()

    M = int(sys.argv[1])
    test(sys.argv[2], sys.argv[3], M)

Protocolo: Os dois programas espiões especificados na linha de comando serão executados. Espera-se que eles interajam apenas através do stdin / stdout. Cada programa receberá seu número atribuído como a primeira linha de entrada. Em cada turno, o espião 1 gera o número de pedras a serem lançadas, o espião 2 lê um número de stdin (representando o lançamento do espião 1) e, em seguida, eles repetem (com as posições invertidas). Quando um dos espiões determina que 26 pedras foram jogadas, elas param e emitem seu palpite para o número do outro espião.

Exemplo de sessão com um spy1 compatível ( >indica entrada para o spy)

> 42
7
> 5
6
> 3
5
27
<program quits>

Se você escolher um muito grande M, e leva muito tempo para ser executado, você pode alternar test(para testrand(na última linha para executar testes aleatórios. Neste último caso, deixe o programa em execução por pelo menos alguns milhares de tentativas para aumentar a confiança.

Exemplo de programa ( spy.py), para M = 42:

import sys

# Carry out the simple strategy for M=42

def writen(n):
    sys.stdout.write(str(n)+"\n")
    sys.stdout.flush()

def readn():
    return int(sys.stdin.readline().strip())

def spy1(n):
    m1,m2 = divmod(n-1, 6)
    writen(m1+1)
    o1 = readn() # read spy2's number

    writen(m2+1)
    o2 = readn()

    rest = 26 - (m1+m2+o1+o2+2)
    if rest > 0:
        writen(rest)
    writen((o1-1)*6 + (o2-1) + 1)

def spy2(n):
    m1,m2 = divmod(n-1, 6)
    o1 = readn() # read spy1's number
    writen(m1+1)

    o2 = readn()
    writen(m2+1)

    rest = 26 - (m1+m2+o1+o2+2)
    if rest > 0:
        readn()

    writen((o1-1)*6 + (o2-1) + 1)

if __name__ == '__main__':
    if len(sys.argv) != 2:
        print("Usage: %s [spy1|spy2]" % (sys.argv[0]))
        exit()

    n = int(input())
    if sys.argv[1] == 'spy1':
        spy1(n)
    elif sys.argv[1] == 'spy2':
        spy2(n)
    else:
        raise Exception("Must give spy1 or spy2 as an argument.")

Exemplo de uso:

python tester.py 42 'python spy.py spy1' 'python spy.py spy2'
nneonneo
fonte
1

Java, M = 2535

OK, aqui está a minha implementação. A cada passo, um espião faz um movimento. Cada movimento possível representa um intervalo de códigos. O espião escolhe a jogada correspondente ao seu código secreto. À medida que jogam mais pedras, a variedade de códigos possíveis reduz até que, no final, para ambos os espiões, apenas um código seja possível de acordo com os movimentos que eles fizeram.

Para recuperar os códigos secretos, você pode reproduzir todas as jogadas e calcular os intervalos de códigos correspondentes. No final, resta apenas um código para cada espião, que é o código secreto que ele queria transmitir.

Infelizmente, o algoritmo conta com uma grande tabela pré-computada com centenas de milhares de números inteiros. O método não poderia ser aplicado mentalmente com mais de 8 a 10 pedras, talvez.

O primeiro arquivo implementa o algoritmo do Spy. A parte estática precomputa uma codeCounttabela que é usada posteriormente para calcular cada movimento. A segunda parte implementa 2 procedimentos, um para selecionar quantas pedras jogar, e o outro para repetir um movimento para ajudar a reconstruir os códigos secretos.

O segundo arquivo testa a classe Spy extensivamente. O método simulatesimula o processo. Ele usa a classe Spy para gerar uma sequência de lançamentos a partir dos códigos secretos e depois reconstrói os códigos a partir da sequência.

Spy.java

package stackexchange;

import java.util.Arrays;

public class Spy
{
    // STATIC MEMBERS

    /** Size of code range for a number of stones left to the other and the other spy's range */
    static int[][] codeCount;

    // STATIC METHODS

    /** Transpose an array of code counts */
    public static int[] transpose(int[] counts){
        int[] transposed = new int[counts[1]+1];
        int s = 0;
        for( int i=counts.length ; i-->0 ; ){
            while( s<counts[i] ){
                transposed[++s] = i;
            }
        }
        return transposed;
    }

    /** Add two integer arrays by element.  Assume the first is longer. */
    public static int[] add(int[] a, int[] b){
        int[] sum = a.clone();
        for( int i=0 ; i<b.length ; i++ ){
            sum[i] += b[i];
        }
        return sum;
    }

    /** Compute the code range for every response */
    public static void initCodeCounts(int maxStones){
        codeCount = new int[maxStones+1][];
        codeCount[0] = new int[] {0,1};
        int[] sum = codeCount[0];
        for( int stones=1 ; stones<=maxStones ; stones++ ){
            codeCount[stones] = transpose(sum);
            sum = add(codeCount[stones], sum);
        }
    }

    /** display the code counts */
    public static void dispCodeCounts(int maxStones){
        for( int stones=1 ; stones<=maxStones ; stones++ ){
            if( stones<=8 ){
                System.out.println(stones + ": " + Arrays.toString(codeCount[stones]));
            }
        }
        for( int s=1 ; s<=maxStones ; s++ ){
            int[] row = codeCount[s];
            int best = 0;
            for( int r=1 ; r<row.length ; r++ ){
                int min = r<row[r] ? r : row[r];
                if( min>=best ){
                    best = min;
                }
            }
            System.out.println(s + ": " + row.length + " " + best);
        }
    }

    /** Find the maximum symmetrical code count M for a number of stones */
    public static int getMaxValue(int stones){
        int[] row = codeCount[stones];
        int maxValue = 0;
        for( int r=1 ; r<row.length ; r++ ){
            int min = r<row[r] ? r : row[r];
            if( min>=maxValue ){
                maxValue = min;
            }
        }
        return maxValue;
    }

    // MEMBERS

    /** low end of range, smallest code still possible */
    int min;

    /** range size, number of codes still possible */
    int range;

    /** Create a spy for a certain number of stones */
    Spy(int stones){
        min = 1;
        range = getMaxValue(stones);
    }

    /** Choose how many stones to throw */
    public int throwStones(int stonesLeft, int otherRange, int secret){
        for( int move=1 ; ; move++ ){
            // see how many codes this move covers
            int moveRange = codeCount[stonesLeft-move][otherRange];
            if( secret < this.min+moveRange ){
                // secret code is in move range
                this.range = moveRange;
                return move;
            }
            // skip to next move
            this.min += moveRange;
            this.range -= moveRange;
        }
    }

    /* Replay the state changes for a given move */
    public void replayThrow(int stonesLeft, int otherRange, int stonesThrown){
        for( int move=1 ; move<stonesThrown ; move++ ){
            int moveRange = codeCount[stonesLeft-move][otherRange];
            this.min += moveRange;
            this.range -= moveRange;
        }
        this.range = codeCount[stonesLeft-stonesThrown][otherRange];
    }
}

ThrowingStones.java

package stackexchange;

public class ThrowingStones
{
    public boolean simulation(int stones, int secret0, int secret1){

        // ENCODING

        Spy spy0 = new Spy(stones);
        Spy spy1 = new Spy(stones);

        int[] throwSequence = new int[stones+1];
        int turn = 0;
        int stonesLeft = stones;

        while( true ){
            // spy 0 throws
            if( stonesLeft==0 ) break;
            throwSequence[turn] = spy0.throwStones(stonesLeft, spy1.range, secret0);
            stonesLeft -= throwSequence[turn++];
            // spy 1 throws
            if( stonesLeft==0 ) break;
            throwSequence[turn] = spy1.throwStones(stonesLeft, spy0.range, secret1);
            stonesLeft -= throwSequence[turn++];
        }

        assert (spy0.min==secret0 && spy0.range==1 );
        assert (spy1.min==secret1 && spy1.range==1 );

//      System.out.println(Arrays.toString(throwSequence));

        // DECODING

        spy0 = new Spy(stones);
        spy1 = new Spy(stones);

        stonesLeft = stones;
        turn = 0;
        while( true ){
            // spy 0 throws
            if( throwSequence[turn]==0 ) break;
            spy0.replayThrow(stonesLeft, spy1.range, throwSequence[turn]);
            stonesLeft -= throwSequence[turn++];
            // spy 1 throws
            if( throwSequence[turn]==0 ) break;
            spy1.replayThrow(stonesLeft, spy0.range, throwSequence[turn]);
            stonesLeft -= throwSequence[turn++];
        }
        int recovered0 = spy0.min;
        int recovered1 = spy1.min;

        // check the result
        if( recovered0 != secret0 || recovered1 != secret1 ){
            System.out.println("error recovering (" + secret0 + "," + secret1 + ")"
                    + ", returns (" + recovered0 + "," + recovered1 + ")");
            return false;
        }
        return true;
    }

    /** verify all possible values */
    public void verifyAll(int stones){
        int count = 0;
        int countOK = 0;
        int maxValue = Spy.getMaxValue(stones);
        for( int a=1 ; a<=maxValue ; a++ ){
            for( int b=1 ; b<=maxValue ; b++ ){
                count++;
                if( simulation(stones, a, b) ) countOK++;
            }
        }
        System.out.println("verified: " + countOK + "/" + count);
    }

    public static void main(String[] args) {
        ThrowingStones app = new ThrowingStones();
        Spy.initCodeCounts(26);
        Spy.dispCodeCounts(26);
        app.verifyAll(20);
//      app.verifyAll(26); // never managed to complete this one...
    }

}

Para referência, a matriz codeCount pré-computada contém os seguintes valores:

1: [0, 1]
2: [0, 1, 1]
3: [0, 2, 1, 1]
4: [0, 3, 2, 1, 1, 1]
5: [0, 5, 3, 2, 2, 1, 1, 1, 1]
6: [0, 8, 5, 4, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1]

Isso estava diretamente relacionado aos conjuntos Tk de Peter Taylor. Nós temos:

(x,y) in Tk  <=>  y <= codeCount[x]
Florian F
fonte
Eu não acho que isso atenda às especificações sem uma maneira de executar os dois espiões em processos separados e comunicar os lances sem compartilhar o acesso a seus rangecampos. Mas estou muito intrigado com o seu método de calcular a tabela. Você tem uma prova de correção? E você está interessado em colaborar em um artigo que discute o problema e calcule sua solução?
Peter Taylor
O alcance do outro espião é uma função dos movimentos passados, como é calculado no método "replay". Eu acredito que está correto. A tabela que eu calculo é exatamente a mesma que você define Tk. Transpondo as trocas de tabela xey, a soma é a soma de todos os filhos possíveis de um nó. Não provei que estava correto, exceto que testei até 22 pedras. Tentei escrever uma resposta adequada para a troca de quebra-cabeças intrigante, mas não consegui explicar de maneira clara e convincente. E principalmente, é o que você já fez.
Florian F
Está bem. Provavelmente não tenho tempo esta semana, mas quando estiver menos ocupado, tentarei encontrar uma prova de que seu método de geração produz a mesma tabela que a minha, porque acho que seria um bom complemento para as coisas que eu ' já escrevi.
Peter Taylor
Na verdade, é bastante simples: sua equivalência ao meu método de cálculo se resume ao lema de que o conjugado da união multiset de duas partições é igual à soma pontual de seus conjugados.
22413 Peter
(batendo na minha cabeça) Mas é claro! Por que não pensei nisso antes? :-)
Florian F
0

ksh / zsh, M = 126

Neste sistema simples, cada espião lança dígitos binários para o outro espião. Em cada lançamento, a primeira pedra é ignorada, as seguintes são cada bit 0 e a última é o bit 1. Por exemplo, para lançar 20, um espião jogaria 4 pedras (ignore 0, 2, adicione 4), então jogue 3 pedras (ignore, 8, adicione 16), porque 4 + 16 = 20.

O conjunto de números não é contíguo. 0 a 126 estão dentro, mas 127 está fora. (Se ambos os espiões têm 127, precisam de 28 pedras, mas 26). Depois, 128 a 158 entram, 159 sai, 160 a 174 entram, 175 está fora, 175 estão fora, 176 a 182 estão dentro, 183 estão fora, 184 a 186 está dentro, 187 está fora e assim por diante.

Execute uma troca automática com ksh spy.sh 125 126, ou execute espiões individuais com ksh spy.sh spy1 125e ksh spy.sh spy2 126. Aqui, kshpode ser ksh93, pdksh ou zsh.

EDIT 14 Jun 2014: Corrija um problema com alguns co-processos no zsh. Eles ficariam ociosos para sempre e não conseguiriam sair, até que o usuário os matasse.

(( stones = 26 ))

# Initialize each spy.
spy_init() {
    (( wnum = $1 ))  # my number
    (( rnum = 0 ))   # number from other spy
    (( rlog = -1 ))  # exponent from other spy
}

# Read stone count from other spy.
spy_read() {
    read count || exit
    (( stones -= count ))

    # Ignore 1 stone.
    (( count > 1 )) && {
        # Increment exponent.  Add bit to number.
        (( rlog += count - 1 ))
        (( rnum += 1 << rlog ))
    }
}

# Write stone count to other spy.
spy_write() {
    if (( wnum ))
    then
        # Find next set bit.  Prepare at least 2 stones.
        (( count = 2 ))
        until (( wnum & 1 ))
        do
            (( wnum >>= 1 ))
            (( count += 1 ))
        done

        (( wnum >>= 1 ))  # Remove this bit.
        (( stones -= count ))
        print $count      # Throw stones.
    else
        # Throw 1 stone for other spy to ignore.
        (( stones -= 1 ))
        print 1
    fi
}

# spy1 writes first.
spy1() {
    spy_init "$1"
    while (( stones ))
    do
        spy_write
        (( stones )) || break
        spy_read
    done
    print $rnum
}

# spy2 reads first.
spy2() {
    spy_init "$1"
    while (( stones ))
    do
        spy_read
        (( stones )) || break
        spy_write
    done
    print $rnum
}

(( $# == 2 )) || {
    name=${0##*/}
    print -u2 "usage: $name number1 number2"
    print -u2 "   or: $name spy[12] number"
    exit 1
}

case "$1" in
    spy1)
        spy1 "$2"
        exit;;
    spy2)
        spy2 "$2"
        exit;;
esac

(( number1 = $1 ))
(( number2 = $2 ))

if [[ -n $KSH_VERSION ]]
then
    eval 'cofork() { "$@" |& }'
elif [[ -n $ZSH_VERSION ]]
then
    # In zsh, a co-process stupidly inherits its own >&p, so it never
    # reads end of file.  Use 'coproc :' to close <&p and >&p.
    eval 'cofork() {
        coproc {
            coproc :
            "$@"
        }
    }'
fi

# Fork spies in co-processes.
[[ -n $KSH_VERSION ]] && eval 'coproc() { "$@" |& }'
cofork spy1 number1
exec 3<&p 4>&p
cofork spy2 number2
exec 5<&p 6>&p

check_stones() {
    (( stones -= count ))
    if (( stones < 0 ))
    then
        print -u2 "$1 is in trouble! " \
            "Needs $count stones, only had $((stones + count))."
        exit 1
    else
        print "$1 threw $count stones.  Pile has $stones stones."
    fi
}

# Relay stone counts while spies throw stones.
while (( stones ))
do
    # First, spy1 writes to spy2.
    read -u3 count report1 || mia spy1
    check_stones spy1
    print -u6 $count

    (( stones )) || break

    # Next, spy2 writes to spy1.
    read -u5 count report2 || mia spy2
    check_stones spy2
    print -u4 $count
done

mia() {
    print -u2 "$1 is missing in action!"
    exit 1
}

# Read numbers from spies.
read -u3 report1 || mia spy1
read -u5 report2 || mia spy2

pass=true
(( number1 != report2 )) && {
    print -u2 "FAILURE: spy1 put $number1, but spy2 got $report2."
    pass=false
}
(( number2 != report1 )) && {
    print -u2 "FAILURE: spy2 put $number2, but spy1 got $report1."
    pass=false
}

if $pass
then
    print "SUCCESS: spy1 got $report1, spy2 got $report2."
    exit 0
else
    exit 1
fi
Kernigh
fonte