Mailinglist Archive: opensuse-programming-de (184 mails)

[Stefan Lang <langstefan@xxxxxx>]

Am Montag, 29. September 2003 16:50 schrieb Bastian Schern:
> Hallo,
>
> ich benötige einen Zufallszahlengenerator, der mir Zufallszahlen aus
> einem vorher festgelegten Zahlenbereich erzeugt. Z.B.:
>
> my_rand_init( int64_t seed, int64_t start, int64_t stop );
> uint64_t my_rand( );
>
> Wichtig ist auch, dass eine erzeugte Zufallszahl nicht noch einmal
> vorkommen darf.
>
> Gibt es so etwas schon?
> Wenn ja: Wo?
> Wenn nicht: Hat jemand eine Idee, wie das am besten zu realisieren ist?
>
> Ach so, ich programmiere in C++, wobei C-Funktionen natürlich auch okay
> sind ;-).
>
> Viele Grüße
> 	Bastian

Hab dasselbe auch schon benötigt und mir die notwendigen Funktionen in
C++ selbst geschrieben. Sie funktionieren.
Im Anhang befindet sich eine Header-Datei (in der beschrieben ist was die 
Funktionen machen) und die zugehörige cpp Datei.
Die Funktion slrandList() ist die du brauchst. ( Die Funktion slrandList() 
benötigt wiederum die anderen Funktionen in der Datei).


-- 
Stefan Lang
EMail: langstefan@xxxxxx
/***************************************************************************
                          sl_std.h  -  description
                             -------------------
    begin                : Don Jul 31 2003
    copyright            : (C) 2003 by Stefan Lang
    email                : langstefan@xxxxxx
 ***************************************************************************/

#ifndef SL_STD_H
#define SL_STD_H

#include <string>
#include <list>

namespace sl
{
  void slrandomize();       // Beschafft einen neuen Startwert für slrand()
                            // Achtung: Verwendet srand() aus std
  int slrand(int lb, int ub);  // Liefert eine Zufallszahl zwischen incl. lb und incl. ub
                            // Achtung: Verwendet rand() aus std

  std::list<long> * slrandList(long lb, long ub, bool de, long num = -1);
      // liefert eine Liste mit Zufallszahlen zwischen incl. lb und incl. ub
      // die Anzahl der Zufallszahlen bestimmt num, ist num == -1
      // werden (ub - lb + 1) Zufallszahlen geliefert
      // ist de == true wird darauf geachtet dass keine Zahl doppelt vorkommt
      // ist de == true und num > ub-lb+1 werden nur ub-lb+1 Zahlen geliefert

  long slrand(std::list<long>*);
}

#endif

/***************************************************************************
                          sl_std.h  -  description
                             -------------------
    begin                : Don Jul 31 2003
    copyright            : (C) 2003 by Stefan Lang
    email                : langstefan@xxxxxx
 ***************************************************************************/

#include <sl_std.h>
#include <ctime>
#include <stdlib.h>
#include <string>
#include <cstring>
#include <ctype.h>
#include <fstream>
#include <sys/types.h>
#include <unistd.h>
#include <iostream>

//#define DEBUG

void sl::slrandomize()       // Beschafft einen neuen Startwert für slrand()
{
  using namespace std;
  time_t t = time(NULL);
  tm c = *(localtime(&t));
  t -= 1000000000;
  if(t < 0) t = -t;
#ifdef DEBUG
  cout<<"Initialisiere mit srand("<<t<<")"<<endl;
#endif
  srand(t);
}


int sl::slrand(int lb, int ub)  // Liefert eine Zufallszahl zwischen incl. lb und incl. ub
{
  using namespace std;
  return (int) (lb+(int) ((double)(ub+1)*rand()/(RAND_MAX+double(lb))));
}

std::list<long>* sl::slrandList(long lb, long ub, bool de, long num)
{
  using namespace std;
  if(lb > ub) return sl::slrandList(ub,lb,num,de);
  if((num < 0) || (de && num > ub-lb)) num = ub-lb+1;
  list<long>* results = new list<long>;
  list<long>::iterator resit;
  list<long>* val = new list<long>;
  for(long i = lb; i <= ub; i++) val->push_back(i);
  for(long i = 0; i < num; i++)
  {
    long nr = slrand(val);
    if(de)
    {
      val->remove(nr);
    }
    results->push_back(nr);
  }
  return results;
}

long sl::slrand(std::list<long>* tlp)
{
  using namespace std;
  if(tlp->end() == tlp->begin()) return 0;
  list<long>::iterator li;
  unsigned long in = 0;
  for(li = tlp->begin(); li != tlp->end(); li++) in++;
  in--;    // wichtig
  unsigned long rr = slrand(0,in);
  li = tlp->begin();
  for(unsigned long i = 0; i < rr; i++) li++;
  return *li;
}