3. Division

Division

  • B

    Hallo Freunde, Hier seht ihr meinen Quotientenblock.

    int q1 = zaehler / x;							
// Beginn Quotientenblock
					int q2 = x / zaehler;
					int diff = zaehler - x; 
					printf("DIFF: %d\n", diff);
					printf("QW/TW: %d\n", q1);
					printf("TW/QW: %d\n", q2);

    Der Ausdruck dazu ist folgender**
    DIFF: 14
    QW/TW: 1
    TW/QW: 0
    TrWurzel= 49 Summe= 1225
    QdWurzel= 35 Qudrt= 1225

    Zeit: 0

    DIFF: 84
    QW/TW: 1
    TW/QW: 0
    TrWurzel= 288 Summe= 41616
    QdWurzel= 204 Qudrt= 41616

    Zeit: 0

    DIFF: 492
    QW/TW: 1
    TW/QW: 0
    TrWurzel= 1681 Summe= 1413721
    QdWurzel= 1189 Qudrt= 1413721

    **

    Irgendwas stimmt nicht, daß er die Division nicht macht. Mit durch Null kann nicht sein, weil laut Ausdruck ja was positives drinn ist in den Zellen. Es kann damit zusammen hängen, daß bei q1 Werte unter Null sind, und die variable die nicht will.

    ich weiss nicht weiter,,,,

    #include <Carbon/Carbon.h>
#include <stdio.h>
#include <ctime>
#include <iostream>

using namespace std;
int main (int argc, char * const argv[])
{
	clock_t t1, t2; // Uhranweisung
    long result;
    t1 = clock(); 

	long long Zaehlgrenze = 10000;										// Initialblock	
	long long zaehler = 1;
	long long trigonal = 0;
	printf("Das Programm sucht innerhalb des Intervalls von 0 bis %d die Zahlen heraus, welche zugleich Quadratzahlen und Trigonalzahlen sind. \n", Zaehlgrenze);

	while (zaehler < Zaehlgrenze)										// Beginn 1. Schleife
	{
	trigonal = trigonal+zaehler;										// Trigonalzahlerhöhung
		for (long long i=1, x = zaehler/2; x*x <= trigonal; i += ++x)  	// Beginn Schleife 2
				if (trigonal== x*x) 
					{

					int q1 = zaehler / x;								// Beginn Quotientenblock
					int q2 = x / zaehler;
					int diff = zaehler - x; 
					printf("DIFF: %d\n", diff);
					printf("QW/TW: %d\n", q1);
					printf("TW/QW: %d\n", q2);							// Ende Quotientenblock

					cout << "TrWurzel=\t " << zaehler  <<"\t" <<" Summe= " << trigonal  << "\nQdWurzel= \t " << x  << "\t Qudrt= " << x*x <<  "\n" <<   endl;
					t2 = clock();														// Zeitnahme
					printf("Zeit: %d\n\n", (t2-t1));
					zaehler = zaehler*5;
					trigonal = zaehler*(zaehler+1)/2;
					}													// Ende If und Ende Schleife 2 im If-Fall
		//printf("Zähler %d\n", zaehler);
		//printf("trigonal %d\n", trigonal);
		//printf("x %d\n", x);
		//printf("quadrat %d\n", x*x);
		zaehler++;														// Zaehlererhöhung
	}																	// Ende Schleife 1
	printf("Das Programm endet mit Zähler %d\n", zaehler);				// Abschlussbericht	
	printf("dessen Trigonalzahl ist %d\n", trigonal);

    result = static_cast<long>( (t2-t1)/CLOCKS_PER_SEC);
	printf("Zeit: %d\n", (t2-t1)); // Zeitdruck
printf("Resultat: %d\n", result);
	return 0;	
}
    0
  • N

    Was du machst, ist eine Division von Ganzzahlen. Da werden beim Ergebnis immer die Nachkommastellen abgeschnitten. Wenn du Nachkommastellen haben willst, solltest du mit float oder double rechnen. Oder zumindest ein static_cast einbauen.

    0
  • B

    1. Wo deklarierst und definierst du eigentlich deine Variable x?

    2. In deiner for-Schleife deklarierst du immer wieder deine Variablen q1, q2, etc. neu. Das ist meiner Meinung nach ein ganz schlechter Stil und erfüllt sicher nicht das, was du dir gedacht hast.

    3. Du teilst immer Integerwerte durcheinander. Das führt dazu, dass Nachkommastellen nicht gespeichert werden.

    4. Das ist reiner C-Code. Du brauchst also kein <iostream> einbinden.

    0
  • U

    1. wird unter C++ std::cout genutzt und das include sollte so heißen: #include <cstdio>

    2. musst du für ne "richtige" Division auch float/float bzw double/double rechnen...

    int q2 = x / zaehler;
