void main()
{
long int g,x,y,a,b,k1,k2,n;
clrscr();
cout<<"\n\t Enter value of n & g";
cin>>n>>g;
cout<<"\n\t Enter value of x & y";
cin>>x>>y;
a=alice(n,g,x);
cout<<"\n\t alice end value:"<<a;
b=bob(n,g,y);
cout<<"\n\t bob end value:"<<b;
k1=alice(n,b,x);
cout<<"\n\t valueof k1 :"<<k1;
k2=alice(n,a,y);
cout<<"\n\t valueof k2 :"<<k2;
getch();
}
int main()
{
int t,i,j,n,m,k,l;
ull ans;
scanf("%d",&t);
while(t--)
{
ac=0;bc=0;
scanf("%d %d",&n,&m);
for(i=0;i<n;i++)
{
for(j=0;j<m;j++)
{
scanf("%llu",&a[i][j]);
}
}
alice(0,n-1,0,m-1);
//printf("ans: %llu ",ans);
//printf("ac: %llu\n",ac);
if(ac==bc)
{
printf("%llu\n",bc+ac);
}
else
{
printf("%llu\n",(bc>ac?bc:ac));
}
}
//printf("%d",t);
return 0;
}
void main(void)
{
unsigned int x = alice(0);
unsigned int i;
for(i = 0; i < 5; i++)
output_alice(x);
}
bool MetavoxelTests::run() {
qDebug() << "Running metavoxel tests...";
// seed the random number generator so that our tests are reproducible
srand(0xBAAAAABE);
// create two endpoints with the same header
QByteArray datagramHeader("testheader");
Endpoint alice(datagramHeader), bob(datagramHeader);
alice.setOther(&bob);
bob.setOther(&alice);
// perform a large number of simulation iterations
const int SIMULATION_ITERATIONS = 100000;
for (int i = 0; i < SIMULATION_ITERATIONS; i++) {
if (alice.simulate(i) || bob.simulate(i)) {
return true;
}
}
qDebug() << "Sent" << highPriorityMessagesSent << "high priority messages, received" << highPriorityMessagesReceived;
qDebug() << "Sent" << unreliableMessagesSent << "unreliable messages, received" << unreliableMessagesReceived;
qDebug() << "Sent" << reliableMessagesSent << "reliable messages, received" << reliableMessagesReceived;
qDebug() << "Sent" << streamedBytesSent << "streamed bytes, received" << streamedBytesReceived;
qDebug() << "Sent" << datagramsSent << "datagrams, received" << datagramsReceived;
qDebug() << "All tests passed!";
return false;
}
int main()
{
int key = 8;
std::string alphabet("abcdefghijklmnopqrstuvwxyz .;_");
Receiver bob( key , alphabet );
Transmitter alice( key , alphabet );
std::string message ="mi nombre es victor miguel sequeiros arapa";
alice.rail_cipher(message);
std::cout << message << std::endl;
bob.rail_decipher(message);
std::cout << message << std::endl;
/*
alice.route_cipher(message);
std::cout << message << std::endl;
bob.route_decipher(message);
std::cout << message << std::endl;
*/
return 0;
};
/**
* @brief act as a server in the protocol.
*
* @param portno the port number to listen on.
* @return non-zero on failure.
*/
int server(int portno)
{
debug("called server() with port %d\n", portno);
int error = 0;
struct sockaddr_in servAddr;
struct sockaddr_in cliAddr;
unsigned cliLen = sizeof(cliAddr);
int listenfd = socket(PF_INET, SOCK_STREAM, 0);
int connfd = -1;
int socketOption = 1;
if(listenfd < 0)
{
error = -1;
goto done;
}
if(setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &socketOption,
sizeof(socketOption)))
{
error = -2;
goto done;
}
memset((unsigned char *) &servAddr, 0, sizeof(servAddr));
servAddr.sin_family = AF_INET;
servAddr.sin_addr.s_addr = INADDR_ANY;
servAddr.sin_port = htons(portno);
if(bind(listenfd, (struct sockaddr *) &servAddr, sizeof(servAddr)) < 0)
{
error = -3;
goto done;
}
debug("about to listen() with fd %d\n", listenfd);
//listen for a connection
listen(listenfd, MAX_QUEUE);
if((connfd = accept(listenfd, (struct sockaddr *) &cliAddr, &cliLen)) < 0)
{
error = -4;
goto done;
}
debug("accepted a connection with fd %d\n", connfd);
//close the socket, only 1 connection is needed
close(listenfd);
error = alice(secret, connfd);
done:
close(listenfd);
close(connfd);
return error;
}
bool MetavoxelTests::run() {
qDebug() << "Running transmission tests...";
qDebug();
// seed the random number generator so that our tests are reproducible
srand(0xBAAAAABE);
// create two endpoints with the same header
QByteArray datagramHeader("testheader");
Endpoint alice(datagramHeader), bob(datagramHeader);
alice.setOther(&bob);
bob.setOther(&alice);
// perform a large number of simulation iterations
const int SIMULATION_ITERATIONS = 10000;
for (int i = 0; i < SIMULATION_ITERATIONS; i++) {
if (alice.simulate(i) || bob.simulate(i)) {
return true;
}
}
qDebug() << "Sent" << highPriorityMessagesSent << "high priority messages, received" << highPriorityMessagesReceived;
qDebug() << "Sent" << unreliableMessagesSent << "unreliable messages, received" << unreliableMessagesReceived;
qDebug() << "Sent" << reliableMessagesSent << "reliable messages, received" << reliableMessagesReceived;
qDebug() << "Sent" << streamedBytesSent << "streamed bytes, received" << streamedBytesReceived;
qDebug() << "Sent" << datagramsSent << "datagrams with" << bytesSent << "bytes, received" <<
datagramsReceived << "with" << bytesReceived << "bytes";
qDebug() << "Created" << sharedObjectsCreated << "shared objects, destroyed" << sharedObjectsDestroyed;
qDebug() << "Performed" << objectMutationsPerformed << "object mutations";
qDebug();
qDebug() << "Running serialization tests...";
qDebug();
if (testSerialization(Bitstream::HASH_METADATA) || testSerialization(Bitstream::FULL_METADATA)) {
return true;
}
qDebug() << "All tests passed!";
return false;
}
int main(int argc, char **argv) {
//Initialize ros usage
ros::init(argc, argv, "follow_the_rabbit");
std::string r_frame,o_frame;
std::string topic_id;
//Create Nodehandlers
ros::NodeHandle nh("~");
ros::NodeHandle n();
nh.param<std::string>("rabbit_frame_id",r_frame,"/rabbit");
nh.param<std::string>("vehicle_frame_id",o_frame,"/base_footprint");
nh.param<std::string>("cmd_vel_topic_id",topic_id,"/fmControllers/cmd_vel");
RabbitFollow alice(r_frame,o_frame);
nh.param<double>("field_of_view_rad",alice.fov,2*M_PI);
nh.param<double>("max_angular_vel",alice.max_ang_vel,1.5);
nh.param<double>("max_linear_vel",alice.max_lin_vel,1.0);
nh.param<double>("oscilation_bounds",alice.oscilation_bound,0.05);
nh.param<double>("target_acquired_tolerance",alice.target_acquired_tolerance,0.1);
alice.nh = &nh;
ros::Timer t = nh.createTimer(ros::Duration(0.05),&RabbitFollow::spin,&alice);
alice.cmd_vel_pub = nh.advertise<geometry_msgs::Twist>(topic_id.c_str(),10);
dynamic_reconfigure::Server<fmControllers::rabbit_follow_paramsConfig> server;
dynamic_reconfigure::Server<fmControllers::rabbit_follow_paramsConfig>::CallbackType cb;
cb = boost::bind(&callback, _1, _2,&alice);
server.setCallback(cb);
t.start();
//Handle callbacks
ros::spin();
}
void main(void)
{
unsigned int x=0;
unsigned int i;
unsigned int borrow=0;
for(i = 0; i < 32;)
{
unsigned int a1 = alice(i);
unsigned int b1 = bob(i);
unsigned int b = borrow;
borrow = 0;
if(a1 < (b1 + b))
borrow = 1;
i += 32;
}
if(borrow == 0) x= 0x1;
else x = 0xffffffff;
output_alice(x);
}
void bob(int r1,int r2,int c1,int c2)
{
if(r2<r1 || c2<c1)
{
return 0;
}
ull fr=0,lr=0,fc=0,lc=0,max;
int i,choice;
for(i=c1;i<=c2;i++)
{
fr+=a[r1][i];
}
for(i=c1;i<=c2;i++)
{
lr+=a[r2][i];
}
for(i=r1;i<=r2;i++)
{
fc+=a[i][c1];
}
for(i=r1;i<=r2;i++)
{
lc+=a[i][c2];
}
max=fr;
choice=1;
if(lr>max)
{
max=lr;
choice=2;
}
if(fc>max)
{
max=fc;
choice=3;
}
if(lc>max)
{
max=lc;
choice=4;
}
bc+=max;
switch(choice)
{
case 1:
alice(r1+1,r2,c1,c2);
break;
case 2:
alice(r1,r2-1,c1,c2);
break;
case 3:
alice(r1,r2,c1+1,c2);
break;
case 4:
alice(r1,r2,c1,c2-1);
break;
}
}
int main(int argc, char **argv)
{
if (argc > 1)
printf ("%s\n", alice (argv[1], getenv("USER")));
}
int main(int argc, char* argv[]) {
if (argc < 3)
usage(std::cout);
int nb_colors = atoi(argv[2]);
srand(time(0));
int nbParties = 10;
if (argc > 3)
nbParties = atoi(argv[3]);
if (argc > 4)
setNumberOfSimulations(atoi(argv[4]));
Graph g;
g.getGraphFromDot(argv[1]);
/*for(int i=0 ; i<6 ; i++)
g.addVertex();
g.addEdge(g.getVertex(1), g.getVertex(2));
g.addEdge(g.getVertex(1), g.getVertex(5));
g.addEdge(g.getVertex(2), g.getVertex(3));
g.addEdge(g.getVertex(2), g.getVertex(5));
g.addEdge(g.getVertex(3), g.getVertex(4));
g.addEdge(g.getVertex(4), g.getVertex(5));
g.addEdge(g.getVertex(0), g.getVertex(5));
*/
MapGame game(g, nb_colors);
std::cout << "The graph has " << game.getGraph().getNbVertices()
<< " vertices" << std::endl;
std::cout << (game.isFinished()?"finished":"not finished") << std::endl;
MonteCarloSelection algoAlice(game, false), algoBob(game, true);
Player alice(algoAlice);
Player bob(algoBob);
int nbGagnees = 0;
std::cout << "Played " << 0 << " games, alice won " << nbGagnees;
std::cout.flush();
for (int i = 0; i < nbParties; ++i)
{
if (game.play(alice, bob))
++nbGagnees;
game.reset();
algoAlice.reset();
algoBob.reset();
std::cout << "\rPlayed " << i+1 << " games, alice won " << nbGagnees;
std::cout.flush();
}
std::cout << std::endl;
std::cout << "alice a gagne " << nbGagnees << "/" << nbParties << " parties" << std::endl;
// MonteCarloNode* mcTree = new MonteCarloNode(&game);
// int nbWon = simulate(mcTree, nbParties, false, UCB1);
// std::cout << "Monte-Carlo a gagne " << nbWon << "/" << nbParties << " parties" << std::endl;
// mcTree->deleteChildren();
// delete mcTree;
// For testing purpose
// g.printGraph(); // Only works on graph generated from a dot file using getGraphFromDot
// std::this_thread::sleep_for(std::chrono::milliseconds(2000));
// End for testing purpose
}
int main() {
std::cout << "start of main" << std::endl;
// ====================================================
// SINGLE OWNER SMART POINTERS
// ====================================================
// first, without smart pointers!
Balloon* alice(new Balloon("Hello Kitty"));
// now, with our homemade single owner smart pointer
dsAutoPtr<Balloon> bob(new Balloon("Spiderman"));
// both alice & bob work like regular pointers...
alice->print();
bob->print();
//
// CHECKPOINT 2A: INSERT NECESSARY EXPLICIT DEALLOCATION
//
delete alice;
// ====================================================
// SIMPLE SHARED POINTERS
// ====================================================
// first, without smart pointers
Balloon* cathy(new Balloon("Buzz Lightyear"));
Balloon* daniel(cathy);
Balloon* elaine(new Balloon("Pokemon"));
Balloon* fred(elaine);
daniel = fred;
fred = NULL;
elaine = cathy;
cathy = NULL;
//
// CHECKPOINT 2B: INSERT NECESSARY EXPLICIT DEALLOCATION
//
delete elaine;
delete daniel;
daniel = NULL;
elaine = NULL;
// now, with our homemade shared pointer
dsSharedPtr<Balloon> cathy2(new Balloon("Buzz Lightyear2"));
dsSharedPtr<Balloon> daniel2(cathy2);
dsSharedPtr<Balloon> elaine2(new Balloon("Pokemon2"));
dsSharedPtr<Balloon> fred2(elaine2);
daniel2 = fred2;
fred2 = NULL;
elaine2 = cathy2;
cathy2 = NULL;
// NOTE: no explicit destruction required!
daniel2 = NULL;
elaine2 = NULL;
// ====================================================
// SHARED POINTERS WITH INTERCONNECTED STRUCTURES
// ====================================================
dsSharedPtr<Balloon> georgette(new Balloon("Mr Potato Head"));
dsSharedPtr<Balloon> henry(new Balloon("Snoopy"));
georgette->addRope2(henry);
henry = new Balloon("Tigger");
georgette->addRope2(henry);
georgette->print2();
henry->print2();
dsSharedPtr<Balloon> isabelle(new Balloon("Shrek"));
henry->addRope2(isabelle);
isabelle = new Balloon("Barney the Purple Dinosaur");
georgette->addRope2(isabelle);
henry->print2();
georgette->print2();
isabelle->print2();
//
// CHECKPOINT 2C: REWRITE THE ABOVE EXAMPLE TO USE SHARED POINTERS
//
// ====================================================
// CYCLIC STRUCTURES
// ====================================================
// FOR CHECKPOINT 3
Balloon* jacob(new Balloon("Dora the Explorer"));
Balloon* katherine(new Balloon("Kung Fu Panda"));
Balloon* larry(new Balloon("Scooby Doo"));
Balloon* miranda(new Balloon("SpongeBob SquarePants"));
Balloon* nicole(new Balloon("Papa Smurf"));
jacob->addRope(katherine);
katherine->addRope(larry);
larry->addRope(jacob);
miranda->addRope(jacob);
nicole->addRope(miranda);
larry->addRope(nicole);
katherine = NULL;
larry = NULL;
miranda = NULL;
nicole = NULL;
// jacob points to a cyclic structure!
// to cleanup this structure:
deleteAll(jacob);
//delete jacob;
jacob = NULL;
std::cout << "end of main" << std::endl;
return 0;
//
// NOTE: when smart pointers go out of scope, the destructors for
// those objects will be called automatically
//
}