Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Chuck-a-Luck (Simulationen)

Simuliere das Spiel Chuck-a-luck

Bei diesem Spiel bezahlt der Spieler pro Runde Euro 1.- als Einsatz.  Er darf nun nacheinander drei Würfel werfen.  Zeigt mindestens ein Würfel eine 6, so erhält  er zunächst den Einsatz zurück.
Zudem erhält er für jede geworfene 6 Euro 1.- als Gewinn ausbezahlt. Liegt keine 6, so verliert er den Einsatz.

Starten Sie mit einem Kapital von Euro 1'000.- und simulieren Sie 1000 Runden.

2 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

Kommentare (2)

gressly 11. März 2014 11:38   reply report
Hoppla. Danke LifeGames: Ich habe die Aufgabe angepasst. Nun ist alles in Euro. Ich glaube ich hatte die Aufgabe zunächst in CHF und dann beim "Internationalisieren" den letzten CHF vergessen.
LifeGamers 8. Februar 2014 20:47   reply report
Soll ich den Euro vorher in CHF umrechnen ? :P

21 Lösung(en)

import java.util.Scanner;

/**
 * Simuliere das Spiel Chuck-a-luck
 * Der Spieler bezahlt CHF 1.- als Einsatz.
 * Er darf nacheinander drei Würfel werfen.
 * Zeigt mindestens ein Würfel eine 6, so erhält
 * er den Einsatz zurück.
 * Zudem erhält er für jede geworfene 6 CHF 1.- als
 * Gewinn ausbezahlt.
 * Liegt keine 6, so verliert er den Einsatz.
 * 
 * @author Philipp Gressly (phi AT gressly DOT ch)
 */
public class Chuck_A_Luck {
  public static void main(String[] args) {
    new Chuck_A_Luck().top();
  }
  void top() {
    int einsatz      = 1;
    int kapital      = einlesen("Startkapital");
    int simulationen = einlesen("Anzahl Simulationen");
    for(int s = 0; s < simulationen; s++) {
       kapital = kapital - einsatz;
       int gewinn = simuliere(einsatz);
       kapital = kapital + gewinn;
    }
    System.out.println("Es bleiben: " + kapital);
  }

  int simuliere(int einsatz) {
    int wurf1 = wirf();
    int wurf2 = wirf();
    int wurf3 = wirf();
    int anz6  = zaehleAnzahlSechser(wurf1, wurf2, wurf3);
    if(1 == anz6) return einsatz + 1;  
    if(2 == anz6) return einsatz + 2;
    if(3 == anz6) return einsatz + 3;
    else return 0; // Kein Gewinn
  }
  
  int zaehleAnzahlSechser(int wurf1, int wurf2, int wurf3) {
    int anz = 0;
    if(6 == wurf1) anz = anz + 1;
    if(6 == wurf2) anz = anz + 1;
    if(6 == wurf3) anz = anz + 1;
    return anz;
  }
  
  int wirf() {
      return (int) ((Math.random() * 6) + 1);
  }
  

  Scanner sc = new Scanner(System.in);
  int einlesen(String wert) {
    System.out.println("Bitte " + wert + " eingeben: ");
    return sc.nextInt();
  }
  
} // end of class Chuck_A_Luck
                

Lösung von: Philipp Gressly Freimann (SANTIS Training AG)

#!/usr/bin/ruby                                                                 
                                                                                
# @autor Philipp Gressly Freimann                                               
# 2011 März                                                                      
# Chuch-a-Luck                                                                  
                                                                                
def einlesen(wert)                                                              
  print "Bitte #{wert} eingeben:"                                               
  # Dezimalzahl (real) einlesen:                                                
  return STDIN.gets.to_f                                                        
end                                                                             
                                                                                
def simuliere(einsatz)                                                          
  wurf1 = wirf()                                                                
  wurf2 = wirf()                                                                
  wurf3 = wirf()                                                                
  anz6  = zaehleAnzahlSechser(wurf1, wurf2, wurf3)                              
  if(1 == anz6): return einsatz + 1 end                                         
  if(2 == anz6): return einsatz + 2 end                                         
  if(3 == anz6): return einsatz + 3 end                                         
  return 0 # Kein Gewinn                                                        
end                                                                             
                                                                                
def wirf()                                                                      
  return 1 + rand(6)                                                            
end                                                                             
                                                                                
