Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 202 ms):
def solve():
    import sys, math
    data = sys.stdin.read().strip().split()
    if not data:
        return
    t = int(data[0])
    index = 1
    out_lines = []
    for _ in range(t):
        if index >= len(data):
            break
        n = int(data[index])
        index += 1
        # Read the sequence (we use 0-indexing)
        arr = list(map(int, data[index:index+n]))
        index += n
        # If the sequence length is 1, answer is the only element.
        if n == 1:
            out_lines.append(str(arr[0]))
            continue
        # Candidate 0: no operations, i.e. the sum of all elements.
        cand0 = sum(arr)
        best = cand0
        # For r = 1 to n-1, consider doing r difference operations.
        # In 0-indexed notation:
        #   L(r) = sum_{j=0}^{r-1} (-1)^(r-1-j) * binom(r-1, j) * arr[j]
        #   R(r) = sum_{j=0}^{r-1} (-1)^(r-1-j) * binom(r-1, j) * arr[n-r+j]
        # and candidate = |R(r)-L(r)|
        for r in range(1, n):
            L_val = 0
            R_val = 0
            for j in range(r):
                sign = 1 if ((r-1-j) % 2 == 0) else -1
                comb = math.comb(r-1, j)
                L_val += sign * comb * arr[j]
                R_val += sign * comb * arr[n - r + j]
            diff = R_val - L_val
            candidate = diff if diff >= 0 else -diff
            if candidate > best:
                best = candidate
        out_lines.append(str(best))
    sys.stdout.write("\n".join(out_lines))

if __name__ == '__main__':
    solve()


Solution 2 (runtime: 281 ms):
import sys
from collections import defaultdict,deque,Counter
from heapq import heappush,heappop,heapify
from math import inf,comb,ceil,log,lcm,gcd,isqrt
from functools import cache
from itertools import accumulate,combinations,permutations
from bisect import bisect_left,bisect_right,insort_left
from random import randint

input=lambda:sys.stdin.readline().rstrip()
inp=lambda:list(map(int,input().split()))
I=lambda:int(input())
fact=[cur:=1]+[cur:=(cur*i)for i in range(1,100)]
def comb(n,k):
    return fact[n]//(fact[n-k]*fact[k])
def f(n,b):
    o=0
    for i in range(n):
        if b:
            if i%2:
                o-=comb(n-1,i)*a[i]
            else:
                o+=comb(n-1,i)*a[i]
        else:
            if i%2:
                o-=comb(n-1,i)*a[~i]
            else:
                o+=comb(n-1,i)*a[~i]

    return o
"""def bf(ox):
    
    n=len(ox)
    o=sum(ox)

    for i in range(1<<(n-1)):
        x=ox.copy()
        for v in range(n-1):
            if (1<<v)&i:
                x=[x[ii]-x[ii+1]for ii in range(len(x)-1)]
            else:
                x=[x[ii+1]-x[ii]for ii in range(len(x)-1)]
            o=max(o,sum(x))
    return o"""

t=I()
for _ in range(t):
    n=I()
    a=inp()
    #n=randint(1,5)
    #a=[randint(-1000,1000)for _ in range(n)]
    o=sum(a)
    for i in range(n-1):
        c1=f(i+1,1)
        c2=f(i+1,0)
        if i==0:
            o=max(o,abs(a[-1]-a[0]))
        else:
            o=max(abs(c1)+abs(c2),o)
    #print(sum(abs(e)for e in a))
    o=max(o,f(n,0),f(n,1))
    print(o)
    #assert o==bf(a),(bf(a),o,a)