int main() { std::vector<int> numbers(50); for (int i = 0; i < 50; ++i) { numbers[i] = i; } int result = parallel_accumulate<std::vector<int>::iterator,int> (numbers.begin(),numbers.end(),0); std::cout << "result: " << result << std::endl; }
void numbers(int *a ,int n , int i , int sum){ if(sum<0) return; if(sum == 0) { count++; return; } int j; for(j=i;j<n;j++){ numbers(a,n,j+1,sum-a[j]); } }
extern "C" char* complex_service_toSortedString(complex_data_t instance, vector_const_t int_vector) { IComplexService* complexService = reinterpret_cast<IComplexService*>(instance->cppHandle); std::vector<int> numbers(reinterpret_cast<const int*>(int_vector->data), reinterpret_cast<const int*>(int_vector->data) + int_vector->size); std::cout << "Calling C++ interface methods from C function" << std::endl; std::string str = complexService->ToSortedString(numbers); char* c_str = (char*)malloc(sizeof(char)*(str.size()+1)); strcpy(c_str, str.c_str()); return c_str; }
std::string numbers(int num) { if ( ! (num >= 0 && num < 1000000000) ) throw std::out_of_range("num should be [0,1000000000)"); if (num < 20 ) return low_numbers[num]; if (num < 100) { int quot = num / 10; int rem = num % 10; if (rem == 0) return tens[quot - 1]; else return numbers(quot * 10) + ' ' + numbers(rem); } if (num < 1000) { int quot = num / 100; int rem = num % 100; if (rem == 0) return numbers(quot) + ' ' + "hundred"; else return numbers(quot * 100) + " and " + numbers(rem); } if (num < 1000000) { int quot = num / 1000; int rem = num % 1000; if (rem == 0) return numbers(quot) + ' ' + "thousand"; else return numbers(quot * 1000) + ' ' + numbers(rem); } //if (num % 1000000 == 0) // return numbers(num/1000000) + ' ' + "million"; // //return numbers((num/1000000) * 1000000) + ' ' + numbers(num%1000000); //if (num % 1000 == 0) // return numbers(num/1000) + ' ' + "thousand"; // //return numbers((num/1000) * 1000) + ' ' + numbers(num%1000); return "huh?"; }
void display(void) { int i,k; numbers(); //-----This is the stuff involved with drawing the screen----// glClearColor (0,0,0,0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); client_render(tclient); glutSwapBuffers(); }
void Optimize() { TimePass::ShmTupleList<int> numbers(SHM_FILE); if (false == numbers.Open()) { printf("errmsg=%s\n", TimePass::Error::GetLastErrmsg().c_str()); return; } // if (false == numbers.Optimize()) { // printf("errmsg=%s\n", TimePass::Error::GetLastErrmsg().c_str()); // return; // } }
void About() { TimePass::ShmTupleList<int> numbers(SHM_FILE); if (false == numbers.Open()) { printf("errmsg=%s\n", TimePass::Error::GetLastErrmsg().c_str()); return; } printf("name = %s capacity = %ld size = %ld" "total_size = %ld, used_size = %ld\n", numbers.Name(), numbers.Capacity(), numbers.Size(), numbers.TotalBytes(), numbers.UsedBytes()); numbers.Close(); }
void SortImpl(const _ExecutionPolicy& _Policy) { vector<int> numbers(5000 + rand() % 10000); std::iota(numbers.begin(), numbers.end(), 0); sort(_Policy, numbers.begin(), numbers.end(), std::greater<int>()); // dsc order Assert::IsTrue(std::is_sorted(numbers.begin(), numbers.end(), std::greater<int>())); std::random_shuffle(numbers.begin(), numbers.end()); sort(_Policy, numbers.begin(), numbers.end()); // asc order Assert::IsTrue(std::is_sorted(numbers.begin(), numbers.end())); }
double *NUMstring_to_numbers (const char32 *s, long *numbers_found) { *numbers_found = Melder_countTokens (s); if (*numbers_found < 1) { Melder_throw (U"Empty string."); } autoNUMvector<double> numbers (1, *numbers_found); long inum = 1; for (char32 *token = Melder_firstToken (s); token != 0; token = Melder_nextToken (), inum++) { Interpreter_numericExpression (0, token, &numbers[inum]); } return numbers.transfer(); }
void StableSortImpl(const _ExecutionPolicy& _Policy) { vector<pair<size_t, size_t>> numbers(5000 + rand() % 10000); for (size_t i = 0; i < numbers.size(); i++) numbers[i] = make_pair(i % 10, numbers.size() - i); std::random_shuffle(numbers.begin(), numbers.end()); for (size_t i = 0; i < numbers.size(); i++) numbers[i].second = i; stable_sort(_Policy, numbers.begin(), numbers.end(), [](const pair<size_t, size_t> &left, const pair<size_t, size_t> &right) { return left.first < right.first; }); // asc order Assert::IsTrue(std::is_sorted(numbers.begin(), numbers.end())); }
int main(){ long n; scanf("%ld\n", &n); std::vector<long long> numbers(n,0); long long total(0), leftSum(0), ways(0); for(long k = 0; k < n; k++){scanf("%lld ", &numbers[k]); total += numbers[k];} for(long k = 0; k < n - 1; k++){leftSum += numbers[k]; if(2 * leftSum == total){++ways;}} printf("%lld\n", ways); return 0; }
void fractab(std::ostream &out, unsigned int size) { std::vector<float> numbers(size); iota(numbers.begin(), numbers.end(), 1); for_each(numbers.begin(), numbers.end(), [&](int line) { for_each(numbers.begin(), numbers.end(), [&](int column) { out << (float) line / column << "\t"; }); out << "\n"; }); }
int main() { int n, k; scanf("%d %d\n", &n, &k); std::vector<int> perm(k); for(int p = 0; p < k; p++) { perm[p] = p; } std::vector<std::vector<int> > numbers(n, std::vector<int>(k, 0)); for(int p = 0; p < n; p++) { for(int q = 0; q < k; q++) { char temp; scanf("%c", &temp); numbers[p][q] = temp - '0'; } scanf("\n"); } long minDiff(1e10); do { long minNum(1e10), maxNum(0); for(int p = 0; p < n; p++) { long current = 0; for(int q = 0; q < k; q++) { current = 10 * current + numbers[p][perm[q]]; } if(current < minNum) { minNum = current; } if(current > maxNum) { maxNum = current; } } long diff = maxNum - minNum; if(diff < minDiff) { minDiff = diff; } } while(next_permutation(perm.begin(), perm.end())); printf("%ld\n", minDiff); return 0; }
void PartialSortImpl(const _ExecutionPolicy& _Policy) { vector<int> numbers(5000 + rand() % 10000); int midPos = 1 + rand() % (numbers.size() - 1); std::iota(numbers.begin(), numbers.end(), 0); partial_sort(_Policy, numbers.begin(), numbers.begin() + midPos, numbers.end(), std::greater<int>()); // dsc order Assert::IsTrue(std::is_sorted(numbers.begin(), numbers.begin() + midPos, std::greater<int>())); Assert::IsTrue(numbers[midPos - 1] >= *std::max_element(numbers.begin() + midPos, numbers.end())); std::random_shuffle(numbers.begin(), numbers.end()); partial_sort(_Policy, numbers.begin(), numbers.begin() + midPos, numbers.end()); // asc order Assert::IsTrue(std::is_sorted(numbers.begin(), numbers.begin() + midPos)); Assert::IsTrue(numbers[midPos - 1] <= *std::min_element(numbers.begin() + midPos, numbers.end())); }
int main() { using Type = int; // milyen típusú számokkal számolunk. // beolvassuk az első, számokat tartalmazó sort, majd egy streambe helyezzük std::string line; std::getline(std::cin, line); std::stringstream numbers(line); // létrehozunk a könnyebb beolvasás és inicializás, illetve konstansság megtartása érdekében egy bemeneti iterátort std::istream_iterator<Type> input(numbers); // az első bemenetre nincs szükségünk. const Type countOfWordsDictionary = *++input, countOfBadWords = *++input; // létrehozzuk a szótárunkat std::vector< std::string > dictionary(countOfWordsDictionary); // feltöltjük a szótárunkat soronként beolvasva a bemenetről std::generate(dictionary.begin(), dictionary.end(), []() { std::string line; std::getline(std::cin, line); return line; }); // kiiratjuk minden tesztesetre, hogy hány szótárbeli szóra hasonló std::generate_n(std::ostream_iterator<Type>(std::cout, "\n"), countOfBadWords, [&dictionary]() { // beolvassuk a bemeneti sort, majd kicseréljük a gömbölyű zárójeleket szögletesre, // hogy egy reguláris kifejezést kapjunk std::string line; std::getline(std::cin, line); std::replace(line.begin(), line.end(), '(', '['); std::replace(line.begin(), line.end(), ')', ']'); std::cout << "regex:" << line << std::endl; std::regex badWord(line); // összeszámoljuk, hogy a szótárunkból mennyi illeszkedik a reguláris kifejezésre return std::accumulate(dictionary.begin(), dictionary.end(), 0, [&badWord](Type sum, std::string word) { return sum + std::regex_match(word, badWord); }); }); return 0; }
int main() { std::vector<int> numbers(1000000, 0); std::ifstream data("numbers.txt"); for ( auto number : C(std::istream_iterator<int>(data)) ) { data >> number; ++numbers[number]; } for ( int index = 0; index < numbers.size(); ++index ) { if ( numbers[index] > 1 ) { std::cout << "\""; std::cout << std::setfill('0') << std::setw(6) << index; std::cout << "\","; std::cout << numbers[index] << '\n'; } } }
int main(int argc, const char * argv[]) { std::vector<int> numbers({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}); binomial_heap<int> binheap(numbers); binheap.print(); std::cout << "MIN = " << binheap.min() << std::endl << std::endl; binheap.extract_min(); binheap.print(); return 0; }
int main(){ long long n, x, y; scanf("%lld %lld %lld", &n, &x, &y); bool possible = 1; std::vector<long long> numbers(n, 1); numbers[n - 1] = y - (n - 1); if(numbers[n - 1] <= 0){possible = 0;} long long sumOfSquares = 0; for(int p = 0; p < n; p++){sumOfSquares += numbers[p] * numbers[p];} if(sumOfSquares < x){possible = 0;} if(possible){for(int p = 0; p < n; p++){printf("%lld ", numbers[p]);}; puts("");} else{puts("-1");} return 0; }
void initMatrix(std::vector<std::vector<int>> &matrix){ int token; std::string input; std::ifstream numbers("matrix.txt"); std::stringstream split; std::vector<int> tmp; while(getline(numbers, input)){ split << input; while(split >> token){ tmp.push_back(token); } matrix.push_back(tmp); tmp.clear(); split.clear(); } numbers.close(); }
int main(){ int numRows, numCols; scanf("%d %d\n", &numRows, &numCols); const int primeGap(100); std::vector<std::vector<long> > numbers(numRows, std::vector<long>(numCols,0)); long currentMax(0); for(int row = 0; row < numRows; row++){ for(int col = 0; col < numCols; col++){ scanf("%ld", &numbers[row][col]); if(numbers[row][col] > currentMax){currentMax = numbers[row][col];} } } long upperBound = currentMax + primeGap; bool * array = new bool[upperBound]; array[0] = array[1] = 0; for(int k = 2; k < upperBound; k++){array[k] = 1;} for(long k = 0; k < sqrt(upperBound); k++){if(array[k]){for(int m = 2 * k; m < upperBound; m += k){array[m] = 0;}}} for(int row = 0; row < numRows; row++){ for(int col = 0; col < numCols; col++){ long diff(0); for(long num = numbers[row][col]; !array[num]; diff++, num++); numbers[row][col] = diff; } } long minMoves(numRows * numCols * primeGap); for(int row = 0; row < numRows; row++){ long total(0); for(int col = 0; col < numCols; col++){total += numbers[row][col];} if(total < minMoves){minMoves = total;} } for(int col = 0; col < numCols; col++){ long total(0); for(int row = 0; row < numRows; row++){total += numbers[row][col];} if(total < minMoves){minMoves = total;} } printf("%ld\n", minMoves); return 0; }
void Read() { TimePass::ShmTupleList<int> numbers(SHM_FILE); if (false == numbers.Open()) { printf("errmsg=%s\n", TimePass::Error::GetLastErrmsg().c_str()); return; } const TimePass::ListNode<int>* p_beg = NULL; for(off_t which_list = 0; which_list < numbers.GetTupleHead()->tuple_amount; ++which_list) { p_beg = numbers.Head(which_list); while (NULL != p_beg) { printf("%d ", p_beg->data); } putchar('\n'); } numbers.Close(); }
int main() { int numbers_[] = { 0, -1, 4, -3, 5, 8, -2 }; const int N = sizeof(numbers_)/sizeof(int); typedef int* base_iterator; base_iterator numbers(numbers_); // Example using make_filter_iterator() std::copy(boost::make_filter_iterator<is_positive_number>(numbers, numbers + N), boost::make_filter_iterator<is_positive_number>(numbers + N, numbers + N), std::ostream_iterator<int>(std::cout, " ")); std::cout << std::endl; // Example using filter_iterator typedef boost::filter_iterator<is_positive_number, base_iterator> FilterIter; is_positive_number predicate; FilterIter filter_iter_first(predicate, numbers, numbers + N); FilterIter filter_iter_last(predicate, numbers + N, numbers + N); std::copy(filter_iter_first, filter_iter_last, std::ostream_iterator<int>(std::cout, " ")); std::cout << std::endl; // Another example using make_filter_iterator() std::copy( boost::make_filter_iterator( std::bind2nd(std::greater<int>(), -2) , numbers, numbers + N) , boost::make_filter_iterator( std::bind2nd(std::greater<int>(), -2) , numbers + N, numbers + N) , std::ostream_iterator<int>(std::cout, " ") ); std::cout << std::endl; return boost::exit_success; }
int PrimeSieve(int position, int top_limit) { // Sieve of Eratosthenes auto counter = 0; // so index matches number std::vector<bool> numbers(top_limit + 1, true); // set 0 and 1 to not prime numbers[0] = false; numbers[1] = false; for (auto i = 2; i < top_limit + 1; ++i) { if (numbers[i]) { for (auto j = 2; j * i <= top_limit + 1; ++j) numbers[j * i] = false; } } for (auto i = 0; i < top_limit + 1; ++i) { if (numbers[i]) ++counter; if (counter == position) return i; } return 0; }
string getPermutation(int n, int k) { vector<int> numbers(n), factorials(n+1); factorials[0] = 1; int sum = 1; for (int i = 1; i <= n; ++i) { numbers[i-1] = i; sum *= i; factorials[i] = sum; } k--; string result = ""; for (int i = 1; i <= n; ++i) { int index = k/factorials[n-i]; result += to_string(numbers[index]); numbers.erase(numbers.begin()+index); k -= index*factorials[n-i]; } return result; }
void display(void) { int i,k; numbers(); //-----This is the stuff involved with drawing the screen----// glClearColor (0,0,0,0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix(); glColor3f(1,1,1); if(db){ for(i=0; i<circle_num; i++){ circle_object(c[i].p.x,c[i].p.y,c[i].r); } } vector2 pt; pt.x = -sqrt(2); pt.y = sqrt(2); int circle = rand()%circle_num; int tmp; glBegin(GL_POINTS); glVertex3f (pt.x, pt.y, 0.0); glEnd(); for(i<0; i<10000; i++){ pt = invertpt(c[circle], pt); tmp = rand()%circle_num; while(tmp == circle){ tmp = rand()%circle_num; } circle = tmp; glBegin(GL_POINTS); glVertex3f (pt.x, pt.y, 0.0); glEnd(); } glPopMatrix(); glutSwapBuffers(); }
int main() { std::string input; std::getline (std::cin, input); // http://stackoverflow.com/questions/5607589/right-way-to-split-an-stdstring-into-a-vectorstring std::stringstream ss(input); std::istream_iterator<std::string> begin(ss); std::istream_iterator<std::string> end; std::vector<std::string> vstrings(begin, end); std::vector<int> numbers(vstrings.size(), 0); for(int i = 0 ; i < vstrings.size() ; ++i) { int num = std::stoi(vstrings[i], nullptr, 10); numbers[i] = num; } int sum = std::accumulate(numbers.begin(), numbers.end(), 0); printf("%d\n", sum); return 0; }
int main(int argc, char *argv[]) { std::string str = "ab2c3d7R4E6"; std::string numbers("0123456789"); std::string alp("qwertyuioplkjhgfdsazxcvbnmQWERTYUIOPLKJHGFDSAZXCVBNM"); std::string::size_type pos = 0; std::cout << "数字:"; while((pos = str.find_first_of(numbers, pos)) != std::string::npos) { std::cout << pos++ << " "; } std::cout << std::endl; pos = 0; std::cout << "字母:"; while((pos = str.find_first_of(alp, pos)) != std::string::npos) { std::cout << pos++ << " "; } std::cout << std::endl; return EXIT_SUCCESS; }
int countPrimes(int n) { if(n <= 1) return 0; int count = 0; vector<bool> numbers(n, true); for(int i = 1; i < numbers.size() - 1; ++i) { if(numbers[i]) { ++count; int prime = i + 1; for(int index = prime - 1; index < n; index += prime) { if(numbers[index]) numbers[index] = false; } } } return count; }
int main() { srand(time(0)); // Initialize data std::vector<int> numbers(1000); for (std::vector<int>::size_type i = 0; i != numbers.size(); ++i) { numbers[i] = i; } // Repeat benchmark 4 times. for (unsigned i = 0; i != 4; ++i) { unsigned p = 0; std::vector<int>::size_type index = rand() % numbers.size(); const char * c = reinterpret_cast<const char *>(&numbers[index]); std::cout << "index: " << index << std::endl; std::cout << "v1: " << test_v1(c, p) << std::endl; std::cout << "v2: " << test_v2(c, p) << std::endl << std::endl; } }
int main(void) { auto limit = 1000; std::vector<int> numbers(limit); { int n(0); std::generate(numbers.begin(), numbers.end(), [&n](){ return n++; }); } auto total = 0; for (auto number : numbers) { if (number % 3 == 0 || number % 5 == 0) { total += number; } } std::cout << "answer: " << total << std::endl; return 0; }