ShaysXIA/CodeInsightBench huggingface dataset:
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: 124 ms):
from collections import Counter

t = int(input())


def solve():
    n = int(input())
    a = list(map(int, input().split()))
    if n == 1:
        print(a[0])
        return
    ans = sum(a)
    while len(a) > 1:
        b = [0] * (len(a) - 1)
        for i in range(len(a) - 1, 0, -1):
            b[i - 1] = a[i] - a[i - 1]
        a = b.copy()
        ans = max(ans, abs(sum(a)))
    print(ans)


for _ in range(t):
    solve()
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: 93 ms):
import sys

inp = sys.stdin.readline

def I(): return int(inp().strip())
def IS(): return inp().strip()
def II(): return map(int, inp().split())
def IL(): return list(map(int, inp().split()))
def SIL(): return sorted(map(int, inp().split()))
from collections import defaultdict, Counter, deque
from array import array
from math import gcd, isqrt



def solve():
    n = I()
    arr = IL()

    neg = False
    pos = False

    if n == 1:
        print((arr[0]))
        return

    for i in range(n):
        if arr[i] < 0:
            neg = True
        
        if arr[i] > 0:
            pos = True
    
    res1 = sum(arr)
    res2 = float("-inf")
    
    while len(arr)!=1:
        new = []
        for i in range(1, len(arr)):
            new.append(arr[i]-arr[i-1])
        res2 = max(res2, abs(sum(new)))
        arr = new.copy()

    print (max(res1, res2))
    
 


T = I()
for _ in range(T):
    solve()
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: 77 ms):
for _ in range(int(input())):
    n = int(input())
    a = list(map(int,input().split()))
    if n==1:
        print(a[0])
        continue
    
    sm = sum(a)
    while(n>1):
        n -=1
        a = [a[i+1]-a[i] for i in range(n)]
        sm = max(sm,abs(sum(a)))
    print(sm)
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 93 ms):
m=int(input())
for _ in range(m):
    n=int(input())
    l=list(map(int,input().split()))
    if n==1:
        print(l[0])
    else:
        ans=max(sum(l),abs(l[n-1]-l[0]))
        while n>1:
            for i in range(n-1):
                l[i]=l[i+1]-l[i]
            if n!=2:
                ans=max(ans,abs(l[n-2]-l[0]))
            if n==2:
                ans=max(ans,abs(l[n-2]))
            #print(n,l,ans)
            n-=1
        print(ans)
        

Solution 2 (runtime: 124 ms):
from itertools import pairwise

numTestCases = int(input())
while numTestCases > 0:
    numTestCases -= 1
    int(input())
    a = [int(s) for s in input().split()]
    res = sum(a)
    while len(a) > 1:
        if a[-1] < a[0]:
            a = list(reversed(a))
        res = max(res, a[-1] - a[0])
        a = [y-x for x,y in pairwise(a)]
    print(res)
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 93 ms):
m=int(input())
for _ in range(m):
    n=int(input())
    l=list(map(int,input().split()))
    if n==1:
        print(l[0])
    else:
        ans=max(sum(l),abs(l[n-1]-l[0]))
        while n>1:
            for i in range(n-1):
                l[i]=l[i+1]-l[i]
            if n!=2:
                ans=max(ans,abs(l[n-2]-l[0]))
            if n==2:
                ans=max(ans,abs(l[n-2]))
            #print(n,l,ans)
            n-=1
        print(ans)
        

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)
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 93 ms):
m=int(input())
for _ in range(m):
    n=int(input())
    l=list(map(int,input().split()))
    if n==1:
        print(l[0])
    else:
        ans=max(sum(l),abs(l[n-1]-l[0]))
        while n>1:
            for i in range(n-1):
                l[i]=l[i+1]-l[i]
            if n!=2:
                ans=max(ans,abs(l[n-2]-l[0]))
            if n==2:
                ans=max(ans,abs(l[n-2]))
            #print(n,l,ans)
            n-=1
        print(ans)
        

Solution 2 (runtime: 93 ms):
for _ in range(int(input())):
    n=int(input())
    a=list(map(int,input().split()))
    not_op = sum(a)
    while(len(a)>2):
        t=[]
        for i in range(1,len(a)):
            t.append(a[i]-a[i-1])
        a=t
        not_op=max(not_op,sum(a))
        neg_a = map(lambda x:-x,a)
        not_op=max(not_op,sum(neg_a))
    if len(a)==1:
        print(a[0])
    else:
        res=max(a[0]-a[1],a[1]-a[0])
        print(max(res,not_op))
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 93 ms):
m=int(input())
for _ in range(m):
    n=int(input())
    l=list(map(int,input().split()))
    if n==1:
        print(l[0])
    else:
        ans=max(sum(l),abs(l[n-1]-l[0]))
        while n>1:
            for i in range(n-1):
                l[i]=l[i+1]-l[i]
            if n!=2:
                ans=max(ans,abs(l[n-2]-l[0]))
            if n==2:
                ans=max(ans,abs(l[n-2]))
            #print(n,l,ans)
            n-=1
        print(ans)
        

