Glückspielvorteil

[CDW]

10 gegen 3
Das Spiel wird mit 2 Spielern gespielt:
Der erste Spieler setzt 10 Euro - diese sind dem zweiten Spieler auf jeden Fall sicher.
Der zweite Spieler würfelt (mit 3 Würfeln) - die Augensumme wird zusammengezählt. Diesen Betrag zahlt der zweite Spieler an den ersten aus.
D.h er bekommt vom ersten Spieler 10 Euro und zahlt die gewürfelte Augensumme an diesen aus.

1.was wäre Deine intuitive Antwort (ohne Programmieren/Rechnen):
wer ist hier im Vorteil ?

Programmieraufgabe:
Dein Programm soll ausgeben, welcher Spieler im Vorteil ist (und/oder ein paar Zahlen ausgeben, so dass es aus diesen ersichtlich wird).

Es bieten sich folgende Varianten: eine Simulation, die das Spiel mehrere 1000 Male durchführt - was kommt hier raus?

oder: ein Programm, welches alle möglichen Würfelkombinationen samt zugehöriger Summe errechnet und aus diesen Daten irgendwelche "Erkenntnisse" gewinnt.

Spoiler: zu den beiden Varianten

bei der Simulation könnten die Spieler mit einem Startkapital anfangen - nach 1000 Runden könnte man diese Werte vergleichen.
Kombinationen:
einfach alle möglichen Kombinationen der 3 Würfel bilden. Nun soll das Programm berechnen, wieviele Kombinationen eine Augensumme <10,>=10 usw. haben.

PS: ich möchte nochmal auf darauf verweisen:
Erklärung zu diesem Forum

m übrigen geht es darum den Quelltext eurer Lösung zu veröffentlichen. Gerne werden auch Binärdateien angenommen, aber Quelltext ist Pflicht, schließlich soll das ganze auch für andere User einen Sinn ergeben.
Beim Posten des Quelltextes verwendet bitte den Spoiler- mit Code-Tag:

 

[xeno]

intuitive antwort: da die zahl zwischen 3 und 12 liegt würde ich sagen, der vorteil liegt beim zweiten spieler, da durchschnittlich um die 7,5 augen liegen. code reiche ich nach. ist wahrscheinlich total falsch

