Programm 16^16



  • 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.


  • Mod

    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) .


  • Mod

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



  • @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;
    }
    


  • @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.


  • Mod

    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!)



  • 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


Anmelden zum Antworten