Odd Even Subarrays

First, the code review:

long int numArrs(int arr[], int n)

With C++14, you can do better than use built-in arrays (decaying to a pointer in a function, whatever the signature says): use rather std::vector, or std::array if you know the size at compile time.

{
    int numEvens[n], l, i, j, evensIJ;

Don't declare your variables unless you're ready to define them. Wait as much as possible to keep the declaration near to where you use your variable.

    if (arr[0] & 1) numEvens[0] = 0;
    else numEvens[0] = 1;

Try not to clutter your code with useless repetitions. For instance you might write:

numEvens[0] = (arr[0] & 1) ? 0 : 1;

or

numEvens[0] = !(arr[0] & 1);

By the way, don't hesitate to declare short functions that the compiler will inline, they'll make your code clearer:

constexpr bool is_odd(int i) { return i & 1; }

    for (i = 1; i < n; i++)
        numEvens[i] = (arr[i] & 1) ? (numEvens[i - 1]) : (1 + numEvens[i - 1]);

Raw loops (for loops which don't say what they're doing) should be replaced with standard, named algorithms whenever you can. Look for instance at std::partial_sum.

    long int count = 0;
    for (l = 2; l <= n; l += 2)

try to give your variables more meaningful names, e.g : l -> length

    {
        if (l > n) break;
        for (i = 0; i < n - l + 1; i++)
        {
            j = i + l - 1;
            evensIJ = numEvens[j] - numEvens[i] + ((arr[i] & 1) ? 0 : 1);
            if (2*evensIJ == (j - i + 1))
                count++;
        }
    }

    return count;
}

This nested loop is why it's taking too much time. There's an O(n) algorithm for this, which relies on dynamic programming (your program doesn't, in my opinion).

The idea is to use a map to keep track of the imbalances you've seen; whenever you come back to an imbalance, it means that you're correcting it, and so you increase your result by the number of times you've visited it:

long int count_balanced_subarrays(const std::vector<int>& input) {

    std::map<int, int> imbalances;
    imbalances[0] = 1; // 0 is the initial position, that's why it's already marked

    unsigned odd_count = 0;
    unsigned even_count = 0;

    long int res = 0; 
    for (unsigned i = 0; i < input.size(); ++i) {
        if (input[i] & 1) ++odd_count;
        else ++even_count;
        res += imbalances[odd_count - even_count]++;
    } 
    return res;
}