1class Solution {
2    // Maximum size for prime number calculation
3    private static final int MAX_SIZE = 100010;
4    // Array to mark prime numbers: true means prime
5    private static boolean[] isPrime = new boolean[MAX_SIZE];
6
7    // Static block to initialize the prime number sieve
8    static {
9        // Initialize all entries as true (potential primes)
10        for (int i = 0; i < MAX_SIZE; i++) {
11            isPrime[i] = true;
12        }
13        // 0 and 1 are not prime numbers
14        isPrime[0] = false;
15        isPrime[1] = false;
16
17        // Sieve of Eratosthenes to mark non-primes
18        for (int i = 2; i < MAX_SIZE; i++) {
19            if (isPrime[i]) {
20                for (int j = i * 2; j < MAX_SIZE; j += i) {
21                    isPrime[j] = false;
22                }
23            }
24        }
25    }
26
27    /**
28     * Calculate the absolute value of the sum by adding nums[i] if i is prime,
29     * and subtracting nums[i] if i is not prime.
30     * @param nums input integer array
31     * @return the absolute value of the calculated sum
32     */
33    public long splitArray(int[] nums) {
34        long total = 0;
35        // Iterate through the array
36        for (int i = 0; i < nums.length; i++) {
37            // Add or subtract based on the index's primality
38            if (isPrime[i]) {
39                total += nums[i];
40            } else {
41                total -= nums[i];
42            }
43        }
44        // Return absolute value of the result
45        return Math.abs(total);
46    }
47}
48

1#include <vector>
2#include <cstring>
3#include <cmath>
4using namespace std;
5
6// Define the maximum possible size for the sieve
7const int MAX_SIZE = 1e5 + 10;
8bool isPrime[MAX_SIZE];
9
10// Sieve of Eratosthenes to precompute prime numbers up to MAX_SIZE
11auto initializePrimes = [] {
12    memset(isPrime, true, sizeof(isPrime));
13    isPrime[0] = isPrime[1] = false;
14    for (int i = 2; i < MAX_SIZE; ++i) {
15        if (isPrime[i]) {
16            // Mark all multiples of i as non-prime
17            for (int j = i * 2; j < MAX_SIZE; j += i) {
18                isPrime[j] = false;
19            }
20        }
21    }
22    return 0;
23}(); // This lambda is executed immediately to fill isPrime[]
24
25class Solution {
26public:
27    // Method to process nums[] according to index primality
28    long long splitArray(vector<int>& nums) {
29        long long result = 0;
30        for (int i = 0; i < nums.size(); ++i) {
31            // If the index is prime, add; if not, subtract
32            result += isPrime[i] ? nums[i] : -nums[i];
33        }
34        // Return absolute value of result
35        return abs(result);
36    }
37};
38

1// Set the maximum number for sieve (limit should be larger than max possible array length)
2const MAX_SIZE = 100010;
3
4// Array to mark whether an index is a prime (true) or not (false)
5const primes: boolean[] = new Array(MAX_SIZE).fill(true);
6
7// Sieve of Eratosthenes to precompute all primes up to MAX_SIZE
8const init = (() => {
9    primes[0] = false;
10    primes[1] = false;
11    for (let i = 2; i < MAX_SIZE; i++) {
12        if (primes[i]) {
13            for (let j = i * 2; j < MAX_SIZE; j += i) {
14                primes[j] = false;
15            }
16        }
17    }
18})();
19
20/**
21 * Given an array of numbers, compute the special sum as follows:
22 * For each index, if it is prime, add nums[i], else subtract nums[i]
23 * Return the absolute value of the final result
24 * @param nums Array of numbers
25 * @returns Absolute value of the computed sum
26 */
27function splitArray(nums: number[]): number {
28    let result = 0;
29    for (let i = 0; i < nums.length; i++) {
30        // Add or subtract based on whether index is prime
31        result += primes[i] ? nums[i] : -nums[i];
32    }
33    return Math.abs(result);
34}
35