Solution 2 (runtime: 125 ms):
tc = int(input())

for _ in range(tc):
    n = int(input())
    a = list(map(int, input().split()))
    res = sum(a)
    if n == 1:
        print(a[0])
    else:
        while len(a) > 2:
            b = []
            for i in range(len(a) - 1):
                b.append(a[i] - a[i + 1])
            res = max(res, sum(b))
            a = a[::-1]
            b = []
            for i in range(len(a) - 1):
                b.append(a[i] - a[i + 1])
            res = max(res, sum(b))
            a = b
            # print(_, a, len(a))
        res = max(a[1] - a[0], a[0] - a[1], a[0] + a[1], res)
        print(res)
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 93 ms):
m=int(input())
for _ in range(m):
    n=int(input())
    l=list(map(int,input().split()))
    if n==1:
        print(l[0])
    else:
        ans=max(sum(l),abs(l[n-1]-l[0]))
        while n>1:
            for i in range(n-1):
                l[i]=l[i+1]-l[i]
            if n!=2:
                ans=max(ans,abs(l[n-2]-l[0]))
            if n==2:
                ans=max(ans,abs(l[n-2]))
            #print(n,l,ans)
            n-=1
        print(ans)
        

Solution 2 (runtime: 77 ms):






for _ in range(int(input())):
	n=int(input())
	a=list(map(int,input().split()))
	if n==1 :
		print(a[0])
	else:
		m=sum(a)
		for i in range(n):
			s=0
			for j in range(n-i-1):
				s+=(-a[j]+a[j+1])
				a[j]=-a[j]+a[j+1]
			m=max(m,s,-s)
		print(m)
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 93 ms):
m=int(input())
for _ in range(m):
    n=int(input())
    l=list(map(int,input().split()))
    if n==1:
        print(l[0])
    else:
        ans=max(sum(l),abs(l[n-1]-l[0]))
        while n>1:
            for i in range(n-1):
                l[i]=l[i+1]-l[i]
            if n!=2:
                ans=max(ans,abs(l[n-2]-l[0]))
            if n==2:
                ans=max(ans,abs(l[n-2]))
            #print(n,l,ans)
            n-=1
        print(ans)
        

Solution 2 (runtime: 156 ms):
# cook your dish here
def get(a):
    s=0
    l=[]
    for i in range(1,len(a)):
        l.append(a[i]-a[i-1])
        
    return l
for _ in range(int(input())):
    n=int(input())
    l=list(map(int,input().split()))
    ans=sum(l)
    while(len(l)!=1):
        t1=get(l)
        t2=get(l[::-1])
        if sum(t1)>=sum(t2):
            l=t1 
        else:
            l=t2 
        ans=max(ans,sum(l))
    print(max(ans,l[0]))
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 93 ms):
m=int(input())
for _ in range(m):
    n=int(input())
    l=list(map(int,input().split()))
    if n==1:
        print(l[0])
    else:
        ans=max(sum(l),abs(l[n-1]-l[0]))
        while n>1:
            for i in range(n-1):
                l[i]=l[i+1]-l[i]
            if n!=2:
                ans=max(ans,abs(l[n-2]-l[0]))
            if n==2:
                ans=max(ans,abs(l[n-2]))
            #print(n,l,ans)
            n-=1
        print(ans)
        

Solution 2 (runtime: 140 ms):

def reduce_list(arr):
    new_arr = [0] * (len(arr) - 1)

    for idx in range(1, len(arr)):
        new_arr[idx-1] = arr[idx] - arr[idx-1]

    return new_arr

def sum(arr):
    sum_v = 0
    for v in arr:
        sum_v += v
    return sum_v


def min_op(arr):
    if len(arr) == 1:
        return sum(arr)

    max_v = sum(arr)

    rev_arr = arr.copy()
    rev_arr.reverse()

    arr = reduce_list(arr)
    rev_arr = reduce_list(rev_arr)

    sum_reduce = sum(arr)
    sum_rev_reduce = sum(rev_arr)

    if sum_reduce > sum_rev_reduce:
        max_v = max(max_v, min_op(arr))
    else:
        max_v = max(max_v, min_op(rev_arr))

    return max_v

t = int(input())

for x in range(0, t):
    s = int(input())
    v = list(map(int, input().split(" ")))

    m = min_op(v)
    print(m)
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 93 ms):
m=int(input())
for _ in range(m):
    n=int(input())
    l=list(map(int,input().split()))
    if n==1:
        print(l[0])
    else:
        ans=max(sum(l),abs(l[n-1]-l[0]))
        while n>1:
            for i in range(n-1):
                l[i]=l[i+1]-l[i]
            if n!=2:
                ans=max(ans,abs(l[n-2]-l[0]))
            if n==2:
                ans=max(ans,abs(l[n-2]))
            #print(n,l,ans)
            n-=1
        print(ans)
        

Solution 2 (runtime: 109 ms):
for _ in range(int(input())):

    n = int(input())
    arr = list(map(int, input().split()))

    ans = sum(arr)

    while len(arr) > 1:
        arr = [arr[i+1]-arr[i] for i in range(len(arr)-1)]
        ans = max(ans, abs(sum(arr)))
    
    print(ans)
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 93 ms):
m=int(input())
for _ in range(m):
    n=int(input())
    l=list(map(int,input().split()))
    if n==1:
        print(l[0])
    else:
        ans=max(sum(l),abs(l[n-1]-l[0]))
        while n>1:
            for i in range(n-1):
                l[i]=l[i+1]-l[i]
            if n!=2:
                ans=max(ans,abs(l[n-2]-l[0]))
            if n==2:
                ans=max(ans,abs(l[n-2]))
            #print(n,l,ans)
            n-=1
        print(ans)
        

Solution 2 (runtime: 109 ms):
for _ in range(int(input())):
    n=int(input())
    a=list(map(int,input().split()))
    s=a
    d=sum(a)
    while len(s)>=1:
        c=[]
        for i in range(len(s)-1):
            c.append(s[i+1]-s[i])
        d=max(d,abs(sum(c)))
        s=c
    if n==1:
        d=sum(a)    
    print(d)
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 93 ms):
m=int(input())
for _ in range(m):
    n=int(input())
    l=list(map(int,input().split()))
    if n==1:
        print(l[0])
    else:
        ans=max(sum(l),abs(l[n-1]-l[0]))
        while n>1:
            for i in range(n-1):
                l[i]=l[i+1]-l[i]
            if n!=2:
                ans=max(ans,abs(l[n-2]-l[0]))
            if n==2:
                ans=max(ans,abs(l[n-2]))
            #print(n,l,ans)
            n-=1
        print(ans)
        

Solution 2 (runtime: 109 ms):
def input_to_list():
    return list(map(int, input().split()))


def function(length,lists):
    lists_rot = lists[::-1]
    ans,temp_ans = 0,0
    for x in lists:
        ans += x
    lists_add = [0] * (length)
    lists_add[0] = 1
    n_sign = 1
    for maxmun in range(length - 1):
        n_sign = n_sign * -1
        add = 0
        temp_ans = 0
        for index in range(maxmun + 1):
            x = lists_add[index]
            lists_add[index] += - add
            temp_ans += lists_add[index] * (lists[index] + lists_rot[index] * n_sign)
            add = x
        ans = max(ans,temp_ans,-temp_ans)

    return ans

times = int(input())
for x in range(times):
    ans = 0
    length = int(input())
    lists = input_to_list()
    print( function(length,lists) )
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 93 ms):
m=int(input())
for _ in range(m):
    n=int(input())
    l=list(map(int,input().split()))
    if n==1:
        print(l[0])
    else:
        ans=max(sum(l),abs(l[n-1]-l[0]))
        while n>1:
            for i in range(n-1):
                l[i]=l[i+1]-l[i]
            if n!=2:
                ans=max(ans,abs(l[n-2]-l[0]))
            if n==2:
                ans=max(ans,abs(l[n-2]))
            #print(n,l,ans)
            n-=1
        print(ans)
        

Solution 2 (runtime: 109 ms):
from collections import defaultdict


def LI():
    return list(map(int, input().split(" ")))
def LS():
    return input().split(" ")
def LC():
    return input().split()
def I():
    return int(input())
def S():
    return input()



def solve(arr):
    ans = sum(arr)
    while len(arr) > 1:
        reverseCopy = list(reversed(arr))
        for i in range(len(arr) - 1):
            arr[i] = arr[i + 1] - arr[i]
            reverseCopy[i] = reverseCopy[i + 1] - reverseCopy[i]
        arr.pop()
        reverseCopy.pop()
        sumArr = sum(arr)
        sumReverseCopy = sum(reverseCopy)
        if sumReverseCopy > sumArr:
            arr = reverseCopy
        ans = max(ans, max(sumArr, sumReverseCopy))
    return ans



for _ in range(I()):
    n = I()
    arr = LI()
    print(solve(arr))
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 93 ms):
m=int(input())
for _ in range(m):
    n=int(input())
    l=list(map(int,input().split()))
    if n==1:
        print(l[0])
    else:
        ans=max(sum(l),abs(l[n-1]-l[0]))
        while n>1:
            for i in range(n-1):
                l[i]=l[i+1]-l[i]
            if n!=2:
                ans=max(ans,abs(l[n-2]-l[0]))
            if n==2:
                ans=max(ans,abs(l[n-2]))
            #print(n,l,ans)
            n-=1
        print(ans)
        

Solution 2 (runtime: 77 ms):
t=int(input())
for _ in range(t):
    n=int(input())
    if n==1:
        print(int(input()))
    else:
      
        lis=list(map(int,input().split()))
        ans=sum(lis)
        for i in range(1,n):
            for j in range(n-1,i-1,-1):
                lis[j]-=lis[j-1]
            ans=max(ans,abs(sum(lis[i:])))
        print(max(abs(lis[-1]),ans))
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 93 ms):
m=int(input())
for _ in range(m):
    n=int(input())
    l=list(map(int,input().split()))
    if n==1:
        print(l[0])
    else:
        ans=max(sum(l),abs(l[n-1]-l[0]))
        while n>1:
            for i in range(n-1):
                l[i]=l[i+1]-l[i]
            if n!=2:
                ans=max(ans,abs(l[n-2]-l[0]))
            if n==2:
                ans=max(ans,abs(l[n-2]))
            #print(n,l,ans)
            n-=1
        print(ans)
        

Solution 2 (runtime: 108 ms):
def difference(numbers, length):
    newlist = []
    for i in range(length-1):

        newlist.append(numbers[i+1]-numbers[i])
    return newlist, length-1

for i in range(int(input())):
    length = int(input())
    answer = list(map(int,input().split()))
    sums = [sum(answer)]

    while length!=1:
        answer, length = difference(answer, length)
        sums.append(max(sum(answer),-sum(answer)))
    print(max(sums))


        # if i == 2:
        #     print(numbers)
        #     print(sum(numbers))
        #     print('-------------------')
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 93 ms):
m=int(input())
for _ in range(m):
    n=int(input())
    l=list(map(int,input().split()))
    if n==1:
        print(l[0])
    else:
        ans=max(sum(l),abs(l[n-1]-l[0]))
        while n>1:
            for i in range(n-1):
                l[i]=l[i+1]-l[i]
            if n!=2:
                ans=max(ans,abs(l[n-2]-l[0]))
            if n==2:
                ans=max(ans,abs(l[n-2]))
            #print(n,l,ans)
            n-=1
        print(ans)
        

Solution 2 (runtime: 124 ms):
for _ in range(int(input())):
    n = int(input())
    a = list(map(int,input().split()))
    if n == 1:
        print(a[0])
        continue
    rta = sum(a)
    while n > 1:
        a = [a[i] - a[i-1] for i in range(1,n)]
        n -= 1
        rta = max(rta, abs(sum(a)))
    print(rta)
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 93 ms):
m=int(input())
for _ in range(m):
    n=int(input())
    l=list(map(int,input().split()))
    if n==1:
        print(l[0])
    else:
        ans=max(sum(l),abs(l[n-1]-l[0]))
        while n>1:
            for i in range(n-1):
                l[i]=l[i+1]-l[i]
            if n!=2:
                ans=max(ans,abs(l[n-2]-l[0]))
            if n==2:
                ans=max(ans,abs(l[n-2]))
            #print(n,l,ans)
            n-=1
        print(ans)
        

Solution 2 (runtime: 108 ms):
t = int(input())
for _ in range(t):
    n = int(input())
    nums = list(map(int, input().split()))
    if n == 1:
        print(nums[0])
    else:
        num_sum = sum(nums)
        max_diff = 0
        diff_num = nums
        while len(diff_num) > 1:
            diff = 0
            for i in range(1, len(diff_num)):
                new_a = diff_num[i] - diff_num[i-1]
                diff += new_a
                diff_num[i-1] = new_a
            diff_num.pop(-1)
            max_diff = max(max_diff, abs(diff))

        print(max(num_sum, max_diff))