Quersumme (Checksum) aus einer long int ermitteln

Peter Piksa

Hallo.

Gibt es eine Funktion die mir aus einer long int Variable die Quersumme ermittelt?

also das hier macht:
zahl = 4561;
quersumme = 4+5+6+1
//quersumme = 16
return(quersumme);

Ich hab mir nämlich sowas mal selbst geschrieben und wollt mal wissen obs das nicht schon gibt...

hmm gibts ned außer eigene geschriebene

Peter Piksa

*lach* gibtz ja nicht. die deppen haben an jeden möglichen scheiss gedacht ausser an sowas *nichtglaubenmag*

Wie oft braucht man eine Funktion, die eine Quersumme berechnet?
Für eine Checksumme sind andere Verfahren viel besser geeignet.

/* Quelle:
**   http://www.hp-gramatke.de/info/german/page0050.htm#Quersumme 
*/

#include <iostream>

namespace Variante_1 {
  /* Die Quersumme einer nicht-negativen ganzen Dezimalzahl x ist durch
  ** die Summe ihrer Ziffern definiert. Eine offenbar sehr einfache
  ** Aufgabe stellt das Berechnen der Quersumme einer ganzen Zahl mittels
  ** Computer dar. Das sollte natürlich hübsch verpackt als wiederverwend-
  ** bare Funktion bereitgestellt werden. Aufgaben mit diesem Schwierig-
  ** keitsgrad kommen durchaus in der Praxis vor. Als Anfängerübung werden
  ** sie ebenfalls gerne verwendet.
  **
  ** Der spontane Ansatz wird von einem geübten C-Programmierer direkt in
  ** den Rechner gehackt - langes Nachdenken erübrigt sich offenbar:
  */
int qsum(int x)
{
  int sum = 0;
  while (x)
    {
      sum += x % 10;
      x /= 10;
    }
  return sum;
}
  /* Das ist eine ganz entzückende Funktion. Solange die Eingabe nicht
  ** verbraucht wurde, spaltet sie mit einer modulo-Division die jeweils
  ** letzte Ziffer ab und addiert sie zu einem Puffer. Anschließend wird
  ** die Eingabe um die letzte Ziffer verkürzt. Rückgabe des Ergebnisses - fertig!
  **
  ** Wie schon erwähnt, eine entzückende Funktion - nur hat sie zwei Schönheitsfehler:
  **
  ** - Sie läuft unrichtig, wenn ein negativer Wert als Aktualparameter x übergeben wird.
  ** - Sie funktioniert nicht für die Quersummenberechnung von 54321.
  */
}

namespace Variante_2 {
  /* Der erste Einwand läßt sich entkräften, indem die aufrufende Funktion
  ** dafür sorgt, daß kein negativer Wert als Aufrufparameter übergeben wird.
  ** Der zweite Schönheitsfehler läßt sich auch durch eine solche Maßnahme nicht
  ** beseitigen, da der Wertebereich bei int für gewöhnlich nur bis 32767 reicht.
  ** Der geübte C-Programmierer weiß natürlich auch hier sofortige Abhilfe. Es
  ** müssen eben der Formalparameter x und die Variable sum auf long int umgestellt
  ** werden - und bei der Konstanten 10 schadet es auch nicht:
  */
long int qsum(long int x)
{
  long int sum = 0L;
  while (x)
    {
      sum += x % 10L;
      x /= 10L;
    }
  return sum;
}
  /* Die neue Funktion berechnet die Quersumme von 54321 ganz vorzüglich, scheitert
  ** aber an der Quersumme einer 12-ziffrigen Zahl. Mancher Kunstprogrammierer fängt
  ** jetzt das Meckern an: .Du weißt wirklich nicht, was Du willst. Erst gefällt Dir
  ** int nicht, dann long int nicht - und nun willst Du etwas, was keiner in der
  ** Praxis braucht."
  **
  ** Da ist was dran. Die Aufgabenstellung war unpräzise formuliert. Also gut, nehmen
  ** wir an, meine Praxis bräuchte das Berechnen der Quersumme ganzer Zahlen, die
  ** gelegentlich mal 200 Ziffern lang sein können. Vor einigen Jahren brauchte meine
  ** Praxis tatsächlich so was...
  */
}

