int main(int argc, char *argv[])
{
if(argc != 3)
{
printf("Usage: %s <number> <bit index>\n", argv[0]);
return 0;
}
unsigned int number = (unsigned int) atoi(argv[1]);
int i = atoi(argv[2]);
printf("Number: %d (0x%x)\n", number, number);
printf("Modifying bit: %d\n", i);
// Check if bit i is set
unsigned int result = isBitISet(number, i);
printResult(i, number, result);
// Set it
number = setBit(number, i);
// Make sure it was set
result = isBitISet(number, i);
printResult(i, number, result);
// Clear bit
number = clearBit(number, i);
// Make sure it was cleared
result = isBitISet(number, i);
printResult(i, number, result);
return 0;
}
int main()
{
srand (time(NULL)); // Do not worry about this, but don't delete it
int age = askForNumber("age");
int favoriteNumbers[3];
askForManyNumbers("your 3 favorite numbers", 3, favoriteNumbers);
printf("Your age is: %d\n", age);
printf("Your 3 favorite numbers are %d %d %d\n", favoriteNumbers[0], favoriteNumbers[1], favoriteNumbers[2]);
int added = favoriteNumbers[0] + favoriteNumbers[1] + favoriteNumbers[2];
int substracted = favoriteNumbers[0] - favoriteNumbers[1] - favoriteNumbers[2];
int multiplied = favoriteNumbers[0] * favoriteNumbers[1] * favoriteNumbers[2];
int divided = favoriteNumbers[0] / favoriteNumbers[1] / favoriteNumbers[2];
printResult("added", added);
printResult("substracted", substracted);
printResult("multiplied", multiplied);
printResult("divided", divided);
int randomFavoriteNumber = favoriteNumbers[rand() % 3];
printf("From your favorite numbers, the next lucky one is: %d\n", randomFavoriteNumber);
printf("If you play the lottery, use the number %d\n", randomFavoriteNumber * age);
return 0;
}
/**
* Gets a matrix from the user and performs the given operation. Then prints the result.
* @param op The matrix operation
* @return An error string message if the operation couldn't be done, EMPTY_STRING if the
* operation was performed.
*/
string oneOperandOperation(MatrixOperation& op)
{
cout << "Operation " << op._name << " requires 1 operand matrix." << endl;
IntMatrix result;
switch (op._id)
{
case TRANS:
printMatrix(result = getMatrix());
result = result.trans();
printResult(MATRIX, (void*) &result);
break;
case TRACE:
printMatrix(result = getMatrix());
if (result.isSquare())
{
int trace = result.trace();
printResult(NUMBER, (void*)&trace);
break;
}
else
{
return "The matrix isn't square";
}
default:
break;
}
return EMPTY_STRING;
}
int main() {
Solution so;
printResult(so.zigzagLevelOrder(nullptr));
printResult(so.zigzagLevelOrder(new TreeNode(1)));
printResult(so.zigzagLevelOrder(new TreeNode(1, new TreeNode(2, new TreeNode(3), nullptr), nullptr)));
printResult(so.zigzagLevelOrder(new TreeNode(1, new TreeNode(2, new TreeNode(3), nullptr), new TreeNode(2))));
printResult(so.zigzagLevelOrder(new TreeNode(3, new TreeNode(9), new TreeNode(20, new TreeNode(15), new TreeNode(7)))));
}
int main() {
Solution so;
printResult(so.generateTrees(0));
printResult(so.generateTrees(1));
printResult(so.generateTrees(2));
printResult(so.generateTrees(3));
printResult(so.generateTrees(4));
}
int main()
{
/// INPUT START
freopen("input.txt", "r", stdin);
freopen("debug.txt", "w", stderr);
int n;
int m;
//cout << "input conditions:\n";
cin >> n >> m;
vvd a(m, vd(n));
vd b(m);
vc type(m);
vc sign(n);
for (int i = 0; i < m; ++i)
{
cin >> type[i];
for (int j = 0; j < n; ++j)
cin >> a[i][j];
cin >> b[i];
}
for (int i = 0; i < n; ++i)
{
cin >> sign[i];
}
vd c(n);
for (int i = 0; i < n; ++i)
{
cin >> c[i];
}
/// INPUT END
vvd dual_a;
vd dual_b;
vd dual_c;
getCanonicalMatrix(a, b, c, sign, type);
printTask(a, b, c);
getDualProblem(a, b, c, dual_a, dual_b, dual_c);
printTask(dual_a, dual_b, dual_c, "dual_task.txt");
cout << "Simplex\n";
printResult(linearProgramming::simplex(a, b, c), sign);
cout << "\nAll vertexes\n";
printResult(linearProgramming::allVertexesCheck(a, b, c), sign);
cout << "\nDual problem simplex\n";
printResult(linearProgramming::simplex(dual_a, dual_b, dual_c), sign, false);
return 0;
}
int main(int argc, char* argv[])
{
printResult(optimize("../sets/burma14.tsp"), 3323);
printResult(optimize("../sets/ulysses16.tsp"), 6859);
printResult(optimize("../sets/berlin52.tsp"), 7542);
// assert(optimize("../sets/kroA100.tsp") == 21282);
// assert(optimize("../sets/ch150.tsp") == 6528);
// assert(optimize("../sets/gr202.tsp") == 40160);
return 0;
}
int main(int argc, char* argv[]) {
if (argc < 2 ) {
printUsage();
exit(2);
}
int samplecount = atoi(argv[1]);
int threadId = 0, i = 0, index = 0;
double mean_counteroverhead = 0, stddev_counteroverhead = 0,\
mean_threadoverhead = 0, stddev_threadoverhead = 0,\
mean_threadswitchoverhead= 0, stddev_threadswitchoverhead = 0;
double threadOverheadArray[samplecount];
double threadswitchOverheadArray[samplecount];
pthread_t aThread;
mean_counteroverhead = getCounteroverhead(samplecount, &stddev_counteroverhead);
// MEASURE THE THREAD CREATION TIME
for ( index = 0; index < samplecount; index++) {
start = count();
threadId = pthread_create( &aThread, NULL, threadFunc, NULL);
pthread_join(aThread, NULL);
threadOverheadArray[index] = end-start-mean_counteroverhead;
}
mean_threadoverhead = getMeanStddev(threadOverheadArray, samplecount, &stddev_threadoverhead);
// printResult(samplecount, mean_threadoverhead, stddev_threadoverhead, "THREAD CREATION TIME");
printResult(samplecount, getDurationinMicroSec(mean_threadoverhead),\
getDurationinMicroSec(stddev_threadoverhead),\
"THREAD CREATION TIME");
// MEASURE THE THREAD CONTEXT SWITCH TIME
for ( index = 0; index < samplecount; index++) {
threadId = pthread_create( &aThread, NULL, threadFunc, NULL);
start = count();
pthread_join(aThread, NULL);
threadswitchOverheadArray[index] = end-start-mean_counteroverhead;
}
mean_threadswitchoverhead = getMeanStddev(threadswitchOverheadArray, samplecount, &stddev_threadswitchoverhead);
//printResult(samplecount, mean_threadswitchoverhead, stddev_threadswitchoverhead, "THREAD CONTEXT SWITCH TIME");
printResult(samplecount, getDurationinMicroSec(mean_threadswitchoverhead),\
getDurationinMicroSec(stddev_threadswitchoverhead),\
"THREAD CONTEXT SWITCH TIME");
return 0;
}
int main()
{
program.state = 3;
program.foo = 4;
int ret = test(&program);
printResult(ret);
ret = foo(6);
printResult(ret);
return foo(ret);
}
void run(t_variable *_var)
{
int _end = 1;
t_result res[9];
double sommeCarre = 0;
double max;
double min;
int deg_lib = 0;
int i = 0;
calcP(_var);
loiBinomial(_var->p, _var);
deg_lib = verifVal(_var, res);
printResult(res, deg_lib);
sommeCarre = calcCarre(res, deg_lib);
printf ("\nloi choisie :\t\t\tB(100, %.4f)\n",_var->p);
printf ("somme des carrés des écarts :\tX² = %.3f\n", sommeCarre);
printf ("degrés de liberté :\t\tv = %d\n", (deg_lib - 2));
while (i < 14 && _end != 0)
{
if (sommeCarre > donnees[deg_lib - 2].nb[i])
i++;
else
{
_end = 0;
max = donnees[0].nb[i - 1];
min = donnees[0].nb[i];
}
}
printf ("validité de l’ajustement :\t%.0f%% < P < %.0f%%\n", min, max);
}
int main(int argc, char *argv[]) {
int i,j,k;
if (argc<2) {
fprintf(stderr, "Usage: dijkstra <filename>\n");
fprintf(stderr, "Only supports matrix size is #define'd.\n");
}
//Open the adjacency matrix file
FILE *fp;
fp = fopen (argv[1],"r");
/*Step 1: geting the working vertexs and assigning values*/
for (i=0;i<NUM_NODES;i++) {
for (j=0;j<NUM_NODES;j++) {
fscanf(fp,"%d",&k);
AdjMatrix[i][j]= k;
}
}
fclose(fp);
chStart=0,chEnd=1999; //15 for small input; 1999 for large input
if (chStart == chEnd) {
printf("Shortest path is 0 in cost. Just stay where you are.\n");
}else{
startBarrier(&myBarrier); /* Start barrier */
startThreads(); /* Start pthreads */
}
printResult();
//}
exit(0);
}
int dijksktra(int graph[V][V], int source)
{
int dist[V];
bool sptSet[V];
int i;
for(i=0;i<V;i++)
{
dist[i]=INT_MAX; // setting the distance to be maximum value of int (or Infinity)s
sptSet[i]=false; // all nodes are not travelled
}
dist[source]=0; // setting the source node's distance = 0
for(i=0;i<V;i++)
{
int u=minDistance(dist,sptSet); // To get the node with minimum distance which is unvisited
sptSet[u]=true;
for(int v=0;v<V;v++)
{
if(!sptSet[v] && graph[u][v] && dist[u]!=INT_MAX && dist[u]+graph[u][v]<dist[v])
{
dist[v]=dist[u]+graph[u][v]; // setting the distance of a node from a node which is already visited
}
}
}
printResult(dist,0);
return 0;
}
vector RetriveCore::retrive(vector<string> files)
{
FeatureExtract fe;
Mat retriveF;
vector< vector<int> > allLenSeq = read();
Mat allGlobal = read();
Mat allLocal = read();
vector<string> cand;
int rv = files.size();
for(int i = 0; i < rv; i ++)
{
retriveF = fe.tomyFeature(files[i]);
#ifdef FILTER_BY_LENGTH
//the minist edit distance
double* dist = distinct(rLenSeq, allLenSeq);
cand = filterByLenSeq(cand, dist, allLenSeq);
#endif
Mat hogFeature = localFeature(retriveF);
Mat local_code = spectralHash(hogFeature);
cand = filterByCode(cand, local_code, allLocal);
printResult(files[i], cand);
cand.clear();
retriveF.release();
}
}
void Manager::Run()
{
std::ofstream myfile;
myfile.open("Output.txt");
int input1, input2, targetOutput;
for(int i=0; i<2000; ++i)
{
inputVals.clear();
targetVals.clear();
input1=rand()%2;
input2=rand()%2;
targetOutput=1;
if(input1==input2) targetOutput=0;
inputVals.push_back(input1);
inputVals.push_back(input2);
targetVals.push_back(targetOutput);
myNet.feedForward(inputVals);
myNet.backProp(targetVals);
myNet.getResults(resultVals);
myfile<<"Pass: "******"\n";
std::cout<<"Input"<<std::endl;
myfile<<"Input\n";
print(inputVals, myfile);
std::cout<<"TargetVals"<<std::endl;
myfile<<"TargetVal\n";
print(targetVals, myfile);
std::cout<<"resultVals"<<std::endl;
myfile<<"resultVal\n";
printResult(resultVals, myfile);
myfile<<"\n";
}
myfile.close();
}
// main program
int main()
{
for (;;) {
std::string input;
std::getline(std::cin, input);
if (input.empty()) break; // empty input line exits the application
auto t = tokenize(input);
try {
auto result = parser<atomtype>::parse(t);
for (auto &z : result) {
// iterate over all comma-separated equations/expressions
printResult(z);
}
}
catch (parser<atomtype>::error &e) {
auto pos = e.t.pos;
std::cerr << std::endl << input << std::endl;
std::cerr << std::string(pos, ' ') << "^~~~~ " << e.msg << std::endl;
}
}
return 0;
}
int main(void)
{
int change = 12; //거스름돈 21원을 만들어 보자.
coinExchange(change);
printResult(change);
}
// Check to see if the ball overcome the net
void Tp1Simulation1::checkNet()
{
// Do nothing if the net has already been crossed
if ( mIsNetCrossed )
return;
// Since we know that the net is not crossed yet, the first y > zone_length indicate crossing of net
if ( mBallPosition.y() >= Tp1Constants::PLAYER_ZONE_LENGTH )
{
mIsNetCrossed = TRUE;
// The net is between this position and the last one so we try to interpolate the z
// if the position is within the limit of the court
if ( mBallPosition.x() >= 0.0f && mBallPosition.x() <= Tp1Constants::COURT_WIDTH )
{
// The very last is == mBallPosition so the one before mBallPosition is size() - 2
Vector lastBallPosition = mBallPositions[mBallPositions.size() - 2];
FLOAT deltaY = mBallPosition.y() - lastBallPosition.y();
FLOAT deltaZ = mBallPosition.z() - lastBallPosition.z();
FLOAT ratioY = abs(mBallPosition.y() - Tp1Constants::PLAYER_ZONE_LENGTH) / deltaY;
FLOAT estimatedZ = mBallPosition.z() + deltaZ * ratioY;
if ( estimatedZ <= Tp1Constants::NET_HEIGHT )
{
cout << "================== Resultats ================== " << endl;
cout << " La balle ne traverse pas le filet (Echec)" << endl << endl;
printResult();
mBallPosition.z() = 0.0f; // This will stop the simulation at the next step
}
}
}
}
/******************************************************************************
* One task/thread per solution. Results are printed by main
* after all of them have been computed.
*/
static void paralleSolutionsSequentialResults()
{
//Create the containers to use and preallocate the memory needed
auto scount = getSolutions().size();
//one thread for each solution for now
std::vector<std::thread> threads;
threads.reserve(scount);
//one future for each solution
std::vector<std::future<long>> futures;
futures.reserve(scount);
// Grab the futures and create a thread for each solution;
for(const auto &s : getSolutions() ){
// get the function pointer for the solution
auto fp = s.second;
// and create a future and a thread for it through a prepared_task.
std::packaged_task<long()> tsk(fp);
futures.emplace_back(std::move(tsk.get_future()));
threads.emplace_back(std::move(tsk));
}
// wait for the threads t finish the computations.
for(auto &t: threads)
t.join();
// print the computed results (and compared them to the expected ones).
for(size_t i=0; i < getSolutions().size(); ++i){
const auto problem = getSolutions().at(i).first;
long result = futures[i].get();
printResult(problem, result);
}
}
//Receive the N input test cases
void inputInt(int total){
int X;
if (ctr==total){
printResult(result,ctr);
}
else{
scanf("%d",&X);
scanf("%c",&trash);
if (X>0 && X<=100){
scanf("%[^\n\t]s",input);
char tmp[256]="";
int checkY = toIntArray(arr,input,0,tmp,X);
// calculate
result[ctr]=0;
calculate(result,arr,k);
ctr++;
k=0;
if (checkY==0){
printf("Please input Yn ( -100 <= Yn <= 100 )!\n");
return;
}
}
else{
printf("Please input X ( 0 < X <= 100 )!");
return;
}
inputInt(total);
}
}
void *listenThread(void *arg)
{
printf("Listen Thread: init sphinx...\n");
if(!sphinxInit())
exit(-1);
if(!recordInit())
exit(-1);
while(!getExitApp())
{
if(getRun())
{
printf("Listen Thread: starting to decode...\n");
pthread_barrier_wait(&startBarrier);
if(!decode())
exit(-1);
printf("Listen Thread: decoding finished...\n");
if (!printResult())
exit(-1);
pthread_barrier_wait(&endBarrier);
} else {
usleep(1000);
}
}
recordClose();
sphinxClose();
printf("Listen thread terminated.\n");
return NULL;
}
int main(void) {
sort(blueOrders, n);
sort(redOrders, m);
solveDynamic();
printResult();
return 0;
}
void partition(int *result, int length)
{
int len = length - 1;
int i;
while(len > 0)
{
if(result[len] == 1)
{
(result[len - 1])++;
result[len] = 0;
len--;
}
else
{
(result[len - 1])++;
(result[len])--;
for(i = result[len]; i > 0; i--)
{
result[len] = 1;
len++;
}
len--;
}
printResult(result, len + 1);
}
}
void qfit::startFitClicked()
{
if(filePath->text().isEmpty()) {
appendLog("Select a file to open!");
return;
}
double error = -1;
// retrive error from the QLineEdit
if(customError->isChecked()) {
error = errorValue->text().toDouble();
if(error <= 0.0) {
appendLog("Custom error is not valid, a default one of 1.0 will be used");
error = 1;
}
}
if(Data::ReadFile(filePath->text().toLatin1().data(), xdata, ydata, yerrors, error)) {
appendLog("Error opening file");
return;
}
// start fittools
delete fit;
if(error <= 0)
fit = new FitTools(xdata, ydata, yerrors, fit_type);
else
fit = new FitTools(xdata, ydata, error, fit_type);
fit->Fit();
printResult();
#ifdef Qwt6_FOUND
plotData();
#endif
}
int main ( void )
{
/* Prototype Declarations */
void getData ( float *num1, float *num2 ) ;
void printResult ( float num1,
float num2,
float result,
int option ) ;
int getOption ( void ) ;
float calc ( int option, float num1, float num2 ) ;
/* Local Declarations */
int option ;
float num1 ;
float num2 ;
float result ;
/* Statements */
option = getOption ( ) ;
getData ( &num1, &num2 ) ;
result = calc ( option, num1, num2 ) ;
printResult ( num1, num2, result, option ) ;
return 0 ;
} /* main */
void printResult(Node* leaf)
{
Node* current = leaf;
if (current && current->parent == NULL)
{
std::cout << "M = " << current->missionaries << " C = " << current->canibals << " B = " << current->boat << "\t";
std::cout << "M = " << 3 - current->missionaries << " C = " << 3 - current->canibals << " B = " << 1 - current->boat << std::endl << std::endl;
return;
}
if (current != NULL)
{
printResult(current->parent);
if (current->boat == 1)
{
std::cout << "Leve " << current->missionaries - current->parent->missionaries << " M e " << current->canibals - current->parent->canibals << " C para a esquerda \t";
}
else
{
std::cout << "Leve " << (3 - current->missionaries) - (3 - current->parent->missionaries) << " M e " << (3 - current->canibals) - (3 - current->parent->canibals) << " C para a direita \t";;
}
std::cout << "ESQUERDA M = " << current->missionaries << " C = " << current->canibals << " B = " << current->boat << "\t\t";
std::cout << "DIREITA M = " << 3 - current->missionaries << " C = " << 3 - current->canibals << " B = " << 1 - current->boat << std::endl << std::endl;
}
}
void solveMissionariesCannibals()
{
Node* root = (Node*) malloc(sizeof(struct Node));
root->missionaries = 3;
root->canibals = 3;
root->boat = 1;
root->parent = NULL;
std::stack<Node*> nodes;
std::vector<Node*> statesVisited;
nodes.push(root);
while (nodes.empty() == false)
{
Node* currentNode = nodes.top();
nodes.pop();
statesVisited.push_back(currentNode);
if (currentNode->missionaries == 0 && currentNode->canibals == 0 && currentNode->boat == 0)
{
printResult(currentNode);
}
addSucessorsToStack(nodes, currentNode, statesVisited);
}
}
int main(int argc,char **argv) {
sort(NUMS, SIZE);
printResult();
return EXIT_SUCCESS;
}
int main()
{
printf("\n\n"); bool result1 = test1();
printf("\n\n"); bool result2 = test2();
printf("\n\n"); bool result3 = test3();
printf("\n\n"); bool result4 = test4();
printf("\n\n****** TEST RESULTS ******\n");
printResult(result1, 1);
printResult(result2, 2);
printResult(result3, 3);
printResult(result4, 4);
printf("\n\n");
return 0;
}
int main(int argv, char **argc)
{
if(argv != 3){
printf("Wrong command.\n");
return 1;
}
srand(time(NULL));
int len = atoi(argc[2]);
int i;
clock_t begin, end;
double time_spent;
if(len < 1){
printf("The number of elements must be larger than 0.\n");
return 1;
}
mytype *A = malloc(len*sizeof(mytype));
MaxSub mySub, mySub2;
//generate data for computation
generateData(A, argc[1], -1000, 1000, len);
//for(i = 0; i < len; i++) printf("%d ", A[i]);
printf("\n");
printf("Using recursive method\n");
begin = clock();
mySub = findMaxSubarray(A, 0, len-1);
end = clock();
time_spent = (double) (end - begin)/CLOCKS_PER_SEC;
printResult(mySub, time_spent);
printf("\nUsing dynamic method\n");
begin = clock();
mySub2 = findMaxSub_Dynamic(A, len);
end = clock();
time_spent = (double) (end - begin)/CLOCKS_PER_SEC;
printResult(mySub, time_spent);
free(A);
}//end main
int main(void) {
calcDist();
solve();
printResult();
printf("\nДиагонали от минималния разрез: ");
writeCut(1, n-1);
return 0;
}
