Quersumme, Folgenglieder addieren



  • Hi Leute,

    ich habe da eine Frage zu dem o.g. Betreff.

    Und zwar: Ich habe einen Anfangswert -> 10.

    Die Quersumme von diesem Wert ist 1, also ist der nächste Wert die 11.
    Jetzt berechne von der 11 wieder de Quersumme und addiere die anderen Folgenglieder dazu, also bisher die 10. Zusätzlich addiere ich die Quersummen aller Folgenglieder dazu. 10+11+1+(1+1)=24

    Mit der 24 wieder das gleich.
    10+11+24+1+(1+1)+(2+4)=54

    usw.

    Bisher habe ich:

    int quersumme=0;
    	int start=10;
    	int value=10;
    	int i=0;
    	printf("10, ");
    
    	do
    	{
    		while(value>0)
    		{
    			quersumme+=value%10;
    			value/=10;
    		}
    		value=start+quersumme;
    
    		printf("%d, ", value);
    		i++;
    	}
    	while(i<50);
    

    Die Ausgabe lautet: 10, 11, 13, 17, 25, ..., also werden hier lediglich die Quersummen aufaddiert.
    Ich komme grad nicht weiter. Hat jemand von euch einen Denkanstoss, wie ich die restlichen Folgenglieder berücksichtige?

    ok, habe es gelöst.

    int main(void)
    {
    	int quersumme=0;	// Quersumme der aktuellen Zahl
    	int start=10;		// starte mit dem Wert 10
    	int i=0;			// Abbruchbedingung und counter für das Array
    	int z=0;			// Hilfvariable für for-schleife innerhalb der while
    	int folge[50];		// Array mit allen Werten
    	folge[0]=10;		// Anfangswert
    	int endwert=0;		// EndWert
    
    	do
    	{
    		quersumme=0;				// quersumme ist hier immer 0
    		while(start>0)				// solange start>10 ist, berechne die Quersumme
    		{
    			quersumme+=start%10;
    			start/=10;
    		}
    		i++;						// erhöhe den Array counter um 1
    		folge[i]=quersumme;			// schreibe die Quersumme der aktuellen Zahl in das Array um eine Position erhöht
    
    		for(z=0;z<=i;z++)			// errechne den nächsten Wert anhand der alten Zahlen und ihrer Quersummen
    			endwert+=folge[z];		// nächste Zahl
    		i++;						// erhöhe den Array counter um 1
    		folge[i]=endwert;			// schreibe die nächste Zahl in das Array um eine Position erhöht
    		start=endwert;				// überschreibe den Startwert
    		endwert=0;					// setze den Endwert für nächste Berechnung wieder auf 0
    	}
    	while(i<50);					// berechne solange die Folgenglieder, bis Bedingung nicht erfüllt
    
    	int a=0;						// Hilfsvariable für die for-Schleife
    	for(a=0;a<50;a+=2)				// a+=2, weil man nur die Zahlen und nicht ihre Quersummen ausgeben möchte
    		printf("%d, ", folge[a]);
    
        return 0;
    }
    

    Allerdings gefällt mir hier die Abbruchbedingung nicht. Wie kann man die "dynamischer" machen, z.b. int außerhalb Wertebereich oder so?
    Jemand eine Idee?

    Grüße,
    sneeker



  • hi!
    du kannst das ganze dynamischer machen, indem du anstelle deiner arrays eine verkettete liste nimmst, vorausgesetzt du willst die zwischenergebnisse speichern.
    den maximalwert von int ( unsigned int wäre hier wohl besser? ) kannst du in limits.h finden http://en.wikipedia.org/wiki/Limits.h

    unsigned number = 4294967295;
    	unsigned another_number = 1;
    
    	if ( 1.0 * number + another_number  > UINT_MAX ) // Konvertierung nach double innerhalb der Klammer.
    		puts ("Touch too much!");
    

    die quersummenberechnung würde ich in eine funktion auslagern.
    die folge für die summenbildung brauchst du nicht immer von vorn zu durchlaufen, wennze den wert zwischenspeicherst.
    wozu ist das ganze mit deinen quersummen und so eigentlich gut? 😃



  • um das mal zu versinnbildlichern:

    #include <stdio.h> 
    #include <stdlib.h> 
    #include <string.h>
    #include <errno.h>
    
    unsigned quersumme ( unsigned zahl )
    {
        unsigned quersumme = 0;
        unsigned rest = 0;
    
        do
    	{
            rest = zahl%10;
            zahl = zahl/10;
            quersumme=quersumme+rest;
        } while (zahl > 0);
    
        return quersumme;
    }
    
    typedef struct zmq ZmQ;  // Zahl mit Quersumme :D
    
    struct zmq
    {
    	unsigned zahl;
    	unsigned quersumme;
    	ZmQ* next;
    };
    
    ZmQ* neues_element()
    {
    	ZmQ* neu = calloc ( 1, sizeof( *neu ));
    	if ( neu == NULL )
    		puts(strerror(errno));
    	return neu;
    }
    
    void zahlengucki ( ZmQ* start )
    {
    	unsigned i = 1;
    	while ( start )
    	{
    		printf ( "%3u) Zahl %11u \t Quersumme %3u\n", i++, 
    								start->zahl, start->quersumme );
    		start = start->next;
    	}
    }
    
    void free_mem ( ZmQ* start )
    {
    	ZmQ* next;
    	while ( start )
    	{
    		next = start->next;
    		free(start);
    		start = next;
    	}
    }
    
    int main()
    {
    	unsigned n = 35;
    	unsigned erste_zahl = 10, summe = erste_zahl, vorher = 0;
    	double checker = 0;
    
    	ZmQ *start, *aktuell;
    
    	start = aktuell = neues_element();
    	if ( start == NULL )
    		return 1;
    	aktuell->zahl = summe;
    	aktuell->quersumme = quersumme ( summe );
    	summe = aktuell->zahl + aktuell->quersumme;
    	vorher = summe;
    
    	while ( n > 1 )
    	{
    		aktuell->next = neues_element();
    		if ( ( aktuell = aktuell->next ) == NULL )
    		{
    			summe = vorher;
    			return 1; // Out of Memory.
    		}
    
    		aktuell->zahl = summe;
    		aktuell->quersumme = quersumme ( summe );
    
    		if (  UINT_MAX < ( checker = 1.0 * aktuell->zahl + aktuell->quersumme + vorher ) ) 
    		{
    			puts("Touch too much!");
    			puts("Press Enter to continue.");
    			getchar();
    			break;
    		}
    
    		summe = checker;
    		vorher = summe;
    		n--;
    	}
    	zahlengucki ( start );
    	printf ( "Summe: %u\n", summe );
    
    	free_mem ( start );
    	return 0;
    }
    

    mfg.



  • Wenn ich das richtig verstehe...

    #include <stdio.h>
    
    unsigned quersumme(unsigned x) {
      if(x < 10) return x;
      return x % 10 + quersumme(x / 10);
    }
    
    int main(void) {
      unsigned x, y;
    
      for(x = 10; x < 1000; x += y) {
        y = x;
        x += quersumme(x);
        printf("%u\n", x);
      }
    
      return 0;
    }
    

    ?



  • sieht schön kurz aus. ab zahl 6 oder so unterscheiden sich aber die ergebnisse.



  • Eh, natürlich. Blöder Denkfehler. So sollte es richtig sein:

    #include <stdio.h>
    
    unsigned quersumme(unsigned x) {
      if(x < 10) return x;
      return x % 10 + quersumme(x / 10);
    }
    
    int main(void) {
      unsigned x;
    
      for(x = 11; x < 10000; x = 2 * x + quersumme(x)) {
        printf("%u\n", x);
      }
    
      return 0;
    }
    


  • seldon schrieb:

    Eh, natürlich. Blöder Denkfehler. So sollte es richtig sein:

    #include <stdio.h>
    
    unsigned quersumme(unsigned x) {
      if(x < 10) return x;
      return x % 10 + quersumme(x / 10);
    }
    
    int main(void) {
      unsigned x;
    
      for(x = 11; x < 10000; x = 2 * x + quersumme(x)) {
        printf("%u\n", x);
      }
    
      return 0;
    }
    

    <TROLL DETECTION INITIATED>
    <WARNING> ⚠ http://img524.imageshack.us/img524/4421/dontfeedthetroll.jpg ⚠ </WARNING>
    <MSG> There were some troll activities </MSG>
    </TROLL DETECTION INITIATED>
    <DONE>



  • Ich nehme einfach mal an, dass du dir nicht die Mühe gemacht hast, den Gedankengang dahinter zu verstehen, also erkläre ich es mal ausführlich:

    Sei q die Quersummenfunktion, so ergibt sich aus der Problembeschreibung

    10 + q(10) = 11
    10 + q(10) + 11 + q(11) = 24
    10 + q(10) + 11 + q(11) + 24 + q(24) = 54

    etc, also

    10 + q(10) = 11
    11 + 11 + q(11) = 24
    24 + 24 + q(24) = 54

    und so weiter. Die Korrelation

    x[n+1] = x[n] + x[n] + q(x[n])

    ist leicht zu sehen. Das Programm setzt das um (mit Ausnahme der 10, die sich aus der Beschreibung nicht entwickeln lässt).

    Oder war das jetzt eine Art Meta-Trolling, um mich zur Trollfütterung zu verleiten?



  • Moin moin was heißt den a+=2 ist a =2 oder wird a mit 2 addiert ?



  • a+=2 ist das gleiche wie a = a+2 💡


Log in to reply