int main ()
{
int array [50];
int num = 0;
int result1 = 0;
int result2 = 0;
bool isInRange = false;
printf ("Enter a number for last array location\n");
scanf ("%i", &num);
initializeArray (array, num);
shuffleArray (array);
checkArray (array, num, &result1, &result2, &isInRange);
if (isInRange)
{
printf ("data[%i] = %i\ndata[%i] = %i\n", result1, num, result2, num);
}
else
{
printf ("There are no duplicates\n");
}
return 0;
}
void shuffle(char *string, char *delim, size_t str_len)
{
char *array[501], *str = NULL, *work = NULL;
size_t len = 0;
bzero(&array, sizeof array);
work = strdup(string);
str = strtok(work, delim);
while(str && *str)
{
array[len] = str;
len++;
str = strtok((char*) NULL, delim);
}
shuffleArray(array, len);
string[0] = 0;
for (size_t i = 0; i < len; i++) {
strlcat(string, array[i], str_len);
if (i != len - 1)
strlcat(string, delim, str_len);
}
free(work);
string[strlen(string)] = 0;
}
void kfold(int *indices, int size, int k)
{
float inc=(float)k/size;
for (int i=0;i<size;i++)
indices[i]=ceil((i+0.9)*inc)-1;
shuffleArray(indices,size);
}
/* Perform an async dns lookup. This is host -> ip. For ip -> host, use
* egg_dns_reverse(). We return a dns id that you can use to cancel the
* lookup. */
int egg_dns_lookup(const char *host, interval_t timeout, dns_callback_t callback, void *client_data)
{
dns_query_t *q = NULL;
int i, cache_id;
sdprintf("egg_dns_lookup(%s, %d)", host, timeout);
if (is_dotted_ip(host)) {
/* If it's already an ip, we're done. */
dns_answer_t answer;
answer_init(&answer);
answer_add(&answer, host);
callback(-1, client_data, host, answer.list);
answer_free(&answer);
return(-1);
}
/* Ok, now see if it's in our host cache. */
for (i = 0; i < nhosts; i++) {
if (!egg_strcasecmp(host, hosts[i].host)) {
dns_answer_t answer;
answer_init(&answer);
answer_add(&answer, hosts[i].ip);
callback(-1, client_data, host, answer.list);
answer_free(&answer);
return(-1);
}
}
cache_id = cache_find(host);
if (cache_id >= 0) {
shuffleArray(cache[cache_id].answer.list, cache[cache_id].answer.len);
callback(-1, client_data, host, cache[cache_id].answer.list);
return(-1);
}
/* check if the query was already made */
if (find_query(host))
return(-2);
/* Allocate our query struct. */
q = alloc_query(client_data, callback, host);
dns_send_query(q);
// /* setup a timer to detect dead ns */
// dns_create_timeout_timer(&q, host, timeout);
/* Send the ipv4 query. */
return(q->id);
}
void startMinimaxRandomNoAlphaBeta(state s, moveGroup mg, int **allMinimaxScores, unsigned int numIters,
unsigned int numUnseenCards, playerNum p)
{
int iterIndex = 0;
unsigned int *posArray = malloc(numUnseenCards*sizeof(unsigned int));
for(unsigned int i=0; i < numUnseenCards; i++)
{
posArray[i] = i;
}
while(iterIndex < numIters)
{
shuffleArray(posArray, numUnseenCards);
state s2 = setNewDeckOrder(s, p, posArray);
saveMinimaxNoAlphaBeta(s2, mg, allMinimaxScores[iterIndex], p);
iterIndex++;
}
free(posArray);
}
void switchBusShift(bus_shift* bss, int busNum, int len)
{
int* arr = (int*)malloc(sizeof(int) * len);
int i;
for( i = 0 ; i < len ; i++)
{
arr[i] = i;
}
shuffleArray(arr, len);
for( i = 0 ; i < len ; i++)
{
if( i != busNum)
{
int ret = browse_bus_shift(bss, busNum, i, len);
if( ret == 0)
{
break;
}
}
}
free(arr);
}
void BoardGenerator::shuffleRandomArrays(){
shuffleArray(randomBoardArray, BOARD_SIZE);
shuffleArray(randomPossibilityArray, NUM_POSS);
}
/* Perform an async dns reverse lookup. This does ip -> host. For host -> ip
* use egg_dns_lookup(). We return a dns id that you can use to cancel the
* lookup. */
int egg_dns_reverse(const char *ip, interval_t timeout, dns_callback_t callback, void *client_data)
{
dns_query_t *q;
int i, cache_id;
sdprintf("egg_dns_reverse(%s, %d)", ip, timeout);
if (!is_dotted_ip(ip)) {
/* If it's not a valid ip, don't even make the request. */
callback(-1, client_data, ip, NULL);
return(-1);
}
/* Ok, see if we have it in our host cache. */
for (i = 0; i < nhosts; i++) {
if (!egg_strcasecmp(hosts[i].ip, ip)) {
dns_answer_t answer;
answer_init(&answer);
answer_add(&answer, hosts[i].host);
callback(-1, client_data, ip, answer.list);
answer_free(&answer);
return(-1);
}
}
cache_id = cache_find(ip);
if (cache_id >= 0) {
shuffleArray(cache[cache_id].answer.list, cache[cache_id].answer.len);
callback(-1, client_data, ip, cache[cache_id].answer.list);
return(-1);
}
/* check if the query was already made */
if (find_query(ip))
return(-1);
q = alloc_query(client_data, callback, ip);
/* We need to transform the ip address into the proper form
* for reverse lookup. */
if (strchr(ip, ':')) {
char temp[128] = "";
socket_ipv6_to_dots(ip, temp);
sdprintf("dots: %s", temp);
size_t iplen = strlen(temp) + 9 + 1;
q->ip = (char *) my_calloc(1, iplen);
// reverse_ip(temp, q->ip);
strlcat(q->ip, temp, iplen);
strlcat(q->ip, "ip6.arpa", iplen);
sdprintf("reversed ipv6 ip: %s", q->ip);
}
else {
size_t iplen = strlen(ip) + 13 + 1;
q->ip = (char *) my_calloc(1, iplen);
reverse_ip(ip, q->ip);
strlcat(q->ip, ".in-addr.arpa", iplen);
}
dns_send_query(q);
// /* setup timer to detect dead ns */
// dns_create_timeout_timer(&q, ip, timeout);
return(q->id);
}
//Note from Blake:
//Iustus wrote this function, it ensures that a new river actually
//creates fresh water on the passed plot. Quite useful really
//Altouh I veto'd it's use since I like that you don't always
//get fresh water starts.
// pFreshWaterPlot = the plot we want to give a fresh water river
//
bool CvMapGenerator::addRiver(CvPlot* pFreshWaterPlot)
{
FAssertMsg(pFreshWaterPlot != NULL, "NULL plot parameter");
// cannot have a river flow next to water
if (pFreshWaterPlot->isWater())
{
return false;
}
// if it already has a fresh water river, then success! we done
if (pFreshWaterPlot->isRiver())
{
return true;
}
bool bSuccess = false;
// randomize the order of directions
int aiShuffle[NUM_CARDINALDIRECTION_TYPES];
shuffleArray(aiShuffle, NUM_CARDINALDIRECTION_TYPES, GC.getGameINLINE().getMapRand());
// make two passes, once for each flow direction of the river
int iNWFlowPass = GC.getGameINLINE().getMapRandNum(2, "addRiver");
for (int iPass = 0; !bSuccess && iPass <= 1; iPass++)
{
// try placing a river edge in each direction, in random order
for (int iI = 0; !bSuccess && iI < NUM_CARDINALDIRECTION_TYPES; iI++)
{
CardinalDirectionTypes eRiverDirection = NO_CARDINALDIRECTION;
CvPlot *pRiverPlot = NULL;
switch (aiShuffle[iI])
{
case CARDINALDIRECTION_NORTH:
if (iPass == iNWFlowPass)
{
pRiverPlot = plotDirection(pFreshWaterPlot->getX_INLINE(), pFreshWaterPlot->getY_INLINE(), DIRECTION_NORTH);
eRiverDirection = CARDINALDIRECTION_WEST;
}
else
{
pRiverPlot = plotDirection(pFreshWaterPlot->getX_INLINE(), pFreshWaterPlot->getY_INLINE(), DIRECTION_NORTHWEST);
eRiverDirection = CARDINALDIRECTION_EAST;
}
break;
case CARDINALDIRECTION_EAST:
if (iPass == iNWFlowPass)
{
pRiverPlot = pFreshWaterPlot;
eRiverDirection = CARDINALDIRECTION_NORTH;
}
else
{
pRiverPlot = plotDirection(pFreshWaterPlot->getX_INLINE(), pFreshWaterPlot->getY_INLINE(), DIRECTION_NORTH);
eRiverDirection = CARDINALDIRECTION_SOUTH;
}
break;
case CARDINALDIRECTION_SOUTH:
if (iPass == iNWFlowPass)
{
pRiverPlot = pFreshWaterPlot;
eRiverDirection = CARDINALDIRECTION_WEST;
}
else
{
pRiverPlot = plotDirection(pFreshWaterPlot->getX_INLINE(), pFreshWaterPlot->getY_INLINE(), DIRECTION_WEST);
eRiverDirection = CARDINALDIRECTION_EAST;
}
break;
case CARDINALDIRECTION_WEST:
if (iPass == iNWFlowPass)
{
pRiverPlot = plotDirection(pFreshWaterPlot->getX_INLINE(), pFreshWaterPlot->getY_INLINE(), DIRECTION_WEST);
eRiverDirection = CARDINALDIRECTION_NORTH;
}
else
{
pRiverPlot = plotDirection(pFreshWaterPlot->getX_INLINE(), pFreshWaterPlot->getY_INLINE(), DIRECTION_NORTHWEST);
eRiverDirection = CARDINALDIRECTION_SOUTH;
}
break;
default:
FAssertMsg(false, "invalid cardinal direction");
}
if (pRiverPlot != NULL && !pRiverPlot->hasCoastAtSECorner())
{
// try to make the river
doRiver(pRiverPlot, eRiverDirection, eRiverDirection, -1);
// if it succeeded, then we will be a river now!
if (pFreshWaterPlot->isRiver())
{
bSuccess = true;
}
}
}
}
return bSuccess;
}