F_n = F_n−1 + F_n−2, mit F₁ = 1 und F₂ = 1.

Die ersten 12 Folgeglieder sind also:

F₁ = 1
F₂ = 1
F₃ = 2
F₄ = 3
F₅ = 5
F₆ = 8
F₇ = 13
F₈ = 21
F₉ = 34
F₁₀ = 55
F₁₁ = 89
F₁₂ = 144

Das 12te Folgeglied, F₁₂, ist das erste mit drei Ziffern.

Welches Folgeglied ist das erste mit 1000 Stellen?

Lösung

Wir benutzen symbolische Variablen, um die auftretenden riesigen Zahlen verarbeiten zu können.

Matlab-Code:

clear
tic

a = sym('1');
b = sym('1');
c = sym('0');
grenze = sym('1e999');
i = 2;

while floor(c / grenze) == 0
    c = a + b;
    a = b;
    b = c;
	i = i + 1;
end

disp(['erste mit 1000 Ziffern: ' int2str(i)])
toc

Ergebnis: 4782
Rechenzeig: 19.329795 Sekunden

Hier sieht man, dass große Zahlen eine Schwäche von Matlab sind. In anderen Programmiersprachen dauert die Berechnung des gewünschten Folgegliedes weniger als eine Sekunde.

Die erste Fibonaccizahl mit 1000 Stellen ist übrigens:

107006626638275893676498058445739688508368389663215166501323520337
531452060469404062188914758248979265780469488817759195748433646667
256995951299603046126274809248218614406943305123477444275027378175
308757939166619214925918675955396642283714894311307469950343954700
198543260972306729019287052644724372611771582182554849112052501320
147861296593138179223555965745203950613755146783754322911960212993
404826070617539770684706820289548690266618543512452190036948064135
744747091170761976694569107009802439343961747410373691250323136553
216477369702316775505159517351846057995491941096777837322966579658
164651390348815425631018422419025984608800011018625555024549393711
365165703944762958471454852342595042858242530608354443542821261100
899286379504800689433030977321783486454311320576565986845628861680
871869383529735064398629764066000072356291790520705116407761481249
188583094594056668833910935094445657635766615161931775379289166158
132715961687748798382182049252034847387438473677193451278702921863
6250627816

012 021 102 120 201 210

Was ist die millionenste lexikografische Permutation der Ziffern 0, 1, 2, 3, 4, 5, 6, 7, 8 und 9?

Lösung

Wir können die gesuchte Permutation Ziffernweise erstellen und müssen nicht alle 1000000 vorhergehenden Permutationen durchlaufen.

Die Anzahl der Möglichkeiten, n Elemente anzuordnen, ist n! (Fakultät). Wie wir dies nutzen zeigen wir an einem kleineren Beispiel: Die 10te Permutation von 0, 1, 2 und 3.

Wir haben 4 Ziffern. Um die erste Ziffer der gesuchten Permutation zu bestimmen, nutzen wir, dass es 3! = 6 Möglichkeiten gibt, die restlichen drei Ziffern anzuordnen. Das bedeutet, dass bei den ersten 6 lexikografischen Permutationen die 0 vorne steht. Bei der 7ten bis 12ten steht die 1 vorne. Wir können daher sicher sein, dass die erste Ziffer der 10ten Permutation die 1 ist.

Wir löschen die 1 aus dem Feld, es bleibt: [0 2 3].
Es gibt noch drei Ziffern. Um die letzten zwei anzuordnen gibt es 2! = 2 Möglichkeiten. Bei der 7ten und 8ten Permutation steht also die 0 vorne, bei der 9ten und 10ten die 2. Wir kennen damit von der gesuchten Permutation schon [1 2 _ _]. Es bleibt übrig: [0 3]

