int felder addieren / subtrahieren

life_drake

Hallo!

Und zwar hab ich folgende Frage:

Ich habe zwei int Felder; man nenne sie v1 = {1, 2, 3} und v2 = {2, 7, 9}.
Wie kann man nun diese Felder schnellst möglich addieren bzw. subtrahieren?

Folgendes Schema:
z.B.: v3[2] = v2[2] + v1[2] und wenn die Zahl größer als 9 dann mach einen Übertrag auf die nächste Zahl.

Dies ist zwar gut und schön; so richtiges Grundschulmathe halt.

Doch gibt es eine für den Computer schnellere Methode zwei int Felder miteinander zu addieren bzw. zu subtrahieren?

for (int i=0;i<3;i++)
{
    v3[i] = v1[i] + v2[i];
    v4[i] = v1[i] - v2[i];
}

hustbaer

Naja, zumindest die i386 Familie kann direkt mit BCDs rechnen, gibts eigene Befehle dafür. Dazu musst du aber wohl inline assembler verwenden, und es wird auch nicht eine Dezimalstelle pro "int" verwendet, sondern pro Dezimalstelle ein "nibble" (4 Bit) - also 2 Dazimalstellen pro Byte.

life_drake

Ok! Danke für die Antwort! Dass heißt dann wohl, dass ich es auf die alte herkömmliche Methode machen werd.

@kurze Frage:
schöne for - Schleife aus der Interpretation meines Textes! Doch trotzdem hast du den Übertrag vergessen!

life_drake schrieb:

Doch trotzdem hast du den Übertrag vergessen!

was soll ein ÜBERTRAG denn sein?

Shinja

Er meint damit wohl, dass du, wenn die Summer 2er Ziffern bei dieser Rechnung >9 wird, du das auf die nächste Zehnerpotenz aufrechnen musst.

life_drake

Wie schon am Anfang erwähnt:

life_drake schrieb:

Folgendes Schema:
z.B.: v3[2] = v2[2] + v1[2] und wenn die Zahl größer als 9 dann mach einen Übertrag auf die nächste Zahl.

Werner Salomon

life_drake schrieb:

Doch gibt es eine für den Computer schnellere Methode zwei int Felder miteinander zu addieren bzw. zu subtrahieren?

Eine schnellere Methode als die von Dir angedeutete wird es wohl nicht geben; nur der Computer macht es schneller als Du.

Hier mein Vorschlag:

#include <iostream>
#include <algorithm>
#include <iterator>

struct Add
{
    Add() : m_carry(0) {}
    int operator()( int a, int b )
    {
        int res = a + b + m_carry;
        if( res > 9 )
        {
            m_carry = 1;
            res -= 10;
        }
        else
            m_carry = 0;
        return res;

    }
private:
    int m_carry;
};

struct Sub
{
    Sub() : m_carry(0) {}
    int operator()( int a, int b )
    {
        int res = a - b - m_carry;
        if( res < 0 )
        {
            m_carry = 1;
            res += 10;
        }
        else
            m_carry = 0;
        return res;

    }
private:
    int m_carry;
};

int main()
{
    using namespace std;
    int v1[] = {2, 7, 9};
    int v2[] = {1, 8, 3};
    const size_t N = sizeof(v1) / sizeof(*v1);
    int v3[N];
    typedef reverse_iterator< int* > Ri;
    transform( Ri( v1 + N ), Ri( v1 ), Ri( v2 + N ), Ri( v3 + N ), Add() ); // addieren
    copy( v3, v3 + N, ostream_iterator< int >( cout << "Summe= ", " " ) ); // ausgeben
    cout << endl;
    transform( Ri( v1 + N ), Ri( v1 ), Ri( v2 + N ), Ri( v3 + N ), Sub() ); // subtrahieren
    copy( v3, v3 + N, ostream_iterator< int >( cout << "Differenz = ", " " ) ); // ausgeben
    cout << endl;

    return 0;
}

Gruß
Werner

life_drake

hmmm ... nett; interessanter Vorschlag

Als ich gesehen habe, dass der nächste Beitrag von Werner Salomon ist, habe ich mir schon gedacht das wieder was schönes mit STL und Funktionsobjekten kommen wird.
Wie immer ... ( *direkt Code abspeichern* )

hustbaer

Oder natürlich noch viel besser: du konvertierst deine Dezimalstellen in Integers, und rechnest dann mit denen. Zur Ausgabe rechnest du es halt wieder zurück.

life_drake

@hustbaer
Schnelligkeit ist wohl nicht deine Stärke!

hustbaer

@life_drake:
Was willst du von mir?