Ich würde gerne eine nach Eingabe, bestimmte Anzahl an Integer Zahlen deklarieren. Und zwar so. Der Benutzer gibt eine Zahl n ein, was heißen soll, dass n int Zahlen erzeugt werden sollen.

von der Idee sowas:

for(int i= 0; i<=n; i++) {
int Ai;
}

Also A0 A1 A2 ... An.. geht natürlich von der Syntax so nicht. Aber ich hoffe ihr versteht meine Idee. Darüberhinaus will ich jedem Integer eine Zufallszahl zwischen 1 und m zuweisen (natürlich paarweise verschieden). Mit zB 4 Zahlen löse ich das problemlos.

Hoffe jemand kann mir da helfen.

Gruß

int n;
//...

int* A = new int[n];

// Jetzt hast du ein Feld von n Integer-Variablen.
// Zugreifen auf die Elemente kannst du beispielsweise so:

A[0] = 10;
A[1] = 5;
int i = A[2];

//Das Zuweisen einer Zufallszahl kann dann so aussehen:
int m;

// m = wasauchimmer;

for(int i=0;i<n;i++)
    A[i]=rand()%m+1;

//Wenn das Feld nicht mehr gebraucht wird, musst du den Speicher freigeben mit
delete[] A;
//danach darfst du das Feld allerdings nicht mehr benutzen.

Das ist jetzt vielleicht ein wenig kompliziert, ich hoffe aber, dass ich dir helfen konnte.

EDIT: Noch was wissenswertes zu der Deklaration der Variablen.
Die Variablen "existieren" nur in dem Block, in dem sie deklariert werden.

Ein Beispiel:

int GlobVar; // Gilt überall, auch in Funktionen und Klassen.

int main()
{
    int Var; // Ist nur in main() bekannt.

    for(;;)
    {
        int LokaleVar; // Gilt nur in der For-Schleife.
    }

    LokaleVar = 1; // Führt zu einem Fehler, da LokaleVar nur in der For-Schleife bekannt ist.
}

MfG, Jochen

vector kann aber noch viel dollere Sachen, weil man sich gar nicht am Anfang auf eine Größe festlegen muss, sondern einfach Elemente hinten dranhängen kann. Mehr dazu in jedem guten C++-Buch.

@Jochen S.: Du magst es wohl gerne unnötig kompliziert?

Weiß noch jemand wie ich die alle unterschiedlich setzen kann? Bei 4 Zahlen habe ich das mit einer whileschleife gemacht . Jedoch wird die Bedingung für jede weitere Zahl die zu überprüfen ist immer länger -.-

Gruß

srand( (unsigned)time( NULL ) );
      A1 = rand()%63;
      A2 = rand()%63;
	while(A2==A1) A2 = rand()%63;
      A3 = rand()%63;
      while(A3==A1 || A3==A2) A3 = rand()%63;
	A4 = rand()%63;
	while(A4==A1 || A4==A2 || A4==A3) A4 = rand()%63;

So hatte ich vor kurzem 4 verschiedene Zahlen erzeugt zwischen 0 und 63.
Hoffe jemand kann mir (Anfänger) da helfen.^^

Gruß

#include <iostream>
#include <vector>

using namespace std;

