Jason Reaves

Algorithm books like to be confusing. The for loop in your example will run n-m+1 times so that becomes the complexity and it'll be multiplied by the complexity of the inner loop. I'll try to demonstrate.

I'll use an example of two while loops because basically a while loop comes out to be the same thing as a for loop in time analysis.

Basically the time analysis on a while loop amounts to
twhile = (tbody + tcond) * r + tcond
twhile being the time of the while loop
tbody being the time of the body of the while loop
tcond being the time of the conditional of the while loop
"r" being how many times the body is to be run

The reason tcond is there at the end is because it will be ran again and become false at the end of loop.

So if you have loops inside of loops for instance:
i=0 while(i<n) { j=0 while(j<k) { A[i][j] += 1 } }

Then we'll call the first while loop T1while and the second while loop T2while so T1 become
T1while = (T2while + t1cond) * r + t1cond --now we know that the cond is constant so we can just fill in a c for constant T1while = (T2while + c) * n + c --we also know the r will be n some outside number passed in to be our problem size T1while = (c * k + c + c) * n + c --now we just simplify like we did in T2while via combining constants and such T1while = (c * k + c) * n + c T1while = c*k*n + c*n + c --hey look at this our problem size is k*n and this now looks like a quadratic equation of sorts... so this function asymptotically would belong to the set O(k*n) T2while = (t2body + t2cond) * r + t2cond --now the cond is a constant like T1while and the r will be k some passed in value ----maybe we're traversing a matrix or something? T2while = (t2body + c) * k + c --the body is a simple statement so it's also constant T2while = (c + c) * k + c -- constant + a constant = a constant T2while = c * k + c --now we can fill this into T1while

Std C++ wants the array size to be a constant so it's known at compile time. If you need dynamic memory you can do something like.
cin >> v; int *a = new int [v] delete[] a;
Alternatively you can look into vectors which allow you to use it as a dynamic array.
c++ reference <vector>

As was said it's due to how the list are compared.
If you want to run the > operator against each pair from the lists you can use zipWith or in the case of [Int] you can sum them and then compare them.
> zipWith (>) [3,2,1] [2,10,100] [True,False,False] > sum [3,2,1] > sum [2,10,100] False