Reihe berechnen nur mit Arithmetik und Logik

Da ich in dem Selben Semester mit dir an der FH D studiere habe ich auch noch eine kleine Frage zum Thema.

meine Reihe sieht so aus :
http://www.bilder-hochladen.net/files/1a0a-7.jpg

und ich bin so weit:

#include<stdio.h>

void main()
{
	printf("*************************************\n");
	printf("*         Schleifenaufgabe          *\n");
	printf("*        Autor: Yannik Baus         *\n");
	printf("*************************************\n\n");

	int m,n,k;
	double p;

	printf("Bitte geben Sie n an:\t");
	scanf_s("%i", &n);

		m=0;
		p=1;
		k=0;

		while(m<=n)	
		{
		p=p+1/k;
		k*3;
		m+1;
		}

	printf("\nDas Ergebnis lautet: %d\n",p);
}

BZW. so weit:

#include<stdio.h>

void main()
{
printf("*************************************\n");
printf("* Schleifenaufgabe *\n");
printf("* Autor: DisasterMaster *\n");
printf("*************************************\n\n");

int m,n,k;
double p;

printf("Bitte geben Sie n an:\t");
scanf_s("%i", &n);

p=1;

for(m=1 ; m<=n ; m++)

for(k=3 ; k>0 ; k=k*3){
p+=1/k;
break;
}

printf("\nDas Ergebnis lautet: %d\n",p);
}

Ich kriege jedoch immer nur eine 0 als antwort.
Bitte schnell um Hilfe.

/edit pumuckl: cpp-Tags. Demnächst bitte selbst machen!

volkard

Die Antwort auf die 0 steht bereits in diesem Thread.
int geteilt durch int ergibt int.

Michael E.

DisasterMaster schrieb:

Ich kriege jedoch immer nur eine 0 als antwort.
Bitte schnell um Hilfe.

Lies dir die erste Seite des Threads durch.

Dummerweise schnall ich es trotzdem nicht. Was muss ich denn jetzt genau machen?

#include<stdio.h>

void main()
{
printf("\n");
printf(" Schleifenaufgabe \n");
printf(" Autor: DisasterMaster \n");
printf("\n\n");

int m,n,k;
double p,f;

printf("Bitte geben Sie n an:\t");
scanf_s("%i", &n);

p=1;

for(m=1 ; m<=n ; m++){

for(k=3 ; k>0 ; k=k*3){
f=1.0/k;
p+=f;
break;
}
}
printf("\nDas Ergebnis lautet: %d\n",p);
}

So zeigt es mir zwar keine 0 mehr an, dafür aber ganz unrealistische Zahlen.

SeppJ

Du hast auch sonst noch sehr viele Grundlagenfehler drin:

void main()
Auch in C heißt dies int main() .

k*3;
Dies berechnet was k*3 ist und verwirft den Wert dann. Es wird nicht der Wert von k verdreifacht!

m+1;
dito.

`

printf("\nDas Ergebnis lautet: %d\n",p); `
%d ist der Formatstring für Integer, p ist ein double.

for(k=3 ; k>0 ; k=k*3){
p+=1/k;
break;
}

Was macht das break dort wohl?

So ich hoffe ich hab die Kritikpunkte richtig verstanden und umgesetzt, jedoch komm jetzt immer 1 raus

#include<stdio.h>

int main()
{
printf("\n");
printf(" Schleifenaufgabe \n");
printf(" Autor: DisasterMaster \n");
printf("\n\n");

int m,n,k,t;
double p,f;

printf("Bitte geben Sie n an:\t");
scanf_s("%i", &n);

k=3;
t=1;
p=1;
for(m=t ; m<=n ; m++){

t=1+1;

for(k=3; m<=n ; m++){

f=1/k;
p=p+f;
k=3*k;
}
}
printf("\nDas Ergebnis lautet: %f\n",p);
}
}

Michael E.

Dann halt zum dritten Mal: 1/k = 0. Auch sonst solltest du nochmal überlegen, wie viele Variablen du brauchst und was die genau machen sollen.

SeppJ

Außerdem ist deine Klammerung glaube ich falsch. Da du es aber selbst beim dritten Anlauf noch nicht hinbekommen hast, deinen Code vernünftig zu formatieren (Benutze den C/C++-Knopf links unter den Smileys), mag ich mir das gerade nicht genauer ansehen.

unskilled

DisasterMaster schrieb:

#include<stdio.h>

int main()
{
  int m,n,k,t;
  double p,f;

  printf("Bitte geben Sie n an:\t");
  scanf_s("%i", &n);

  k=3;
  t=1;
  p=1;
  for(m=t ; m<=n ; m++)
  { 
    t=1+1;
    for(k=3; m<=n ; m++)
    {
      f=1/k;
      p=p+f;
      k=3*k;
    }
  }
  printf("\nDas Ergebnis lautet: %f\n",p);
}

sind keine fehler korrigiert außer die } zu viel.
aber vll guckt es sich jz wer an, wo man es auch lesen kann...
was nen "copyright" in so nem post sucht, werd ich wohl auch niemals verstehen...
naja - vll falls der lehrer googelt sieht er wenigstens, dass es keine fertig-lösung war...

