Problem:
 Score : 1000 points    Problem Statement Given are N points on the circumference of a circle centered at (0,0) in an xy -plane.
The coordinates of the i -th point are (\cos(\frac{2\pi T_i}{L}),\sin(\frac{2\pi T_i}{L})) .  Three distinct points will be chosen uniformly at random from these N points.
Find the expected x - and y -coordinates of the center of the circle inscribed in the triangle formed by the chosen points.      Constraints  3 \leq N \leq 3000  N \leq L \leq 10^9  0 \leq T_i \leq L-1  T_i<T_{i+1}  All values in input are integers.         Input Input is given from Standard Input in the following format:  N  L  T_1  :  T_N       Output Print the expected x - and y -coordinates of the center of the circle inscribed in the triangle formed by the chosen points.
Your output will be considered correct when the absolute or relative error is at most 10^{-9} .        Sample Input 1 3 4
0
1
3      Sample Output 1 0.414213562373095 -0.000000000000000  The three points have the coordinates (1,0) , (0,1) , and (0,-1) . The center of the circle inscribed in the triangle formed by these points is (\sqrt{2}-1,0) .       Sample Input 2 4 8
1
3
5
6      Sample Output 2 -0.229401949926902 -0.153281482438188       Sample Input 3 10 100
2
11
35
42
54
69
89
91
93
99      Sample Output 3 0.352886583546338 -0.109065017701873

Solution (Python):
from math import sin,cos,pi
N,L=map(int,input().split())
S=N*(N-1)*(N-2)/6
T=[int(input())*pi/L for _ in range(N)]
print(sum([sum([cos((T[i]+T[j]))*(N+2*(i-j))for j in range(i+1, N)])for i in range(N)])/S,sum([sum([sin((T[i]+T[j]))*(N+2*(i-j))for j in range(i+1,N)])for i in range(N)])/S)

Solution (Python):
from math import sin,cos,pi
N,L=map(int,input().split())
S=N*(N-1)*(N-2)/ 6
T=[int(input())*pi/L for _ in range(N)]
print(sum([sum([cos((T[i]+T[j]))*(N+2*(i-j)) for j in range(i+1, N)]) for i in range(N)])/S,sum([sum([sin((T[i]+T[j]))*(N+2*(i-j)) for j in range(i+1,N)]) for i in range(N)])/S)

Solution (Python):
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
    n,L=map(int,input().split())
    T=[int(input()) for _ in range(n)]
    s=0
    from math import pi
    from cmath import rect
    for j in range(n):
        for i in range(j): 
            s+=-rect(1,(T[i]+T[j])*pi/L)*(j-i-1) 
            s+= rect(1,(T[i]+T[j])*pi/L)*(n-(j-i+1)) 
    s/=n*(n-1)*(n-2)/6
    print(s.real,s.imag)
resolve()

Solution (Python):
import sys
from math import *
from itertools import *

input = sys.stdin.readline

N, L = list(map(int,input().split()))
T = [int(input().strip()) for i in range(N)]
T.sort()

pairN = factorial(N)/(factorial(N-2)*factorial(2))
tripleN = factorial(N)/(factorial(N-3)*factorial(3))

ans = [0,0]
for i0, i1 in combinations(range(N),2):
	t0, t1 = T[i0], T[i1]
	tn = (t0+t1)/2
	to = tn+(L/2.0)
	cn = (cos(2.0*pi*tn/L),sin(2.0*pi*tn/L))
	co = (cos(2.0*pi*to/L),sin(2.0*pi*to/L))

	onum = (i1-i0)-1
	nnum = N-2-onum
	ans[0] += (cn[0]*nnum + co[0]*onum)/tripleN
	ans[1] += (cn[1]*nnum + co[1]*onum)/tripleN

print(" ".join(map(str,ans)))

Solution (Python):
from math import cos, sin, pi
from itertools import combinations
N, L = map(int, input().split())
T = [int(input()) for _ in range(N)]
PI2oL = 2*pi/L

csum, ssum = 0, 0
count = 0
for i, j in combinations(range(N), 2):
    count += 1
    mid1, num2 = (T[i] + T[j]) / 2, j - i - 1
    mid2, num1 = (mid1 + L/2) % L, N - num2 - 2
    csum += cos(PI2oL*mid1) * num1 + cos(PI2oL*mid2) * num2
    ssum += sin(PI2oL*mid1) * num1 + sin(PI2oL*mid2) * num2

print(csum/count/(N-2)*3, ssum/count/(N-2)*3)

Solution (Python):


import math

N, L = list(map(int, input().split()))
T = [int(input()) for _ in range(N)]

x, y = 0, 0
for i in range(N - 1):
  for j in range(i + 1, N):
    a = (T[i] + T[j]) / 2
    b = a + L / 2
    t = j - i - 1
    k = N - 2 - t
    x += k * math.cos(2 * math.pi * a / L)
    x += t * math.cos(2 * math.pi * b / L)
    y += k * math.sin(2 * math.pi * a / L)
    y += t * math.sin(2 * math.pi * b / L)
x /= N * (N - 1) * (N - 2) / 3 / 2
y /= N * (N - 1) * (N - 2) / 3 / 2
print(x, y)

Solution (Python):


import math

N, L = list(map(int, input().split()))
T = [int(input()) for _ in range(N)]

K = N * (N - 1) * (N - 2) / 3 / 2
x, y = 0, 0
for i in range(N - 1):
  for j in range(i + 1, N):
    a = (T[i] + T[j]) / 2
    b = a + L / 2
    t = j - i - 1
    k = N - 2 - t
    x += k * math.cos(2 * math.pi * a / L) / K
    x += t * math.cos(2 * math.pi * b / L) / K
    y += k * math.sin(2 * math.pi * a / L) / K
    y += t * math.sin(2 * math.pi * b / L) / K