//bsp.:
int q2 = 100 / 30;
int q2 = 3;
/*alle dezimalstellen werden also einfach abgeschnitten... 99/100 ist also auch 0*/
//--------------------------
float q2 = (float)x / (float)zaehler;
//wieder unser bsp.:
float q2 = 100/30 == 10/3;
float q2 = 3,3333333;

    result = static_cast<long>( (t2-t1)/CLOCKS_PER_SEC);

    ist noch immer falsch...

    4. ein Thread pro Thema würde auch reichen... (mir kams doch von anfang an bekannt vor - da hätt ichs mir au sparen können : / )
    http://www.c-plusplus.net/forum/viewtopic-var-t-is-220904-and-start-is-10.html

    bb

    PS: @all: ich würds lassen, ihm iwas erklären zu wollen - anscheind is er unfähig zu lesen (wie man am letzten thread merkt)...

    0
  • B

    Hallo, also ich hab in Double umgewandelt und die Deklaration in den Dekl. Block an den Anfang verlegt.

    Ergebnis:
    **
    DIFF: 14
    QW/TW: 0
    TW/QW: 0
    TrWurzel= 49 Summe= 1225
    QdWurzel= 35 Qudrt= 1225

    Zeit: 0

    DIFF: 84
    QW/TW: 0
    TW/QW: 0
    TrWurzel= 288 Summe= 41616
    QdWurzel= 204 Qudrt= 41616

    Zeit: 0

    **

    Das scheint nicht zu reichen....

    0
  • B

    Hallo @all

    ER VERSTEHT NICHT ALLES BEIM ERSTEN MAL......

    0
  • N

    brak schrieb:

    Hallo, also ich hab in Double umgewandelt

    Das glaube ich dir nicht. Bestimmt ist der Resultattyp immer noch int . Aber wenn du nicht bereit bist, den neuen Code zu zeigen, können wir dir auch nicht helfen...

    brak schrieb:

    Hallo @all

    ER VERSTEHT NICHT ALLES BEIM ERSTEN MAL......

    Kein Grund, für das selbe Problem zwei Threads aufzumachen.

    0
  • U

    brak schrieb:

    ER VERSTEHT NICHT ALLES BEIM ERSTEN MAL......

    Wie lächerlich... Du kannst ja mal die beiden Threads durchgehen und zählen, wie oft dir jemand erklärt hat, was du falsch gemacht hast...
    Ich hab dir dazu auch noch was aus der MSDN kopiert, was du so 1:1 übernehmen konntest - und du hast es einfach ignoriert... Also heul jz mal nich rum und lies noch mal alles in Ruhe durch, probiers noch mal und poste dann noch mal, was du gerade hast oder lass es bleiben, verkauf deinen PC und kauf dir ne Konsole und spiel was ohne Nachdenken...

    bb

    0
  • B
     

    diff = zaehler - x;								// Beginn Quotientenblock
					float q1 = (float)zaehler / (float)x;								
					float q2 = (float)x / (float)zaehler;

    So hab ichs gemacht.
    Das ist das Ergebnis:

    DIFF: 84
    QW/TW: -1610612736
    TW/QW: -1610612736
    TWu= 288 Su= 41616
    QWu= 204 Qu= 41616

    Zeit: 0

    DIFF: 492
    QW/TW: -2147483648
    TW/QW: 1610612736
    TWu= 1681 Su= 1413721
    QWu= 1189 Qu= 1413721

    Das mit dem include # include <sctdio> stimmt auch nicht. Ohne iostream gibts immer ERROR

    0
  • B

    Wir wollen mal nicht ärgerlich werden... Es ist ja alles freiwillig.

    Hier den Code zur Controlle.

    #include <Carbon/Carbon.h>
