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;
}
