Codility “PermMissingElem” Solution This is my solution to the PermMissingElem problem, I wonder what can be improved? Expected worst case time complexity is O(N), but the performance test shows that it's O(N) or O(N * log(N)), which I suppose there's some solution out there that can truly achieve pure O(N)?

function solution(A) {
    const size = A.length;
    let sum = 0;

    for (i=0;i&lt;size;i++){
        sum += A[i];
    }

    return (((size+ 1)*(size + 2))/2) - sum
}


The original problem is quoted as follows:


  A zero-indexed array A consisting of N different integers is given.
  The array contains integers in the range [1..(N + 1)], which means
  that exactly one element is missing.
  
  Your goal is to find that missing element.
  
  Write a function:
  
  int solution(int A[], int N); that, given a zero-indexed array A,
  returns the value of the missing element.
  
  For example, given array A such that:
  
  A[0] = 2   A1 = 3   A[2] = 1   A[3] = 5 the function should return
  4, as it is the missing element.
  
  Assume that:
  
  N is an integer within the range [0..100,000]; the elements of A are
  all distinct; each element of array A is an integer within the range
  [1..(N + 1)]. 
  
  Complexity:
  
  expected worst-case time complexity is O(N); expected worst-case space
  complexity is O(1), beyond input storage (not counting the storage
  required for input arguments). Elements of input arrays can be
  modified.
With your JavaScript version, there is not much to optimize. So I am just going to provide some minor improvements:


Within a function, it is better to declare your variables using the var keyword. You should apply this to the i inside for() loop
The JavaScript interpreter is a single thread: this means, unfortunately, you can not perform real parallelism to sum different chunks of the array.
You can choose better variables and function names.