/*! First increase or decrease zombie's alertness depending
on player proximity. Then use alertness to check whether
the zombie starts actively hunting. */
void update_alertness( game g ) {
creature Z = g->ZombieListHead;
int d;
while( Z != NULL ) {
chr z = Z->Character;
// If a zombie sees another zombie hunting, it increases
// alertness.
creature Z1 = g->ZombieListHead;
int num_alert = 0;
while(Z1 != NULL) {
chr z1 = Z1->Character;
d = distance(z1->pos, z->pos);
num_alert += z1->alert && d <= zombie_sight_range && d > 0;
Z1 = Z1->Next;
}
if(!z->alert) z->alertness += (randint(0, num_alert) != 0);
d = distance( g->pc->pos, z->pos );
if( d <= zombie_sight_range ) {
if( z->alertness < max_alertness ) {
z->alertness++;
}
} else if( z->alertness > 0 ) {
if(randint(0, (d - z->alert)/(zombie_sight_range + z->alertness))) z->alertness--;
}
int check = randint( 0, max_alertness );
if( ( z->alert && d > zombie_sight_range ) || ! z->alert ) {
z->alert = ( check < z->alertness );
}
Z = Z->Next;
}
}
void test() {
/* Field testing: NWERC 2012 Problem I, Kattis pieceittogether */
/* TODO: UVa 11294, UVa 10319 */
for (int n = 1; n <= 15; n++) {
for (int iter = 0; iter < 100; iter++) {
int cnt = randint(1, 100);
vii clauses(cnt);
for (int i = 0; i < cnt; i++) {
int a = randint(1, n) * (randint(1, 2) == 1 ? 1 : -1);
int b = randint(1, n) * (randint(1, 2) == 1 ? 1 : -1);
clauses[i] = ii(a, b);
}
// cout << n << " " << iter << " " << cnt << endl;
TwoSat ts(n);
iter(it,clauses) {
ts.add_or(it->first, it->second);
}
if (ts.sat()) {
vector<bool> is_true(n+1, false);
// for (int i = 0; i < size(all_truthy); i++) if (all_truthy[i] > 0) is_true[all_truthy[i]] = true;
rep(i,0,n) if (V[n+(i+1)].val == 1) is_true[i+1] = true;
for (int i = 0; i < cnt; i++) {
bool a = is_true[abs(clauses[i].first)],
b = is_true[abs(clauses[i].second)];
assert_true((clauses[i].first > 0 ? a : !a) || (clauses[i].second > 0 ? b : !b), true);
}
} else {
for (int j = 0; j < (1<<n); j++) {
// Spawns a food source by rolling against the spawn rate
void spawn_food_source() {
if (randreal() <= food_source_spawn_rate) {
add_food_source(randint(1, grid_size), randint(1, grid_size), food_source_radius, food_source_rations);
if (global_debug) {
printf("Spawned food source at %i,%i with %i rations\n", food_list.back()->x, food_list.back()->y, food_list.back()->rations);
}
}
}
int test_F_mpn_mul_precache()
{
mp_limb_t * int1, * int2, * product, * product2;
F_mpn_precache_t precache;
mp_limb_t msl;
int result = 1;
unsigned long count;
for (count = 0; (count < 30) && (result == 1); count++)
{
unsigned long limbs2 = randint(2*FLINT_FFT_LIMBS_CROSSOVER)+1;
unsigned long limbs1 = randint(2*FLINT_FFT_LIMBS_CROSSOVER)+1;
int1 = (mp_limb_t *) malloc(sizeof(mp_limb_t)*limbs1);
mpn_random2(int1, limbs1);
F_mpn_mul_precache_init(precache, int1, limbs1, limbs2);
unsigned long count2;
for (count2 = 0; (count2 < 30) && (result == 1); count2++)
{
#if DEBUG
printf("%ld, %ld\n",limbs1, limbs2);
#endif
unsigned long limbs3 = randint(limbs2)+1;
int2 = (mp_limb_t *) malloc(sizeof(mp_limb_t)*limbs3);
product = (mp_limb_t *) malloc(sizeof(mp_limb_t)*(limbs1+limbs2));
product2 = (mp_limb_t *) malloc(sizeof(mp_limb_t)*(limbs1+limbs2));
F_mpn_clear(int2, limbs3);
mpn_random2(int2, limbs3);
F_mpn_mul_precache(product, int2, limbs3, precache);
if (limbs1 > limbs3) msl = mpn_mul(product2, int1, limbs1, int2, limbs3);
else msl = mpn_mul(product2, int2, limbs3, int1, limbs1);
unsigned long j;
for (j = 0; j < limbs1+limbs3 - (msl == 0); j++)
{
if (product[j] != product2[j]) result = 0;
}
free(product2);
free(product);
free(int2);
}
F_mpn_mul_precache_clear(precache);
free(int1);
}
return result;
}
void Population::nextgen()
{
int nchildren = 0;
Genome** children = 0;
if (nspecies > MAXSPECIES)
{
nspecies = MAXSPECIES;
listshorten<Species*>(species, nspecies);
}
for (int i = 0; i < nspecies; i++)
{
species[i]->ngenomes /= 2;
listshorten<Genome*>(species[i]->genomes, species[i]->ngenomes);
int nbreed = globalfitness ? species[i]->avgfitness / globalfitness * NPOP - 1 : 1;
if (species[i]->ngenomes == 0 || (nspecies > MINSPECIES && ((nbreed <= 0 && nspecies) || (species[i]->staleness > StaleLimit && i != 0))))
{
delete species[i];
listremove<Species*>(species, nspecies, i);
continue;
}
for (int j = 0; j < nbreed; j++)
{
Genome* child = 0;
if (randfloat() < CrossoverChance)
{
Genome* g1 = species[i]->genomes[randint(0, species[i]->ngenomes-1)];
Genome* g2 = species[i]->genomes[randint(0, species[i]->ngenomes-1)];
child = mutate(cross(g1, g2));
}
else
{
Genome* g1 = species[i]->genomes[randint(0, species[i]->ngenomes-1)];
child = mutate(g1);
}
listappend<Genome*>(children, nchildren, child);
}
species[i]->ngenomes = std::min(KEEPOLD, species[i]->ngenomes);
listshorten<Genome*>(species[i]->genomes, species[i]->ngenomes);
}
if (nchildren > NPOP - KEEPOLD * nspecies)
{
nchildren = NPOP - KEEPOLD * nspecies;
listshorten<Genome*>(children, nchildren);
}
addtospecies(children, nchildren);
generation++;
}
/****************************************************************
SampleImage
Samples the entire image and stores the sample in a list.
Based on width,height it randomly samples the entire image.
Exceptions:
None
****************************************************************/
void SampleSet::SampleImage(Matrixu* pGrayImageMatrix,
uint numberOfSamples,
int w,
int h,
Matrixu* pRGBImageMatrix,
Matrixu* pHSVImageMatrix,
float scaleX,
float scaleY )
{
try
{
ASSERT_TRUE( pGrayImageMatrix != NULL || pRGBImageMatrix != NULL || pHSVImageMatrix != NULL );
//find the width and height based on the current scale
int scaledWidth = cvRound( float(w) * scaleX );
int scaledHeight = cvRound( float(h) * scaleY );
int numberOfRows;
int numberOfColumns;
if ( pGrayImageMatrix != NULL )
{
numberOfRows = pGrayImageMatrix->rows() - scaledHeight - 1;
numberOfColumns = pGrayImageMatrix->cols() - scaledWidth - 1;
}
else if( pRGBImageMatrix != NULL )
{
numberOfRows = pRGBImageMatrix->rows() - scaledHeight - 1;
numberOfColumns = pRGBImageMatrix->cols() - scaledWidth - 1;
}
else
{
numberOfRows = pHSVImageMatrix->rows() - scaledHeight - 1;
numberOfColumns = pHSVImageMatrix->cols() - scaledWidth - 1;
}
ASSERT_TRUE( numberOfSamples <= ( numberOfRows * numberOfColumns ) );
//resize the sample list to the required number of samples
m_sampleList.resize( numberOfSamples );
#pragma omp for
for ( int i = 0; i < (int)numberOfSamples; i++ )
{
m_sampleList[i].m_pImgGray = pGrayImageMatrix;
m_sampleList[i].m_col = randint( 0, numberOfColumns );
m_sampleList[i].m_row = randint( 0, numberOfRows );
m_sampleList[i].m_height = h;
m_sampleList[i].m_width = w;
m_sampleList[i].m_pImgColor = pRGBImageMatrix;
m_sampleList[i].m_pImgHSV = pHSVImageMatrix;
m_sampleList[i].m_scaleX = scaleX;
m_sampleList[i].m_scaleY = scaleY;
}
}
EXCEPTION_CATCH_AND_ABORT( "Failed to random sample entire image for the number of samples" );
}
int Game::room_number()
{
// need to improve ending if run out of possible rooms
n1 = randint(2, 20);
n2 = randint(2, 20);
n3 = randint(2, 20);
if(n1==n2 || n2==n3 || n3==n1) {
cerr << "\nRandomizer engine fail: numbers are equal";
n1 = randint(2, 20);
n2 = randint(2, 20);
n3 = randint(2, 20);
} //need to improve rerandom if finds equal int
for(int i = 0; i != curr_rooms.size(); ++i) { // iterate trough rooms vector and check if was before
if (n1 == curr_rooms[i]) {
n1 = randint(2, 20);
} else if (n2 == curr_rooms[i]) {
n2 = randint(2, 20);
} else if (n3 == curr_rooms[i]) {
n3 = randint(2, 20);
}
if(n1 == curr_rooms[i] && n2 == curr_rooms[i] && n3 == curr_rooms[i]) { // simulate full curr_rooms vector // need to improve
cerr << "\nRun out of room numbers";
cout << "\nYou`ve found the exit!";
return -1;
}
//else {
// cerr << "\nRun out of room numbers";
// cout << "\nYou`ve found the exit!";
//}
}
return n1, n2, n3;
}
void test() {
/* Field testing: SPOJ HORRIBLE */
int n = 100000;
vi arr(n);
for (int i = 0; i < n; i++) {
arr[i] = randint(-1000, 1000);
}
segment_tree x(arr);
segment_tree_slow xslow(arr);
for (int i = 0; i < 100000; i++) {
int op = randint(0, 2);
if (op == 0) {
int a = randint(0, n-1),
b = randint(a, n-1);
assert_equal(xslow.query(a, b), x.query(a, b));
} else if (op == 1) {
int idx = randint(0, n-1),
val = randint(-1000, 1000);
x.update(idx, val);
xslow.update(idx, val);
} else if (op == 2) {
int a = randint(0, n-1),
b = randint(a, n-1),
v = randint(-1000, 1000);
x.range_update(a, b, v);
xslow.range_update(a, b, v);
}
}
}
int
rate_next(iter_t *iter)
{
if (iter->i1) {
iter->i1 = 0;
return (int)randint(0,3);
} else {
iter->i1 = 1;
return (int)randint(5,9);
}
}
word_t test_randword1(rand_t state)
{
word_t res = 0;
int bits = (int) randint(7, state);
int i;
for (i = 0; i < bits; i++)
res |= (WORD(1) << randint(WORD_BITS, state));
return res;
}
void test5() {
const int n = 97;
int count = 0;
perm root(*range(n));
int a = 0, b = 0;
while (a == b) {
a = randint(1, n);
b = randint(1, n);
}
swap(root[a], root[b]);
dfs(root, -1);
}
const char *
response(response_t type)
{
if (!type)
type = randint(RES_TYPES) + 1;
/* wait to count the totals until it's used for the first time */
if (!response_totals[type])
count_responses(type);
return res[type][randint(response_totals[type])];
}
int getch(int h, int ch)
{
if (randint(0,2)!=0) return ch;
int nch;
if (ch < 3)
nch = ch + randint(1,2);
else if (ch > h-4)
nch = ch + randint(-2,0);
else
nch = ch + randint(-2,2);
return nch;
}
int test_F_mpn_mul()
{
mp_limb_t * int1, * int2, * product, * product2;
mp_limb_t msl, msl2;
int result = 1;
unsigned long count;
for (count = 0; (count < 30) && (result == 1); count++)
{
unsigned long limbs2 = randint(2*FLINT_FFT_LIMBS_CROSSOVER)+1;
unsigned long limbs1 = limbs2 + randint(1000);
int1 = (mp_limb_t *) malloc(sizeof(mp_limb_t)*limbs1);
mpn_random2(int1, limbs1);
unsigned long count2;
for (count2 = 0; (count2 < 30) && (result == 1); count2++)
{
#if DEBUG
printf("%ld, %ld\n",limbs1, limbs2);
#endif
int2 = (mp_limb_t *) malloc(sizeof(mp_limb_t)*limbs2);
product = (mp_limb_t *) malloc(sizeof(mp_limb_t)*(limbs1+limbs2));
product2 = (mp_limb_t *) malloc(sizeof(mp_limb_t)*(limbs1+limbs2));
F_mpn_clear(int2, limbs2);
mpn_random2(int2, randint(limbs2-1)+1);
msl = F_mpn_mul(product, int1, limbs1, int2, limbs2);
msl2 = mpn_mul(product2, int1, limbs1, int2, limbs2);
unsigned long j;
for (j = 0; j < limbs1+limbs2 - (msl == 0); j++)
{
if (product[j] != product2[j]) result = 0;
}
result &= (msl == msl2);
free(product2);
free(product);
free(int2);
}
free(int1);
}
return result;
}
// Creates the starting bacteria and populates the list
void create_starting_bacteria() {
int s, i;
Strain* strain;
for (s = 0; s < num_strains; s++) {
strain = strains[s];
for (i = 1; i <= start_population_per_strain; i++) {
add_bacterium(strain, randint(1,grid_size), randint(1,grid_size));
}
}
}
int test_F_mpn_splitcombine_bits()
{
mp_limb_t * int1, * int2;
ZmodF_poly_t poly;
int result = 1;
unsigned long count;
for (count = 0; (count < 30000) && (result == 1); count++)
{
unsigned long limbs = randint(300)+1;
unsigned long bits = randint(500)+1;
unsigned long coeff_limbs = randint(100) + (bits-1)/FLINT_BITS + 1;
unsigned long length = (FLINT_BITS*limbs - 1)/bits + 1;
unsigned long log_length = 0;
while ((1L << log_length) < length) log_length++;
#if DEBUG
printf("limbs = %ld, bits = %ld, coeff_limbs = %ld\n", limbs, bits, coeff_limbs);
#endif
int1 = (mp_limb_t *) malloc(sizeof(mp_limb_t)*limbs);
int2 = (mp_limb_t *) malloc(sizeof(mp_limb_t)*limbs);
ZmodF_poly_init(poly, log_length, coeff_limbs, 0);
mpn_random2(int1, limbs);
F_mpn_FFT_split_bits(poly, int1, limbs, bits, coeff_limbs);
F_mpn_clear(int2, limbs);
F_mpn_FFT_combine_bits(int2, poly, bits, coeff_limbs, limbs);
#if DEBUG
F_mpn_printx(int1, limbs); printf("\n\n");
unsigned long i;
for (i = 0; i < length; i++) { F_mpn_printx(poly->coeffs[i], coeff_limbs); printf("\n");}
printf("\n");
F_mpn_printx(int2, limbs); printf("\n\n");
#endif
unsigned long j;
for (j = 0; j < limbs; j++)
{
if (int1[j] != int2[j]) result = 0;
}
ZmodF_poly_clear(poly);
free(int2);
free(int1);
}
return result;
}
string randstr(int llen, int rlen, int lc, int rc){
string res = "";
int len = randint(llen, rlen);
for (int i = 0; i < len; ++i){
char ch = randint(lc, rc);
res.push_back(ch);
}
return res;
}
char *mkalphanum(int len) {
//returns an alphanumeric string of len length
int size = len + 1;
char *s = malloc(sizeof(char) * size);
char c;
s[size] = 0;
for (int i = 0; i < size;i++) {
int typeflag = randint(1);
if (typeflag == 0)
s[i] = randalpha();
else
s[i] = randint(9) + '0';
}
s[size] = '\0';
return s;
}
bool make_decision(int n)
{
if (n > 100 || n < 1) error("Wrong percentage");
int t = randint(1, 100);
if (t <= n) return true;
else return false;
}
Link* Link::insert(Link* n) // insert n before this object; return n
{
if (n->value < 1 || n->value > system_length) error("Too low/high value in inserted link");
if (n == 0) return this;
if (this == 0) return n;
while (true)
{
while (this->find(n) != 0) // Проверка на присутствие свободных слотов на этом уровне.
{
if (n->value >= system_length) n->level++;
else n->value = randint(1, 10);
}
if (n->value > this->value) // Если элемент больше по значению, добавляем его после данного элемента.
{
if (succ) succ->prev = n;
n->succ = succ;
n->prev = this;
succ = n;
return n;
}
else // Если элемент меньше по значению, вставляем его до этого элемента.
{
n->succ = this; // this object comes after n
if (prev) prev->succ = n;
n->prev = prev; // this object's predecessor becomes n's predecessor
prev = n; // n becomes this object's predecessor
return n;
}
}
}
static
void
try_mkdir(int dofork)
{
void * a0 = randptr();
int a1 = randint();
int result, pid, status;
char buf[128];
snprintf(buf, sizeof(buf), "mkdir(%p, %d)",
(a0), (a1));
printf("%-47s", buf);
pid = dofork ? fork() : 0;
if (pid<0) {
err(1, "fork");
}
if (pid>0) {
waitpid(pid, &status, 0);
return;
}
result = mkdir(a0, a1);
printf(" result %d, errno %d\n", result, errno);
if (dofork) {
exit(0);
}
}
void init(void)
{
for(uint8_t i = 0; i < matrix_xyz_len; i++) {
vars.xyz[i] = (xyz_t){
.x = randint(0, LEDS_X),
.y = randint(0, LEDS_Y),
.z = randint(0, LEDS_Z)
};
}
clear_buffer();
}
void effect(void)
{
clear_buffer();
for(uint8_t i = 0; i < matrix_xyz_len; i++) {
xyz_t xyz = vars.xyz[i];
for(uint8_t j = 0; j < 3; j++) {
if(xyz.z + j < LEDS_Z) {
set_led(xyz.x, xyz.y, xyz.z + j, MAX_INTENSITY);
}
}
uint8_t z = xyz.z;
z++;
if(z >= LEDS_Z) z = 0;
vars.xyz[i].z = z;
}
}
main(int argc, char* argv[]) {
sset h,i,j,r;
int n,seed;
string cmd;
n = 1000;
dkst F(n);
seed = 1;
if (argc > 1) sscanf(argv[1],"%d",&seed);
srandom(seed);
int vec[n+1];
misc::genPerm(n,vec);
for (j = 1; j <= n; j++) F.setkey(j,vec[j],vec[vec[j]]);
for (j = 2; j <= n; j++) F.insert(j,F.root(1));
// cout << F;
for (i = 1; i <= 10*n; i++) {
r = F.root(1);
j = randint(1,n);
F.remove(j,r);
for (h = 1; h <= n; h++) {
if (F.key2(h) != vec[vec[h]]) {
cout << "bad key2 value for " << h << endl;
cout << F;
exit(1);
}
}
r = F.root(j == 1 ? 2 : 1);
F.insert(j,r);
// cout << F;
}
}
static
void
try_getdirentry(int dofork)
{
int a0 = randint();
void * a1 = randptr();
size_t a2 = randsize();
int result, pid, status;
char buf[128];
snprintf(buf, sizeof(buf), "getdirentry(%d, %p, %lu)",
(a0), (a1), (unsigned long)(a2));
printf("%-47s", buf);
pid = dofork ? fork() : 0;
if (pid<0) {
err(1, "fork");
}
if (pid>0) {
waitpid(pid, &status, 0);
return;
}
result = getdirentry(a0, a1, a2);
printf(" result %d, errno %d\n", result, errno);
if (dofork) {
exit(0);
}
}
void placeMonster (char entityArray[MAP_SIZE][MAP_SIZE], entity entityInfo[], char mapArray[MAP_SIZE][MAP_SIZE], int roomWidth, int roomHeight, int monNumber) {
int posx,posy;
generatePosition(roomWidth, roomHeight, &posx, &posy);
while ((mapArray[posx][posy]!= EMPTY_SPACE) || (entityArray[posx][posy] != NO_ENTITY)) {
generatePosition(roomWidth, roomHeight, &posx, &posy);
}
char symbolChoose = randint(4); //char to save space
char monSymbol;
if (symbolChoose == 0) { //choose a non-unique symbol for the monster
// you wanted a unique identifier? maybe next time
monSymbol = '#';
} else if (symbolChoose == 1) {
monSymbol = '&';
} else if (symbolChoose == 2) {
monSymbol = '$';
} else if (symbolChoose == 3) {
monSymbol = '+';
} else if (symbolChoose == 4) {
monSymbol = '*';
}
entityArray[posx][posy] = monSymbol; //dump all the map specific info on the entity
entityInfo[monNumber].entityx = posx;
entityInfo[monNumber].entityy = posy;
entityInfo[monNumber].entitySymbol = monSymbol;
return;
}
void do_grad(int* studentsInRoom, sema gradAllowedMutex, int* gradsEaten, sema roomTypeMutex, enum studentType* currentStudentType) {
while (1) {
sema_down(gradAllowedMutex);
sema_down(roomTypeMutex);
if (*currentStudentType != ugrad && *studentsInRoom < 2) {
(*studentsInRoom) += 1;
*currentStudentType = grad;
sema_up(roomTypeMutex);
(*gradsEaten) += 1;
// 6 grads have eaten, lock out more grads until ugrads get a turn
if (*gradsEaten == NUM_GRADS) { sema_down(gradAllowedMutex); }
printf("grad eating...\n");
sleep(randint());
printf(" grad done\n");
sema_down(roomTypeMutex);
(*studentsInRoom) -= 1;
if (*studentsInRoom == 0) { *currentStudentType = empty; }
sema_up(roomTypeMutex);
} else {
sema_up(roomTypeMutex);
}
}
}
/* Make a password, 10-15 random letters and digits
*/
void makepass(char *s)
{
int i;
i = 10 + randint(6);
make_rand_str(s, i);
}
void CloudParticle::remove_neighbor(const CloudParticle*const p)
{
for (int i = 0; i < (int)neighbors.size();)
{
std::vector<CloudParticle*>::iterator iter = neighbors.begin() + i;
if (*iter == p)
{
neighbors.erase(iter);
continue;
}
i++;
}
if (effect->particles.size() <= 2)
return;
if (!neighbors.size())
{
std::map<Particle*, bool>::iterator next_iter;
int offset;
CloudParticle* next;
while (true)
{
next_iter = effect->particles.begin();
offset = randint((int)effect->particles.size());
for (int j = 0; j < offset; j++)
next_iter++;
next = (CloudParticle*)next_iter->first;
if ((next != this) && (next != p))
break;
}
neighbors.push_back(next);
next->add_incoming_neighbor(this);
}
}
int main()
try {
srand(time(0));
const int test_val = 75;
while (true) {
skip_list sl;
for (int i = 0; i<23; ++i)
sl.insert(randint(100));
sl.debug_print();
cout << "Enter value to remove: ";
int x;
cin >> x;
if (x==-1) return 0;
element* p = sl.find(x);
sl.remove(x);
sl.debug_print();
cout << "\n";
}
}
catch (exception& e) {
cerr << "exception: " << e.what() << endl;
}
catch (...) {
cerr << "exception\n";
}
/*
** gen_rand_symbol - generates random password of specified type
** INPUT:
** char * - symbol.
** unsigned int - symbol type.
** OUTPUT:
** int - password length or -1 on error.
** NOTES:
** none.
*/
int
gen_rand_symbol (char *symbol, unsigned int mode)
{
int j = 0;
char *str_pointer;
int random_weight[94];
int max_weight = 0;
int max_weight_element_number = 0;
for (j = 0; j <= 93; j++) random_weight[j] = 0;
str_pointer = symbol;
j = 0;
/* Asign random weight in weight array if mode is present*/
for (j = 0; j <= 93 ; j++)
if ( ( (mode & smbl[j].type) > 0) &&
!( (S_RS & smbl[j].type) > 0))
random_weight[j] = 1 + randint(20000);
j = 0;
/* Find an element with maximum weight */
for (j = 0; j <= 93; j++)
if (random_weight[j] > max_weight)
{
max_weight = random_weight[j];
max_weight_element_number = j;
}
/* Get password symbol */
*str_pointer = smbl[max_weight_element_number].ch;
max_weight = 0;
max_weight_element_number = 0;
return (0);
}
