class Summer extends Thread {
    int begin;
    int end;
    int[] sharedBuffer;
    int sum = 0;

    Summer(int begin, int end, int[] sharedBuffer) {
        this.begin = begin;
        this.end = end;
        this.sharedBuffer = sharedBuffer;
    }

    @Override
    public void run() {
        for (int i = begin; i < end; i++) {
            sum += sharedBuffer[i];
        }
    }

    int getSum() {
        return sum;
    }
}

public class Main {

    public static void main(String[] args) {

        System.out.println("Hello World!");
        int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        Summer thread1 = new Summer(0, 5, numbers);
        Summer thread2 = new Summer(5, 10, numbers);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        int sum = thread1.getSum() + thread2.getSum();
        System.out.println(sum);

    }
}

#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <omp.h>
#include "pch.h"
#include <stdio.h>
#include <stdlib.h>

using namespace std;

int main()
{
    const int n = 100;
    int sum = 0;
    int array[n];

    for (int i = 0; i < n; i++)
    {
        array[i] = i+1;
    }

#pragma omp parallel num_threads(4) //reduction (+:sum)
    for (int i = 0; i < n; i++)
    {
        sum = sum + array[i];
    }

    printf("%d\n", sum);

    int filteredArray[33];
    int tempCounter = 0;
#pragma omp prallalel num_threads(4)
    for (int i = 0; i < n; i++)
    {
        if (array[i] % 3 == 0)
        {
            filteredArray[tempCounter] = array[i];
            tempCounter++;
        }
    }
    int sum2 = 0;
#pragma omp parallel num_threads(4)
    for (int i = 0; i < 33; i++)
    {
        filteredArray[i] = filteredArray[i] * filteredArray[i] * filteredArray[i];
        sum2 += filteredArray[i];
    }

    printf("%d\n", sum2);

    return 0;
}


#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include "thrust/host_vector.h"
#include "thrust/device_vector.h"
#include "thrust/sequence.h"
#include "thrust/copy.h"

#include <stdio.h>

struct is_cube
{
    __device__ bool operator () (int item)
    {
        return item % 3 == 0;
    }
};

struct cube
{
    __device__ int operator () (int item)
    {
        return item * item * item;
    }
};

int main()
{


    thrust::host_vector<int> data(100);
    thrust::device_vector<int> results(100);

    thrust::sequence(data.begin(), data.end(), 1);

    results = data;

    int sum = thrust::reduce(results.begin(), results.end());

    std::cout << std::endl;

    std::cout << sum << std::endl;



    thrust::device_vector<int> filtered_vector(33);

    thrust::copy_if(results.begin(), results.end(), filtered_vector.begin(), is_cube());

    thrust::device_vector<int> cubed_vector(33);

    thrust::transform(filtered_vector.begin(), filtered_vector.end(), cubed_vector.begin(), cube());

    int sum2 = thrust::reduce(cubed_vector.begin(), cubed_vector.end());

    std::cout << std::endl;

    std::cout << sum2 << std::endl;

    return 0;
}