def zaehleAnzahlSechser(wurf1, wurf2, wurf3)                                    
  anz = 0                                                                       
  if(6 == wurf1): anz = anz + 1 end                                             
  if(6 == wurf2): anz = anz + 1 end                                             
  if(6 == wurf3): anz = anz + 1 end                                             
  return anz                                                                    
end                                                                             
                                                                                
# START                                                                         
                                                                                
einsatz                = 1                                                      
kapital                = einlesen("Startkapital")                               
simulationen           = einlesen("Simulationen")                               
                                                                                
# starte simulation:                                                            
aktuelleSimulation = 1                                                          
while(aktuelleSimulation <= simulationen)                                       
  kapital = kapital - einsatz                                                   
  gewinn  = simuliere(einsatz)                                                  
  kapital = kapital + gewinn                                                    
  aktuelleSimulation = aktuelleSimulation + 1;                                  
end                                                                             
puts "Es verbleiben #{kapital} Euro."   
                

Lösung von: Philipp Gressly Freimann (SANTIS Training AG)

import random
s = 1000 # Startkapital = 1000 Euro
for n in range (1000): # 1000 Runden
    a = random.randint(1,6)
    b = random.randint(1,6)
    c = random.randint(1,6)
    s = s - 1
    if a==6 or b==6 or c==6:
        s = s + 1
    if a==6:
        s = s + 1
    if b==6:
        s = s + 1
    if c==6:
        s = s + 1
print "Sie haben noch", s, "Euro"
                

Lösung von: Dmitriy Khoroshev (Schweizerische Alpine Mittelschule Davos)

/*--- Programm-Parameter ---*/                       
DCL KO_RUNDEN        BIN FIXED(31) VALUE(1000);      
DCL KO_ANZWURF       BIN FIXED(31) VALUE(3);         
DCL ZW_KAPITAL       BIN FIXED(31) INIT(1000) STATIC;
                                                     
/*--- Interne Variablen ---*/                        
DCL IND_RUNDE        BIN FIXED(31) INIT(0);          
DCL IND_WURF         BIN FIXED(31) INIT(0);          
DCL IND_TREFFER      BIN FIXED(31) INIT(0);          
DCL ZAHL(KO_ANZWURF) BIN FIXED(31) INIT(0,0,0);      
DCL ZW_RUNDE         PIC'ZZZ9'     INIT(0);          
DCL ZW_ZAHL          PIC'9'        INIT(0);          
DCL ZW_GEWINNP       PIC'9'        INIT(0);          
DCL ZW_KAPITALP      PIC'ZZZ9'     INIT(ZW_KAPITAL); 
                                                     
/*--- Programm ---*/                                 
DO IND_RUNDE = 1 TO KO_RUNDEN;                                   
  IND_TREFFER = 0; /* Init pro Runde */                          
  ZW_KAPITAL -= 1; /* Einsatz = 1.- */                           
  ZW_RUNDE = IND_RUNDE;                                          
  PUT SKIP EDIT('Runde ' !! TRIM(ZW_RUNDE))(A);                  
  PUT EDIT('. Ihre Zahlen: ')(A);                                
  DO IND_WURF = 1 TO KO_ANZWURF;                                 
    ZAHL(IND_WURF) = TRUNC((RANDOM()*6)+1);                      
    ZW_ZAHL = ZAHL(IND_WURF);                                    
    PUT EDIT(ZW_ZAHL !! ' ')(A);                                 
    IF(ZAHL(IND_WURF)) = 6 THEN IND_TREFFER += 1;                
  END; /* IND_WURF = 1 TO KO_ANZWURF */                          
  SELECT(IND_TREFFER);                                           
    WHEN(0) PUT SKIP LIST(' > Sorry, leider nichts gewonnen.');  
    WHEN(1,2,3) DO;                                              
      ZW_GEWINNP = IND_TREFFER;                                  
      PUT SKIP LIST(' > Cool, du hast soeben ' !! ZW_GEWINNP !!  
                     ' CHF gewonnen');                           
      ZW_KAPITAL += (IND_TREFFER + 1); /* Plus Einsatz zurück */ 
    END;                                                         
    OTHER DO;                                                    
      PUT SKIP LIST('FEHLER: Mehr als 3 Zahlen gezogen.');       
      PUT SKIP LIST('Bitte Programm prüfen.');                   
      IND_RUNDE = KO_RUNDEN;                                     
    END;                                                         
  END; /* SELECT(IND_TREFFER); */                                
  ZW_KAPITALP = ZW_KAPITAL;                                      
  PUT SKIP LIST(' > Dein Kapital: ' !! ZW_KAPITALP !! ' CHF');   
