Programm 16^16

HexaPentol

Hallo Leute!

Ich möchte das Ergebnis von 16^16 haben. Nur ein Taschenrechner ist mir zu blöd,
also wollt' ich das ganze als Programm (in C++) schreiben. Nur leider springt die Zahl bei der letzten * 16 Rechnung auf 0 um, obwohl ich unsigned long long int verwende.

Hier ist der Code:

#include <iostream>

using namespace std;

int main()
{
    unsigned long long int summe; // Variable deklarieren
    int i;

    i = 1;  // Die Werte zuweisen
    summe = 16;

    do {
        summe *= 16; // Die Summe immer mal 16
        cout << summe << "\n"; // Jetzige Summe ausgeben
        i++;
    }while(i<=15);

    cout << "\n" << summe; // Entgültige Summe ausgeben
    return 0;
}

Das Ergebnis (Console Application) ist aber wie folgt:

256
4096
65536
1048576
16777216
268435456
4294967296
68719476736
1099511627776
17592186044416
281474976710656
4503599627370496
72057594037927936
1152921504606846976
0

0

Entweder hab ich falsch programmiert, oder ich verwende die Falsche maximal Größe.

Columbo

16^16 = 2^64
I.e. schreib std::uint64_t(-1) in einen String und inkrementiere die letzte Ziffer (sie kann nicht 9 sein ). Der größte Ganzzahltyp, den dein Compiler unterstützten muss, ist unsigned long long , und der wird wohl ein Bit zu klein sein (64 statt 65) .

SeppJ

Falls es dir wirklich nur um das Ziel und nicht den Weg geht, so ist das Ergebnis 18446744073709551616.

tntnet

@SeppJ Deine Signatur ist gut: "Korrekte Rechtschreibung und Grammatik sind das sprachliche Äquivalent zu einer Dusche und gepflegter Kleidung.".

Weil es hier zum Thema passt: "Entgültige" => "Endgültige". Ach ja, und hier das Programm

#include <iostream>
int main()
{
    std::cout << "18446744073709551616" << std::endl;
}

HexaPentol

@Arcoth

Danke, jetzt verstehe ich das auch etwas besser.

@SeppJ

Nein, mir geht es nicht nur um das Ergebnis sondern auch um den Weg. Sonst hätte ich hier überhaupt keinen Beitrag geschrieben.

@tntnet

Warum du auf meinem Beitrag überhaupt antwortest ist mir ein Rätsel. Hauptsache deinen Senf dazu geben? Zusammengefasst besteht deine Antwort daraus, dass du mich auf einen Rechtschreibfehler hinweist. Dass der Code in diesem Fall kompletter Müll ist, muss ich nicht sagen. Du wirst dann warscheinlich nochmal darauf antworten, aber ich werde es dann weder lesen noch darauf reagieren.

Columbo

HexaPentol schrieb:

Warum du auf meinem Beitrag überhaupt antwortest ist mir ein Rätsel.

…und warum du auf seinen Beitrag, gerade weil er dir so sinnentleert erscheint, so vehement antwortest, ist mir ein Rätsel. Posten und posten lassen, sag' ich immer. Falls dir ein Post nicht hilft, lassen. Falls ein Post destruktiv ist, technisch grob falsch und/oder beleidigend, werden Mods das regeln und alte Hasen den Poster zurechtweisen. (Ab und zu werden sogar alte Hasen (bspw. hustbaer) andere, noch viel ältere Hasen (volkard) zurechtweisen! Immer ein Spektakel. Stay tuned!)

Werner Salomon

Hallo HexaPentol,

wenn Du mit Ganzzahlen, die jenseits der maximalen Werte für int&Co stehen, rechnen möchtest, so lohnt sich eine kleine Klasse (hier Zahl), in der Du einfach die Ziffern der Zahl im Dezimalsystem in einem std::vector speicherst.
Da man damit auch rechnen möchte, muss man die einzelnen Rechenoperationen natürlich selbst implementieren. Wobei die Multiplikation mit einem Faktor noch relativ einfach ist.

Könnte dann so aussehen:

#include <ostream>
#include <vector>
#include <cassert>

class Zahl
{
public:
    Zahl( int x = 0 )
        : m_digits()
    {
        assert( x >= 0 );
        do
        {
            m_digits.push_back( x % 10 );
            x /= 10;
        }
        while( x > 0 );
    }

    Zahl& operator*=( int faktor )
    {
        assert( faktor > 0 );
        int carry = 0;
        for( auto& dig: m_digits )
        {
            dig *= faktor;
            dig += carry;
            carry = dig / 10;
            dig %= 10;
        }
        for( ; carry > 0; carry /= 10 )
            m_digits.push_back( carry % 10 );
        return *this;
    }

    friend std::ostream& operator<<( std::ostream& out, const Zahl& z )
    {
        for( auto dig = z.m_digits.rbegin(); dig != z.m_digits.rend(); ++dig )
            out << *dig;
        return out;
    }

private:
    std::vector< int > m_digits;
};

Und jetzt nur noch 'unsigned long long' gegen Zahl austauschen:

int main()
{
    int i = 1;  // Die Werte zuweisen
    Zahl summe = 16;    // Deklarieren und Initialisieren sollte in C++ eins sein

    do {
        summe *= 16; // Die Summe immer mal 16
        cout << summe << "\n"; // Jetzige Summe ausgeben
        i++;
    }while(i<=15);

    cout << "\n" << summe; // Entgültige Summe ausgeben
    return 0;
}

.. und Du erhältst das gewünschte Ergebnis

Gruß
Werner