Example #1
0
// multiplication produces pairs of random numbers and
// prompts user for product
void multiplication()
{
   int x; // first factor
   int y; // second factor
   int response = 0; // user response for product

   // use sentinel-controlled repetition
   cout << "Enter -1 to End." << endl;

   // loop until sentinel value read from user
   while ( response != -1 ) 
   {
      x = rand() % 10; // generate 1-digit random number
      y = rand() % 10; // generate 1-digit random number

      cout << "How much is " << x << " times " << y << " (-1 to End)? ";
      cin >> response;

      // loop until sentinel value or correct response
      while ( (response != -1) && (response != (x * y)) ) 
      {
         incorrectMessage();
         cin >> response;
      } // end while

      if ( response == (x * y) ) // correct response
         correctMessage();
   } // end while

   cout << "\nThat's all for now. Bye." << endl;
} // end function multiplication
Example #2
0
File: utils.cpp Project: cajal/cmt
set<int> CMT::randomSelect(int k, int n) {
	if(k > n)
		throw Exception("k must be smaller than n.");
	if(k < 0 || n < 0)
		throw Exception("n and k must be non-negative.");

	// TODO: a hash map could be more efficient
	set<int> indices;

	if(k <= n / 2) {
		for(int i = 0; i < k; ++i)
			while(indices.insert(rand() % n).second != true) {
				// repeat until insertion successful
			}
	} else {
		// fill set with all indices
		for(int i = 0; i < n; ++i)
			indices.insert(i);
		for(int i = 0; i < n - k; ++i)
			while(!indices.erase(rand() % n)) {
				// repeat until deletion successful
			}
	}

	return indices;
}
Example #3
0
int main()
{
    unsigned int array[SIZE];
    unsigned int c;

    srand(time(nullptr));	// use current time in seconds as random seed

    for(c = 0 ; c < SIZE ; c++)	// randomize contents of array
        array[c] = rand() * rand();
    cout << "An array of " << SIZE << " random numbers:\n\n";
    for(c = 0 ; c < SIZE ; c++)	// display array (5 numbers per row)
        cout << setw(15) << array[c] << ((c+1)%5 ? "" : "\n");
    cout << endl;

    bucketsort(array, SIZE);	// sort array

    cout << "The same array sorted:\n\n";
    //for( c = 0 ; c < 5 ; c++ )	// print a header?
    //    cout << "     9876543210";
    //cout << '|' << endl;
    for(c = 0 ; c < SIZE ; c++)	// display array (5 numbers per row)
        cout << setw(15) << array[c] << ((c+1)%5 ? "" : "\n");
    cout << endl;

    system("PAUSE");
    return 0;
} // end function main
Example #4
0
void generate_data(mpi::communicator local, mpi::communicator world)
{
  using std::srand;
  using std::rand;

  // The rank of the collector within the world communicator
  int master_collector = local.size();

  srand(time(0) + world.rank());

  // Send out several blocks of random data to the collectors.
  int num_data_blocks = rand() % 3 + 1;
  for (int block = 0; block < num_data_blocks; ++block) {
    // Generate some random data
    int num_samples = rand() % 1000;
    std::vector<int> data;
    for (int i = 0; i < num_samples; ++i) {
      data.push_back(rand());
    }

    // Send our data to the master collector process.
    std::cout << "Generator #" << local.rank() << " sends some data..."
              << std::endl;
    world.send(master_collector, msg_data_packet, data);
  }

  // Wait for all of the generators to complete
  (local.barrier)();

  // The first generator will send the message to the master collector
  // indicating that we're done.
  if (local.rank() == 0)
    world.send(master_collector, msg_finished);
}
Example #5
0
//------------------------------------------------------------------------------
void my1BhvScout::Evaluate(void)
{
	mActive = true;
	if(mInput->info.bview)
	{
		mDrive.drive = MOVE_F;
		mDrive.turn = mInput->info.bside;
		mActive = false; // can be override
	}
	else
	{
		// basically turn away fom obstacle
		if(!mSense->r_safe&&mSense->l_safe)
			mDrive.turn = TURN_L;
		else if(mSense->r_safe&&!mSense->l_safe)
			mDrive.turn = TURN_R;
		else
		{
			// 1/8 chance turning
			mDrive.turn = rand()%2? TURN_R : TURN_L;
			mDrive.turn = rand()%4==0? mDrive.turn : TURN_0;
		}
		mDrive.drive = mDrive.turn? MOVE_0 : MOVE_F; // don't move if turning
	}
	// assign drive parameters
	mDrive.dist = mDrive.drive*1.0;
	mDrive.angle = mDrive.turn*0.5; // only turn half as much
}
 virtual void
 run (Arg)
   {
     ulong l1 (rand() % 1000);
     ulong l2 (rand() % 1000);
     string s1 (randStr(50));
     string s2 (randStr(50));
     const char* cp (s1.c_str());
     
     verifyWrapper<ulong> (l1, l2);
     verifyWrapper<ulong&> (l1, l2);
     verifyWrapper<ulong*> (&l1, &l2);
     verifyWrapper<ulong*> ((0), &l2);
     verifyWrapper<ulong*> (&l1, (0));
     verifyWrapper<ulong const&> (l1, l2);
     
     verifyWrapper<string> (s1, s2);
     verifyWrapper<string&> (s1, s2);
     verifyWrapper<string*> (&s1, &s2);
     
     verifyWrapper<const char*> (cp, "Lumiera");
     
     
     verifySaneInstanceHandling();
     verifySaneMoveHandling();
     verifyWrappedRef ();
     
     verifyFunctionResult ();
     verifyFunctionRefResult ();
   }
