Lottozahlenprogramm Hilfe!

Belli

int i, ziehungen = 0;
initialisiert nur ziehungen ...

#include <iostream>
#include <vector>
#include <ctime>

template<typename T>
void swap(T &var1, T &var2) {
	T temp = var1;
	var1 = var2;
	var2 = temp;
}

template<typename T>
void mix_vector(std::vector<T> &vec) {
	srand((unsigned)time(NULL));
	for(size_t i = 0; i < vec.size(); ++i) {
		size_t ran_num1 = rand() % vec.size();
		size_t ran_num2 = rand() % vec.size();
		swap(vec[ran_num1], vec[ran_num2]);
	}
}

template<typename T>
void bubble_sort(std::vector<T> &vec) {
	bool swapped;
	do {
		swapped = false;
		for(size_t i = 0; i < vec.size()-1; ++i) {
			if(vec[i] > vec[i+1]) {
				swap(vec[i], vec[i+1]);
				swapped = true;
			}
		}
	} while(swapped);
}

int main() {
	const int LOTTO_NUMS = 49;
	int max_nums;
	do {
		std::cout << "Anzahl der Lottozahlen, die gezogen werden sollen: ";
		std::cin >> max_nums;
	} while(max_nums < 1 || max_nums > 12);

	std::vector<unsigned int> lotto_nums(LOTTO_NUMS);
	for(size_t i = 0; i < lotto_nums.size(); ++i)
		lotto_nums[i] = i+1;

	mix_vector(lotto_nums);

	for(size_t i = 0; i < LOTTO_NUMS-max_nums; ++i)
		lotto_nums.pop_back();

	bubble_sort(lotto_nums);

	std::cout << "Die " << max_nums << " Lottozahlen lauten: ";
	for(int i = 0; i < max_nums; ++i)
		std::cout << lotto_nums[i] << ' ';
}

Achso, ähm... Der vector ist einfach eine sicherere Methode als new und delete zu benutzen.
Ist also ziemlich leicht wie du siehst.

Skym0sh0

Ich frage mich wie man bei solchen Fragestellungen/Fragern noch antwortet.
Und ihr habt ja echt teilweise noch Hoffnung, dass es den Fragestellern wichtig ist oder die sich mit der Materie beschäftigen oO

Skym0sh0 schrieb:

Ich frage mich wie man bei solchen Fragestellungen/Fragern noch antwortet.
Und ihr habt ja echt teilweise noch Hoffnung, dass es den Fragestellern wichtig ist oder die sich mit der Materie beschäftigen oO

Wenn es wirklich eine Hausaufgabe ist, dann muss er sich wohl damit beschäftigen, denn sonst wird er bald ein richtiges Problem in der Schule / Uni haben. Was er daraus macht ist nicht mein Ding.

volkard

#include <iostream>
#include <vector>
#include <ctime>

template<typename T>
void swap(T &var1, T &var2) {
	T temp = var1;
	var1 = var2;
	var2 = temp;
}
//Ok, aber std::swap würde uch gehen. Sagen wir mal, außer std::vector will man 
//die STL meiden. 

template<typename T>
void mix_vector(std::vector<T> &vec) {
	srand((unsigned)time(NULL));//Nicht hier. Immer nur am ANfang der main()
	for(size_t i = 0; i < vec.size(); ++i) {//Warum alle und nicht nur max_nums?
		size_t ran_num1 = rand() % vec.size();//Ungeschickt. http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle
		size_t ran_num2 = rand() % vec.size();
		swap(vec[ran_num1], vec[ran_num2]);
	}
}

template<typename T>
void bubble_sort(std::vector<T> &vec) {
	bool swapped;
	do {
		swapped = false;
		for(size_t i = 0; i < vec.size()-1; ++i) {
			if(vec[i] > vec[i+1]) {
				swap(vec[i], vec[i+1]);
				swapped = true;
			}
		}
	} while(swapped);
}
//statt swapped ist es geschickter, den maximalen Index sich zu merken, wo 
//noch eine Vertauschung stattgefunden hatte und im nächsten Durchlauf bis 
//dahin nur zu laufen. 

