Ich möchte ein Kleines Spiel programmieren. Dafür möchte ich gerne 8 zufällige Zahlen erzeugen und die kleinste davon soll ermittelt werden und nicht weiter benutzt werden.

Mein Frage: Könnt ihr mir einen Tipp geben wie man das elegant lösen kann? Mir fällt nur eine Lösung ein wo ich unglaublich viele if oder else if Bedingungen machen müsste.

Beispiel:

int a,b,c,d,e,f,g,h;

a = (rand()%6)+1+7;
b = (rand()%6)+1+7;
c = (rand()%6)+1+7;
d = (rand()%6)+1+7;
e = (rand()%6)+1+7;
f = (rand()%6)+1+7;
g = (rand()%6)+1+7;
h = (rand()%6)+1+7;

Das Ergebnis:

a= 9
b= 9
c= 11
d= 13
e= 8
f= 11
g= 10
h= 8

Hier soll dann e oder h rausgeschmissen werden. Ich habe das hier absichtlich so gewählt das 2 Variablen den minimal Wert hat da das durch aus passieren kann.

Schon mal danke

Ich würde da ein Array verwenden, die 8 Werte reinschreiben, das Array sortieren und dann die ersten 7 Werte verwenden.

PS. Hier noch ein getestetes Beispiel:

int value[8];

	// array füllen
	for(int i = 0; i < 8; i++)
		value[i] = (int)rand() % 100;

	// array sortieren
	for(int i = 0; i < 7; i++)
	{
		for(int y = i + 1; y < 8; y++)
		{
			if(value[i] < value[y])
			{
				int v = value[i];
				value[i] = value[y];
				value[y] = v;
			}
		}
	}

	// in value[0] steht jetzt der größte und in value[7] der kleinste Wert

Gruß
Franz

#include <algorithm>
#include <iostream>
#include <iterator>
#include <random>
#include <vector>

using namespace std;

int main() {
    mt19937 random_gen((random_device())());
    vector<int> random_values;
    generate_n(back_inserter(random_values), 8,
            [&random_gen]() {
                uniform_int_distribution<int> d(8, 13);
                return d(random_gen);
            });
    random_values.erase(min_element(random_values.begin(), random_values.end()));
    copy(random_values.begin(), random_values.end(), ostream_iterator<int>(cout, "\n"));
}

ich denke mal ich neheme erst mal das mit der Array, programmiere noch nicht so lange und muss mir das mit den Vektoren erst noch aneignen

Mit Array ist es tendenziell komplizierter als mit einem vector. Da du hier im C++-Forum bist, würde ich dir raten, erst vector zu lernen und C-Style Arrays zunächst völlig zu ignorieren. Denn ansonsten lernst du eher C als C++.

Unfug.

Begründung von mir:
zu "Mit Array ist es tendenziell komplizierter als mit einem vector.":

Bei einem Array musst du von Hand die Größe mittracken und vor allem nach dem Löschen des kleinsten Elementes alle nachfolgenden verschieben. v.erase() ist wesentlich einfacher.

zu: "Da du hier im C++-Forum bist, würde ich dir raten, erst vector zu lernen und C-Style Arrays zunächst völlig zu ignorieren. Denn ansonsten lernst du eher C als C++."

Man darf in C++ auch sehr gerne Klassen und insbesondere auch die STL benutzen. Benutzt man weder Klassen noch die STL, kann man auch gleich C nehmen.

Und gerade Anfänger müssen sich bei variabel großen Arrays auch noch um Speichermanagement kümmern -> all das braucht man bei vector nicht. Es ist also wesentlich einfacher.

Ich sehe daher keinen Grund, ein Array statt eines std::vectors zu nehmen (höchstens ein std::array, aber darum ging es hier ja nicht).

Welcher Teil davon soll Unfug sein? Begründung?

Begründung von mir:
zu "Mit Array ist es tendenziell komplizierter als mit einem vector.":

Gar nicht. Musst das Array ein Mal durchrattern, bei jedem Schritt den Wert mit dem bisher gespeicheten Kleinsten vergleichen und falls er kleiner ist, Wert und Array-Index merken. Und am Schluss dann den Wert auf den der gespeicherte Index zeigt auf 'gelöscht' setzen.

Das ist eine einfache kleine Funktion.

Gar nicht. Musst das Array ein Mal durchrattern, bei jedem Schritt den Wert mit dem bisher gespeicheten Kleinsten vergleichen und falls er kleiner ist, Wert und Array-Index merken. Und am Schluss dann den Wert auf den der gespeicherte Index zeigt auf 'gelöscht' setzen.

Das ist eine einfache kleine Funktion.

was bedeutet "auf 'gelöscht' setzen"? Wie soll das konkret bei eine C-Array aussehen?

Man könnte natürlich smart pointer verwenden. Dann muss man aber wiederum bei jedem Aufruf prüfen, ob der Wert gültig ist. Klingt für mich nach übertriebenem Overkill.

was bedeutet "auf 'gelöscht' setzen"? Wie soll das konkret bei eine C-Array aussehen?

Man nehme einen Wert ausserhalb der Menge der gültigen Werte.

Diskutiert ihr jetzt ernsthaft darüber, ob man bei einem Container mit variabler Anzahl von Elementen ein Vector nimmt oder ein Array mit 'ich setze Werte die zZ nicht gültig sind'?

Sieht ganz so aus.

Jockelx schrieb:

Diskutiert ihr jetzt ernsthaft darüber, ob man bei einem Container mit variabler Anzahl von Elementen ein Vector nimmt oder ein Array mit 'ich setze Werte die zZ nicht gültig sind'?