END; /* IND_RUNDE = 1 TO KO_RUNDEN */     
PUT SKIP LIST('=== ENDE ===');            
                

Lösung von: Valentin Marolf (AXA)

'Solution for VBA

'Spieleinstellungen
Const Runden As Integer = 1000              'Anzahl Runden
Const StartKapital As Integer = 1000        'Startkapital in CHF
Const Einsatz As Integer = 1                'Einsatz in €
Const Gewinn As Integer = 1                 'Gewinn in €
Const Gewinnziffer As Byte = 6              'Gewinn bei Ziffer 6
Const Wuerfel As Byte = 3                   'Anzahl Wuerfel pro Wurf


'Aufrufende Prozedur
Sub Chuck_a_Luck()

'Variablen
Dim i As Long                               'Schleifenvariable
Dim Kasse As Long                           'Aktuelles Vermögen des Spielers

'Initialisierung
Kasse = StartKapital * 0.88                 '1CHF=0,88€

'Routine
For i = 1 To Runden
    Kasse = (Kasse - Einsatz) + (Werfen * Gewinn)
Next i

Debug.Print Kasse

End Sub

'Gibt false zurück, wenn keine Sechs geworfen wurde
Private Function Werfen() As Byte
'Variablen
Dim i As Byte                               'Schleifenvariable
Dim count As Byte                           'Trefferzahl

'Initialisierung
count = 0
Randomize

'Routine
For i = 1 To Wuerfel
    If Int(6 * Rnd + 1) = Gewinnziffer Then
        count = count + 1
    End If
Next i

'Rückgabe
Werfen = count
    
End Function
                

Lösung von: Felix Reinhold ()

//Simulation von Chuck-a-Luck

#include <iostream>
#include <stdlib.h>

int wuerfeln();

int main(void)	{
	int einsatz, runden;
	std::cout << "Wie viel Geld: ";
	std::cin >> einsatz;
	std::cout << "Wie viele Runden: ";
	std::cin >> runden;
	for(int i = 0; i < runden; i++)	{
		einsatz--;
		int treffer = 0;
		for(int j = 0; j < 3; j++)	{
			if((rand() % 6 + 1) == 6)	{
				treffer++;
			}
		}
		einsatz += treffer;	
		if(einsatz == 0)	{
			std::cout << "Sie haben nach der " << i << " Runde kein Geld mehr!!" << std::endl;
			break;
		}
	}
	std::cout << "\n\n";
	std::cout << "Sie haben noch: " << einsatz << "\n\n";
	system("pause");
	return 0;
}
                

Lösung von: Name nicht veröffentlicht

;Programmiersprache: PureBasic, Version 4.60

OpenConsole()

PrintN("Wie hoch ist das Startkapital? (Euro)")
kapital = Val(Input())
PrintN("Wie viele Runden sollen simuliert werden?")
runden = Val(Input())

For i = 0 To runden
  PrintN("Runde Nummer "+Str(i)+", Kapital: "+Str(kapital))
  wurf1 = Random(5)+1
  wurf2 = Random(5)+1
  wurf3 = Random(5)+1
  
  kapital = kapital - 1
  PrintN("Zahle Einsatz! - 1 Euro!")
  
  If wurf1 = 6 Or wurf2 = 6 Or wurf3 = 6
    kapital = kapital+1
    PrintN("Ein Würfel zeigt eine 6! + 1 Euro!")
    If wurf1 = 6
      kapital = kapital+1
      PrintN("Wurf 1 ist eine 6! + 1 Euro!")
    EndIf
    If wurf2 = 6
      kapital = kapital+1
      PrintN("Wurf 2 ist eine 6! + 1 Euro!")
    EndIf
    If wurf3 = 6
      kapital = kapital+1
      PrintN("Wurf 3 ist eine 6! + 1 Euro!")
    EndIf
  Else
    PrintN("Verloren! kein Würfel zeigt eine 6!")
  EndIf
    
 
Next i

PrintN("Der Endstand nach "+Str(runden)+" Runden beträgt "+Str(kapital)+" Euro.")
Input()
                

