Frankengewinnspiel (Unterprogramme)
Das Spielfeld des Frankengewinnspiels besteht aus beliebig vielen, ab Eins (1) nummerierten Feldern. Auf jedem Feld gibt es einen Gewinn, welcher entsprechend der Feldnummer ist. Auf dem Feld 8 liegen 8.-- Fr. usw. Der Betrag von jedem Feld, das man besucht, darf als Gewinn mitgenommen werden.
Die Spielvorschrift besteht aus den folgenden Regeln:
- Wählen Sie ein Feld zwischen 1 und 99.
- Nehmen Sie das Geld und gehen Sie nach folgender Vorschrift zum nächsten Feld:
- Feldnummer ungerade? Feld ? Feld * 3 + 1
- Feldnummer gerade? Feld ? Feld / 2
Wiederholen Sie Schritt 2, bis Sie auf dem Feld 1 landen.
- Schreiben Sie ein Unterprogramm, welches zu einem gewählten Startwert den Gewinn ausgibt.
- Schreiben Sie ein Programm, welches die Gewinne für alle 99 Startmöglichkeiten ausgibt.
- Was ist der maximale Gewinn dieses Spiels?
- Wie heißt die höchste erreichte Feldnummer, wenn Sie den Startwert frei wählen? Ergänzen Sie dazu das Programm aus Aufgabe c).
Hinweis: Die Spielvorschrift dieser Aufgabe ist als Collatz-FolgeLothar Collatz (1910 - 1990) oder Ulam-SequenzStanislaw Ulam (1909 - 1984) bekannt.
0 Kommentare
Bitte melde dich an um einen Kommentar abzugeben
10 Lösung(en)
/**
* 4_46 Frankengewinnspiel
*
* @author Martin Guggisberg
* @version 1.0
*/
public class Frankengewinnspiel
{
public static void main(String[] args){
new Frankengewinnspiel().start();
}
public void start()
{
// Alle 99 Felder durchspielen
for (int i = 1; i < 100; i = i + 1){
System.out.println("Startposition: "+i+" Gewinnsumme: "+spiel(i));
}
}
/**
* Collatzfolge für startwert
* Ausgabe auf den Bildschirm
*
* @param platz = startwert
*
*/
public int spiel(int platz)
{
int summe = 0;
while (platz != 1){
summe = summe + platz;
// alle erreichten Felder auch ausgeben (folgende Zeile auskommentieren)
// System.out.print(platz + " ");
if (ungerade(platz)){
platz=platz*3+1;
}
else{
platz = platz / 2;
}
}
summe = summe + 1; // 1 addieren als letzter Platz
return summe;
}
boolean ungerade(int zahl){
return 1 == zahl % 2;
}
}
def spiel(platz):
summe=0
while(platz!=1):
summe = summe +platz
if platz % 2 == 1:
platz = platz * 3 + 1
else:
platz = platz/2
return summe
for i in range(1, 99):
print 'Startposition ' +repr(i).rjust(2)+ ' Gewinn ' + repr(spiel(i))
function gewinnBerechnen() {
var startFeld = document.getElementById("startwert").value;
if (startFeld == "all") alleGewinneBerechnen();
else if (startFeld == "clear") websitenInhaltLoeschen();
else einGewinnBerechnen(startFeld, true);
}
function alleGewinneBerechnen() {
var maximalGewinn = 1;
var momentanerGewinn = 0;
for (startFeld = 1; startFeld <= 99; startFeld++) {
momentanerGewinn = einGewinnBerechnen(startFeld, false);
if (maximalGewinn < momentanerGewinn) maximalGewinn = momentanerGewinn;
}
ausgabe("Grösstmöglicher Gewinn", maximalGewinn);
}
function einGewinnBerechnen(startFeld, startwertGewaehlt) {
var aktuellesFeld = startFeld * 1;
var hoechstesFeld = 1;
var gesamtGewinn = 0;
while (aktuellesFeld > 1) {
if (hoechstesFeld < aktuellesFeld) hoechstesFeld = aktuellesFeld;
gesamtGewinn += aktuellesFeld;
aktuellesFeld = aktuellesFeldBerechnen(aktuellesFeld);
}
gesamtGewinn++;
ausgabe(startFeld, gesamtGewinn);
if (startwertGewaehlt) ausgabe("Höchstes erreichtes Feld", hoechstesFeld);
return gesamtGewinn;
}
function aktuellesFeldBerechnen(aktuellesFeld) {
if (aktuellesFeld % 2 == 0) return aktuellesFeld / 2;
return aktuellesFeld * 3 + 1;
}
function ausgabe(startWert, gewinn) {
var body = document.getElementById("body");
var neuerParagraph = document.createElement("p");
neuerParagraph.innerHTML = startWert + ": " + gewinn;
body.appendChild(neuerParagraph);
}
********************************************************************
*** HTML ********************************************************
********************************************************************
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>PHP - Seite</title>
<meta name="author" content="Tobias Widner" />
<meta name="version" content="04.04.2012 V. 1.0" />
<script type="text/javascript" src="code.js" />
</head>
<body id="body">
<h1>PHP - Seite</h1>
<p>Feldnummer eingeben: [1-99]</p>
<p><input type="text" id="startwert" /></p>
<p><input type="button" value="Let's rumble!" onclick="gewinnBerechnen()" id="starten" /></p>
<p><span id="gewinnAusgabe">Gewinn: </span></p>
</body>
</html>
Lösung von: Tobias Widner (SANTIS TRAINING AG / CS)
*&---------------------------------------------------------------------*
*& Report ZTCOLLATZ
*&
*&---------------------------------------------------------------------*
*& Ich habe die Lösung ein wenig angepasst so, wie ich
*& sie für interessant hielt. LG
*&---------------------------------------------------------------------*
REPORT ztcollatz.
DATA: p_start TYPE i,
p_mod TYPE i,
p_cur_sum TYPE I.
DO 99 TIMES.
WRITE: / 'This is the solution for startfield: ', sy-index.
p_start = sy-index.
PERFORM solvecollatz.
WRITE: /.
WRITE: / p_cur_sum, 'Franken, have been collected.'.
WRITE: / '--------------------------------------------------------------'.
p_cur_sum = 0.
ENDDO.
*&---------------------------------------------------------------------*
*& Form SOLVECOLLATZ
*&---------------------------------------------------------------------*
FORM solvecollatz.
p_cur_sum = p_cur_sum + p_start.
WRITE / p_start.
IF p_start EQ 1.
EXIT. "ende der rekursion
ELSE.
p_mod = p_start MOD 2.
IF p_mod EQ 0. "wenn p_start gerade
p_start = p_start / 2.
PERFORM solvecollatz.
ELSE. "wenn startwert ungerade
p_start = p_start * 3 + 1.
PERFORM solvecollatz.
ENDIF.
ENDIF.
ENDFORM. " SOLVECOLLATZ
Lösung von: Benjamin Kluszynski (( Coder :-) ))
/**
* Frankengewinnspiel aus Programmieraufgaben.ch
* @version 0.1 (Feb 27, 2015)
* @author Philipp Gressly Freimann
* (philipp.gressly@santis.ch)
*/
public class FrankenGewinnSpiel {
public static void main(String[] args) {
new FrankenGewinnSpiel().top();
}
int maximalgewinn = 0;
int hoechsteFeldnummer = 0;
/* Haupt Einstiegspunkt */
void top() {
for(int i = 1; i < 100; i++) {
System.out.println("Gewinn für Feld " + i + " ist " + gewinn(i));
}
System.out.println("Das höchste Feld ist " + hoechsteFeldnummer);
System.out.println("Der Maximalgewinn beträgt " + maximalgewinn + " Fr.");
}
int gewinn(int i) {
if(i > hoechsteFeldnummer) {
hoechsteFeldnummer = i;
}
int gewinn = i;
if(1 == i) {return 1;} // Abbruch bei i = 1
if(gerade(i)) {
gewinn = gewinn + gewinn(i / 2);
} else {
gewinn = gewinn + gewinn(i * 3 + 1);
}
if(gewinn > maximalgewinn) {
maximalgewinn = gewinn;
}
return gewinn;
}
boolean gerade(int i) {
return 0 == i%2;
}
} // end of class FrankenGewinnSpiel
Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)
var maxSum = 0,
maxField = 0,
currRes = [],
listAllFields = confirm("Alle besuchten Felder auflisten?"),
i = 1;
function play(field) {
var fields = [];
while (field > 1) {
fields.push(field);
if (field % 2 == 0) field /= 2;
else field = field * 3 + 1;
}
fields.push(1);
return[fields, eval(fields.join("+"))]; // gibt die felder und die summe zurück
}
// ausgabe
document.write("<p>");
for (i; i <= 99; i++) {
currRes = play(i);
document.write("<b>Startfeld " + i + "</b>: ");
if (listAllFields) document.write("[" + currRes[0].join(", ") + "] /// ");
document.write(currRes[1] + " Fr.<br>");
maxSum = Math.max(maxSum, currRes[1]);
maxField = Math.max(maxField, Math.max.apply(Math, currRes[0]));
}
document.write(
'</p><p>' +
'Der maximale Gewinn dieses Spieles ist ' + maxSum + ' Fr.<br>' +
'Die höchste besuchte Feldnummer war ' + maxField + '.</p>'
);
Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)
using System;
public class Program
{
public static void Main()
{
int totalS = 0;
int totalF = 0;
Spiel myGame = new Spiel();
for (int i=1; i<100;i++)
{
myGame.Summe=1;
myGame.HoechstesFeld = 1;
myGame.Feld=i;
myGame.durchlauf();
Console.WriteLine("{0} | {1},-", i, myGame.Summe);
if (myGame.Summe > totalS)
totalS=myGame.Summe;
if (myGame.HoechstesFeld > totalF)
totalF=myGame.HoechstesFeld;
}
Console.WriteLine("max Gewinn {0},- hoechstes Feld: {1}", totalS,totalF);
}
}
public class Spiel
{
public int Feld {get; set; }
public int Summe {get; set; }
public int HoechstesFeld {get; set; }
public void durchlauf()
{
while (Feld != 1)
{
if (Feld > HoechstesFeld)
HoechstesFeld = Feld;
Summe += Feld;
if (Feld % 2 == 0)
Feld = Feld/2;
else
Feld = Feld*3+1;
}
}
}
Lösung von: Name nicht veröffentlicht
class Rueckgabe():
def __init__(self, feld, boerse):
self.feld = feld
self.boerse = boerse
def gewinn(feld):
boerse = 0
groesstesFeld = 0
while feld != 1:
if feld > groesstesFeld:
groesstesFeld = feld
boerse = boerse + feld
if feld % 2 == 1:
feld = feld * 3 + 1
else:
feld //= 2
t = Rueckgabe(groesstesFeld, boerse + 1)
return t
maxFeld = 0
maximum = 0
groesstesFeld = 0
for i in range(1, 100):
if gewinn(i).boerse > maximum:
maximum = gewinn(i).boerse
maxFeld = i
if gewinn(i).feld > groesstesFeld:
groesstesFeld = gewinn(i).feld
print(i, gewinn(i).boerse)
print("Maximum", maximum, "bei Feld: ", maxFeld)
print("Hoechstes Feld: ", groesstesFeld)
Lösung von: Peter Pan (Home Office)
// NET 7.x | C# 11.x | VS-2022
// beliebiger Startwert (hier: 57)
Console.WriteLine($"Gewinn: {Game(57).MaxValue}\n");
// Startwerte von 1 bis 99
var games = Games(1, 100).ToList();
games.ForEach(g => Console.WriteLine($"Startfeld: {g.StartField} | Gewinn: {g.MaxValue} | Höchstes Feld: {g.MaxField}\nFelder: {string.Join(", ", g.Fields)}\n"));
Console.WriteLine($"Maximaler Gewinn: {games.Max(x => x.MaxValue):###,##0}");
Console.WriteLine($"Höchste Feldnummer: {games.Max(x => x.MaxField):###,##0}");
static IEnumerable<int> Collatz(int n) {
if (n < 1) yield break;
yield return n;
do {
n = (n % 2 == 0) ? n / 2 : 3 * n + 1;
yield return n;
} while (n > 1);
}
static FieldType Game(int n) {
var col = Collatz(n);
return new FieldType(n, col.ToList(), col.Max(), col.Sum());
}
static IEnumerable<FieldType> Games(int first, int last) {
for (var i = first; i < last; i++)
yield return Game(i);
}
record struct FieldType(int StartField, IEnumerable<int> Fields, int MaxField, int MaxValue);
Lösung von: Jens Kelm (@JKooP)
// C++ 20 | VS-2022
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <sstream>
struct fieldtype {
const int start_field;
const std::vector<int> fields;
const int max_field;
const int max_value;
};
auto string_join{ [] <typename T>(const std::vector<T>&v, const char* sep = ", ") -> std::string {
if (v.empty()) return "";
std::ostringstream os;
std::copy(v.begin(), v.end() - 1, std::ostream_iterator<T>(os, sep));
os << v.back();
return os.str();
} };
auto collatz(int n) {
std::vector<int>v{};
if (n < 1) return v;
v.push_back(n);
do {
n = !(n & 1) ? n / 2 : 3 * n + 1;
v.push_back(n);
} while (n > 1);
return v;
}
auto game(int n) -> fieldtype {
const auto col{ collatz(n) };
return{ n, col, *std::max_element(col.begin(), col.end()), std::accumulate(col.begin(), col.end(), 0) };
}
auto games(int first, int last) {
std::vector<fieldtype>v{};
for (auto i{ first }; i < last; ++i)
v.push_back(game(i));
return v;
}
auto operator<<(std::ostream& os, const fieldtype& ft) -> std::ostream& {
os << "Startfeld: " << ft.start_field << " | ";
os << "Gewinn: " << ft.max_value << " | ";
os << "Hoechstes Feld: " << ft.max_field;
os << "\nFelder: " << string_join(ft.fields) << "\n";
return os;
}
inline constexpr auto print{ [] <typename T>(const T & t) { for (const auto& i : t) std::cout << i << "\n"; } };
inline constexpr auto maxima{ [] <typename T, typename F>(const T & t, const F & f) { return *std::max_element(t.begin(), t.end(), f); } };
auto main() -> int {
// beliebiger Startwert (hier: 57)
std::cout << "Gewinn: " << game(57).max_value << "\n";
// Startwerte von 1 bis 99
const auto g{ games(1, 100) };
print(g);
// Maxima
const auto max_val{ maxima(g, [](auto a, auto b) {return b.max_value > a.max_value; }) };
const auto max_fld{ maxima(g, [](auto a, auto b) {return b.max_field > a.max_field; }) };
std::cout << "Maximaler Gewinn: " << max_val.max_value << "\n";
std::cout << "Hoechste Feldnummer: " << max_fld.max_field << "\n";
}
Lösung von: Jens Kelm (@JKooP)
Verifikation/Checksumme:
a, b) In=1: Out=1; In=2: Out=3; In=15: Out=694
c) In= 63; Out=105 098
d) In=27; Maxfeld=9232
Aktionen
Neue Lösung hinzufügen
Bewertung
Durchschnittliche Bewertung:
Meta
| Zeit: | |
| Schwierigkeit: | k.A. |
| Webcode: | qnfv-rirb |
| Autor: | Stefan Dürrenberger (IDM Studios GmbH) |