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!

names-opt.txt

Diese 36K Textdatei enthält über 5000 Vornamen. Beginne damit, die Namen alphabetisch zu sortieren. Anschließend ermittle den alphabetischen Wert jedes Namens und multipliziere diesen mit der Position in der Liste, um die Punktzahl des Namens zu finden.

Beispiel:

Wenn die Liste alphabetisch sortiert ist, ist COLIN der 938ste Name. Der Wert des Namens ist . Die Punktzahl ist also .

Was ist die Summe aller Punktzahlen in der Datei?

Lösung

Durch die Verwendung der Matlab-Funktion “textread” können wir die lowlevel-Routinen umgehen und erhalten direkt einen Vektor mit Namen. Diesen zu sortieren kostet nur einen weiteren Befehl. Anschließend werden die Buchstabenwerte ermittelt, wobei jeweils 64 abgezogen werden muss, damit das A den Wert 1 bekommt.

Matlab-Code:

function euler022

    clear
    tic

    names = textread('names-opt.txt', '%s');
    names = sort(names);

    n = length(names);
    res = 0;

    for i = 1 : n
        c = char(names(i));
        d = double(c) - ones(1, length(double(c))) * 64;
        res = res + sum(d) * i;
    end

    res
    toc
end

Ergebnis: 871198282
Rechenzeit: 0.158471 Sekunden

Wenn und gilt mit , dann sind und ein Paar befreundeter Zahlen und und werden befreundete Zahlen genannt.

Beispiel:

Die echten Teiler von 220 sind 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 und 110.

Es ist also

Die echten Teiler von 284 sind 1, 2, 4, 71 und 142.

Es ist also

Finde die Summe aller befreundeten Zahlen unter 10000!

Lösung

In einer Schleife werden alle Zahlen von 1 bis 10000 mit der Summe der Teiler der Summe der Teiler von sich selbst verglichen. Wenn diese gleich sind, muss noch ausgeschlossen werden, dass es sich um eine vollkommene Zahl handelt. Eine natürliche Zahl wird vollkommene Zahl (auch perfekte Zahl) genannt, wenn sie genauso groß ist wie die Summe ihrer positiven echten Teiler.

Um die Teiler herauszufinden, implementieren wir eine eigene kleine Funktion.

Matlab-Code:

function  euler021

    clear;
    tic

    amicable = 0;
    for i = 1 : 10000
        if i == divSum(divSum(i)) && i ~= divSum(i)
            amicable = [amicable i];
        end
    end

    sum(amicable)
    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: 31626
Rechenzeit: 4.948899 Sekunden

.

Was ist die Quersume der Fakultät von 100?

Lösung

Da Matlab nicht symbolisch rechnet, erhalten wir für die Fakultät von 100 nur eine Näherung. Die Eingabe

factorial(100)

ergibt als Ergebnis: 9.3326e+157

Dies hilft uns nicht bei der Berechnung der Quersumme, aber immerhin wissen wir so schon, wie viele Stellen das Ergebnis hat (nämlich 158).

Wir erstellen daher einen Vektor mit Integerwerten von 0 bis 9 und der Länge 160, speichern in der letzten Stelle die 1 und lassen dann die Zahlen von 2 bis 100 mit einer eigenen Multiplikationsfunktion verarbeiten. Dabei wird der jeweilige Faktor mit jeder Stelle des Vektors multipliziert. Anschließend wird jeweils der Übertrag in die höheren Felder übernommen, so dass die Einträge des Vektors einstellig bleiben.

Matlab-Code:

function euler020

    clear;
    tic

    vecLength = 160;
    n = 100;

    f = zeros(1, vecLength);
    f(vecLength) = 1;

    for i = 2 : n
        f = multiply(f, i);
    end

    sum(f)
    toc
end

function m = multiply(f, g)

    vecLength = length(f);
    m = zeros(1, vecLength);
    for i = vecLength : -1 : 1
        if f(i) > 0
            m(i) = m(i) + f(i) * g;
            j = i;
            while m(j) > 9
                m(j - 1) = m(j - 1) + floor(m(j) / 10);
                m(j) = mod(m(j), 10);
                j = j - 1;
            end
        end
    end
end

Ergebnis: 648
Rechenzeit: 0.003774 Sekunden

Lösung

Möglichkeit 1

Wir wissen:

Der 1.1.1901 war ein Dienstag.
Die Monate eines Jahres haben [31 (x) 31 30 31 30 31 31 30 31 30 31] Tage.
(x) ist 28, oder bei einem Schaltjahr 29.
Jedes Jahr, das durch 4 teilbar ist, ist ein Schaltjahr, außer den Jahren die durch 100 teilbar sind, es sei denn sie sind auch durch 400 teilbar.