int main() {
	const int LOTTO_NUMS = 49;
	int max_nums;
	do {
		std::cout << "Anzahl der Lottozahlen, die gezogen werden sollen: ";
		std::cin >> max_nums;
	} while(max_nums < 1 || max_nums > 12);

	std::vector<unsigned int> lotto_nums(LOTTO_NUMS);
	for(size_t i = 0; i < lotto_nums.size(); ++i)
		lotto_nums[i] = i+1;

	mix_vector(lotto_nums);

	for(size_t i = 0; i < LOTTO_NUMS-max_nums; ++i)
		lotto_nums.pop_back();
//lotto_nums.resize(max_nums);

	bubble_sort(lotto_nums);

	std::cout << "Die " << max_nums << " Lottozahlen lauten: ";
	for(int i = 0; i < max_nums; ++i)
		std::cout << lotto_nums[i] << ' ';
}

Werner Salomon

Skym0sh0 schrieb:

Ich frage mich wie man bei solchen Fragestellungen/Fragern noch antwortet.
Und ihr habt ja echt teilweise noch Hoffnung, dass es den Fragestellern wichtig ist oder die sich mit der Materie beschäftigen oO

ich unterstelle mal, Du meinst hier nicht 'wie' sondern 'wieso man überhaupt antwortet'. Nun ich meinerseits neige dazu, in dieser Weise zu antworten:

#include <iostream>
#include <algorithm> // copy, iter_swap
#include <iterator> // ostream_iterator
#include <numeric> // partial_sum
#include <vector>
#include <ctime> // std::time
#include <cstdlib> // std::rand

template< typename I, typename F >
void random_drawing( I from, I to, I last, F rnd )
{
    using std::iter_swap;
    const std::ptrdiff_t sz = last - from;
    for( I i = from; i != to; ++i )
        iter_swap( i, from + rnd() % sz );
}

int main()
{
    using namespace std;
    srand( static_cast< unsigned int >(time(nullptr)) );
    const int N = 6;
    vector< int > zahlen( 49, 1 );
    partial_sum( begin(zahlen), end(zahlen), begin(zahlen) ); // alle Zahlen von 1 bis 49

    int anzBloecke;
    cout << "Wieviel Bloecke wollen Sie spielen? ";
    if( cin >> anzBloecke ) // warum das hier auf 12 begrenzen?
    {
        for( int block=1; block<=anzBloecke; ++block )
        {
            random_drawing( begin(zahlen), begin(zahlen)+N, end(zahlen), std::rand ); // Ziehung von N Zahlen
            // --   sortieren und ausgeben
            sort( begin(zahlen), begin(zahlen)+N );
            copy(  begin(zahlen), begin(zahlen)+N, ostream_iterator< int >( cout << block << ".Block: ", " " ) );
            cout << endl;
        }
    }
    return 0;
}

jetzt gibt es den Fragesteller betreffend mehrere Möglichkeiten:
1.) der Fragesteller versteht nichts und ignoriert die Antwort
2.) der Fragesteller gibt den Code als seine Hausarbeit ab und der Lehrer/Dozent sieht, dass sich das der Fragesteller nicht selbst erarbeitet haben kann und gibt ihm eine schlechte Note.
3.) (wie 2.) aber der Lehrer/Dozent akzeptiert das - dann ist er selber Schuld, die Noten an diesem Institut sind eh' nichts wert
4.) der Fragesteller versteht die Antwort zwar nicht, meint aber dass das so ok ist und beginnt, sich mit der Materie zu beschäftigen und gezielt nachzufragen.

Das wären IMHO die Möglichkeiten mit fallender Wahrscheinlichkeit. Fall 4 würde mir am besten gefallen, aber passiert fast nie.
Und warum mache ich das jetzt (oder WTFIsUrQ, oder sonst wer) und das obwohl man manchmal dafür geschlagen wird oder die Antwort sofort vom Moderator gelöscht wird? - die Wahrheit ist: just coding for fun.

volkard schrieb:

template<typename T>
void swap(T &var1, T &var2) { ...}
//Ok, aber std::swap würde uch gehen. Sagen wir mal, außer std::vector will man 
//die STL meiden.

warum eigentlich? STL von Anfang an - std::swap ist wirklich nicht schwer zu verstehen.

Gruß
Werner

krümelkacker

Werner Salomon schrieb:

template< typename I, typename F >
void random_drawing( I from, I to, I last, F rnd )
{
    using std::iter_swap;
    const std::ptrdiff_t sz = last - from;
    for( I i = from; i != last; ++i )
        iter_swap( i, from + rnd() % sz );
}

to wird gar nicht benutzt. So, wie es jetzt ist, wär ich mir gar nicht sicher, ob das einer Gleichverteilung von Permutationen entspricht. Und dabei meine ich jetzt gar nicht, dass ggf rnd()%sz keine Gleichverteilung hat. Ich würde das noch so modifizieren:

template< typename I, typename F >
void random_drawing( I from, I to, I last, F rnd )
{
    using std::iter_swap;
    std::ptrdiff_t sz = last - from;
    for( I i = from; (i != to) && sz>1; ++i, --sz )
//                   ^^^^^^^^^^^^^^^^^       ^^^^
        iter_swap( i, i + rnd() % sz );
//                    ^
}

daddy_felix

Werner Salomon schrieb:

volkard schrieb:
template<typename T>
void swap(T &var1, T &var2) { ...}
//Ok, aber std::swap würde uch gehen. Sagen wir mal, außer std::vector will man 
//die STL meiden.
warum eigentlich? STL von Anfang an - std::swap ist wirklich nicht schwer zu verstehen.

Vielleicht weil die Aufgabe möglicherweise nicht mit STL-Algorithmen gelöst werden darf?

Klar, schwer zu verstehen ist das alles nicht. Ich gehe aber davon aus, dass Sachen wie sort und copy zu Übungszwecken selbst implementiert werden sollen. Schlimmstenfalls hat auch der Lehrer noch nie was von STL gehört und kann damit nichts anfangen. Sollte nicht sein, lässt sich aber nicht ausschließen.

Werner Salomon

Autsch - mit dem 'to' hast Du völlig Recht, so hätte man auch std::random_shuffle nehmen können - ich hab's korrigiert. Das war vorher auch so, aber ich hatte die Variablen umbenannt.

Die Sache mit der Gleichverteilung ist die Frage. Den Gedanken hatte ich auch, sah aber keinen Grund es nicht so zu machen. Ich denke hier http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle steht einiges zum Thema - bin gerade beim Durchlesen.

Gruß
Werner

PS.: @volkard: Danke für den Link.

Elraser1993

zuerst mal habe ich hier von keinem erwartet er solle meine hausaufgabe erledigen also könnt ihr eure dummen kommentare für euch behalten wen ihr nicht helfen wollt dan haltet einfach euren mund ja habe mir ein Buch geholt und es nun alleine fertig gestellt hat zwar etwas länger gedauert aber auch ohne hilfe.

Trotzdem nochmal danke an die die sich wirklich damit beschäftigt haben und auch versucht haben mir zu helfen.

damit ist das thema abgehakt.

SeppJ

Elraser1993 schrieb:

zuerst mal habe ich hier von keinem erwartet er solle meine hausaufgabe erledigen also könnt ihr eure dummen kommentare für euch behalten wen ihr nicht helfen wollt dan haltet einfach euren mund ja habe mir ein Buch geholt und es nun alleine fertig gestellt hat zwar etwas länger gedauert aber auch ohne hilfe.

Diese Kommentare wären die beste Hilfe gewesen, die du hättest bekommen können, wenn du sie ernst genommen und über dein Verhalten nachgedacht hättest. Du bekommst hier eben nicht nur Hilfe zu deinem Problem (welches du gar nicht genau formuliert hast - dies ist ein weiteres Problem von dir, bei dem dir diese Kommentatoren helfen wollten), sondern auch dazu, wie du dir selber helfen kannst oder wie du leichter fremde Hilfe bekommst. Leider hast du dies nicht erkannt und dein neuester Thread geht schon wieder genau so los wie dieser hier. Das heißt, du wirst höchstwahrscheinlich auch nur wieder hochtrabende Scherzantworten zu deinem Thema bekommen, anstatt Hilfe auf deinem eigentlichen Niveau.