Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Kokosnuss-Problem (Unterprogramme)

In einer stürmischen Sommernacht sind die drei Piraten Peter, Jack und William von ihrem Piratenschiff gespült wurden. Glücklicherweise konnten sie sich auf einer einsamen Insel retten.

Am nächsten Morgen stellen sie fest, dass es neben reichlich Trinkwasser auch jede Menge Kokosnüsse und eine paar friedliche Tiere auf der kleinen Insel gibt. 

Da sie nichts zu essen haben, sammeln sie den ganzen Tag lang einen großen Haufen Kokosnüsse und wollen diesen dann später gerecht aufteilen. Jedoch bricht die Dunkelheit früher als erwartet herein, die Müdigkeit macht sich längst breit und so wird die Teilung auf den nächsten Tag verschoben.

In der Nacht wacht Peter auf. Er traut den anderen beiden nicht über den Weg und möchte sich daher sein Drittel schon mal sichern. So zählt er die Kokosnüsse, teilt die gesamte Anzahl durch drei und versteckt seinen Anteil unweit der Quelle unter Laub und Sand. Bei seiner Rechnung ergibt sich ein Rest von einer Nuss, die er kurzerhand einem Affen spendiert und sich danach wieder beruhigt Schlafen legt.

Nur eine Stunde später erwacht Jack. Auch er will sich seinen Teil vorab sichern, schafft ein Drittel von den noch vorhandenen Nüssen zur Seite und gibt eine Nuss - die beim Teilen übrig bleibt - einem Affen. Anschließend geht auch er wieder schlafen.

Das gleiche Schauspiel vollzieht sich später in der Nacht ein drittes Mal. Auch William wird wach und abermals erhält ein Affe eine Nuss, da auch dieses Mal die Division nicht glatt aufgeht.

Tags darauf sagt aus Scham keiner der Piraten etwas über den arg geschrumpften Haufen und so wird nochmals durch drei geteilt. Wieder erhält ein Affe eine Nuss, da die Division nicht aufgeht.

Nun die Rätselfrage: Wie viele Kokosnüsse haben die drei Piraten Peter, Jack und William am Tag vorher mindestens gesammelt?

0 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

9 Lösung(en)

public class Kokonusproblem {

    static boolean valid(int n, int nuesse) {
	for (int k = n; k != 0; k--, nuesse -= 1 + nuesse / n)
	    if (nuesse % n != 1)
		return false;
	return nuesse != 0 && (nuesse % n == 0);
    }

    public static void main(String[] args) {
	int x = 0;
	for (int n = 3; n < 10; n++) { // für 3 bis 9 Piraten
	    while (!valid(n, x))
		x++;
	    System.out.printf("%d: %d%n", n, x);
	}
    }
}

                

Lösung von: Houssein Fofana ()

function isMinumumHeap(num) {
  for (var i = 1; i <= 4; i++) {
    if (num % 3 != 1) return false;
    num -= (num - 1) / 3;
  }
  return true;
}

var coconuts = 1;
while (!isMinumumHeap(coconuts * 3 + 1)) coconuts++;
console.log(
  "Die Piraten hatten mindestens " + (--coconuts * 3 + 1) +
    " Kokosnüsse gesammelt."
);
/* Bleibt nur noch die frage: warum muss man kokosnüsse horten und eventuelle
|  anteile an dahergelaufene affen verfüttern, nur damit mitmenschen einen 
|  nicht übervorteilen können? Und das, obwohl noch viele kokosnüsse in hülle
|  und fülle vorhanden sind... Versteh einer die kapitalisten.
----------------------------------------------------------- lissalanda@gmx.at */
                

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

/**
 * 2016-08-04
 * @author Sam Yiming Miao
 */
package ch.toastgott.programmieraufgaben;

public class Kokusnussproblem {
	public static void main(String[] args) {
		int total_coconut = 0;
		int new_coconut = 0;
		int repetitions = 0;
		while (repetitions != 4) {
			if (new_coconut % 3 == 1) {
				new_coconut--;
				new_coconut -= new_coconut / 3;
				repetitions++;
			} else {
				total_coconut++;
				new_coconut = total_coconut;
				repetitions = 0;
			}
		}
		new_coconut /= 2;
		System.out.println("Damit die Geschichte logisch ist, müssen mindestens " + total_coconut + " Kokusnüsse vorhanden sein.");
		System.out.println("Nach der letzten Teilung erhält jeder Pirat " + new_coconut + " Kokusnüsse.");
	}
}
                

Lösung von: Sam Yiming Miao (Schule ist gut genug)

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

using namespace std;

int wieVieleKokusnuse(int wieVieleSchon, int wieLangeNoch)
{
	if(wieLangeNoch > 0)
	{
		wieVieleSchon *= 3;
		wieVieleSchon++;
		wieLangeNoch--;
		wieVieleSchon = wieVieleKokusnuse(wieVieleSchon, wieLangeNoch);
	}
	return wieVieleSchon;
}

int main()
{
	int min = wieVieleKokusnuse(1, 4);
	cout << "Sie haben mindistens " << min << " Kokusnuese gesamelt" << endl;
	return 0;
}

                

Lösung von: Name nicht veröffentlicht

package coconut;

public class Coconut {
	public static void main (String[] argv) {
		int CocoCount = CoconutDilema(4, 3);
		System.out.println(CocoCount);
	}

	public static int CoconutDilema(int n, int div) {
		int sum = div+1; 
		for(int x=1; x < n; x++){
			sum = sum*div + 1;
		}
		return sum;
	}
	
	public static int CoconutDilema(int n) {
		return CoconutDilema(n, 3);
	}
}
                

Lösung von: Daniel Peters ()

coco=0
while True:
    i=0
    temp=coco
    while i<4:
        if temp%3==1:
            temp-=1
            temp=int(temp*2/3)
            i+=1
        else:
            break
    if i==4:
        print(coco)
        break
    else:
        coco+=1
#Für die Faulen; die Lösung ist 79
                

Lösung von: Name nicht veröffentlicht

# Kokosnuss-Problem
# Author: Apop85

for nuts in range(1,10**6,3):
	split_1=((nuts-1)/3*2)
	split_2=((split_1-1)/3*2)
	split_3=((split_2-1)/3*2)
	if (nuts%3,split_1%3,split_2%3,split_3%3) == (1,1,1,1):
		print('Die Piraten haben mindestens '+str(nuts)+' Nüsse gesammelt.')
        break
                

Lösung von: Name nicht veröffentlicht

using System;

// Programmieraufgaben.ch Aufgaben-Code: hw5c-oehm

namespace KokosProblem
{
    class Program
    {
        static void Main()
        {
            // Variablen deklarieren
            int minHaufen = 1, currentHaufen;
            bool[] requirements = new bool[4];
            
            // Berechnung der "Haufen" Kokosnüsse
            while (!requirements[0] || !requirements[1] || !requirements[2] || !requirements[3])
            {
                minHaufen++;
                currentHaufen = minHaufen;
                for (int runs = 0; runs < requirements.Length; runs++)
                {
                    requirements[runs] = false;
                    requirements[runs] = HaufenMachen(currentHaufen);
                    currentHaufen = currentHaufen / 3 - 1;
                }
                // Console.WriteLine($"\t{requirements[0]}\t|\t{requirements[1]}\t|\t{requirements[2]}\t|\t{requirements[3]}\t|\t{minHaufen.ToString("000")}");
            }

            // Ausgabe
            Console.WriteLine($"Die Piraten müssen mindestens {minHaufen} Kokosnüsse gesammelt haben.");
        }
        static bool HaufenMachen(int number)
        {
            // Prüfe, ob eine Kokosnuss abgegeben wird
            if(number % 3 == 1)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }
}

                

Lösung von: Howard Dennis King (IT-Schule Stuttgart)

 public partial class Kokusproblem : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            //Schleife um die Anzahl der Piraten zu erhöhen. Ab 8+ wird die Berechnung rapide langsamer.
            for (int piraten = 3; piraten <= 7; piraten++)
            {
                //Wieviel Prozent nach einem Diebstahl übrig bleiben z.B 2/3 bei 3 Piraten oder 6/7 bei 7 Piraten.
                double prozente = ((double)(piraten - 1)) / ((double)piraten);
                //Eine leere Liste von Größen der einzelnen Kokusnusshaufen.
                List<long> list = new List<long>();
                //Startwert für den Kokusnusshaufen
                long i = 2*piraten + 1;

                //Schleife die so lange läuft bis es eine Liste von Zahlen gibt, die das Problem lößt:
                //zB:   3 Piraten:79->52->34->22->14
                //oder: 4 Piraten: 1021->765->573->429->321->240
                //Die Liste muss immer 2 länger sein, als die Anzahl der Piraten
                while (list.Count() < piraten + 2)
                {   
                    //vor jedem Durchlauf wird die Liste geleert
                    list.Clear();
                    //Kopie der größe des aktuellen Haufens
                    double j = i;
                    //Hinzufügen des ersten Wertes, der am Ende die Lösung sein könnte
                    list.Add(i);

                    //Nun wird so lange der Haufen verkleinert, wie es noch ganzzahlige kleinere Haufen ergibt.
                    bool isn = true;
                    while (isn)
                    {
                        //errechnen des nächst kleineren Haufens
                        j = (j - 1) * prozente;
                        //Hilfsfunktion, um zu prüfen ob das Ergebnis eine natürlich Zahl ist.
                        isn = isN(j);
                        //Wenn die Zahl natürlich ist wird sie der Liste angefügt.
                        if (isn) 
                        {
                            list.Add((long)j); 
                        }
                    }
                    //Der Haufen wird auf die nächst sinnvolle Größe erhöht, um erneut zu prüfen ob es eine Lösung gibt.
                    i = i + piraten;
                }
                //Ausgabe des Ergebnisses für die jeweilige Anzahl der Piraten
                Response.Write(piraten+ " Piraten:"+ list.FirstOrDefault()+ "<br>");
            }
        }

        //Gibt true oder false je nachdem ob eine natürliche Zahl übergeben wurde.
        private bool isN(double j)
        {
            long t = 0;
            return long.TryParse(j.ToString(), out t);
        }
    }
                

Lösung von: Thomas Ni (keine)

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit:
Schwierigkeit: k.A.
Webcode: hw5c-oehm
Autor: ()

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen