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: 140 ms):
mod = 1e9 + 7


def binpow(a, n):
    res = 1
    while n != 0:
        print(bin(n))
        if n & 1:
            res = res * a % mod
        a = a * a % mod
        n >>= 1
    return res


def resheto(n):
    # n = int(input())
    primes = [int(a) for a in range(n + 1)]
    primes[1] = 0

    i = 2
    while i <= n:
        j = i + i
        while j <= n:
            primes[j] = 0
            j += i

        i += 1
    primes = [i for i in primes if i != 0]
    return primes


def delit(x):
    arr = []
    for i in range(2, int(x ** 0.5) + 1):
        if x % i == 0:
            arr.append(i)
            arr.append(x // i)
    return sorted(arr)


# n, k = 100000, 1
# arr = [10000] * 99999
# arr.append(-1)


def xfind(arr, x):
    r = len(arr) - 1
    l = 0
    while l <= r:
        mid = (l + r) // 2

        if arr[mid] == x:
            return True

        elif arr[mid] < x:
            l = mid + 1

        elif arr[mid] > x:
            r = mid - 1

    return False



from math import ceil
import bisect

from decimal import Decimal, getcontext

getcontext().prec = 15
#
# resh = resheto(10**6)

# def s(arr):
#     s = 0
#     for i in range(len(arr)):
#         mn = 1000000
#         for j in range(i, len(arr)):
#             mn = min(mn, arr[j])
#             s += mn
#     print(s)


from bisect import bisect_left, bisect_right

# def bs_l(a, x, lo=0, hi=None):
#     if hi is None: hi = len(a)
#     pos = bisect_left(a, x, lo, hi)
#     return pos if pos != hi and a[pos] == x else -1
#
# def bs_r(a, x, lo=0, hi=None):
#     if hi is None: hi = len(a)
#     pos = bisect_right(a, x, lo, hi)
#     return pos if pos != hi and a[pos] == x else -1

def pref_sum(arr):
    pref_sum_arr = [0] * len(arr)
    pref_sum_arr[0] = arr[0]
    for i in range(1, len(arr)):
        pref_sum_arr[i] = pref_sum_arr[i-1] + arr[i]
    return pref_sum_arr


def fibonacci(n):
    if n < 2:
        return n
    pp = 0
    p = 1
    for i in range(n - 1):
        pp, p = p, pp + p
    return p


import math
def fibonacci_binet(n):
    sqrt5 = math.sqrt(5)
    phi = (1 + sqrt5) / 2
    psi = (1 - sqrt5) / 2
    return round((phi**n - psi**n) / sqrt5)


from math import ceil
from bisect import bisect_left, bisect_right
from math import gcd, factorial
from decimal import Decimal
getcontext().prec = 4


def new_arr(arr):
    x = []
    for i in range(len(arr) - 1):
        x.append(arr[i+1] - arr[i])
    return x

def solve():
    n = int(input())
    arr = [int(a) for a in input().split()]
    ans = sum(arr)
    
    while len(arr) > 1:
        rev_arr = new_arr(arr[::-1])
        arr = new_arr(arr)
        ans = max(ans, sum(arr), sum(rev_arr))
        
    print(ans)


def main():
    t = int(input())
    for _ in range(t):
        # if _ == 152:
        #     n, k = map(int, input().split())
        #     s = input()
        #     print(s)
        # else:
        solve()


main()