Es gibt nun noch zwei Ziffern. Um die letzte Ziffer anzuordnen gibt es eine Möglichkeit. Bei der 9ten Permutation steht also die 0 vorne, bei der 10ten die 3. Wir wissen nun, dass die gesuchte Permutation mit [1 2 3 _] beginnt. Es bleibt nur noch die 0 übrig, diese muss daher an letzter Stelle stehen: [1 2 3 0].

Dieses Verfahren übernehmen wir für die größere Aufgabe. Ist die Nummer n der gesuchten Permutation eine gerade Zahl, kann es zu Problemen kommen, daher suchen wir die Permutation der nächstkleineren ungeraden Zahl n-1.

Matlab-Code:

clear
tic

gesucht = 1e6;
ziffern = 0 : 9;
ergebnis = [];

if (mod(gesucht, 2) == 0)
    gesucht = gesucht - 1;
    flip = 1;
else
    flip = 0;
end

while gesucht > 0
    i = length(ziffern) - 1;
    j = floor(gesucht / factorial(i));
    gesucht = gesucht - j * factorial(i);

    if (gesucht > 0)
        j = j + 1;       % da die erste Ziffer 0 ist
        ergebnis = [ergebnis ziffern(j)];

        % benutzte Ziffer entfernen:
        ziffern = [ziffern(1 : j - 1) ziffern(j + 1 : end)];
    end
end

ergebnis = [ergebnis ziffern];
if (flip == 1)
    ergebnis(end - 1 : end) = fliplr(ergebnis(end - 1 : end));
end

disp(ergebnis)
toc

Ergebnis: 2 7 8 3 9 1 5 4 6 0
Rechenzeit: 0.000690 Sekunden

Wir definieren hier eine n-stellige Zahl als pandigital, wenn sie alle Ziffern von 1 bis n genau ein Mal enthält. Zum beispiel ist die die Zahl 15234 pandigital, da alle Ziffern von 1 bis 5 genau ein Mal vorkommen.

Das Produkt 7254 ist ungewöhnlich, da die Gleichung mit Faktoren und Produkt gemeinsam betrachtet neunstellig pandigital ist.

Finde die Summe aller Produkte, für die eine solche pandigitale Gleichung aufgestellt werden kann.

Lösung

Wir brauchen in der gewünschten Gleichung 9 Ziffern. Dies kann auf zwei unterschiedliche Arten erreicht werden: entweder xx * xxx = xxxx oder x * xxxx = xxxx. Wir testen vom kleinstmöglichen Produkt 1234 bis zum größtmöglichen 9876. Die Ziffern werden zunächst aufgeteilt. Wir prüfen, ob jede Ziffer nur ein Mal vorkommt und ob alle Ziffern größer als 0 sind.
Anschließend testen wir zuerst die Möglichkeit xx * xxx = xxxx, indem wir für den ersten Faktor 12 bis 98 testen. für jeden Kandidaten testen wir, ob das gewünschte Produkt durch diesen Faktor teilbar ist. Ist dies der Fall, testen wir, ob der Quotient noch größer oder gleich 100 ist, da wir noch drei Ziffern benötigen. Danach werden die Ziffern der beiden Faktoren in das Feld zu den Ziffern des Produktes gespeichert. Erneut wird geprüft, ob keine Ziffer doppelt vorkommt und ob alle Ziffern größer als 0 sind.

Nur wenn alle Tests erfolgreich sind, haben wir ein neues ungewöhnliches Produkt gefunden.

Im zweiten Schritt verfahren wir ähnlich mit der Möglichkeit x * xxxx = xxxx.

Matlab-Code:

tic
anzahl = 0;
summe = 0;
res = [];