int main()
{
int value;
vector< int > theValues;

while( cin >> value, value != 0 )
{
theValues.push_back( value );
}

// Du kannst so lange Zahlen eingeben, bis du eine 0 eingibst, jede Zahl wird in den Vektor kopiert. Umgang mit Vektor wird dir ja vll bekannt sein? Wenn nicht, du kannst über Iteratoren oder Indizies( sowas hier [0] ) auf die einzelnen Elemente zugreifen.

Lg freeG

EDIT:
Weiß nicht ob du das gemeint hast, war auf deinen Post davor bezogen nicht auf deinen letzten.

Ok ich habs glaub falsch verstanden.
Meinst du so:

int anzahlMines = 10;
vector< int > mines;

for( int i = 0; i != 10; ++i )
{
mines.push_back( rand() % 63 );
}

Lg freeG

Das Setzen der Zahlen ist doch einfach:

for(int i=0;i<n;i++)
{
    A[i] = rand()%m+1;
}

// oder mit einer while-schleife

int i=0;
while(i<n)
{
    A[i++] = rand()%m+1;
}

// rand()%m+1 liefert eine Zahl zwischen 1 und m

MfG, Jochen

Vector ist mir bekannt. Das Problem ist halt das ich n paarweise verschiedene Zahlen erzeugen will.

Das wäre etwas wie:

int n; 
cin >> n; //ANZAHL DER ZAHLEN
vector<int> val(n);
srand( (unsigned)time( NULL ) );
for(int i = 0; i <= n-1; i++) {
val[i] = rand()%m; 
}

Nur diese Zahlen wären im Allgemeinen nicht paarweise verschieden.

PS: ERZEUGT rand()%m; dann nur Zahlen zwischen 0 und m-1?

@SeppJ:
Wiso ist das denn kompliziert? Wenn die Größe eines Feldes bekannt ist und sich nicht mehr verändert, spricht doch auch nichts gegen ein dynamisches Feld. Ein solches Feld ist IMHO auch recht einfach zu Handhaben. Sollte das Feld noch erweitert werden, würde ich auch zu vector tendieren.

Nenn mir einen Vorteil eines dynamischen Arrays gegenüber Vector. Nur einen. Dafür habe ich mindestens einen gravierenden Nachteil des des dynamischen Arrays: Kein RAII. D.h. man ist für das Aufräumen selber verantwortlich. Sobald das Programm auch nur ein bisschen komplexer wird, wird es kompliziert.

Dazu bietet Vector auch noch jede Menge Zusatzfeatures: Erweiterbarkeit, Kopierbarkeit( ), Bekannte Größe, verschiedene Zugriffsmethoden, einheitliches Interface (d.h. Austauschbarkeit mit anderen Containern). Und das alles für lau.

int Random(int m)
{
    static std::vector<int> A(m);
    static NumValues = 0;

    bool RunLoop = true;
    int x;

    while(RunLoop)
    {
        x = rand()%m+1;
        for(int i=0;i<NumValues;i++)
        if(A[i]==x)RunLoop = false;
        RunLoop = !RunLoop;
    }

    if(++NumValues>=m)NumValues=0;
    return x;
}

Die Funktion liefert Zufallszahlen zwischen 1 und m und verhindert Wiederholungen. (Hab sie nicht getestet, müsste aber korrekt sein.)

Eventuell kann dir die Funktion ja nützlich sein.

MfG, Jochen

Vector ist mir bekannt. Das Problem ist halt das ich n paarweise verschiedene Zahlen erzeugen will.

Wenn ich dich recht verstehe: Schreib doch erstmal die Zahlen der Reihenfolge nach in den vector und dann mach ein random_shuffle.

@Maxi und Jochen S.: Testet Eure Vorschläge mal mit 10.000 oder 100.000 Zahlen und staunt wie lange selbst ein heutiger Rechner dafür braucht.

Vielleicht kann mir jemand noch zum Schluss diese Frage beantworten.

rand()%m; // ERZEUGT Zahlen zwischen 0 und m

oder

rand()%m; // ERZEUGT Zahlen zwischen 0 und m-1

ps. laut Aufgabenstellung soll das Feld beliebig groß sein (jedoch nicht zu groß -.-) Denke so eine Begrenzung durch das Konsolenfenster ist legitim.

Kleine Optimierung meiner Funktion Random:

int Random(int m)
{
    static std::vector<int> A(m);
    static NumValues = 0;

    bool RunLoop = true;
    int x = rand()%m+1;
    int var = 0;

    while(RunLoop)
    {
        for(int i=0;i<NumValues;i++)
            if(A[i]==x){RunLoop = false;x=var++;}
        RunLoop = !RunLoop;
    }

    if(++NumValues>=m)NumValues=0;
    return x;
}

Dürfte schneller sein. Ist aber nicht mehr ganz so zufällig

MfG, Jochen

RNG ohne Duplikate.
Laufzeitverhalten ist linear beim Erzeugen, konstant beim Ziehen. Speicherverbrauch wächst leider auch linear

Edit:
2. Posting auf der Seite

BAHA schrieb:

Vector ist mir bekannt. Das Problem ist halt das ich n paarweise verschiedene Zahlen erzeugen will.

Wenn ich dich recht verstehe: Schreib doch erstmal die Zahlen der Reihenfolge nach in den vector und dann mach ein random_shuffle.

einfacher gehts gar nicht mehr - schneller auch nicht.

#include <algorithm> //random_shuffle
#include <iostream> //ein + ausgabe
#include <vector> //unser container für die zahlen
#include <cstdlib> //unsere zufallszahlen-funktion

int main()
{
  using namespace std;

  srand(time(0)); //zufallszahlen generator initialisieren
  rand(); //die erste zufallszahl ist nicht gut genug für uns
    //dieser zufallszahlengenerator wird intern (so lang nicht anders angegeben) von random_shuffle verwendet

  int max;
  cin >> max;
  vector<int> numbers(max);
  for(int i(0); i != max; ++i)
    numbers[i] = i;
/*numbers sieht jz (bei max==5) so aus: {0; 1; 2; 3; 4}*/

  int count;
  cin >> count;
  if(count > max)
    return EXIT_FAILURE;
  random_shuffle(numbers.begin(), numbers.end()); //mischen
/*numbers sieht jz z.Bsp. so aus: {3; 2; 4; 0; 1}*/
  numbers.resize(count);
/*numbers sieht (bei count==3) so aus: {3; 2; 4}*/

//die ausgabe, damit du auch siehst, dass es funktioniert:
  for(vector<int>::const_iterator i(numbers.begin()), e(numbers.end()); i != e; ++i)
    cout << *i << endl;

  char dont_close;
  cin >> dont_close;
}

random_shuffle(numbers.begin(), numbers.end()); //mischen
die Zeile ist vermutlich die einzige, die du nicht verstehst.
Sollte aber eigtl ganz intuitiv zu verstehen sein.
Dokumentation dazu:
http://www.cplusplus.com/reference/algorithm/random_shuffle/

bb

PS: Gabs bei std::vector nicht auch irgendwo im Standard nen Satz zum CTor(die iteratoren-Überladung) von wegen: Wenn der iterator zu nem size_t gecastet werden kann, dann werden Zahlen eingefügt? Habs gerad nicht auf die Schnelle finden können, war mir aber eigtl relativ sicehr... -.-

PS: Gabs bei std::vector nicht auch irgendwo im Standard nen Satz zum CTor(die iteratoren-Überladung) von wegen: Wenn der iterator zu nem size_t gecastet werden kann, dann werden Zahlen eingefügt? Habs gerad nicht auf die Schnelle finden können, war mir aber eigtl relativ sicehr... -.-

was meinen? es gibt einen konstruktor, der X-mal den Wert Y einfügt, das hat aber nichts mit einem cast zu tun.

unskilled schrieb:

PS: Gabs bei std::vector nicht auch irgendwo im Standard nen Satz zum CTor(die iteratoren-Überladung) von wegen: Wenn der iterator zu nem size_t gecastet werden kann, dann werden Zahlen eingefügt? Habs gerad nicht auf die Schnelle finden können, war mir aber eigtl relativ sicehr... -.-

was meinen? es gibt einen konstruktor, der X-mal den Wert Y einfügt, das hat aber nichts mit einem cast zu tun.

Ne, den meinte ich nicht.
Mir war so, als ob es irgendwo nen (sequentiellen) COntainer gab, bei dem bei der Iterator-Überladung des inserts und/oder des CTors so etwas stand, wie:
if 'Iterator' could be cast to an size_t ...

habs aber nicht gefunden - hab 3 Standards(bzw Drafts: '95,'03,'05) durchsucht aber nichts gefunden - wer weiß, wo ich das wieder gelesen hatte... : D

bb

eine zeit noch etwas vor concepts und type_traits (zumindest erlaubt es das verwenden von type traits).

#include <iostream>
#include <iterator>

template<typename T>
struct counter
{
	typedef std::bidirectional_iterator_tag iterator_category;
	typedef T value_type;
	typedef std::ptrdiff_t difference_type;
	typedef difference_type distance_type;
	typedef value_type* pointer;
	typedef value_type& reference;
	typedef const value_type& const_reference;

	reference operator++()
	{
		return ++me;
	}
	reference operator--()
	{
		return --me;
	}

	reference operator*()
	{
		return me;
	}
	const_reference operator*() const
	{
		return me;
	}

	counter(T me = T())
	:	me(me)
	{}

private:
	T me;
};

template<typename T>
bool operator== (counter<T> lhs, counter<T> rhs)
{
	return *lhs == *rhs;
}

template<typename T>
bool operator!= (counter<T> lhs, counter<T> rhs)
{
	return !(lhs == rhs);
}

namespace std
{
	template<typename T>
	typename counter<T>::difference_type distance(counter<T> lhs, counter<T> rhs)
	{
		return static_cast<typename counter<T>::difference_type>( *rhs - *lhs );
	}

	template<typename T, typename diff_t>
	void advance(counter<T>& these, diff_t diff)
	{
		*these += diff;
	}
}

#include <vector>

int main()
{
	std::vector<int> container(counter<int>(3), counter<int>(8));

	std::copy(container.begin(), container.end(), std::ostream_iterator<int>(std::cout, "\r\n"));

	system("PAUSE");
}

ist zwar nicht ganz standard-konform, im namespace std funktionen zu überladen, aber das ist ja auch bei swap gängige praxis, da weder der msvc noch der gcc immer adl nutzen.

im standard steht aber mal wieder nicht, dass distance benutzt werden soll, um die größe herauszubekommen -> zumindest der msvc nutzt es nicht, weder die 9 noch die 10 - stinkt -.-'
oder hab ich da irgendwo nen denkfehler gemacht, bei der distance-überladung?
das random_access_tag wollt ich nicht nutzen, weil ich dann angst habe, dass intern iwo pointer-artithmetik genutzt wird und komische fehler auftreten^^

bb

int Random(int m)
{
    static std::vector<int> A(m);
    static NumValues = 0;
   
    bool RunLoop = true;
    int x = rand()%m+1;
    int var = 0;

    while(RunLoop)
    {
        for(int i=0;i<NumValues;i++)
            if(A[i]==x){RunLoop = false;x=var++;}
        RunLoop = !RunLoop;
    }

    if(++NumValues>=m)NumValues=0;
    return x;
}

Dürfte schneller sein. Ist aber nicht mehr ganz so zufällig

Pfui: Wenn Du 'ne Funktion "mit Zustand" willst, schreib 'nen "Funktor" (Klasse) und benutze keine static Variablen!

Fehler: NumValues ohne Typ deklariert.

Fehler: A wird nie mit Werten x gefüllt.

Doof: RunLoop. Wenn man den Test hinter einem Funktionsaufruf verstecken kann, lässt sich dieser in der Schleifenbedingung verwenden, so dass Du kein RunLoop brauchst. Damit wird die Schleife auch leichter verständlich. Eine Endlosschleife a la while(true) oder for(;; ) mit break in der Mitte wäre auch denkbar, um RunLoop loszuwerden.

Doof: Keine Gleichverteilung für die übrig gebliebenen Zahlen.

Doof: Schlechte Laufzeitklasse: O(n²) für n Ziehungen mit n<=m. Das geht besser.

Da es um das Setzen von Mienen auf Feldern geht und sowieso Speicher für alle Felder reserviert wird, wobei nur maximal eine Miene auf ein Feld kommen soll, kann man den Test, ob das Feld schon besetzt ist, viel eleganter durch eine einzige if-Abfrage regeln. Man wählt so lange eine neue zufällige Position aus, bis man ein freies Feld gefunden hat. Die Zahl der zu setzenden Mienen ist ja typischerweise auch nur ein kleiner Bruchteil der Anzahl der Felder, so dass im Schnitt weniger als zwei "Versuche" pro Miene benötigt werden. Damit es keine Endlosschleife gibt, sollte man die Zahl der Mienen nach oben hin durch Feldanzahl/3 (oder so) begrenzen.

kk