#include <stdio.h>
#include <ctime>
#include <iostream>
//#include <cstdio>
using namespace std;
int main (int argc, char * const argv[])
{
	clock_t t1, t2; // Uhranweisung
    long result;
    t1 = clock(); 

	long long Zaehlgrenze = 10000;										// Initialblock	
	long long zaehler = 1;
	long long trigonal = 0;
	int diff;
	float q1, q2;
	printf("Das Programm sucht innerhalb des Intervalls von 0 bis %d die Zahlen heraus, welche zugleich Quadratzahlen und Trigonalzahlen sind. \n", Zaehlgrenze);

	while (zaehler < Zaehlgrenze)										// Beginn 1. Schleife
	{
	trigonal = trigonal+zaehler;										// Trigonalzahlerhöhung
		for (long long i=1, x = zaehler/2; x*x <= trigonal; i += ++x)  	// Beginn Schleife 2
				if (trigonal== x*x) 
					{
					diff = zaehler - x;								// Beginn Quotientenblock
					float q1 = (float)zaehler / (float)x;								
					float q2 = (float)x / (float)zaehler;

					printf("DIFF: %d\n", diff);
					printf("QW/TW: %d\n", q1);
					printf("TW/QW: %d\n", q2);							// Ende Quotientenblock

					cout << "TWu=\t " << zaehler  <<"\t" <<" Su= " << trigonal  << "\nQWu= \t " << x  << "\t Qu= " << x*x <<  "\n" <<   endl;
					t2 = clock();														// Zeitnahme
					printf("Zeit: %d\n\n", (t2-t1));
					zaehler = zaehler*5;
					trigonal = zaehler*(zaehler+1)/2;
					}													// Ende If und Ende Schleife 2 im If-Fall
		//printf("Zähler %d\n", zaehler);
		//printf("trigonal %d\n", trigonal);
		//printf("x %d\n", x);
		//printf("quadrat %d\n", x*x);
		zaehler++;														// Zaehlererhöhung
	}																	// Ende Schleife 1
	printf("Das Programm endet mit Zähler %d\n", zaehler);				// Abschlussbericht	
	printf("dessen Trigonalzahl ist %d\n", trigonal);

    result = static_cast<long>( (t2-t1)/CLOCKS_PER_SEC);
	printf("Zeit: %d\n", (t2-t1)); // Zeitdruck
printf("Resultat: %d\n", result);
	return 0;	
}
    0
  • U

    auch wenn sich das ganze nicht wirklich bei dir bessert...
    Ich hab ma versucht, bissl was lesbares daraus zu machen - hoffe mal, dass das ich damit nichts kaputt gemacht hab ^^ war zu faul zum nachdenken - wieso auch, wenn du das auch nicht machst...

    #include <ctime>
#include <iostream>