Sieht ganz so aus.

Klang für mich übrigens ziemlich contra Array.

Klang für mich übrigens ziemlich contra Array.

Du bist also eher nicht so der Freund kleiner, angepasster und ultraperformanter Lösungen, sondern legst mehr Wert auf Universallösungen.

Deine Meinung sei dir gegönnt.

Ich stehe eher auf dem Standpunkt eines Users hier, der in seiner Sig folgenden Spruch hat/hatte: "die dümmsten Programmierer schreiben die dicksten Programme".

Das lässt sich sogar noch auf die Spitze treiben, wie ein Freund von mir zu sagen pflegt: "die beste Software ist keine Software".

Obwohl, ich glaub nicht mal dann wäre es mir die "Performance" wert.

Nun ja, im nächsten Fall, in dem wir dann alle eine Funktion brauchen, die aus 8 Zahlen mit beschränkten Gültigkeitswerten die kleinsten Werte auf ungültige Werte setzt, können wir ja dann alle ein Array verwenden.

Wieso "alle ein Array verwenden"?
Du nimmst einfach das, was am besten zu den Anforderungen passt.

Das lässt sich sogar noch auf die Spitze treiben, wie ein Freund von mir zu sagen pflegt: "die beste Software ist keine Software".

Also im vorliegenden Fall: "Generier nur sieben Zahlen."

Andromeda schrieb:

Das lässt sich sogar noch auf die Spitze treiben, wie ein Freund von mir zu sagen pflegt: "die beste Software ist keine Software".

Also im vorliegenden Fall: "Generier nur sieben Zahlen."

Oder: "achte beim Erzeugen darauf, dass die kleinste Zahl nur ein Mal vorkommt".

Wieso "alle ein Array verwenden"?
Du nimmst einfach das, was am besten zu den Anforderungen passt.

Ja ich schon. OP auch? Vermutlich nicht.
Daher ist der Vorschlag erstmal einen vector zu benutzen für einen Anfänger völlig richtig und nachvollziehbar. Zumal es sogar in den unwahrscheinlichen Fällen, dass ein Array ohne zusätzliche, lästige Aufgaben verwendet werden kann, immer noch völlig korrekt und sauber ist, ein vector oder ähnliches als container zu verwenden.

Ja ich schon. OP auch? Vermutlich nicht.
Daher ist der Vorschlag erstmal einen vector zu benutzen für einen Anfänger völlig richtig und nachvollziehbar. Zumal es sogar in den unwahrscheinlichen Fällen, dass ein Array ohne zusätzliche, lästige Aufgaben verwendet werden kann, immer noch völlig korrekt und sauber ist, ein vector oder ähnliches als container zu verwenden.

Ich finde es gerade blöd, einen Anfänger zu sehr vor den grundlegen Prinzipien der Computerei abzuschirmen. Aber darüber gibt es ja verschiedene Ansichten.

Ich vermute mal, dass alle Top-Coder ziemlich zu Anfang eine Phase hatten, in der sie sich ausgiebig mit LowLevel-Zeugs und Maschinensprache beschäftigten. Sicher kann man das auch später lernen, aber dann baut man IMHO nicht die Assoziationen auf, die für ein Tiefenverständnis wichtig sind.

Bei einem Array musst du von Hand die Größe mittracken und vor allem nach dem Löschen des kleinsten Elementes alle nachfolgenden verschieben. v.erase() ist wesentlich einfacher.

Echt? So richtig mit "alle nachfolgenden verschieben"?! Ist das die einzige Möglichkeit, etwas aus einem vector/array zu "löschen"?
Deshalb vielleicht besser erstmal die Grundlagen lernen.
Und wozu muss man die Größe mittracken?? Sie ist vorher 8 und nach dem "rauslöschen" 7. Fertig.
Das hochkomplizierte Rauslöschen des Arrayelements an Position p geht übrigens mit

arr[p]=arr[7];

Das hochkomplizierte Rauslöschen des Arrayelements an Position p geht übrigens mit

arr[p]=arr[7];

Kannst du das bitte erläutern?

Demnach wäre arr[7] doch unlöschbar bzw. immer gelöscht.
Ich kann deine Gedanken nicht nachvollziehen.

volkard schrieb:

Das hochkomplizierte Rauslöschen des Arrayelements an Position p geht übrigens mit

arr[p]=arr[7];

Kannst du das bitte erläutern?

Demnach wäre arr[7] doch unlöschbar bzw. immer gelöscht.
Ich kann deine Gedanken nicht nachvollziehen.

LOL, du bist wohl auch nicht so der "Freund kleiner, angepasster und ultraperformanter Lösungen". Ne, lass mal lieber ne If-Abfrage bei jeder Nutzung des Arrays einfügen. Du solltest wirklich mal einen Gang zurückschalten.

LOL, du bist ...

Nix LOL. Sag wie das funktioniert und lass mich nicht dumm sterben.

du hast also ein array arr mit den elementen arr[0]...arr[7], findest irgendwie heraus, dass bspw. arr[3] das kleinste ist und kopierst dann den wert von arr[7] nach arr[3].

natürlich sollte das programm dann wissen, dass arr[7] ungültig ist, z.b. mit der zuweisung letztes_array_element=6;

edit: die vector-klasse in c++ macht eigentlich nichts anderes.
der unterschied ist einfach, dass sich da schonmal jemand die arbeit gemacht hat, dieses prinzip zu programmieren, damit sich andere leute nicht mehr damit beschäftigen müssen und gleich loslegen können.