for(m=t ; m<=n ; m++)
  { 
    t=1+1;
    for(k=3; m<=n ; m++)

das sieht beim ersten drübergucken aber mehr als falsch aus

bb

Ich glaube ich habe es geschafft. juhu
Vielen Dank für die große Hilfe!

Werner Salomon

Hallo .. ein kleiner Programmier Contest mit SeppJ und Volkard, da darf mein Beitrag nicht fehlen:

#include <iostream>
#include <cmath> // std::acos (nur zur Kontrolle)
#include <numeric> // accumulate

#include <boost/iterator/iterator_adaptor.hpp>

// --   Folge: 1/(2*m+1)^2
class A : public boost::iterator_adaptor< A, int, double, boost::bidirectional_traversal_tag, const double >
{
public:
    explicit A( int m = 0 ) 
        : iterator_adaptor_( m )
    {}
    double dereference() const 
    { 
        int z = 2 * base() + 1;
        return 1.0 / (double(z) * z); // double(z) sonst integer-overflow!
    }
};

namespace { const double PI = std::acos(-1.0); }

int main () 
{
    using namespace std;

    cout.precision( 8 ); // zeigt den Unterschied zwischen s[n] und s[unendlich]
    const int nn[] = { 0, 1, 2, /*n=*/ 530947 }; // .. zeigen Se das Ergebnis der ersten drei Teilsummen und das Ergebnis für n
    double sum = 0;
    A a(0);
    for( const int* n = nn; n != nn+sizeof(nn)/sizeof(*nn); a = A(*n++ + 1) )
        cout << "n=" << *n << "; sum=" << (sum = accumulate( a, A(*n + 1), sum )) << endl;

    cout << "n=unendlich; sum = " << (PI*PI/8) << endl;
    return 0;
}

Gruß
Werner

Michael E.

[0, 1, 2, 530947].each { |n| puts (0..n).inject(0) { |sum, i| sum + 1.0 / (2*i+1)**2 } }

sum [1/(2*x+1)^2 | x <- [0..530947]]

Michael E.

Haskell schrieb:

sum [1/(2*x+1)^2 | x <- [0..530947]]

Die Ausgabe für n = 0,1,2 fehlt :p

Stimmt. Dann würde ich es wahrscheinlich so machen:
map (\n -> sum [1/(2*x+1)^2 | x <- [0..n]]) [0, 1, 2, 530947]

Also für so etwas sind funktionale Sprachen wirklich gut. Btw.: Welche Sprache ist denn deine, Michael E.?

Michael E.

Ruby. Ich muss schon sagen: Deins ist hübsch Irgendwann beschäftige ich mich auch mal mit Haskell...

Ruby.

Ruby? Das hätte ich jetzt nicht erwartet.

Deins ist hübsch Irgendwann beschäftige ich mich auch mal mit Haskell...

Ja, ich stecke auch noch ganz am Anfang, aber Haskell (oder funktionale Sprachen im Allgemeinen) ist schon faszinierend. Kann ich nur empfehlen.

SeppJ

Dieses kleine Juwel darf natürlich auch nicht fehlen:

#include <iostream>

template<unsigned n> double sum()
{
  return sum<n-1>() + 1./((2*n+1)*(2*n+1));
}

template<> double sum<0>()
{
  return 1.;
}

int main()
{
  std::cout << "0: " << sum<0>() << '\n'
       << "1: " << sum<1>() << '\n'
       << "2: " << sum<2>() << '\n'
       << "530947: " << sum<530947>() << '\n';

}

Funktioniert für Testfälle einwandfrei. Der Fall mit 530947 compiliert bei mir seit 5 Minuten. Spezielle Compileroptionen sind nötig, um die Rekursionstiefe zu erhöhen. Ich melde mich noch einmal wenn das Übersetzen erfolgreich war (falls mir der Speicher nicht vorher überläuft - der Prozess belegt bereits 200 MB).

edit: Nach über einer Stunde und einem halben Gigabyte Speicherverbrauch ist der Compiler immer noch nicht fertig. Ich breche die Sache mal ab, da ich keine Lust habe, dass über Nacht eventuell wichtige Prozesse wegen Speichermangels beendet werden. Wenn jemand einen flotten Rechner mit reichlich RAM rumstehen hat, kann er ja mal ausprobieren, wie lange die Übersetzung braucht. Würde mich jedenfalls sehr interessieren.

brotbernd

Für den msvc hab ich den Schalter nicht gefunden. mingw hört nach einer halben Stunde ohne Meldung einfach auf. Mit welchem Compiler/Optionen hast du es probiert.

SeppJ

brotbernd schrieb:

Für den msvc hab ich den Schalter nicht gefunden. mingw hört nach einer halben Stunde ohne Meldung einfach auf. Mit welchem Compiler/Optionen hast du es probiert.

Mit g++. Der meldet einem quasi sofort, dass die maximale Rekursionstiefe (500) erreicht wurde und dass man diese mit -ftemplate-depth-NN erhöhen kann.

Wenn ich 10000 als Templateargument nehme, dauert das Compilieren bei mir so um die 10-20 Sekunden. Aber ich habe das Gefühl, dies geht nicht linear hoch. 20000 ist schon im niedrigen Minutenbereich. Und das ist immer noch ein Faktor 25 kleiner als der gewünschte Parameter. Vermutlich muss man dafür wirklich mal einen Rechner über Nacht stehen lassen.

Wie lange braucht eigentlich die Haskellversion?