int main (int argc, char * const argv[])
  {
    const clock_t t1 (clock ());

    const size_t max (10000);
    size_t trigonal (0);
    std::cout << "Das Programm sucht innerhalb des Intervalls von 1 bis "
      << max
      << " die Zahlen heraus, welche zugleich Quadratzahlen und Trigonalzahlen sind"
      << std::endl;

    size_t zaehler (0);
    for (; zaehler < max; ++zaehler)
      {
        trigonal += zaehler;
        for (size_t i (1), x = zaehler/2; x*x <= trigonal; i += ++x)
          {
            if (trigonal== x*x) 
              {
                diff = zaehler - x;
                const float q1 = (float)zaehler / (float)x;
                const float q2 = 1 / q1;

                std::cout << clock () << std::endl <<
                  << "\t" << "DIFF:\t" << diff << "\r\n"
                  << "\t" << "QW / TW:\t" << q1 << "\r\n"
                  << "\t" << "TW / QW:\t" << q2 << std::endl;

                std::cout << "\t" << "TWu=\t" << zaehler << "\r\n"
                  << "\t" << "Su=\t" << trigonal << "\r\n"
                  << "\t" << "QWu=\t" << x << "\r\n"
                  << "\t" << "Qu=\t" << x*x << std::endl;

                zaehler *= 5;
                trigonal = zaehler*(zaehler+1) / 2;
              }
          }
      }
    std::cout << "Das Programm endet mit Zaehler " << zaehler << ".\r\n"
      << "dessen Trigonalzahl ist " << trigonal;
    const clock_t t2 (clock ());
    const float dt = (double) (t2-t1) / CLOCKS_PER_SEC;
    std::cout << "Benoetigte Zeit dafuer: " << dt << std::endl;
    return 0;	
  }

    for (size_t i (1), x = zaehler/2; x*x <= trigonal; i += ++x)
  {
    if (trigonal== x*x) {}
  }

    sieht ineffektiv aus, oder? du brauchst davon doch gar nichts - sind alles nur hilfsvariablen, oder?

    außerdem ist das alles viel zu lang... versuch doch mal, das ganze mit klassen zu machen...

    /*trigonalzahl.hpp*/
template <class Tnumber, class Tcount = Tnumber>
  class TTrigonalZahl
    {
      private:
        Tcount count;
        Tnumber number;
      public:
        TTrigonalZahl ()    :  count (1), number (1)    {}
        TTrigonalZahl (size_t steps)
          :  count (1), number (1)
          {
            Steps (--steps);
          }
        void Next ()          {number += ++count;}
        void Steps (const size_t count)
          {
            for (size_t i (0); i != count; ++i)
              this->Next ();
          }
        TTriangonalZahl& operator ++ ()
                              {Next (); return *this;}
        Tnumber Get () const  {return number};
    };

    für das Stoppen würde ich auch ne Klasse bevorzugen...

    /*stopuhr.hpp*/

#include <ctime>

class TTimeDiff
  {
      private:
        const clock_t start;
        float &time;
      public:
        TTimeDiff (float &_time) : start (clock ()), time (_time) {}
        ~TTimeDiff ()             {Now ();}

        void Now ()
          {
            const clock_t end (clock ());
            time = (float) (end-start) / CLOCKS_PER_SEC;
          }
  };

    also haben wir:

    (da ich nicht genau verstanden hab, was du nun machen willst und was nicht, hab ichs einfach mal so gemacht)

    #include "trigonalzahl.hpp"
#include "stopuhr.hpp"
#include <iostream>

int main ()
  {
    float time (0);
    TTimeDiff TimeDiff (time);
      {
        size_t max (-1);
        std::cout << "Geben Sie das Maximum ein";
        std::cin >> max;
        while (max == -1)
          {
            std::cout << "Falsche Eingabe - Sie muessen eine ganze Zahl im Bereich von 0...2^31-2 eingeben";
            std::cin >> max;
          }
        for (TTrigonalZahl <size_t> tzahl; tzahl.Get () < max; ++tzahl)
          {
            TTrigonalZahl <size_t> i (1);
            for (; i.Get () * i.Get () < tzahl.Get (); ++i)
              {}
            if (i.Get () * i.Get () == tzahl.Get ())
              {
                TimeDiff.Now ();
                std::cout << "[" << time << "] Die Trigonalzahl " << tzahl.Get () << " ist gleichzeitig das Quadrat einer anderen Trigonalzahl (" << i << ")" << std::endl;
              }
          }
      }
    std::cout << "Benoetigte Zeit:" << time << std::endl;
  }

    hatte gerade lange weile - kannst mich ja ma davon überzeugen, dass die Zeit ne ganz verschwendet war...

    bb

    0
Anmelden zum Antworten