Zahlen von 1 - 100

Visual Newbie

[#include <iostream>
using namespace std;

int main ()

{
int i;

for (i = 0 ; i < 100; i++)

{
cout << " Das Ergebnis von 1 - 100 ist : " << i << endl;

}

return 0;

}]

Wie sag ich ihm, das er alle Ergebnisse zusammenrechnen soll? Oder kann man das ganze auch anders in einer Schleife verpacken???

Vielen Dank

CStoll

Indem du ihm den Auftrag gibt, die einzelnen Werte der Zählvariablen aufzusummieren:

int sum=0;
for(i=1;i<=100;++i)//wenn du bis einschließlich 100 zählen willst, nimm <=
  sum+=i;
cout<<"Summe ist "<<sum<<endl;

-Foo-

#include <iostream>

int main() {
 int summe = 0;
 for( int i = 1; i <= 100; i++ ) {
  summe += i; // summe = summe + i;
 }
 std::cout << "Summe: " << summe << std::endl;

c++-lernen/logisch denken

Visual Newbie

Wie würde ein Structogramm dazu aussehen?

Sascha081088

|---------------------------|
| 100mal                    |
| |-------------------------|
| |sum:=sum+i               |
|---------------------------|
|A:sum                      |
|---------------------------|
|END                        |
|---------------------------|

So oder so ähnlich!

GPC

Kommt schon, bringt mal mehr "Wir-verwirren-die-Einsteiger-weil-sie-zwei-Threads-aufmachen" Vorschläge.

#include <iostream>

template <int N>
struct Sum {
  enum { value = N + Sum<N-1>::value };
};

template <>
struct Sum<1> {
  enum { value = 1 };
};

//blub blub
int main() {
  std::cout<<Sum<100>::value;
return 0;
}

Sascha081088

Nein warum den? Warum kompliziert wenns auch einfach geht?

GPC schrieb:

"weil-sie-zwei-Threads-aufmachen"

GPC

Sascha081088 schrieb:

Nein warum den? Warum kompliziert wenns auch einfach geht?

Du weißt aber schon, dass mein Code ne simple Rekursion zur Compile-Zeit ist, oder? Das ist nicht wirklich komplex.

Sascha081088

Mag schon sein aber für ein Anfänger mag es etwas kompliziert aussehen somal ein Anfänger manche Befehle, Funktionen etc. noch nicht kennt!

#include <iostream>
#include <numeric>
#include <algorithm>
using namespace std;

class InkrementierIterator
{
	int m_wert;

public:
	InkrementierIterator(int wert) : m_wert(wert) {}
	int operator*() const { return m_wert; }

	InkrementierIterator &operator++()
	{
		++m_wert;
		return *this;
	}

	bool operator!=(const InkrementierIterator &anderer) const
	{
		return m_wert != anderer.m_wert;
	}
};

int summe(int erster, int letzter)
{
	return accumulate(InkrementierIterator(erster), InkrementierIterator(letzter+1), 0, plus<int>());
}

int main()
{
	cout << summe(1, 100) << endl;
    cin.get();
}

Jester

wie wär's mit

sumTo(unsigned int limit) 
{
  return limit*(limit+1)/2
}

int main()
{
  cout << sumTo(100);
}

Oder ist da zu einfach und zu schnell?

-Foo-

#include <fstream>
#include <cstdlib>

int main() {
	std::ofstream out( "source.cpp" );
	out << "#include <iostream>" << std::endl
	 	<< "int main() {" << std::endl
		<< "	int sum = 0;" << std::endl;

	for( int i = 0; i < 100; i++ ) {
		out << "	sum = sum";
		for( int y = 0; y < i + 1; y++ ) {
			out << " + 1";
		}
		out << ";" << std::endl;
	}

	out << "	std::cout << \"Summe der Zahlen von 1 bis 100 ist gleich:\"" << std::endl
		<< "		<< sum << std::endl;" << std::endl
		<< "	return( 0 );" << std::endl
		<< "}" << std::endl;

	out.close();

	system( "g++ -o calcs source.cpp" );
	system( "./calcs" );
}

#include <iostream>
int main(){std::cout<<5050<<std::endl;return(0);}