edit: zwischen 3 und 18 natürlich ;(

Spoiler: die lösung ist aber interessant:

//
// * Spieler A bezahlt 10? an Spieler B
// * Spieler B würfelt mit drei Würfeln
// * Spieler B bezahlt die Anzahl der Augen an Spieler A in ?
//
// Frage: Wer ist im Vorteil?
// Getestet wird in 1.000.000 Durchläufen
//

using System;

class Gluecksspiel {
    public static void Main() {
        Random wuerfel = new Random();
        int vorteilA = 0;
        int vorteilB = 0;
        int gewinnA = 0;
        int gewinnB = 0;
        int vorteilNiemand = 0;

        for( int i=0; i<1000000; i++) {
            int wurf1 = wuerfel.Next(1, 7); 
            int wurf2 = wuerfel.Next(1, 7); 
            int wurf3 = wuerfel.Next(1, 7); 
    
            if( (wurf1 + wurf2 + wurf3) > 10) {
                vorteilA++;
                gewinnA += (wurf1 + wurf2 + wurf3)-10;
            } else if( (wurf1 + wurf2 + wurf3) < 10) {
                vorteilB++;
                gewinnB += 10-(wurf1 + wurf2 + wurf3);
            } else {
                vorteilNiemand++;
            }   
    
        }   
        gewinnA -= 1000000;
        gewinnB -= 1000000;
        Console.WriteLine("Vorteile für Spieler A:      {0}", vorteilA);
        Console.WriteLine("Gewinn von Spieler A:        {0}\n", gewinnA);
        Console.WriteLine("Vorteile für Spieler B:      {0}", vorteilB);
        Console.WriteLine("Gewinn von Spieler B:        {0}\n", gewinnB);
        Console.WriteLine("Ausgleichende Gerechtigkeit: {0}", vorteilNiemand);
    }   
}

Ausgabe:

Vorteile für Spieler A: 500009
Gewinn von Spieler A: 458121

Vorteile für Spieler B: 374508
Gewinn von Spieler B: -42793

Ausgleichende Gerechtigkeit: 125483

SpielerA bekommt also in 50% aller fälle mehr geld zurück bei einem Gewinn von etwa 46cent pro Spiel.

 

[SilentBoB]

da die zahl zwischen 3 und 12 liegt

die Zahl liegt doch zwischen 3 und 18 (3x6) oder hab ich jz nen Denkfehler?

Oh ok hast schon editiert

 

[Gelöschtes Mitglied 14523]

Original von xeno
intuitive antwort: da die zahl zwischen 3 und 12 liegt würde ich sagen, der vorteil liegt beim zweiten spieler, da durchschnittlich um die 7,5 augen liegen. code reiche ich nach. ist wahrscheinlich total falsch

Denke bei 3 Würfeln liegt die Zahl zwischen 3 und 18.
Intuitiv werden die Zahlen 9,10,11,12 am öftersten gewürfelt also glaube ich, dass Spieler 1 die besseren Karten besitzt.

 

[Eydeet]

@xeno: Ich denke, du hast da einen kleinen Schönheitsfehler in deinem Programm:

Spoiler: ...

Du zählst Vorteile, aber nicht, wie groß diese Vorteile tatsächlich sind. So könnte es theoretisch sein, dass Spieler 2 in der Hälfte der Fälle 1 Euro gewinnt, in der anderen Hälfte aber 5 Euro verliert.

Spoiler: Meine Lösung (Python)

import random
geldA = 0

for i in range(100000):
    summe  = random.randrange(1, 7)
    summe += random.randrange(1, 7)
    summe += random.randrange(1, 7)
    geldA = geldA - 10 + summe

print "Geldgewinn von Spieler 1:", geldA, "Euro"
print "Geldgewinn von Spieler 2:", -geldA, "Euro"

Einige Testläufe über 100 000 Spiele:
Geldgewinn von Spieler 1: 50860 Euro
Geldgewinn von Spieler 2: -50860 Euro
-------
Geldgewinn von Spieler 1: 48116 Euro
Geldgewinn von Spieler 2: -48116 Euro
-------
Geldgewinn von Spieler 1: 48626 Euro
Geldgewinn von Spieler 2: -48626 Euro

Spieler 1 gewinnt also grob gerundet pro Spiel durchschnittlich 50ct.

Das würde sich auch in etwa mit meinem mathematischen Ansatz decken:
Ein Würfel zeigt im Durchschnitt (1+2+3+4+5+6)/6 (=3,5) an. Bei drei Würfeln wäre das 3,5 * 3 = 10,5.

 

[xeno]

@Eydeet:

stimmt, hab ich nicht dran gedacht. hab das mal eingebaut und festgestellt, daß Spieler A tatsächlich etwa 46cent pro runde gewinnt. kannst du diesen genaueren wert bestätigen?

 

[Gelöschtes Mitglied 14523]

Spoiler: C#

Random augenzahl = new Random();
int rundenanzahl = 10000;
int wurfsumme;
int geld2 = 0;

for (int i = 0; i < rundenanzahl; i++)
    {
       wurfsumme = 0;
       for (int j = 0; j < 3; j++)
           {
                 wurfsumme += augenzahl.Next(1,7);
           }
       geld2 += 10 - wurfsumme;
    }

Ergebnis:
Spieler1 verdient: 5109
Spieler2 verdient: -5109

 

[goflo]

Meine cpp Lösung:

Spoiler: main.cpp

#include <iostream>
#include <time.h>

using namespace std;

int main() {
	int rSum = 0;
	int sumPlayer1 = 0;
	int sumPlayer2 = 0;
	
	srand(time(NULL));
	
	for (int i = 0; i < 100000; i++) {
		rSum = 0;
		
		for (int j = 0; j < 3; j++) {
			rSum += (rand() % 6) + 1;
		}
		
		sumPlayer2 += 10 - rSum;
		sumPlayer1 += rSum;
	}
	
	cout << "Konto Spieler 1: " << sumPlayer1 << endl;
	cout << "Konto Spieler 2: " << sumPlayer2 << endl;
	
	return 0;
}

Ergebnis zum Beispiel nach 100.000 Runden:
Konto Spieler 1: 1050175
Konto Spieler 2: -50175

 

[Gelöschtes Mitglied 14523]

@goflo, ich glaube du hast noch nen kleinen Denkfehler in deinem Programm

Spoiler: ...

r = (rand() % 16) + 3;

Du würfelst mit nur 1nen Würfel welcher die Augenzahlen 3-18 besitzt anstatt mit 3 Würfel(Augenzahl je Würfel = 1-6)
=> bei dir ist die Chance eine 18 zu würfeln genausogroß wie jene Chance eine 11 zu würfeln. Ne 18 kannst du aber nur mit 3 6er erreichen, im Gegensatz dazu eine 11 mit 3+3+5, 4+4+3, 6+4+1, usw..

 

[goflo]

@ Binäru$:
Muss ich dir recht geben. Da habe ich es mir wohl zu einfach gemacht...

 

[Eydeet]

Original von xeno
hab das mal eingebaut und festgestellt, daß Spieler A tatsächlich etwa 46cent pro runde gewinnt. kannst du diesen genaueren wert bestätigen?

Das kommt ungefähr hin. Ich habe etwa 50 Cent pro Runde ausgerechnet.

 

[Elderan]

Hallo,
hier mein PHP Programm, welches sich stochastischen Mitteln zunutze macht, um die Frage zu beantworten:

Spoiler: PHP

<?php
$kombinationen = array();

//Anzahl an Kombinationen pro Augensumme
for($a = 1; $a <= 6; $a++) {
	for($b = 1; $b <= 6; $b++) {
		for($c = 1; $c <= 6; $c++) {
			$kombinationen[$a+$b+$c]++;
		}
	}
}

$einsatz_spieler_1 = 10;

//Was fuer eine Augensumme hat Spieler2 im Schnitt
$sum = 0;
for($i=3;$i<=18; $i++) {
	$sum += $kombinationen[$i]*$i;
}
$durchschnittsgewinn = $sum/(6*6*6);

echo "Durchschnittsaugenzahl für Spieler 2: $durchschnittsgewinn (Augensumme) <br>";
echo "Macht fuer Spieler 1: ".($durchschnittsgewinn - $einsatz_spieler_1)." Euro pro Spiel";

?>

Oder mathematisch:

Spoiler: Mathematik

Die Anzahl an Kombinationen für eine bestimmte Augensumme ist zwischen 10 und 11 symmetrisch, d.h. P(10) = P(11), P(9) = P(12) usw. (achja, hier zu sagen, dass ein Würfel die Zahlen 1 bis 6 hat und der Schnitt 3,5 ist, also 3*3,5=10,5 reicht so noch nicht aus, wenn man für Kombinationen argumentiert.)

Da Spieler1 10 Euro einsetzt, wird er häufiger etwas gewinnen als verlieren, da er nur bei 3 bis 9 verliert, bei 11 bis 18 gewinnt. Also bei 7 Augensummen verliert, bei 8 Augensummen gewinnt, und 1 mal nix passiert.

Da er bei 9 einen Euro verliert aber bei 11 einen Euro gewinnt und P(11) > P(9) gilt, stehen seine Chancen ganz gut


Um das zu berechnen was Spieler1 gewinnt:
Naja Spieler2 muss ja für jeden Würfel die Augenzahl an Spieler1 zurückzahlen. Da ein Würfel die Augenzahlen 1, ..., 6 hat, und jede gleich wahrscheinlich ist, muss Spieler2 pro Würfel im Schnitt 3,50 Euro Zahlen, Insgesamt also im Schnitt 10,50 Euro.

 

[reach44]

Meine Java-Lösung:

Spoiler: Java

public class Vorteil
{
	public static void main (String[] args)
	{
		int p1Guthaben=0, spielAnzahl=10000, p2Guthaben=0;
		for (int x=0; x<spielAnzahl;x++)
		{
			int wuerfel=0;
			for (int y=0; y<3; y++) wuerfel += ((int)(Math.random()*6))+1;
			p2Guthaben += 10 - wuerfel;
			p1Guthaben += wuerfel - 10;
		}
	System.out.println(p1Guthaben + " " + p2Guthaben);
	}
}

 

[CDW]

Seltsam, dass nur Elderan die Kombinationen betrachtet hat - dabei finde ich diese um einiges Aussagekräfitger als Simulationen

Spoiler: Prolog

wuerfeln(W):-member(W,[1,2,3,4,5,6]).
wuerfele(Comparator,Limit,Count):-findall(_,
	       (wuerfeln(W1),wuerfeln(W2),wuerfeln(W3),
	        call(Comparator,W1+W2+W3,Limit)),Sums),
	length(Sums,Count).

Anfragen:
Syntax: (Operator,Limit, "Kombinationen, die die Bedingung erfüllen" )

wuerfele(=:=,10,Kombos),length(Kombos,Anzahl).
Anzahl = 27,
Kombos = [(1,3,6),(1,4,5),...

?- wuerfele(<,10,Kombos),length(Kombos,Anzahl).
Anzahl = 81,
Kombos = [(1,1,1),(1,1,2),(1,1,3)...

?- wuerfele(>,10,Kombos),length(Kombos,Anzahl).
Anzahl = 108,
Kombos = [(1,4,6),(1,5,5),(1,5,6)...

Sind also 27 Möglichkeiten, eine 10 zu würfeln, 81 unter 10 zu bleiben und 108 > als 10

vollständigkeitshalber die Simulation:

wuerfele(Sum):-Sum is random(6)+random(6)+random(6)+3.
sim(0,0,0).
sim(Count,P1,P2):-NCount is Count-1,
	sim(NCount,P1_,P2_),wuerfele(Num),P1 is P1_-10+Num,P2 is P2_+10-Num.

Anfrage:
?- sim(1000000,Player1,Player2).
Player1 = 501701,
Player2 = -501701 ?
yes

 

[Kenniej91]

Original von Eydeet

Original von xeno
hab das mal eingebaut und festgestellt, daß Spieler A tatsächlich etwa 46cent pro runde gewinnt. kannst du diesen genaueren wert bestätigen?

Das kommt ungefähr hin. Ich habe etwa 50 Cent pro Runde ausgerechnet.

Wieso etwa?
3.50? pro Würfel als Erwartungswert, mal 3 ist 10.50?^^

Beziehungsweise mein Programm:

int main(void)
{
double a = 1 + 2 +3 + 4 + 5 + 6;
a /= 6; 
if((10 / 3) < a)
{
cout << "Spieler 2 ist im Vorteil" << endl;
}
else
{
cout << "Spieler 1 ist im Vorteil" << endl;
}
cin >> a;
}

Gehört also zu Fragestellung 2,
auch wenn's n bisschen geschummelt ist^^

 

[Eydeet]

Original von Kenniej91

Original von Eydeet

Original von xeno
hab das mal eingebaut und festgestellt, daß Spieler A tatsächlich etwa 46cent pro runde gewinnt. kannst du diesen genaueren wert bestätigen?

Das kommt ungefähr hin. Ich habe etwa 50 Cent pro Runde ausgerechnet.

Wieso etwa?
3.50? pro Würfel als Erwartungswert, mal 3 ist 10.50?^^

Das war vielleicht ein wenig missverständlich formuliert. Ausgerechnet habe ich auch genau 50 Cent, aber meine Simulation hat natürlich nur ungefähr 50 Cent Gewinn pro Durchlauf ergeben.

 

[D31~$0u1]

Meine Lösung:

Spoiler: Meine Lösung in BlitzMax

'Framework und import
Framework brl.Graphics
Import brl.Timer
Import brl.linkedlist
Import brl.D3D7Max2D
Import brl.Random
Import brl.StandardIO


Global KapitalS1:Int
Global KapitalS2:Int
Global Wuerfel1:Int
Global Wuerfel2:Int
Global Wuerfel3:Int
Global SumGes:Int
Global S1Vorteil:Int
Global S2Vorteil:Int

SeedRnd MilliSecs()

KapitalS1 = 1000
KapitalS2 = 1000

Function Vorteil1()
  S1Vorteil = S1Vorteil + 1
  Print "Vorteil für Spieler1"
  Print " "
EndFunction

Function Vorteil2()
  S2Vorteil = S2Vorteil + 1
  Print "Vorteil für Spieler2"
  Print " "
EndFunction



For i:Int = 1 To 2000
 Print i + ". Runde:"
 Print " "
  KapitalS1 = KapitalS1 - 10
  KapitalS2 = KapitalS2 + 10
	Wuerfel1 = Rnd(1, 6)
	Print Wuerfel1
	Wuerfel2 = Rnd(1, 6)
	Print Wuerfel2
	Wuerfel3 = Rnd(1, 6)
	Print Wuerfel3
	SumGes = Wuerfel1 + Wuerfel2 + Wuerfel3
 Print "Gewürfelt wurde insgesamt: " + SumGes
 Print " "

 If SumGes > 10 Then Vorteil1()
 If SumGes < 10 Then Vorteil2()
 
 KapitalS1 = KapitalS1 + SumGes
 KapitalS2 = KapitalS2 - SumGes
 
 Print "Kapital von Spieler1: " + KapitalS1
 Print "Kapital von Spieler2: " + KapitalS2
 Print "Ende Runde" + i
 Print " "

Next

Print "Endgültiges Kapital von Spieler1: " + KapitalS1
Print "Endgültiges Kapital von Spieler2: " + KapitalS2
Print "Gesamt Vorteile von Spieler1: " + S1Vorteil
Print "Gesamt Vorteile von Spieler2: " + S2Vorteil
Print " "
If S1Vorteil > S2Vorteil Then Print "Spieler1 hatte insgesamt " + (S1Vorteil - S2Vorteil) + "  Vorteile mehr als Spieler2"
If S1Vorteil < S2Vorteil Then Print "Spieler2 hatte insgesamt " + (S2Vorteil - S1Vorteil) + "  Vorteile mehr als Spieler1"
Print " "
If KapitalS1 > KapitalS2 Then Print "Spieler1 hat insgesamt " + (KapitalS1 - KapitalS2) + "  Euro mehr als Spieler2"
If KapitalS1 < KapitalS2 Then Print "Spieler2 hat insgesamt " + (KapitalS2 - KapitalS1) + "  Euro mehr als Spieler1"
WaitKey
end

 

[Athelstan]

Hier meine Lösung, sie berechnet alle möglichen Kombinationen und sortiert dann je nach Größe der Augensumme zu Spieler1, Spieler2 oder Niemandem bei der Summe 10.

a = (1..6).to_a
b = a
c = a
zaehler1 = 0
zaehler2 = 0
zaehler3 = 0
a.each { |part1|
	b.each { |part2|
		c.each { |part3|
			if (part1+part2+part3) > 10
				zaehler1 += 1
			elsif (part1+part2+part3) < 10
				zaehler2 += 1
			elsif (part1+part2+part3) == 10
				zaehler3 += 1
			end
		}
	}
}
puts "Spieler A: #{zaehler1}"
puts "Spieler B: #{zaehler2}"
puts "Niemand: #{zaehler3}"
puts "Gesamt: #{zaehler1+zaehler2+zaehler3}"

Ausgabe:

athelstan@portanigra:~$ ruby Gluecksspiel.rb
Spieler A: 108
Spieler B: 81
Niemand: 27
Gesamt: 216

 

[Stein]

Ich habe auch getippt das der 10ner-Mann gewinnt, denn 18-3= 15;15 /2 = 7,5 er würfelt durchschnittlich eine 7,5

Spoiler: Python Simulation

import random

def gewinn():
    augenzahl = random.randrange(1,7,1)+random.randrange(1,7,1)+random.randrange(1,7,1)
    return 10 - augenzahl
#Gewinn des Wuerfelspielers:                                                                                                                                   
w = 0

for i in range(1001):
    w += gewinn()
print w

Spoiler: python Berechnung

 w_gew = 0
for i in range(1,7,1):
    for j in range(1,7,1):
        for k in range(1,7,1):
            w_gew += 10-(i+k+j)
print w_gew

 

[smaster100]

besser spät als nie

mein code in c#:

Spoiler: c#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace _10gegen3
{
class Program
{
static void Main(string[] args)
{
long money_spieler1 = 10000;
long money_spieler2 = 10000;

int wuerfel1 = 0;
int wuerfel2 = 0;
int wuerfel3 = 0;
int score = 0;
Random r = new Random();

for (long count = 0; count < 1000000; count++)
{
money_spieler1 = money_spieler1 - 10;
money_spieler2 = money_spieler2 + 10;


wuerfel1 = r.Next(1, 7);
wuerfel2 = r.Next(1, 7);
wuerfel3 = r.Next(1, 7);

score = wuerfel1 + wuerfel2 + wuerfel3;

money_spieler1 = money_spieler1 + score;
money_spieler2 = money_spieler2 - score;
}

if (money_spieler1 > money_spieler2)
{
Console.WriteLine("Spieler 1 hat gewonnen mit " + money_spieler1 + " zu " + money_spieler2);
}
else
{
Console.WriteLine("Spieler 2 hat gewonnen mit " + money_spieler2 + " zu " + money_spieler1);
}
}
}
}

Ausgabe:
Spieler 1 hat gewonnen mit 511427 zu -491427