Venture

Esse é uma breve análise sobre a carta Venture.

Tradução livre...:  Tesouro \$1. Quando você joga isso, revele as cartas do seu deck até que você revele um treasure. Discarte as outras cartas. Jogue aquele tesouro.

Como descrito, Venture fornece \$1 + o valor do próximo tesouro a ser revelado. Inicialmente com Coopers, Venture fornece basicamente \$2. A questão inicial que levanto é, qual o valor que 4 Ventures fornecem?  Num jogo de Big Money, qual a proporção ideal de Golds e Ventures  que um deck poderia ter?

Bom, minha solução proposta é considerar as seguintes simplificações:
1) O valor fornecido por esse Treasure é obviamente aleatório. Iremos investigar o caso do valor médio.
2) Iremos desprezar o fato de não haver  um "próximo tesouro".

No caso de apenas um Venture, o valor médio fornecido por ele é \$1 + o valor médio dos Treasures do Deck. Para os demais Ventures podemos calcular com a seguinte recursão.

Seja $V$ é a função que mapeia o índice com o valor do Venture, $M$ a função de valor médio das cartas pelo número de Ventures.
Por exemplo, considere $G$, a quantidade de Golds e $C$ a quantidade de Coppers no deck.


\begin{equation*}
M(0) = \frac{3G + C}{G + C}
\end{equation*}

O próximo venture fornecerá (em média)

\begin{equation*}
V(1) = 1 + M(0)
\end{equation*}

... o que mudará o valor médio dos Treasures do Deck para...

\begin{equation*}
M(1) = \frac{(V(1) + M(0).(G+C)}{G+C+1}
\end{equation*}

De forma geral...

\begin{equation*}
M(n) = \frac{V(n) + M(n-1).(G+C+n-1)}{G+C+n}
\end{equation*}

Não é bacana resolver essa recursão. E dado que a série é discreta, aqui um programinha que simula o problema. O programa a seguir imprime uma matriz M(g,n) do valor médio dos Tresures do Deck, onde g é a quantidade de Golds no deck - 1 e n a quantidade de ventures -1 em função de c (quantidade de coppers).

require 'matrix'
args = ARGV.map{|arg| Integer(arg)}
class Venture
  
  def initialize(n=100,g=100, c=7)
    @c = c
    @venture = Array.new(n) { Array.new(g) {-1}}
  end
  
  def print(n, g)
    n.times{ |i|
      g.times { |j|
        memoized_value(i, j)
      }
    }
    n.times{ |i|
      line = ""
      g.times { |j|
        line << "#{1.0 * @venture[i][j]/ (i + j + @c)} "
      }
      puts line 
    }
  end
    
  def memoized_value(n, g)
    @venture[n][g] = value(n,g) if @venture[n][g] == -1
    @venture[n][g]  
  end
  
  def value(n,g)
    if (n == 0)
     3*g + @c
    else
     1 + 1.0 * value(n-1, g)*(n+g+@c)/(n+g+@c -1)
    end
  end
end
Venture.new(*args).print(args[0],args[1])

Os resultados obtidos obviamente variam com a quantidade de Coppers no Deck. Quanto maior a média, mais eficiente os Ventures serão em relação aos Golds.

Cenário com 7 Coppers

Cenário com 3 Coppers

Cenário com 1 Copper