// Generates a random position in the rectangle created by MinPos and MaxPos
POS_2D GetRandomPosition(POS_2D MinPos, POS_2D MaxPos)
{
	POS_2D newPos;
	newPos.X = rand()%(MaxPos.X-MinPos.X+1) + MinPos.X;
	newPos.Y = rand()%(MaxPos.Y-MinPos.Y+1) + MinPos.Y;

	return newPos;
}
Example #8
0
File: main.cpp Project: CCJY/coliru
/*The populate matricies function is to define the variables mA and mB and to set it up.
  The conditional statements in lines 17 through 20 set up the size of the rows and columns
  lines 22 and 23 define the numbers that will be in the matricies. to be random numbers that must be between 0 and nine.
*/
void populateMatrices(vector<int>& mA, vector<int>& mB, int ROWS, int COLUMNS)
{
    for (int rowIdx = 0; rowIdx < ROWS; rowIdx++)
	{
		for (int columnIdx = 0; columnIdx < COLUMNS; columnIdx++) 
		{
			mA[rowIdx + columnIdx] = rand() % 10;
			mB[rowIdx + columnIdx] = rand() % 10;
		}
	}
}
Example #9
0
//起始乱序分牌
void GameServer::mixedOrder(int x[], int n)
{
    srand(static_cast<unsigned int>(time(0)));
    int index1,index2,tmp;
    for(int i=0;i<n;i++){
        index1=rand()%54;
        index2=rand()%54;
        tmp=x[index1];
        x[index1]=x[index2];
        x[index2]=tmp;
    }
}
Example #10
0
int rollDice()
{
    int die1 = 1 + rand() % 6;
    int die2 = 1 + rand() % 6;

    int sum = die1 + die2;

    cout << "Player rolled " << die1 << " + " << die2
         << " = " << sum << endl;

    return sum;
}
void ScenePointSprite::initScene()
{
    compileAndLinkShader();

    glClearColor(0.5f,0.5f,0.5f,1.0f);
    glEnable(GL_DEPTH_TEST);

    //float c = 2.5f;
    //projection = glm::ortho(-0.4f * c, 0.4f * c, -0.3f *c, 0.3f*c, 0.1f, 100.0f);

    angle = (float)(PI / 2.0);

    numSprites = 50;
    locations = new float[numSprites * 3];
    srand( (unsigned int)time(0) );
    for( int i = 0; i < numSprites; i++ ) {
        vec3 p(((float)rand() / RAND_MAX * 2.0f) - 1.0f,
            ((float)rand() / RAND_MAX * 2.0f) - 1.0f,
            ((float)rand() / RAND_MAX * 2.0f) - 1.0f);
        locations[i*3] = p.x;
        locations[i*3+1] = p.y;
        locations[i*3+2] = p.z;
    }

    // Set up the buffers
    GLuint handle;
    glGenBuffers(1, &handle);

    glBindBuffer(GL_ARRAY_BUFFER, handle);
    glBufferData(GL_ARRAY_BUFFER, numSprites * 3 * sizeof(float), locations, GL_STATIC_DRAW);

    delete [] locations;

    // Set up the vertex array object
    glGenVertexArrays( 1, &sprites );
    glBindVertexArray(sprites);

    glBindBuffer(GL_ARRAY_BUFFER, handle);
    glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 0, ((GLubyte *)NULL + (0)) );
    glEnableVertexAttribArray(0);  // Vertex position

    glBindVertexArray(0);

    // Load texture file
    glActiveTexture(GL_TEXTURE0);
    GLuint tid = SOIL_load_OGL_texture("flower.png", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_FLAG_MIPMAPS|SOIL_FLAG_INVERT_Y);
    glBindTexture(GL_TEXTURE_2D, tid);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    prog.setUniform("SpriteTex", 0);
    prog.setUniform("Size2", 0.15f);
}
Example #12
0
int *line_segments_generation()
{
	int *lines = new int[LINE_NUM*4];

	srand(time(0));

	for (int i = 0; i < LINE_NUM; i++) {
		lines[4*i] = rand() % W;
		lines[4*i + 1] = rand() % H;
		lines[4*i + 2] = rand() % W;
		lines[4*i + 3] = rand() % H;
	}

	return lines;
}
Example #13
0
int main ()
{
	srand ( time ( 0 ) );
	int a;
	string c;
	int levelup = 1;
	int rCount = 0;
	int level;
	cout << "Enter your level ( 1 for one-bit, 2 for two-bit and so on ): ";
	cin >> level;
	for ( int count = 1; count <= level; count++ )
		levelup *= 10;
		levelup--;
	for ( int count = 1; count <= 10; count++ )
	{
		int x = 1 + rand() % 9, y = 1 + rand() % levelup;
		cout << "What is " << x << " multiple by " << y << "?" << endl;
		int z;
		cin >> z;
		a = 1 + rand() % 4;
		switch ( a )
		{
			case 1:
				c = "Very well";
				break;
			case 2:
				c = "Perfectly!"; 
				break;
			case 3:
				c = "Great job!";
				break;
			case 4:
				c = "Keep working in the same spirit!";
				break;
		}
		if ( z == x * y )
		{
			cout << c << endl;
			rCount++;
		}
		else
			repeat( x, y, z );
	}
	
	if ( ( rCount * 10 ) < 75 )
		cout << "Please ask your teacher to help you!" << endl;
	return 0;
}
Example #14
0
int main() {
    int n = 1000;
    int capacity = 2000000;
    vector<int> weights (n);
    vector<int> values (n);
    for (int i=0;i<n;i++) {
        weights[i] = rand()%capacity;
        values[i] = rand()%capacity;
    }

    double optimal_value = get_optimal_value(capacity, weights, values);

    std::cout.precision(10);
    std::cout << optimal_value << std::endl;
    return 0;
}
Example #15
0
// generate number from 1 to factor-1
inline int generateNumber( int factor=1 ) {
	int power;
	power = pow( 10, factor); 

	// generate number from 1 to power-1 e.g. 1 to 9; 1 to 99
	return (1 + rand() % (power-1));
}
Example #16
0
/*
	Purpose: To shuffle the cards in the Deck, can be more than once but will be 
			 Less than or equal to the MAX_SHUFFLE count, prevents from shuffling 
			 the Deck 4 billion times.

	Entry: The number of times to shuffle the Deck

	Exit: The cards in the deck have now been placed in a random order
*/
void Deck::Shuffle(int TimesToShuffle)
{
	cout << "Will shuffle " << TimesToShuffle << " times." << endl;
	if((TimesToShuffle > 0) && (TimesToShuffle <= MAX_SHUFFLE))
	{
		int iCount = 0;

		while(iCount < TimesToShuffle)
		{
			for(int i = 0; i < MAX_NUMBER_OF_CARDS; i++)
			{
				srand(static_cast<int>(time(0)));
				int RandomNumber = rand() % MAX_NUMBER_OF_CARDS;

				Card Temp = m_Deck[i];
				m_Deck[i] = m_Deck[RandomNumber];
				m_Deck[RandomNumber] = Temp;
			}

			iCount++;
		}
	}
	else
	{
		cout << "The number of times to shuffle is not a valid value!" << endl;
	}
}
Example #17
0
    void
    verify_MultimapIters()  ///< @see IterTools_test#verify_filterRepetitions
    {
        MAP testMap;
        for (uint i=0; i<NUM_ELMS; ++i)
        {
            uint n = 1 + rand() % 100;
            do testMap.insert (make_pair (i,n));
            while (--n);
        }
        CHECK (NUM_ELMS < testMap.size(), "no repetition in test data??");

        IntIter keys = eachDistinctKey (testMap);

        cout << "distinct_keys";
        CHECK (keys);
        pullOut (keys);
        CHECK (!keys);

        cout << "values_4_key";
        IntIter vals = eachValForKey (testMap, NUM_ELMS); // non-existent key
        CHECK (!vals);

        vals = eachValForKey (testMap, 0);
        CHECK (vals);
        pullOut (vals); // should produce anything between 1 and 100 entries
        CHECK (!vals);
    }