Lösung von: Ich Bins (tubs)

// Copyright 2012, Christian J. Kiewiet.
//
///////////////////////////////////////////////////////////////////////////////
// Lösung zur Aufgabenstellung ``Chuck-a-Luck (Simulationen)''
//
// ``Simuliere das Spiel Chuck-a-luck. Bei diesem Spiel bezahlt der Spieler pro
// Runde Euro 1.- als Einsatz.  Er darf nun nacheinander drei Würfel werfen.  
// Zeigt mindestens ein Würfel eine 6, so erhält  er zunächst den Einsatz 
// zurück. Zudem erhält er für jede geworfene 6 Euro 1.- als Gewinn ausbezahlt. 
// Liegt keine 6, so verliert er den Einsatz. Starten Sie mit einem Kapital 
// von CHF 1'000.- und simulieren Sie 1000 Runden.''
///////////////////////////////////////////////////////////////////////////////
#include <cstdlib>
#include <iostream>

class ChuckALuck {
  public:
    /** Seeds the PRNG with the current time in seconds. */
    inline ChuckALuck () { srand(time(0)); }
    
    /** Performs |kSimulations| dice rolls with three dice.  Every every dice
     * showing six, the player's capital is increased by 1.  Returns the
     * capital after all simulations, aborts on depletion of capital. */
    int Simulate() {
      int capital(kInitialCapital);
      for (int i = kSimulations; i-- && capital--; )
        for (int i = 3, j = 0; i--; j += static_cast<int>((rand() % 6) == 5),
                                    capital += j);
      return capital;
    }
    
  private:
    static const int kInitialCapital = 1000;
    static const int kSimulations = 1000;
};

int main(int argc, char* argv[]) {
  ChuckALuck game;
  game.Simulate();
}
                

Lösung von: Christian Kiewiet ()

#!/usr/bin/python3

#http://www.programmieraufgaben.ch/aufgabe/chuck-a-luck/c3u0jrfq

#zufallsgenerator importieren, initialisieren
import random
random.seed()

#Starteinsatz 1000€
einsatz = 1000
print("Dein Starteinsatz beträgt 1000€ gespielt werden 1000 Runden")
runde = 0
while not runde == 1000:
    
#pro Runde 1€ Einsatz
    einsatz = einsatz - 1

#Nacheinander 3 Würfel werfen
    wuerfel1 = random.randint(1,6)
    wuerfel2 = random.randint(1,6)
    wuerfel3 = random.randint(1,6)
    runde = runde + 1

#zeigt 1 Würfel eine 6 -> Einsatz zurück
    if wuerfel1 == 6:
        einsatz = einsatz + 1
    
#für jede weitere 6 1€ gewinn
    if wuerfel2 == 6:
        einsatz = einsatz + 1
    if wuerfel3 == 6:
        einsatz = einsatz + 1
print(runde, "wurden gespielt", einsatz, "€ habe ich noch")

                

Lösung von: Name nicht veröffentlicht

