Java :: Aufgabe #175

3 Lösungen Lösungen öffentlich

Mononacci, Fibonacci, Multinacci

Anfänger - Java von hollst - 09.07.2017 um 12:16 Uhr
Die Fibonacci-Folge beginnt bekanntlich mit {1, 1}, also zwei Einsen
und jedes Folgeglied ist die Summe seiner zwei Vorgänger. Wir wollen die Fibonacci-Folge wegen der zwei Starteinsen "fibo2" nennen.

Unter einer Multinacci-Folge (fibok) sei eine Folge verstanden, die mit k Einsen beginnt
und jedes Folgeglied die Summe der k Vorgängerglieder ist. Ist k = 1, so heiße der Spezialfall Mononacci.

Die Glieder der Multinacci-Folgen werden ab Glied k immer größer und streben gegen unendlich.
Allerdings strebt der Quotient zweier benachbarter Folgeglieder immer gegen einen endlichen Grenzwert, bei fibo2
ist es bekanntlch der goldene Schnitt phi (phi = 1.618034).

Wir wollen den entsprechenden Grenzwert der Multinacci-Folgen mit "phi_fibok" benennen.

Schreibe ein Programm, das für k = 1, 2, 3 ... 100 die ersten 10 Glieder der Multinacci-Folgen ab Glied k und den Grenzwert phi_fibok ausgibt.

Hinweis: Beider der Grenzwertbildung könnt ihr es mit sehr große Zahlen zu tun bekommen, deshalb Ergebnis auf Plausibilität testen!

Lösungen:

vote_ok
von KarinB (300 Punkte) - 13.07.2017 um 23:37 Uhr
Quellcode ausblenden Java-Code
import java.util.*;

public class MultinaccioMitGrenzwert {

    public static void main(String[] args) {
	List<Integer> mult = new ArrayList<Integer>();
	System.out.println("1 1 1 1 1 1 1 1 1 1 ");
	System.out.println("phi_fib1: 1");

	// for zum Zeilendurchlauf und Ausgeben
	for (int i = 2; i <= 100; i++) {
	    int k0 = i;
	    int k1 = 2 * i - 1;
	    mult.add(new Integer(k0));
	    mult.add(new Integer(k1));
	    int nr = 2;
	    boolean gw = false;
	    double phi = (double) k1 / (double) k0;

	    // while zum Aufbau der Array-Listen
	    while ((mult.size() < 10) || ((mult.size() > 10) && !gw)) {
		int next = 0;

		// Zahlen aufbauen
		if (i <= nr)
		    for (int j = 0; j < i; j++)
			next += mult.get(nr - j - 1);
		else {
		    for (int j = 0; j < nr; j++)
			next += mult.get(nr - j - 1);
		    next += (i - nr);
		}

		mult.add(new Integer(next));

		// Grenzwertberechung, Epsilon = 0.0001
		if (!gw) {
		    if (((double) next / (double) mult.get(nr - 1)
			    - (double) mult.get(nr - 1) / (double) mult.get(nr - 2)) < 0.0001) {
			gw = true;
			phi = (double) next / (double) mult.get(nr - 1);
		    }
		}
		nr++;
	    }

	    // ausgeben
	    for (int j = 0; j < 10; j++) {
		int zahl = mult.get(j);
		System.out.print(zahl + " ");
	    }

	    System.out.println();
	    System.out.println("phi_fib" + i + ": " + phi);
	    System.out.println();
	    mult.clear();
	}

    }
}
vote_ok
von PC-principal (1330 Punkte) - 04.08.2017 um 18:15 Uhr
Quellcode ausblenden Java-Code
import java.math.BigDecimal;
import java.math.RoundingMode;

public class Multinacci {
	public static void main(String[] args) {
	
		int k = 100;
		int anzahlGlieder=10;
		
		BigDecimal phi_fibok = BigDecimal.ZERO;
		BigDecimal fibok = BigDecimal.ONE;
		BigDecimal[] array = new BigDecimal[k];

		for (int p = 0; p < array.length; p++) {
			array[p] = BigDecimal.ONE;
		}

		for (int w = 0; w < anzahlGlieder; w++) {
			for (int i = 0; i < k - 1; i++) {
				fibok = fibok.add(array[i]);
			}
			for (int h = 0; h < array.length - 1; h++) {
				array[h] = array[h + 1];
			}
			array[array.length - 1] = fibok;
			System.out.println(fibok.toString());
		}

		phi_fibok = array[array.length - 1].divide(array[array.length - 2], 10, RoundingMode.HALF_UP);
		System.out.println(phi_fibok);
	}
}
vote_ok
von JenZor (40 Punkte) - 21.12.2017 um 14:57 Uhr
Quellcode ausblenden Java-Code
import java.util.ArrayList;

public class Main {
	
	public static void main(String[] args) {
		Multinacci m;
		
		for (int i = 1; i <= 100; i++ ) {
			m = new Multinacci(i);

			m.calculateNextNElements(10);
			
			m.printFirstNElements(10);
			
			System.out.println(m.getPhi());
			
			System.out.println();
		}	
	}
}

public class Multinacci {
	
	private final int k;
	private float phi;
	
	private int calculatedElements;
	private ArrayList<Integer> multinacciList;
	

	public Multinacci(int k) {
		this.k = k;
		
		calculatedElements = 0;
		
		phi = 0.0f;
		
		multinacciList = new ArrayList<Integer>();

		for(int i = 0; i < k; i++) {
			multinacciList.add(1);
		}
		
	}

	public int getK() {
		return this.k;
	}
	
	public float getPhi() {
		return this.phi;
	}
	
	public void calculateNextNElements(int n) {

		for(int j = 0; j < n; j++) {
			
			
			int newElement = 0;
			
			for(int i = 0; i < this.k; i++ ) {
				newElement = newElement + multinacciList.get(multinacciList.size() - 1 - i);
			}
			
			this.multinacciList.add(newElement);
			this.calculatedElements++;
			this.refreshPhi();
		}
	}
	
	public ArrayList<Integer> getFirstNElementsList(int n) {
		if(n < calculatedElements) {
			calculateNextNElements(n - calculatedElements);
		}
			
		ArrayList<Integer> firstNElementsList = new ArrayList<Integer>();
		
		for(int i = 0; i < n; i++) {
			firstNElementsList.add(this.multinacciList.get(k + i));
		}
		
		return firstNElementsList;
	}
	
	private void refreshPhi() {

		this.phi = (float) multinacciList.get(multinacciList.size() -1 ) / (float) multinacciList.get(multinacciList.size() - 2);
	}
	
	public void printMultinacciList() {	
		
		System.out.println(multinacciList);
	}
	
	public void printFirstNElements(int n) {
		System.out.println(getFirstNElementsList(n));
	}
	
}