Matlab-Code:

tag = 2; % Dienstag
monatTage0 = [31 28 31 30 31 30 31 31 30 31 30 31];
monatTage1 = [31 29 31 30 31 30 31 31 30 31 30 31];
schaltJahr = zeros(100, 1);

treffer = 0;

for jahr = 4 : 4 : 100
    schaltJahr(jahr) = 1;
end

for jahr = 1 : 100
    if schaltJahr(jahr) == 0
        for monat = 1 : 12
            if mod(tag, 7) == 0
                treffer = treffer + 1;
            end
            tag = mod(tag + monatTage0(monat), 7);
        end
    else
        for monat = 1 : 12
            if mod(tag, 7) == 0
                treffer = treffer + 1;
            end
            tag = mod(tag + monatTage0(monat), 7);
        end
    end
end

treffer

Ergebnis: 171
Rechenzeit: 0.000573 Sekunden

Möglichkeit 2

Wir haben 100 Jahre zu je 12 Monaten, also 1200 Monate. Es gibt 7 Wochentage. Es fängt zwar nicht jeder siebte Monat mit einem Montag an, bei 100 Jahren stimmt diese Aussage aber statistisch in etwa.

1200 / 7 = 171.43

Abgerundet: 171

3 + 7 + 4 + 9 = 23

Finde den Weg mit der größten Summe von der Spitze zur Basis des folgenden Dreiecks:

Lösung

Möglichkeit 1

Für den Startpunkt gibt es nur eine Möglichkeit. Von dort aus haben wir in jedem Schritt zwei Auswahlmöglichkeiten, daher ist die Anzahl der möglichen Wege 2¹⁴ = 16384. Das sind nicht zu viele, um sie alle durchzutesten. Die einfachste Lösung ist daher wieder eine brute-force Variante. Dazu könnte man einen rekursiven Algorithmus schreiben, oder einfach 14 for-Schleifen ineinander schachteln.

Matlab-Code:

d =[75 00 00 00 00 00 00 00 00 00 00 00 00 00 00
    95 64 00 00 00 00 00 00 00 00 00 00 00 00 00
    17 47 82 00 00 00 00 00 00 00 00 00 00 00 00
    18 35 87 10 00 00 00 00 00 00 00 00 00 00 00
    20 04 82 47 65 00 00 00 00 00 00 00 00 00 00
    19 01 23 75 03 34 00 00 00 00 00 00 00 00 00
    88 02 77 73 07 63 67 00 00 00 00 00 00 00 00
    99 65 04 28 06 16 70 92 00 00 00 00 00 00 00
    41 41 26 56 83 40 80 70 33 00 00 00 00 00 00
    41 48 72 33 47 32 37 16 94 29 00 00 00 00 00
    53 71 44 65 25 43 91 52 97 51 14 00 00 00 00
    70 11 33 28 77 73 17 78 39 68 17 57 00 00 00
    91 71 52 38 17 14 91 43 58 50 27 29 48 00 00
    63 66 04 68 89 53 67 30 73 16 69 87 40 31 00
    04 62 98 27 23 09 70 98 73 93 38 53 60 04 23];

maxWeg = 1;
aktWeg = d(1,1);

for s2 = 1 : 2
    for s3 = s2 : s2 + 1
        for s4 = s3 : s3 + 1
            for s5 = s4 : s4 + 1
                for s6 = s5 : s5 + 1
                    for s7 = s6 : s6 + 1
                        for s8 = s7 : s7 + 1
                            for s9 = s8 : s8 + 1
                                for s10 = s9 : s9 + 1
                                    for s11 = s10 : s10 + 1
                                        for s12 = s11 : s11 + 1
                                            for s13 = s12 : s12 + 1
                                                for s14 = s13 : s13 + 1
                                                    for s15 = s14 : s14 + 1
aktWeg = d(1,1) + d(2,s2) + d(3,s3) + d(4,s4) + d(5,s5) + d(6,s6)...
      + d(7,s7) + d(8,s8) + d(9,s9) + d(10,s10) + d(11,s11) + d(12,s12)...
      + d(13,s13) + d(14,s14) + d(15,s15);
  if aktWeg > maxWeg
      maxWeg = aktWeg;
  end
                                                    end
                                                end
                                            end
                                        end
                                    end
                                end
                            end
                        end
                    end
                end
            end
        end
    end
end

Ergebnis: 1074
Rechenzeit: 0.005123 Sekunden

Möglichkeit 2

Die andere Möglichkeit besteht darin, logisch an das Problem heranzugehen. Wir betrachten folgendes Beispieldreieck:

In der letzten Zeile gibt es jeweils keine Entscheidungsmöglichkeit mehr. Wenn wir dort angekommen sind, steht fest, wie lang der Weg ist. In der vorletzten Zeile gibt es jeweils zwei Möglichkeiten. Der Algorithmus soll jeweils die bessere benutzen. Wir können also zu jedem Element der vorletzten Zeile jeweils das bessere der beiden möglichen Nachfolger addieren:

Daraus wird:

Wir fahren fort mit der dritten Zeile:

Daraus wird:

Die zweite Zeile:

Und zuletzt die erste Zeile:

Das Ergebnis ist 27.

Matlab-Code:

d = zeros(15);
d(1,1) = 75;
d(2,1:2) = [95 64];
d(3,1:3) = [17 47 82];
d(4,1:4) = [18 35 87 10];
d(5,1:5) = [20 04 82 47 65];
d(6,1:6) = [19 01 23 75 03 34];
d(7,1:7) = [88 02 77 73 07 63 67];
d(8,1:8) = [99 65 04 28 06 16 70 92];
d(9,1:9) = [41 41 26 56 83 40 80 70 33];
d(10,1:10) = [41 48 72 33 47 32 37 16 94 29];
d(11,1:11) = [53 71 44 65 25 43 91 52 97 51 14];
d(12,1:12) = [70 11 33 28 77 73 17 78 39 68 17 57];
d(13,1:13) = [91 71 52 38 17 14 91 43 58 50 27 29 48];
d(14,1:14) = [63 66 04 68 89 53 67 30 73 16 69 87 40 31];
d(15,1:15) = [04 62 98 27 23 09 70 98 73 93 38 53 60 04 23];

opt = d;
for k = 14 : -1 : 1
    for p = 1 : k
    	opt(k, p) = opt(k, p) + max(opt(k + 1, p), opt(k + 1, p + 1));
    end
end

disp(opt(1,1))

Rechenzeit: 0.000105 Sekunden, also Faktor 50 schneller als die erste Version.

one two three four five

Die Anzahl der Buchstaben beträgt 3 + 3 + 5 + 4 + 4 = 19.

Wie viele Buchstaben werden benötigt, um die Zahlen von 1 bis 1000 (einschließlich) aufzuschreiben?

Hinweise:
Leerzeichen werden nicht gezählt.
Beispiele: 342 (three hundred and forty-two) enthält 23 Buchstaben und 115 (one hundred and fifteen) enthält 20 Buchstaben.

Lösung

Es werden zunächst die Anzahlen der Buchstaben der Zahlen 1 bis 19 festgelegt. Die anderen Zahlen werden kombiniert (siehe Kommentare im Programmtext).

Matlab-Code:

z = zeros(1000, 1);

% Zahlen von 1 bis 19 manuell:
z(1:19) = [3, 3, 5, 4, 4, 3, 5, 5, 4, 3, 6, 6, 8, 8, 7, 7, 9, 8, 8];

% erste Ziffer von Zahlen 20 bis 99:
z(20:39) = 6;
z(40:69) = 5;
z(70:79) = 7;
z(80:99) = 6;

% zweite Ziffer von Zahlen 20 bis 99:
for d = 2 : 9
    for e = 1 : 9
        z(10 * d + e) = z(10 * d + e) + z(e);
    end
end

% erste Ziffer der Zahlen über 100
for h = 1 : 9
    z(100 * h : 100 * (h + 1) - 1) = z(h);
end

% "hundret and":
z(100:999) = z(100:999) + 10;

% kein "and" für Vielfache von 100:
for h = 1 : 9
    z(100 * h) = z(100 * h) - 3;
end

% zweite und dritte Ziffer:
for h = 1 : 9
    z(100*h +1 : 100*(h+1) -1) = z(100*h +1 : 100*(h+1) - 1) + z(1 : 99);
end

% 1000:
z(1000) = 11;

summe = sum(z)

Was ist die Quersumme von 2¹⁰⁰⁰?

Lösung

Da Matlab nicht von sich aus ausreichend genau mit so großen Zahlen zurechtkommt, müssen wir uns selber eine “Zahl” programmieren.

Idee:

Statt einer Zahl benutzen wir einen Vektor vec, dessen Elemente vec(i) für die Ziffern stehen. Wir brauchen 302 Ziffern (Länge des Vektors). Im ersten Schritt setzen wir die erste Stelle von vec auf 1. Dann beginnen wir eine Schleife, in der in jedem Schritt der gesamte Vektor mit 2 multipliziert wird. Wird dabei eine der “Ziffern” größer als 10, muss eine 1 übertragen werden zur nächsten Ziffer.

Beispiel mit kürzerem Vektor:

Start:

vec = 1, 0, 0, 0

Multiplikation mit 2:

vec = 2, 0, 0, 0

keine Ziffer ist größer als 10. Multiplikation mit 2:

vec = 4, 0, 0, 0

keine Ziffer ist größer als 10. Multiplikation mit 2:

vec = 8, 0, 0, 0

keine Ziffer ist größer als 10. Multiplikation mit 2:

vec = 16, 0, 0, 0

erste Ziffer ist größer als 10, daher Übertrag:

vec = 6, 1, 0, 0

Multiplikation mit 2:

vec = 12, 2, 0, 0

erste Ziffer ist größer als 10, daher Übertrag:

vec = 2, 3, 0, 0

Der aktuelle Vektor stellt also die Zahl 32 dar. Die Multiplikation mit 2 führen wir 1000 mal durch. Anschließend summieren wir die Vektorelemente auf.

Matlab-Code:

vec = zeros(1,302);
vec(1) = 1;

for i = 1 : 1000
    vec = vec .* 2;
    for j = 1 : 301
        if vec(j) >= 10
            vec(j) = vec(j) - 10;
            vec(j + 1) = vec(j + 1) + 1;
        end
    end
end

summe = 0;
for j = 1 : 302
    summe = summe + vec(j);
end

summe

Ergebnis: 1366
Rechenzeit: 0.004519 Sekunden

Wie viele Wege gibt es in einem 20×20 Gitter?

Lösung

Da man nicht in die falsche Richtung gehen darf, muss jeder Weg 20 Bewegungen nach rechts und 20 Bewegungen nach unten enthalten.

Gesucht ist daher die Anzahl der Permutationen dieser Bewegungen. Bei einem 2×2 Gitter lässt sich dies leicht aufschreiben:

0: nach rechts
1: nach unten

mögliche Wege:

0011
0101
0110
1001
1010
1100

also 6 Möglichkeiten.

Die Anzahl der Permutationen lässt sich mit dem Binomialkoeffizienten berechnen:

Dabei ist die Anzahl der zurückgelegten Wegstücke und die Anzahl der Wege nach rechts. Es ist offensichtlich die Anzahl der nötigen Wegstücke das doppelte der Kantenlänge . Die Wegstücke nach rechts sind genau die Kantenlänge:

Dies ist eine Zeile in Matlab:

factorial(40)/(factorial(20)*factorial(20))

Ergebnis: 137846528820

Beginne mit einer natürlichen Zahl n. Ist n gerade, so nimm als nächstes n / 2. Ist n ungerade, so nimm als nächstes 3n + 1.

Erstaunlicherweise endete die Folge bisher immer mit …, 4, 2, 1 – egal welche Startzahl man probiert hat. Die Collatz-Vermutung lautet: Jede so konstruierte Zahlenfolge endet im Zykel 4,2,1 egal, mit welcher natürlichen Zahl man beginnt.

Beispiel: n = 13

Es resultiert die Folge: 13, 40, 20, 10, 5, 16, 8, 4, 2, 1

Wenn wir mit 13 anfangen, erhalten wir eine Folge mit 10 Gliedern. Aus welcher Startzahl n unter einer Millionen folgt die längste Collatz-Kette?

Lösung

Es werden alle Zahlen von 1 bis 1000000 auf die Länge ihrer Collatz-Kette geprüft:

max = [1 1];

for it = 1 : 1000000
    coll = it;
    count = 1;
    while coll ~= 1
        if mod(coll, 2) == 0
            coll = coll / 2;
        else
            coll = coll * 3 + 1;
        end
        count = count + 1;
    end
    if count > max(1)
        max(1) = count;
        max(2) = it;
    end
end

max

Ergebnis: Länge 525 für n = 837799
Rechenzeit: 11.141164 Sekunden

Verbesserungen

Wir müssen die Zahlen von 1 bis 500000 nicht testen, da es jeweils ein gibt, das zu der gleichen Kette führt, nur mit einem zusätzlichen Glied vorweg.
Wir müssen außerdem nur die ungeraden Zahlen testen, da die geraden Zahlen in der oberen Hälfte jeweils das Folgeglied einer ungeraden Zahl in der ersten Hälfte sind.

Verbesserter Algorithmus:

max = [1 1];

for it = 500001 : 2 : 1000000
    coll = it;
    count = 1;
    while coll ~= 1
        if mod(coll, 2) == 0
            coll = coll / 2;
        else
            coll = coll * 3 + 1;
        end
        count = count + 1;
    end
    if count > max(1)
        max(1) = count;
        max(2) = it;
    end
end

max

Rechenzeit: 3.036126 Sekunden