program ChuckALuck (input, output);
{ Bei diesem Spiel bezahlt der Spieler pro Runde Euro 1.- als Einsatz.  Er darf nun nacheinander drei Würfel werfen.  Zeigt mindestens ein Würfel eine 6, so erhält  er zunächst den Einsatz zurück.
Zudem erhält er für jede geworfene 6 Euro 1.- als Gewinn ausbezahlt. Liegt keine 6, so verliert er den Einsatz.
Starten Sie mit einem Kapital von 1'000.- und simulieren Sie 1000 Runden. }

  const
  STARTWERT = 1000;
  RUNDEN = 1000;
  WURFANZAHL = 3;
  WUERFELSEITEN = 6;

  var
  Geld,
  i, j: integer;
  bankrott,               // wird gesetzt wenn einem das Geld ausgeht.
  sechsGeworfen: boolean; // wird gesetzt wenn man diese Runde 6 gew. hat.

begin
  { initialisieren }
  Randomize; { Zufallszahlengenerator initialisieren }
  Geld := STARTWERT;
  bankrott := false;
  i := 1;

  { "Simulation": }
  while (i <= RUNDEN) and (not bankrott) do
  begin
    i := i + 1;
    Geld := Geld - 1;
    sechsGeworfen := false;

    for j := 1 to WURFANZAHL do
      if (Random(WUERFELSEITEN) + 1) = WUERFELSEITEN then
      begin
        Geld := Geld + 1;
        sechsGeworfen := true;
      end; { if (Random(WUERFELSEITEN) + 1) = WUERFELSEITEN then }

    if sechsGeworfen then
      Geld := Geld + 1;

    if Geld = 0 then
      bankrott := true;
  end; { while (i <= RUNDEN) and (not bankrott) }

  { Endausgabe: }
  if bankrott then
    writeln('Sie sind leider vor dem Ende bankrott gegangen')
  else
    writeln('Rest: ', Geld);

end. { ChuckALuck }

                

Lösung von: Patrick Reif ()

# Python 3.4.2

from random import randint

kapital = 1000

for i in range(1001):
    ergebnisse = list()
    kapital -= 1
    for wurf in range(3):
        augenzahl = randint(1, 6)
        ergebnisse.append(augenzahl)

    # Mindestens eine 6: Einsatz zurueck
    if 6 in ergebnisse:
        kapital += 1

    # Fuer jede 6 den Gewinn ausbezahlen
    for i in ergebnisse:
        if i == 6:
            kapital += 1

print('Kapital nach 1000 Runden:', kapital)
                

Lösung von: Hilli Hilli ()

<?php

	/**
	* Chuck-a-Luck
	* @author Lukas Müller
	*/
	
	$wuerfe = array(rand(1, 6),rand(1, 6),rand(1, 6));
	$treffer_mittelwert = array();
	$kapital = 1000;
	for($i = 0; $i <= $kapital; $i++){
		$wuerfe = array(rand(1, 6),rand(1, 6),rand(1, 6));
		$zaehler = 0;
		for($h = 0; $h <=3; $h++){
			if($wuerfe[$h] == 6){
				$zaehler++;
			}
		}
		$treffer_mittelwert[$i] = $zaehler;
		switch ($zaehler){
			case 0:
				$kapital--;
			break;
			case 1:
				$kapital++;
			break;
			case 2:
				$kapital += 2;
			break;
			case 3:
				$kapital += 3;
			break;
		}
	}
	echo "<p>Durchschnittlich hat man in einer Runde " . round(array_sum($treffer_mittelwert)/count($treffer_mittelwert), 3) . " sechser. <br />";
	echo "Das Endkapital beträgt $kapital.-</p>";
?>
                

Lösung von: Lukas Müller (Informatik Studium)

import random
runde = 0
guthaben = 1000

while runde < 1000:
    guthaben -=1
    wurfliste = []
    versuch = 0
    while versuch < 3:
        wurf = random.randint(1,6)        
        wurfliste.append(wurf)
        versuch +=1        
    if 6 in wurfliste:
        guthaben +=1   

    sechs_gewuerfelt = wurfliste.count(6)
    guthaben +=sechs_gewuerfelt#für jede gewürfelte sechs gibt es einen Euro
    runde+=1  

print(guthaben)
                

Lösung von: Py Thon ()

using System;

namespace Chuck_a_luck {
	class Program {
		static void Main() {
			Random rnd = new Random();
			int runde = 1, kapital = 1000;

			for (;
				runde <= 1000 && kapital > 0;
				runde++) {

				kapital--;

				for (int i = 0; i < 3; i++)
					if (rnd.Next(1, 7) == 6) kapital++;
			}

			Console.WriteLine("Das Spiel wurde in Runde {0} mit {1} Euro Kapital beendet", --runde, kapital);

			Console.ReadKey(true);
		}
	}
}
                

Lösung von: Marcel Kapma ()

var balance = 1000,
    i = 1;
    
function roll() {
   var j = 1;
   balance--;
   for(j; j <= 3; j++) 
      if (Math.round((Math.random() * 6) + 1) == 6) balance++;
}

for (i; i <= 1000; i++) roll();
console.log("Guthaben nach 1000 Runden: " + balance + " €");

                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

object ChuckaLuckSimu extends App {
var Kapital:Int = 1000
var inti = scala.util.Random
var counter:Int = 0
var random_1 = inti.nextInt(7)
var random_2 = inti.nextInt(7)
var random_3 = inti.nextInt(7)
while(counter != 1000){
  Kapital = Kapital - 1
  if(random_1 == 0){
    random_1 = inti.nextInt(7)
  }
  else if(random_2 == 0){
    random_2 = inti.nextInt(7)
  }
  else if(random_3 == 1000){
    random_3 = inti.nextInt(7)
  }
  else{
    if(random_1 == 6){
      Kapital = Kapital + 1
    }
    if(random_2 == 6){
      Kapital = Kapital + 2
    }
    if(random_3 == 6){
      Kapital = Kapital +3
    }
    random_1 = inti.nextInt(7)
    random_2 = inti.nextInt(7)
    random_3 = inti.nextInt(7)
    counter = counter + 1
  }
}
println("Dein Kapital jetzt beträgt " + Kapital )
}
                

Lösung von: Name nicht veröffentlicht

import random
random.seed ()

Versuche= 1000
Kapital = 1000

while Versuche != 0:

    Kapital -= 1

    x1 = random.randint(1,6)
    if(x1) == 6:
        Kapital +=1
        print("juhhu")

    x2 = random.randint(1,6)
    if(x2) == 6:
        Kapital +=1

    x3 = random.randint(1,6)
    if(x3) == 6:
        Kapital +=1

    Versuche -= 1

print(Kapital)

                

Lösung von: La Ku ()

from random import randint
print(sum([1000]+[1 if 6 in [randint(1,6),randint(1,6),randint(1,6)] else (-1) for i in range(1000)]))
                

Lösung von: rob ert (tub)

REPORT WUERFELN.

DATA: lv_geld  TYPE int4 VALUE 1000,
      lv_wurf1 TYPE i,
      lv_wurf2 TYPE i,
      lv_wurf3 TYPE i.


DO 1000 TIMES.

lv_geld = lv_geld - 1.

CALL FUNCTION 'AKB_RANDOM'
 EXPORTING
   MIN           = 1
   MAX           = 6
 IMPORTING
   RND           = lv_wurf1.

CALL FUNCTION 'AKB_RANDOM'
 EXPORTING
   MIN           = 1
   MAX           = 6
 IMPORTING
   RND           = lv_wurf2.

CALL FUNCTION 'AKB_RANDOM'
 EXPORTING
   MIN           = 1
   MAX           = 6
 IMPORTING
   RND           = lv_wurf3.

IF (  lv_wurf1 <> 6 AND lv_wurf2 <> 6 AND lv_wurf3 <> 6 ).

ELSE.
    lv_geld = lv_geld + 1.

    If ( lv_wurf1 = 6 ).

        lv_geld = lv_geld + 1.

    ENDIF.

    IF ( lv_wurf2 = 6 ).

        lv_geld = lv_geld + 1.

    ENDIF.

    IF ( lv_wurf3 = 6 ).

        lv_geld = lv_geld + 1.

    ENDIF.

ENDIF.

ENDDO.

WRITE:/ lv_geld.
                

Lösung von: Name nicht veröffentlicht

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

using namespace std;

int main()
{
	srand(time(NULL));
	int kapital = 1000;
	int ergebnis;

	for (int i = 1; i < 1000; i++)
	{
		kapital--;
		for (int j = 1; j <= 3; j++)
		{
			ergebnis = rand() % 6;

			if (ergebnis == 5)
			{
				kapital++;
			}
		}
	}
	cout << kapital << endl;

	system("PAUSE");
}
                

Lösung von: Name nicht veröffentlicht

Private Sub CommandButton1_Click()
Dim einsatz As Integer
Dim result As Integer
Dim guthaben As Integer
Dim sechser As Integer


guthaben = 1000
einsatz = 1


For k = 0 To 1000
    guthaben = guthaben - einsatz
    sechser = 0
    For i = 0 To 2
        result = Int((6 * Rnd) + 1)
        If result = 6 Then
            guthaben = guthaben + einsatz
            sechser = sechser + 1
        End If
    
        If sechser >= 2 Then
            guthaben = guthaben + einsatz
        End If
    Next
Next
End Sub



                

Lösung von: Ozan Gümüstas ()

Verifikation/Checksumme:

Pro Spiel verliert man im Durchschnitt ca. 7.87 Cent (das entspricht einem Erwartungswert von 17/216 für das Casino, also für den Spielbetreiber).

Nach 1000 Simulationen sollten bei einem Startkapital von Euro 1000 noch ca. 920 Euro als Kapital übrig bleiben.

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit:
Schwierigkeit: k.A.
Webcode: c3u0-jrfq
Autor: Philipp Gressly Freimann (SANTIS Training AG)

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen