Programmieren lernen

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)