namespace Variante_3 {
  /* Ein Wechsel der Sichtweise auf die Aufgabenstellung ist zwangsweise nötig. Ein
  ** genauerer Blick zeigt, daß das Abtrennen jeder Ziffer zwei Divisionen durch 10
  ** erfordert. Das ist ganz schön aufwendig. Das Aufaddieren der einzelnen Ziffern
  ** will ich hier nicht gesondert bewerten, da es unabhängig von der Rechenmethode
  ** ohnehin geschehen muß.
  **
  ** Wer sich bewußt macht, daß im gewöhnlichen Leben Zahlen durch das Aufschreiben
  ** von Ziffern dargestellt werden, kommt der Lösung der Aufgabe ein gutes Stück
  ** näher. Die Divisionen sind genaugenommen nur durch die interne Darstellung der
  ** Zahlen im Rechner bedingt. Folgerung: Wenn die bisherige Darstellung ungünstig
  ** war, dann muß eine bessere verwendet werden. Eine, die eine Aufschreibung
  ** darstellt, aber keine Codierung. Wie wäre es, einen Eingabestring zu verwenden?
  */
long int qsum(char * x)
{
  long int sum = 0L;
  while (*x)
    {
      sum += (long)(int)(*x - '0');
      x++;
    }
  return sum;
}
  /* Unter der Voraussetzung, daß eine gültige Zifferneingabe vorliegt, was billiger-
  ** weise angenommen darf (haben wir nämlich vorhin auch zugestanden), verringert
  ** sich der Rechenaufwand pro Ziffer auf eine Subtraktion, eine Addition und das
  ** Weiterschalten eines Lesezeigers. Auf der untersten Maschinenebene sind das
  ** also drei Additionen pro Ziffer, was eine erfreuliche Verbesserung darstellt.
  ** Das gilt auch bei kurzen Zifferneingaben. Der einzige Wermutstropfen dieser
  ** Funktion: Auch sie verarbeitet nur ganze Zahlen bis zu einer bestimmten Länge n,
  ** die durch den Wertebereich des Typs long int gegeben ist. Eine Abschätzung kann
  ** davon ausgehen, daß pro Ziffer die Summe um maximal 9 wächst. Eine Zahl, die nur
  ** aus der Ziffer 9 aufgebaut ist, erreicht am frühesten das Limit.
  **
  ** n = ((2^31)-1)/9 = 238609294
  **
  ** Fazit: da Ganzzahlen von knapp 2,4 Milliarden Ziffern Länge in der Praxis eher
  ** selten verarbeitet werden, sollte uns das Ergebnis vorerst genügen. Aber auch
  ** für kurze Ziffernfolgen lohnt es sich, über die geeignete interne Darstellung
  ** des Datenobjektes nachzudenken.
  */
}

int main()
{
  std::cout << "Variante_1::qsum(4561)   = " << Variante_1::qsum(4561) << std::endl;
  std::cout << "Variante_2::qsum(4561)   = " << Variante_2::qsum(4561) << std::endl;
  std::cout << "Variante_3::qsum(\"4561\") = " << Variante_3::qsum("4561") << std::endl;

  return 0;
}

Daniel E.

Original erstellt von Peter Piksa:
*lach* gibtz ja nicht. die deppen haben an jeden möglichen scheiss gedacht ausser an sowas *nichtglaubenmag*

Huch? C (und C++ noch viel mehr) werden doch immer wieder gerne deswegen kritisiert, weil sie an so viel 'Scheiß nicht gedacht haben'. Um die Quersumme im Dezimalsystem zu berechnen braucht man übrigens keine Funktion, sondern den Modulooperator mit dem Dividend[1] 'zahl' und dem Divisor[1] 9.

[1]: Wie lautet die korrekte Terminologie für Modulo?

[ Dieser Beitrag wurde am 13.03.2003 um 15:04 Uhr von Daniel E. editiert. ]

Peter Piksa

Is ja heftig!

Hätte nicht gedacht dass man das mit so wenig Sourcecode machen kann....schaut euch mal meinen an *lach*