print(x, y)

Solution (Python):
from math import sin, cos, pi
N, L = map(int, input().split())
NN = N * (N-1) * (N-2) // 6
T = [int(input())*pi/L for _ in range(N)]
print(sum([sum([cos((T[i]+T[j])) * (N+2*(i-j)) for j in range(i+1, N)]) for i in range(N)])/NN, sum([sum([sin((T[i]+T[j])) * (N+2*(i-j)) for j in range(i+1, N)]) for i in range(N)])/NN)

Solution (Python):
import math
N,L=map(int,input().split())
T=[int(input()) for i in range(N)]
X=0
Y=0
for i in range(N):
    for j in range(i+1,N):
        angle=math.pi*(T[j]+T[i])/L
        
        X+=math.cos(angle)*(N-2-(j-i-1)*2)
        Y+=math.sin(angle)*(N-2-(j-i-1)*2)
A=(N*(N-1)*(N-2))//6
print(X/A,Y/A)

Solution (Python):

from math import cos, sin, pi
n, L = map(int, input().split())
t = [int(input()) for _ in range(n)]
ans = [0, 0]
for i in range(n):
    for j in range(i + 1, n):
        k = (n - 1 - j + i) - (j - i - 1)
        ans[0] += cos(pi * (t[i] + t[j]) / L) * k
        ans[1] += sin(pi * (t[i] + t[j]) / L) * k
for i in range(2):
    ans[i] /= n * (n - 1) * (n - 2) / 6
print(*ans, sep=' ')

Solution (Python):
from math import sqrt, sin, cos, pi
import time

def main():
    N,L = map(int, input().split())
    t = [int(input()) for i in range(N)]
    
    

    comb = N * (N-1) * (N-2) / 6
    ans_X, ans_Y = 0, 0
    for i in range(N-1):
        for j in range(i+1,N):
            theta = pi * (t[j] + t[i]) / L

            I_X = cos(theta) * (N - 2*(j-i))
            I_Y = sin(theta) * (N - 2*(j-i))
            ans_X += I_X / comb
            ans_Y += I_Y / comb
            
    
    print(ans_X, ans_Y)


if __name__ == "__main__":
    
    main()

Solution (Python):
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
    n,l=map(int,input().split())
    T=[int(input()) for _ in range(n)]
    import math,cmath
    pi=math.acos(-1)
    ans=0
    for i in range(n):
        for j in range(i+1,n):
            ans+=cmath.rect(1,(T[i]+T[j])*pi/l)*(n-(j-i+1))
            ans+=-cmath.rect(1,(T[i]+T[j])*pi/l)*(j-i-1)
    ans/=n*(n-1)*(n-2)/6
    print(ans.real,ans.imag)
resolve()

Solution (Python):
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
    n,l=map(int,input().split())
    T=[int(input()) for _ in range(n)]
    ans=0
    import math
    import cmath
    pi=math.acos(-1)
    for i in range(n):
        for j in range(i+1,n):
            ans+=cmath.rect(1,(T[i]+T[j])*pi/l)*(n-(j-i+1))
            ans+=-cmath.rect(1,(T[i]+T[j])*pi/l)*(j-i-1)
    ans/=n*(n-1)*(n-2)/6
    print(ans.real,ans.imag)
resolve()

Solution (Python):
import math
pi = math.acos(-1)
N, L = map(int, input().split())
NN = N * (N-1) * (N-2) // 6
T = [int(input()) for _ in range(N)]
print(sum([sum([math.cos((T[i]+T[j])*pi/L) * (N+2*(i-j)) for j in range(i+1, N)]) for i in range(N)])/NN, sum([sum([math.sin((T[i]+T[j])*pi/L) * (N+2*(i-j)) for j in range(i+1, N)]) for i in range(N)])/NN)

Solution (Python):
import math

N,L=map(int,input().split())
T=[int(input()) for i in range(N)]

ANSX=ANSY=0

for i in range(N-1):
    for j in range(i+1,N):
        ANSX+=math.cos((T[i]+T[j])*math.pi/L)*(N-(j-i+1))
        ANSY+=math.sin((T[i]+T[j])*math.pi/L)*(N-(j-i+1))

        ANSX+=math.cos((T[i]+T[j])*math.pi/L+math.pi)*(j-i-1)
        ANSY+=math.sin((T[i]+T[j])*math.pi/L+math.pi)*(j-i-1)

print(ANSX/(N*(N-1)*(N-2)//6),ANSY/(N*(N-1)*(N-2)//6))

Solution (Python):
from cmath import rect, pi
def main():
    n, m = map(int, raw_input().split())
    a = [int(raw_input()) for _ in xrange(n)]
    a.sort()
    ans = 0j
    for i, x in enumerate(a):
        for j in xrange(i + 1, n):
            t = rect(1., pi * (x + a[j]) / m)
            ans += t * (n - j + i - 1) - t * (j - i - 1)
    ans /= n * (n - 1) * (n - 2) / 6
    print "%.12f %.12f" % (ans.real, ans.imag)
main()

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

import numpy as np

pi = np.pi

N,L = map(int,readline().split())
T = np.array(read().split(),np.int64)

theta = (T[:,None] + T[None,:]) * (pi/L)
a = np.arange(N)
coef = N-2*(a[None,:] - a[:,None])
coef = np.triu(coef,1)

cnt = N*(N-1)*(N-2)/6
x = np.sum(np.cos(theta) * coef) / cnt
y = np.sum(np.sin(theta) * coef) / cnt
print(x,y)