% entweder xx * xxx = xxxx oder x * xxxx = xxxx
for produkt = 1234 : 9876
    ziffer = ones(1, 9);
    ziffer(6) = floor(produkt / 1000);
    ziffer(7) = floor(mod(produkt, 1000) / 100);
    ziffer(8) = floor(mod(produkt, 100) / 10);
    ziffer(9) = mod(produkt, 10);
    if (length(unique(ziffer(6 : 9))) == 4 && min(ziffer(6 : 9)) > 0 )
        for q = 12 : 98    % xx * xxx = xxxx ?
            if (mod(produkt, q) == 0)
                d = produkt / q;
                if (d < 100)
                    % es ergibt sich nur xx * xx = xxxx, nicht pandigital
                    continue
                end

                ziffer(1 : 2) = [floor(q / 10), mod(q, 10)];
                ziffer(3 : 5) = [floor(d / 100), ...
                    floor(mod(d, 100) / 10), mod(d, 10)];
                if (length(unique(ziffer)) == 9 && min(ziffer) > 0)
                    anzahl = anzahl + 1;
                    res(anzahl, : ) = ziffer;
                    disp([produkt d q]);
                    summe = summe + produkt;
                    break
                end
            end
        end

        for q = 2 : 9
            if (mod(produkt, q) == 0)
                d = produkt / q;
                if (d < 1000)   % 1 x 3 = 4 Ziffern
                    continue
                end
                ziffer(1) = q;
                ziffer(2 : 5) = [floor(d / 1000), ...
                    floor(mod(d, 1000) / 100), ...
                    floor(mod(d, 100) / 10), mod(d, 10)];
                if (length(unique(ziffer)) == 9 && min(ziffer) > 0)
                    anzahl = anzahl + 1;
                    res(anzahl, : ) = ziffer;
                    disp([produkt d q]);
                    summe = summe + produkt;
                    break
                end
            end
        end
    end
end
disp(summe)
toc

Ergebnis: 45228
Rechenzeit: 0.507799 Sekunden

1ct, 2ct, 5ct, 10ct, 20ct, 50ct, 1€ (100ct) und 2€ (200ct).

Zwei Euro (200ct) können zum Beispiel wie folgt kombiniert werden:

Wie viele unterschiedliche Möglichkeiten (ohne Beachtung der Reihenfolge der Münzen) gibt es?

Lösung

Diese Aufgabe ist schwieriger als die vorherigen. Es gibt eine Vielzahl an möglichen Lösungsalgorithmen (rekursiv oder mit dynamic programming). Hier soll nur einer erklärt werden.

Wir überlegen zunächst, wie viele Möglichkeiten es gibt, eine Summe nur aus 1ct Münzen zu kombinieren:

Es gibt immer genau eine Möglichkeit, nämlich die, den gewünschten Betrag aus der entsprechenden Anzahl an 1ct Münzen zu addieren. Nun nehmen wir die 2ct Münzen hinzu. Bei 0ct und 1ct hilft uns diese Münze nicht, sie wird erst bei 2ct interessant. Dort verschafft sie uns neben der Möglichkeit, die 2ct aus zwei 1ct Münzen zu kombinieren, die Alternative, nur die 2ct Münze zu benutzen. Das gleiche gilt für 3ct:

Bei 4ct haben wir nun drei Möglichkeiten, bei 6ct schon 4 und so weiter. Wir können die Anzahl der Möglichkeiten berechnen, indem wir bei 2ct anfangen und jeweils die Anzahl der Möglichkeiten zwei weiter links zu der Anzahl der Möglichkeiten nur mit 1ct addieren:

2ct: 1 + 1 = 2
3ct: 1 + 1 = 2
4ct: 1 + 2 = 3
5ct: 1 + 2 = 3
…
17ct: 1 + 8 = 9

Wir verfahren genau so mit den 5ct Münzen, nur dass wir nun bei 5ct beginnen und immer die Anzahl der Möglichkeiten 5 Stellen weiter links addieren:

und 10ct:

Dies lassen wir bis 200ct und mit allen Münzen durchlaufen. Da Matlab Arrays mit 1 statt mit 0 anfangen, müssen wir den Index um 1 verschieben.

Matlab-Code:

function moglich = e031(ziel)
    tic
    munzen = [1 2 5 10 20 50 100 200];
    verschiedeneMunzen = length(munzen);
    mogl = zeros(1, ziel+1);
    mogl(1) = 1;

    for m = 1 : verschiedeneMunzen
        for j = munzen(m) + 1 : ziel +1
            mogl(j) = mogl(j) + mogl(j - munzen(m));
        end
    end
    moglich = mogl(ziel+1);
    toc;
end

Ergebnis: 73682
Rechenzeit: 0.000045 Sekunden

Da keine Summe ist, ist 1 nicht enthalten.

Die Summe dieser drei Zahlen ist

Finde die Summe aller Zahlen, die als die Summe der fünften Potenzen ihrer Ziffern dargestellt werden können.

Lösung

Die größte 5er Potenz einer Ziffer ist . Da wir die Potenzen addieren müssen, können wir mit 5 Ziffern maximal erreichen. Da dies 6-stellig ist, müssen alle 5-stelligen Zahlen getestet werden. Mit 6 Ziffern können wir maximal erreichen. Wir müssen also die 6-stelligen Zahlen bis 354294 testen. Mit 7 Ziffern können wir maximal erreichen, also muss keine Zahl mit 7 oder mehr Ziffern getestet werden, da diese nicht in Frage kommen.

Matlab-Code:

function summe = e030()
    tic;
    pot = 5;
    summe = 0;
    for i = 2 : 354294
        akt = i;
        aktSum = 0;
        while akt > 0
            aktSum = aktSum + (mod(akt, 10))^pot;
            akt = floor(akt / 10);
        end
        if aktSum == i
            summe = summe + i;
        end
    end
    toc;
end

Ergebnis: 443839
Rechenzeit: 0.516144 Sekunden

Wenn man aus diesen 16 Zahlen die doppelten löscht, bleiben 15 unterschiedliche übrig:

4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125

Wie viele unterschiedliche Zahlen erhält man für und ?

Lösung

Hier bekommt man bei anderen Programmiersprachen Probleme, da Zahlen wie 100^100 nicht im Integerbereich liegen. Matlab kommt mit so großen Zahlen aber zurecht, wir implementieren daher einen Brute Force Ansatz.

Matlab-Code:

function n = e029()
    tic;
    max = 100;
    res = zeros(1, (max-1)^2);
    index = 0;
    for a = 2 : max
        for b = 2 : max
            index = index + 1;
            res(index) = a^b;
        end
    end
    res = sort(res);
    n = 1;
    for i = 2 : index
        if res(i) ~= res(i - 1)
            n = n + 1;
        end
    end
    toc;
end

Ergebnis: 9183
Rechenzeit: 0.010267 Sekunden

veröffentlicht. Es ergibt sich, dass die Formel 40 Primzahlen für die aufeinanderfolgenden Werte für n=0 bis 39 erzeugt.

Wenn allerdings n=40, ist das Ergebnis durch 41 teilbar, die Reihe an Primzahlen endet dort also.

Mit Hilfe von Computern hat man die unglaubliche Formel

gefunden, die 80 aufeinanderfolgende Primzahlen für n=0 bis 79 erzeugt. Das Produkt der Koeffizienten -79 und 1601 ist -126479.

Wir betrachten die allgemeine quadratische Formel

wobei der Betrag von a und b jeweils unter 1000 liegt. Mit welchen Koeffizienten produziert die quadratische Formel die meisten Primzahlen für aufeinanderfolgende Werte für n, beginnend mit n=0? Geben Sie das Produkt der Koeffizienten an!

Lösung

Für n=0 soll die Formel schon eine Primzahl erzeugen. Es ist aber

Daher muss b eine Primzahl sein. Wir erzeugen daher ein Feld mit allen Primzahlen von 1 bis 999.

Betrachten wir nun den zweiten Koeffizienten. Da für n=1 eine Primzahl erzeugt werden soll, muss

eine Primzahl sein. Da b eine Primzahl ist, ist b auf jeden Fall ungerade. Wenn wir 1 addieren, erhalten wir eine gerade Zahl. Da das Ergebnis wieder ungerade sein muss, ist a auf jeden Fall ungerade.

Damit das Ergebnis positiv wird, muss gelten:

Es ergibt sich folgender Algorithmus.

Matlab-Code:

tic;
pList = primes(1000);
N = length(pList);
n = 0 : 80;
best = 0;

for x = 1 : N
    b = pList(x);
    for a = - (b + 2) : 2 : 999
        p = n.^2 + a * n + b;
        q = 1;
        while (p(q) > 0 && isprime(p(q)) && q < 80)
            q = q+1;
        end
        if (best < q)
            paar = [a b];
            best = q;
        end
    end
end
disp(prod(paar))
toc

Ergebnis: -59231
Rechenzeit: 7.772937 Sekunden

Die Eulerformel und die angegebene “unglaubliche Formel” gehören beide zu der Familie

wobei bei der Eulerformel i = 40 und bei der unglaublichen Formel i = 0 gilt. Das Ergebnis dieser Aufgabe entspricht i = 9.

21 22 23 24 25
20 07 08 09 10
19 06 01 02 11
18 05 04 03 12
17 16 15 14 13

Die Summe der Zahlen auf den beiden Diagonalen ist 101 (die 1 in der Mitte wird nur ein mal gezählt!).

Was ist die Summe der Zahlen auf den beiden Diagonalen, wenn die Spiralmatrix 1001 Elemente breit ist?

Lösung

Es gibt hier verschiedene Lösungsmöglichkeiten. Im Folgenden werden zwei davon vorgestellt.

Möglichkeit 1

Das Problem kann gelöst werden, indem die gewünschte Matrix erstellt und die gesuchten Elemente addiert werden. Dies ist allerdings mit einem erheblichen Aufwand verbunden. Wir wollen diese Lösung daher gar nicht erst implementieren und uns gleich die nächste Möglichkeit anschauen:

Möglichkeit 2

Wenn man die gesuchten Zahlen anschaut, fällt schnell auf, dass sie mit Ausnahme der 1 in Viererblocks auftreten:

1; 3 5 7 9; 13 17 21 25; 31 37 43 49; …

Die Zahlen im ersten Block erhält man, indem man jeweils 2 auf den Vorgänger addiert. Für den nächsten Block muss man jeweils 4 addieren, dann jeweils 6 und so weiter.

Die größte zu addierende Zahl ist 1001*1001, wir schreiben also eine einfache Schleife.

Matlab-Code:

function sum = e028(size)
    tic;
    sum = 1;
    akt = 1;
    summand = 2;
    fertig = 0;

    while fertig == 0
        for i = 1 : 4
            akt = akt + summand;
            if akt <= size*size
                sum = sum + akt;
            else
                fertig = 1;
            end
        end
        summand = summand + 2;
    end
    toc
end

Ergebnis: 669171001
Rechenzeit: 0.000087 Sekunden

Möglichkeit 3

Wenn wir die Zahlen noch ein wenig genauer anschauen, sehen wir, dass die Zahlen rechts oben jeweils die Quadrate der unteraden Zahlen sind, also für alle ungeraden n kleiner oder gleich 1001:

Die anderen drei Zahlen ergeben sich zu:

Addiert man diese vier Zahlen für einen Schritt auf, ergibt sich:

Wir erhalten dadurch den folgenden Algorithmus.

Matlab-Code:

function sum = e028(size)
    tic;
    sum = 1;
    for n = 3 : 2 : size
        sum = sum + 4 * n^2 - 6 * n + 6;
    end
    toc
end

Ergebnis: 669171001
Rechenzeit: 0.000006 Sekunden

Als Dezimalbruch dargestellt sind die Stammbrüche mit den Nennern 2 bis 10:

1/2 = 0.5
1/3 = 0.(3)
1/4 = 0.25
1/5 = 0.2
1/6 = 0.1(6)
1/7 = 0.(142857)
1/8 = 0.125
1/9 = 0.(1)
1/10 = 0.1

Dabei meint 0.1(6) den periodischen Bruch 0.16666… und hat die 1-ziffrige sich wiederholende Periode 6. 1/7 hat eine 6-ziffrige Periode.

Finde den Wert von d unter 1000, für den 1/d die längste Periode hat.

Lösung

Es gibt hier verschiedene Lösungsmöglichkeiten. Im Folgenden werden zwei davon vorgestellt.

Möglichkeit 1

Wie bei den meisten Problemen können wir mit Brute Force zur Lösung kommen. Dazu gehen wir alle Zahlen von 1 bis 1000 durch, führen manuell die Berechnung des Kehrwertes durch und schreiben diesen in einen String. Anschließend suchen wir in diesem String nach der längsten Periode.

Matlab-Code:

function d = e026
    maxPeriode = 0;
    maxD = 0;
    for i = 1 : 1000
        periode = perDivision(1,i);
        if length(periode) > maxPeriode
            maxPeriode = length(periode);
            maxD = i;
        end
    end
    d = maxD;
end

function periode = perDivision(a, b)

    bs = num2str(b);
    ziffernB = length(bs);
    y = char(zeros(1,10000));
    letzterEintrag = 0;
    periode = [];

    done = 0;
    while (done == 0)     

        a = a * 10;
        while (a < b)
            a = a * 10;
            letzterEintrag = letzterEintrag + 1;
            y(letzterEintrag) = '0';
        end

        teiler = floor(a / b);
        teilerS = num2str(teiler);

        letzterEintrag = letzterEintrag + 1;
        if length(teilerS) == 1
            y(letzterEintrag) = teilerS;
        else
            y(letzterEintrag : letzterEintrag + 1) = teilerS;
        end

        letzterEintrag = letzterEintrag + length(teilerS)-1;

        a = a - teiler * b;
        if (a == 0)
            break
        end

        periodeGefunden = 0;

        if (letzterEintrag > 2 * ziffernB)
            snippet = y(letzterEintrag - ziffernB + 1 : letzterEintrag);
            teiler = strfind(y(1 : letzterEintrag), snippet);
            lTeiler = length(teiler);
            if (lTeiler == 3)
                  if (teiler(3) - teiler(2) == teiler(2) - teiler(1))
                        periodeGefunden = strcmp(y(teiler(1) : ...
                            teiler(2)), y(teiler(2) : teiler(3)));
                  end
            end
        end

        if (periodeGefunden)
            periode = y(teiler(2) : teiler(3) - 1);
            done = 1;
        end

        if (letzterEintrag > 10000)
            done = 1;
        end
    end
end

Ergebnis: 983
Rechenzeit: 9.558173 Sekunden

Möglichkeit 2

Alternativ können wir uns folgendes vor Augen führen. Der Dezimalbruch 0.(1) ist bekanntlich gleich dem Bruch 1/9. Gleiches gilt für 0.(2) = 2/9, …, 0.(8) = 8/9, 0.(9) = 9/9 = 1.
Dies funktioniert auch mit mehrstelligen Zahlen, z.B. 1/7 = 0.(142857) = 142857/999999.

Für eine gegebene Zahl d können wir die Länge der Periode von 1/d finden, indem wir die kleinste Zahl bestimmen, die nur aus 9en besteht (9999…) und die ohne Rest durch d teilbar ist.

Die Zahl 10^n-1 – 1 ist 999… mit n 9en. Wir können herausfinden, ob diese Zahl ganzzahlig durch d teilbar ist, indem wir den Modulo berechnen: mod(10^n-1 – 1, d). Dieser ist dann gleich 0.
Vereinfachend kann man das kleinste n bestimmen, so dass mod(10^n-1, d) = 1.