Example #18
0
// 洗牌和发牌
void DeckOfCards::shuffleAndDeal()
{
    int row;
    int column;

    for (int card = 1; card <= 52; card++) {
        do {
            row = rand() % 4; // 随机花色
            column = rand() % 13; // 随机数字
        } while (deck[row][column] != 0);

        deck[row][column] = card;
        cout << showCard(row, column)
            << (card % 2 == 0 ? '\n' : '\t');
    }
}
Example #19
0
// Display message for correct answer
// To reduce student fatigue, display four different messages based on generated 
// random number
void displayAfterCorrectAnswer()
{
	srand( time(NULL) );
	int numberMessage;
	numberMessage = (rand() % 4 + 1); // random generate number from 1 to 4

	// Display different messages based on random number generated
	switch( numberMessage )
	{
		case 1:
			cout << "Very good!" << endl;
			break;
		case 2:
			cout << "Excellent!" << endl;
			break;
		case 3: 
			cout << "Nice work!" << endl;
			break;
		case 4: 
			cout << "Keep up the good work!" << endl;
			break;
		default:
			cout << "Uknown case..." << endl;
			break;
	}
}
Example #20
0
MatrixXd CMT::MLR::sample(const MatrixXd& input) const {
	if(input.rows() != mDimIn)
		throw Exception("Inputs have wrong dimensionality.");

	// distribution over outputs
	ArrayXXd prob = predict(input);

	MatrixXd output = MatrixXd::Zero(mDimOut, input.cols());

	#pragma omp parallel for
	for(int j = 0; j < input.cols(); ++j) {
		double urand = static_cast<double>(rand()) / RAND_MAX;
		double cdf = 0.;

		for(int k = 0; k < mDimOut; ++k) {
			cdf += prob(k, j);

			if(urand < cdf) {
				output(k, j) = 1.;
				break;
			}
		}
	}

	return output;
}
Example #21
0
// guessGame generates numbers between 1 and 1000 and checks user's guess
void guessGame()
{
   int answer; // randomly generated number
   int guess; // user's guess
   char response; // 'y' or 'n' response to continue game

   // loop until user types 'n' to quit game
   do 
   {
      // generate random number between 1 and 1000
      // 1 is shift, 1000 is scaling factor
      answer = 1 + rand() % 1000;

      // prompt for guess
      cout << "I have a number between 1 and 1000.\n" 
         << "Can you guess my number?\n" 
         << "Please type your first guess." << endl << "? ";
      cin >> guess;

      // loop until correct number
      while ( !isCorrect( guess, answer ) ) 
         cin >> guess;      

      // prompt for another game
      cout << "\nExcellent! You guessed the number!\n"
         << "Would you like to play again (y or n)? ";
      cin >> response;

      cout << endl;
   } while ( response == 'y' );
} // end function guessGame
Example #22
0
// Display message for wrong answer
void displayAfterWrongAnswer()
{
	srand( time(NULL) ); 				// seed random generator
	int numberMessage;					// random number to display different messages
	numberMessage = (rand() % 4 + 1); 	// random number from 1 to 4
	
	// Display different messages based on random number generated
	switch( numberMessage )
	{
		case 1:
			cout << "No. Please try again." << endl;
			break;
		case 2:
			cout << "Wrong. Try once more." << endl;
			break;
		case 3: 
			cout << "Don't give up!" << endl;
			break;
		case 4: 
			cout << "Keep trying." << endl;
			break;
		default:
			cout << "Uknown case..." << endl;
			break;
	}
}
double PleC::uniRandNum(){

  double r1; 
  do{r1=1.0*rand()/RAND_MAX;}while(r1<=0 || r1>=1);

  return r1;
}
string generatePhrase(string a1[20], string a2[20], string a3[20] )
{
	std::stringstream ss;	
	char s[256];
	int i1, i2, i3;

	i1 = rand() % 6;
	i2 = rand() % 5;
	i3 = rand() % 7;

	ss << a1[i1] SPC a2[i2] SPC a3[i3];

	ss.getline(s, 256);

	return s;
}
Example #25
0
void ScenePointSprite::initScene()
{
    compileAndLinkShader();

    glClearColor(0.5f,0.5f,0.5f,1.0f);

    glEnable(GL_DEPTH_TEST);

    numSprites = 50;
    locations = new float[numSprites * 3];
    srand( (unsigned int)time(0) );
    for( int i = 0; i < numSprites; i++ ) {
        vec3 p(((float)rand() / RAND_MAX * 2.0f) - 1.0f,
               ((float)rand() / RAND_MAX * 2.0f) - 1.0f,
               ((float)rand() / RAND_MAX * 2.0f) - 1.0f);
        locations[i*3] = p.x;
        locations[i*3+1] = p.y;
        locations[i*3+2] = p.z;
    }

    // Set up the buffers
    GLuint handle;
    glGenBuffers(1, &handle);

    glBindBuffer(GL_ARRAY_BUFFER, handle);
    glBufferData(GL_ARRAY_BUFFER, numSprites * 3 * sizeof(float), locations, GL_STATIC_DRAW);

    delete [] locations;

    // Set up the vertex array object
    glGenVertexArrays( 1, &sprites );
    glBindVertexArray(sprites);

    glBindBuffer(GL_ARRAY_BUFFER, handle);
    glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 0, ((GLubyte *)NULL + (0)) );
    glEnableVertexAttribArray(0);  // Vertex position

    glBindVertexArray(0);

    // Load texture file
    GLuint w, h;
    const char * texName = "../media/texture/flower.bmp";
    BMPReader::loadTex(texName, w, h);

    prog.setUniform("SpriteTex", 0);
    prog.setUniform("Size2", 0.15f);
}
Example #26
0
void init(list<int>& list) {
	while (list.size() < 10000) {
		int add = rand() % 20000;
		list.push_back(add);
		list.sort();
		list.unique();
	}
}
double unit_uniform_random_variable()
{
	double x;
	do {
		x = double(rand())/RAND_MAX;
		} while (x == 0.0 || x == 1.0);
	return x;
}
Example #28
0
void my_qsort(int * arr, int n) {
	if (n <= 1)
		return; // массив в 1 или 0 элементов уже упорядочен
	int * pivotPtr = arr + rand() % n; // случайный выбор опорного элемента
	int newPivotIdx = partition(arr, arr + n - 1, pivotPtr) - arr;
	my_qsort(arr, newPivotIdx);
	my_qsort(arr + newPivotIdx + 1, n - (newPivotIdx + 1));
}
Example #29
0
void repeat ( int x, int y, int z )
{
	int a, b;
	string c, d;
	a = 1 + rand() % 4, b = 1 + rand() % 4;
	switch ( a )
	{
		case 1:
			c = "Very well";
			break;
		case 2:
			c = "Perfectly!"; 
			break;
		case 3:
			c = "Great job!";
			break;
		case 4:
			c = "Keep working in the same spirit!";
			break;
	}
	switch ( b )
	{
		case 1:
			d = "It's wrong! Try again!";
			break;
		case 2:
			d = "No. Please try again!";
			break;
		case 3:
			d = "Do not be discouraged!";
			break;
		case 4:
			d = "No. Continue your attempts!";
			break;
	}
	if ( z == x * y )
		cout << c << endl;
	else
	{
		cout << d << endl;
		cout << "What is " << x << " multiple by " << y << "?" << endl;
		cin >> z;
		repeat ( x, y, z );
	}
}
void my_qsort(int * arr, int l, int r) {
	if (l >= r)
	    return;
	
	int pivot = rand() % (r - l) + l;
	int j = partition(arr, l, r, pivot);
	my_qsort(arr, l, j);
	my_qsort(arr, j + 1, r);
}