Jeszcze chciałem dodać tutaj swoje 2 grosze do kwestii tych ruletek.
Zakładając, że gramy narazie TYLKO na czerwone/czarne, można sobie skonstruować taki skrypt (chociaż nie jestem mistrzem Java)
Kod:
import com.sun.org.apache.xpath.internal.operations.Bool;
import ptolemy.plot.Plot;
import ptolemy.plot.PlotApplication;
import java.util.*;
public class Symulacja
{
public class Structure
{
public int index;
public int occurs;
public int getIndex()
{
return this.index;
}
}
private int red;
private int black;
private int in_row;
private Plot plot;
private Random rand;
private Boolean prev;
private ArrayList<Boolean> result;
private List<Structure> dispersion;
private PlotApplication app;
public Symulacja()
{
this.result = new ArrayList<Boolean>();
this.dispersion = new ArrayList<Structure>();
this.in_row = 0;
this.red = 0;
this.black = 0;
this.plot = new Plot();
this.rand = new Random();
}
public void runSym()
{
Boolean b = rand.nextBoolean();
if(b)
++red;
else
++black;
if(this.red == 0 && this.black == 0)
this.prev = b;
else
if(b == this.prev)
{
++in_row;
}
else
{
this.prev = b;
Structure findInList = this.findIndex(this.in_row);
if(findInList == null)
{
Structure struct = new Structure();
struct.index = in_row;
struct.occurs = 1;
dispersion.add(struct);
}
else
{
dispersion.get(dispersion.indexOf(findInList)).occurs++;
}
in_row = 0;
}
this.result.add(b);
}
private void organizeList()
{
this.dispersion.sort(Comparator.comparing(Structure::getIndex));
}
private Structure findIndex(int elem)
{
for (Structure struc: dispersion)
{
if(struc.index == elem)
return struc;
}
return null;
}
public void printSymulation()
{
for(Boolean res : this.result)
{
if(res)
System.out.print(1);
else
System.out.print(0);
}
}
public void printDispersion()
{
for(Structure struc: this.dispersion)
{
System.out.println("Rozmiar: " + struc.index + " WystÄ…pienia: " + struc.occurs);
}
}
public void plotDispersion()
{
this.organizeList();
for(Structure struc: this.dispersion)
{
this.plot.addPoint(0, struc.index, struc.occurs, true);
}
this.app = new PlotApplication(plot);
this.app.setSize(800,400);
this.app.setLocation(100, 100);
this.app.setTitle("Symulacja");
}
public int stopLoss(int value)
{
int stopMoney = 0;
for(int i=0;i<this.dispersion.size();++i)
if(i == 0)
stopMoney = value;
else
stopMoney *= 2;
return stopMoney;
}
public static void main(String[] args)
{
Symulacja sym = new Symulacja();
for(int i = 0; i<10000000;i++)
sym.runSym();
sym.organizeList();
sym.printDispersion();
sym.plotDispersion();
System.out.println("Wkład krytyczny: " + sym.stopLoss(1));
}
}
I przy 10 000 000 symulacji okazuje się, że krotność wystąpienia długości jednakowych kolorów np. 11111111 (krotność 8), daje takie rezultaty:
Kod:
Rozmiar: 0 WystÄ…pienia: 2496912
Rozmiar: 1 WystÄ…pienia: 1250442
Rozmiar: 2 WystÄ…pienia: 625130
Rozmiar: 3 WystÄ…pienia: 311961
Rozmiar: 4 WystÄ…pienia: 156296
Rozmiar: 5 WystÄ…pienia: 78379
Rozmiar: 6 WystÄ…pienia: 39277
Rozmiar: 7 WystÄ…pienia: 19521
Rozmiar: 8 WystÄ…pienia: 9801
Rozmiar: 9 WystÄ…pienia: 4935
Rozmiar: 10 WystÄ…pienia: 2470
Rozmiar: 11 WystÄ…pienia: 1164
Rozmiar: 12 WystÄ…pienia: 613
Rozmiar: 13 WystÄ…pienia: 327
Rozmiar: 14 WystÄ…pienia: 158
Rozmiar: 15 WystÄ…pienia: 73
Rozmiar: 16 WystÄ…pienia: 32
Rozmiar: 17 WystÄ…pienia: 16
Rozmiar: 18 WystÄ…pienia: 15
Rozmiar: 19 WystÄ…pienia: 6
Rozmiar: 20 WystÄ…pienia: 2
Rozmiar: 21 WystÄ…pienia: 1
Rozmiar: 22 WystÄ…pienia: 1
Oczywiście tutaj wystąpienia tych elementów zależą od konkretnej symulacji.
Mimo wszystko można obliczyć prawdopodobieństwo wystąpienia danej sekwencji i moment odcięcia (pogodzenia się z porażką), gdzie będzie się nam to najbardziej opłacało.
Trzeba tylko pamiętać, że przy wkładzie 1 zł, podczas wystąpienia sekwencji 22 porażek, nasz kapitał musiałby wynosić:
Kod:
Wkład krytyczny: 4 194 304 zł
Wykres zależności wystąpień od częstości wygląda następująco:
Musze zaznaczyć, że tak naprawdę na komputerze nie da się wykonać poprawnej symulacji tych zjawisk, gdyż algorytmy losujące mocno zależą tutaj od pracy procesora i tak naprawdę przy naprawdę zaawansowanej analizie da się przewidzieć wynik losowania. W kryptografii gdzie właśnie często bazuje się na zmiennych losowych zmienne te brane są z np. szumów na oscyloskopie, ciężko jednak uwierzyć ze serwisy umożliwiające grę w ruletkę używają takich mechanizmów.
Wszystko jest dość skomplikowane.
Do tego dochodzi jeszcze właśnie kwestia zielonego pola, które tylko komplikuje nam przewidywania