Matlab Code:

function d = e026
    numMax = 0;
    for i = 901 : 2 : 999
        num = 1;
        while mod(sym(10)^sym(num), sym(i)) ~= 1 && num < 1000
            num = num + 1;
        end
        if num ~= 1000
            if (numMax < num)
                numMax = num;
                d = i;
            end
        end
    end
end

Leider kann Matlab nicht gut mit großen genauen Zahlen umgehen, daher müssen wir sym() verwenden. Dadurch dauern alle Rechenoperationen sehr sehr lange. In einer anderen Programmiersprache wäre dieser Ansatz wohl schneller, in Matlab ist er langsamer als Möglichkeit 1. Wir haben hier vorausgesetzt, dass die gesuchte Zahl ungerade und größer als 900 ist.

Ist diese Summe der Teiler kleiner als die Zahl selbst, heißt die Zahl defizient. Ist die Teilersumme dagegen größer, so spricht man von einer abundanten Zahl.

Da 12 die kleinste abundante Zahl ist, ist die kleinste Zahl, die als Summe von zwei abundanten Zahlen geschrieben werden kann, 24. Mit mathematischer Analysis kann gezeigt werden, dass alle natürlichen Zahlen, die größer als 28123 sind, als Summe von zwei abundanten Zahlen geschrieben werden können. Dieses obere Limit kann nicht weiter gedrückt werden, obwohl bekannt ist, dass die größte Zahl, die nicht als Summe von zwei abundanten Zahlen ausgedrückt werden kann, sehr viel kleiner ist (kleiner als 21000).

Finde die Summe aller positiven natürlichen Zahlen, die nicht als Summe zweier abundanten Zahlen ausgedrückt werden können.

Lösung

Hier könnte man zu einem Brute-Force Ansatz greifen, indem man alle abundanten Zahlen von 1 bis 21000 bestimmt, alle Kombinationen aus diesen bildet, die doppelten Kombinationen löscht, den Vektor sortiert und prüft, welche Zahlen nicht darin enthalten sind. Dies sind die Zahlen, die nicht als Summe von zwei abundanten Zahlen geschrieben werden können.

Da aber ungefähr jede dritte Zahl abundant ist, gibt es zwischen 1 und 21000 ca. 7000 abundante Zahlen, also 49000000 Kombinationen. Diese zu berechnen dauert relativ lange.

Statt dessen können wir von jeder betrachteten Zahl in einer Schleife die abundanten Zahlen abziehen und prüfen, ob bei der Subtraktion wieder eine abundante Zahl herauskommt. In diesem Fall kann die Zahl als Summe von zwei abundanten Zahlen ausgedrückt werden und wir können mit der nächsten Zahl weitermachen. So sparen wir sehr viel Rechenzeit, da die Schleifen vorzeitig mit break verlassen werden können.

Matlab-Code:

function  euler023

    clear
    tic

    target = 21000;

    abundant = 0;
    for i = 1 : target
        if i < divSum(i)
            abundant = [abundant i];
        end
    end
    abundant = abundant(2 : length(abundant));
    toc

    tic
    notPossible = 0;
    for i = 1 : target
        possible = 0;
        for a = 1 : length(abundant)
            comp = i - abundant(a);
            if comp <= 0
                break
            end
            if find(abundant == comp) ~= 0
                possible = 1;
                break
            end
        end
        if possible == 0
            notPossible = [notPossible i];
        end
    end
    sum(notPossible)
    toc
end

function d = divisors(z)

    d = 1;
    for i = 2 : z / 2
        if mod(z, i) == 0
            d = [d i];
        end
    end
end

function s = divSum(z)

    s = sum(divisors(z));
end

Ergebnis: 4179871
Rechenzeit: 49.913802 Sekunden

Es gibt elegantere Lösungen für diese Aufgabe!