Python 2, 246 bytes

I have taken a similar approach to my answer at Calculate π with quadratic convergence . The last line takes the Nth power of pi and sums the digits. The N=5000 test takes a minute or so.

from decimal import* d=Decimal N=input() getcontext().prec=2*N j=d(1) h=d(2) f=h*h g=j/h a=j b=j/h.sqrt() t=j/f p=j for i in bin(N)[2:]:e=a;a,b=(a+b)/h,(a*b).sqrt();c=e-a;t-=c*c*p;p+=p k=a+b l=k*k/f/t print sum(map(int,`l**N`.split('.')[1][:N])) 

Some tests:

$ echo 1 | python soln.py 1 $ echo 3 | python soln.py 6 $ echo 5 | python soln.py 24 $ echo 500 | python soln.py 2305 $ echo 5000 | python soln.py 22852 

The ungolfed code:

from decimal import * d = Decimal N = input() getcontext().prec = 2 * N # constants: one = d(1) two = d(2) four = two*two half = one/two # initialise: a = one b = one / two.sqrt() t = one / four p = one for i in bin(N)[2:] : temp = a; a, b = (a+b)/two, (a*b).sqrt(); pterm = temp-a; t -= pterm*pterm * p; p += p ab = a+b pi = ab*ab / four / t print sum(map(int, `pi ** N`.split('.')[1][:N])) 

Python - 191 Bytes

t=i=1L;k=n=input();f=2000*20**n;A=range(n+1) for k in range(2,n):A=[(A[j-1]+A[j+1])*j>>1for j in range(n-k+1)];f*=k while k:k=(1-~i*n%4)*f/A[1]/i**n;t+=k;i+=2 print sum(map(int,`t`[-n-4:-4])) 

~4x faster version - 206 bytes

t=i=1L;k=n=input();f=2000*20**n;A=[0,1]+[0]*n for k in range(1,n): f*=k for j in range(-~n/2-k+1):A[j]=j*A[j-1]+A[j+1]*(j+2-n%2) while k:k=(1-~i*n%4)*f/A[1]/i**n;t+=k;i+=2 print sum(map(int,`t`[-n-4:-4])) 

Input is taken from stdin. Output for n = 5000 takes approximately 14s with the second script (or 60s with the first).

Sample usage:

$ echo 1 | python pi-trunc.py 1 $ echo 2 | python pi-trunc.py 14 $ echo 3 | python pi-trunc.py 6 $ echo 4 | python pi-trunc.py 13 $ echo 5 | python pi-trunc.py 24 $ echo 50 | python pi-trunc.py 211 $ echo 500 | python pi-trunc.py 2305 $ echo 5000 | python pi-trunc.py 22852 

The formula used is the following:

where A_n is the n^thAlternating Number, which can be formally defined as the number of alternating permutations on a set of size n (see also: A000111). Alternatively, the sequence can be defined as the composition of the Tangent Numbers and Secant Numbers (A_2n = S_n, A_2n+1 = T_n), more on that later.

The small correction factor c_n rapidly converges to 1 as n becomes large, and is given by:

For n = 1, this amounts to evaluating the Leibniz Series. Approximating π as 10^½, the number of terms required can be calculated as:

which converges (rounded up) to 17, although smaller values of n require considerably more.

For the calculation of A_n there are several algorithms, and even an explicit formula, but all of them are quadratic by n. I originally coded an implementation of Seidel's Algorithm, but it turns to be too slow to be practical. Each iteration requires an additional term to be stored, and the terms increase in magnitude very rapidly (the "wrong" kind of O(n²)).

The first script uses an implementation of an algorithm originally given by Knuth and Buckholtz:

Let T_1,k = 1 for all k = 1..n

Subsequent values of T are given by the recurrence relation:

T_n+1,k = 1/2 [ (k - 1) T_n,k-1 + (k + 1) T_n,k+1 ]

A_n is then given by T_n,1

(see also: A185414)

Although not explicitly stated, this algorithm calculates both the Tangent Numbers and the Secant Numbers simultaneously. The second script uses a variation of this algorithm by Brent and Zimmermann, which calculates either T or S, depending on the parity of n. The improvement is quadratic by n/2, hence the ~4x speed improvement.