long int quersumme(long int fkt_zahl)
{
    long int zahl = fkt_zahl;
    long int last_zahl = zahl;
    long int count_1000000000 = 0, 
            count_100000000 = 0,
            count_10000000 = 0,
            count_1000000 = 0,
            count_100000 = 0,
            count_10000 = 0,
            count_1000 = 0,
            count_100 = 0,
            count_10 = 0,
            count_1 = 0;
    long int zwischenwert = 0;

    if (zahl >= 1000000000)
    {
        while ((zahl/1000000000) >= 1)
        {
            count_1000000000++;
            zahl = zahl-1000000000;
            //printf("%d\n", zahl);
        }
    printf("%ld wurde %ldx durch 1000000000 geteilt\n", last_zahl, count_1000000000);
    last_zahl = zahl;
    }

    if (zahl >= 100000000)
    {
        while ((zahl/100000000) >= 1)
        {
            count_100000000++;
            zahl = zahl-100000000;
            //printf("%d\n", zahl);
        }
    printf("%ld wurde %ldx durch 100000000 geteilt\n", last_zahl, count_100000000);
    last_zahl = zahl;
    }

    if (zahl >= 10000000)
    {
        while ((zahl/10000000) >= 1)
        {
            count_10000000++;
            zahl = zahl-10000000;
            //printf("%d\n", zahl);
        }
    printf("%ld wurde %ldx durch 10000000 geteilt\n", last_zahl, count_10000000);
    last_zahl = zahl;
    }

    if (zahl >= 1000000)
    {
        while ((zahl/1000000) >= 1)
        {
            count_1000000++;
            zahl = zahl-1000000;
            //printf("%d\n", zahl);
        }
    printf("%ld wurde %ldx durch 1000000 geteilt\n", last_zahl, count_1000000);
    last_zahl = zahl;
    }

    if (zahl >= 100000)
    {
        while ((zahl/100000) >= 1)
        {
            count_100000++;
            zahl = zahl-100000;
            //printf("%d\n", zahl);
        }
    printf("%ld wurde %ldx durch 100000 geteilt\n", last_zahl, count_100000);
    last_zahl = zahl;
    }

    if (zahl >= 10000)
    {
        while ((zahl/10000) >= 1)
        {
            count_10000++;
            zahl = zahl-10000;
            //printf("%d\n", zahl);
        }
    printf("%ld wurde %ldx durch 10000 geteilt\n", last_zahl, count_10000);
    last_zahl = zahl;
    }

    if (zahl >= 1000)
    {
        while ((zahl/1000) >= 1)
        {
            count_1000++;
            zahl = zahl-1000;
            //printf("%d\n", zahl);
        }
    printf("%ld wurde %ldx durch 1000 geteilt\n", last_zahl, count_1000);
    last_zahl = zahl;
    }

    if (zahl >= 100)
    {
        while ((zahl/100) >= 1)
        {
            count_100++;
            zahl = zahl-100;
            //printf("%d\n", zahl);
        }
    printf("%ld wurde %ldx durch 100 geteilt\n", last_zahl, count_100);
    last_zahl = zahl;
    }

    if (zahl >= 10)
    {
        while ((zahl/10) >= 1)
        {
            count_10++;
            zahl = zahl-10;
            //printf("%d\n", zahl);
        }
    printf("%ld wurde %ldx durch 10 geteilt\n", last_zahl, count_10);
    last_zahl = zahl;
    }

    if (zahl >= 1)
    {
        while ((zahl/1) >= 1)
        {
            count_1++;
            zahl = zahl-1;
            //printf("%d\n", zahl);
        }
        printf("%ld wurde %ldx durch 1 geteilt\n", last_zahl, count_1);
    }

    zwischenwert = (count_1000000000 + count_100000000 + count_10000000 + count_1000000 + count_100000 + count_10000 + count_1000 + count_100 + count_10 + count_1);
    return(zwischenwert);
}

joa du hast viel zu lernen ach uebrigens du STINKST

Original erstellt von Peter Piksa:
**Is ja heftig!

Hätte nicht gedacht dass man das mit so wenig Sourcecode machen kann....schaut euch mal meinen an *lach*
**

Du kannst das ganze ja auch als dreizeiler schreiben:

#include <stdio.h>

long int qsum(long int x)
{
  long int sum;
  for(sum=0L;x;sum+=x%10L,x/=10L);
  return sum;
}

int main()
{
  printf("qsum(4561) = %i\n", qsum(5461));
  return 0;
}

Peter Piksa

Was bedeutet 10L und was ist x/=10L

[ Dieser Beitrag wurde am 13.03.2003 um 21:45 Uhr von Peter Piksa editiert. ]

Legolas

Moin,

L ->

integer constants in any of the three bases may be followed by an 'l' or 'L' to indicate a long constant, like 17l or 0xFfL

einfach mal Google oder ein gutes Buch fragen ... oder selber wissen

Legolas