ShaysXIA/CodeInsightBench huggingface dataset:
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 109 ms):
# -*- coding: utf-8 -*-
"""
Created on Fri Feb 21 22:10:53 2025

@author: hp
"""
t = int(input())  # Number of test cases

for _ in range(t):
    n = int(input())  # Length of the sequence
    v = list(map(int, input().split()))  # The sequence

    max_sum = sum(v)  # Track the maximum sum encountered

    while len(v) > 1:
        # Try without reversing
        diff_v = [v[i] - v[i - 1] for i in range(1, len(v))]
        max_sum = max(max_sum, sum(diff_v))  # Update max sum

        # Try with reversing
        v.reverse()
        rev_diff_v = [v[i] - v[i - 1] for i in range(1, len(v))]
        max_sum = max(max_sum, sum(rev_diff_v))  # Update max sum

        # Pick the better option
        if sum(diff_v) > sum(rev_diff_v):
            v = diff_v
        else:
            v = rev_diff_v

    print(max_sum)


Solution 2 (runtime: 78 ms):
import sys

# Fast Input
def inp(): return sys.stdin.readline().strip()
def inplist(): return list(map(int, inp().split()))

# Debugging function
def debug(*args):
    print("DEBUG:", *args, file=sys.stderr)

def solve():
    n = int(input())
    a = list(map(int, input().split()))

    if n == 1:
        print(a[0])
        return
    ans = sum(a)
    while n > 1:
        n -= 1
        a = a[::-1]
        a = [a[i+1] - a[i] for i in range(n)]
        ans = max(ans, abs(sum(a)))
    print(ans)

def main():
    t = 1
    t = int(inp())  # Uncomment if multiple test cases exist
    for _ in range(t):
        solve()

if __name__ == "__main__":
    main()
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 109 ms):
# -*- coding: utf-8 -*-
"""
Created on Fri Feb 21 22:10:53 2025

@author: hp
"""
t = int(input())  # Number of test cases

for _ in range(t):
    n = int(input())  # Length of the sequence
    v = list(map(int, input().split()))  # The sequence

    max_sum = sum(v)  # Track the maximum sum encountered

    while len(v) > 1:
        # Try without reversing
        diff_v = [v[i] - v[i - 1] for i in range(1, len(v))]
        max_sum = max(max_sum, sum(diff_v))  # Update max sum

        # Try with reversing
        v.reverse()
        rev_diff_v = [v[i] - v[i - 1] for i in range(1, len(v))]
        max_sum = max(max_sum, sum(rev_diff_v))  # Update max sum

        # Pick the better option
        if sum(diff_v) > sum(rev_diff_v):
            v = diff_v
        else:
            v = rev_diff_v

    print(max_sum)


Solution 2 (runtime: 108 ms):
import sys

input = lambda: sys.stdin.readline().rstrip("\r\n")

INF = int(1e18)


def solve():
    N = int(input())
    a = [int(v) for v in input().split()]
    ans = sum(a)
    while len(a) > 1:
        ans = max(ans, abs(a[0] - a[-1]))
        a = [a[i] - a[i - 1] for i in range(1, len(a))]
    return ans


for _ in range(int(input())):
    # solve()
    print(solve())
    # print("YES" if solve() else "NO")
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 109 ms):
# -*- coding: utf-8 -*-
"""
Created on Fri Feb 21 22:10:53 2025

@author: hp
"""
t = int(input())  # Number of test cases

for _ in range(t):
    n = int(input())  # Length of the sequence
    v = list(map(int, input().split()))  # The sequence

    max_sum = sum(v)  # Track the maximum sum encountered

    while len(v) > 1:
        # Try without reversing
        diff_v = [v[i] - v[i - 1] for i in range(1, len(v))]
        max_sum = max(max_sum, sum(diff_v))  # Update max sum

        # Try with reversing
        v.reverse()
        rev_diff_v = [v[i] - v[i - 1] for i in range(1, len(v))]
        max_sum = max(max_sum, sum(rev_diff_v))  # Update max sum

        # Pick the better option
        if sum(diff_v) > sum(rev_diff_v):
            v = diff_v
        else:
            v = rev_diff_v

    print(max_sum)


Solution 2 (runtime: 108 ms):
t=int(input())
while t:
	t-=1
	n = int(input())
	a = list(map(int, input().split()))

	total = sum(a)
	while n > 1:
		left = sum(a[:n-1])-sum(a[1:n])
		right = sum(a[1:n])-sum(a[:n-1])

		total = max(total, left, right)
		if left >= right:
			a.reverse()

		for i in range(0, n-1):
			a[i] = a[i+1]-a[i]
		
		n-=1
		a = a[0:n]
		
	print(max(total, a[0]))
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 109 ms):
# -*- coding: utf-8 -*-
"""
Created on Fri Feb 21 22:10:53 2025

@author: hp
"""
t = int(input())  # Number of test cases

for _ in range(t):
    n = int(input())  # Length of the sequence
    v = list(map(int, input().split()))  # The sequence

    max_sum = sum(v)  # Track the maximum sum encountered

    while len(v) > 1:
        # Try without reversing
        diff_v = [v[i] - v[i - 1] for i in range(1, len(v))]
        max_sum = max(max_sum, sum(diff_v))  # Update max sum

        # Try with reversing
        v.reverse()
        rev_diff_v = [v[i] - v[i - 1] for i in range(1, len(v))]
        max_sum = max(max_sum, sum(rev_diff_v))  # Update max sum

        # Pick the better option
        if sum(diff_v) > sum(rev_diff_v):
            v = diff_v
        else:
            v = rev_diff_v

    print(max_sum)


Solution 2 (runtime: 171 ms):
import sys
data = sys.stdin.read().splitlines()

line = 2
while (line < len(data)):
    arr = list(map(int, data[line].split()))
    new_arr = arr
    diff = sum(arr)
    # print(arr, "...diff=", diff)
    if len(arr) == 2:
        diff = max(abs(arr[0]-arr[1]), diff)
    elif len(arr) > 2:
        for i in range(len(arr)-2):
            new_arr = [new_arr[i+1]-new_arr[i] for i in range(len(new_arr)-1)]
            diff = max(abs(new_arr[0]-new_arr[-1]), diff, abs(sum(new_arr)))
            # print(new_arr, "...diff=", diff)
    print(diff)
    line += 2
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 109 ms):
# -*- coding: utf-8 -*-
"""
Created on Fri Feb 21 22:10:53 2025

@author: hp
"""
t = int(input())  # Number of test cases

for _ in range(t):
    n = int(input())  # Length of the sequence
    v = list(map(int, input().split()))  # The sequence

    max_sum = sum(v)  # Track the maximum sum encountered

    while len(v) > 1:
        # Try without reversing
        diff_v = [v[i] - v[i - 1] for i in range(1, len(v))]
        max_sum = max(max_sum, sum(diff_v))  # Update max sum

        # Try with reversing
        v.reverse()
        rev_diff_v = [v[i] - v[i - 1] for i in range(1, len(v))]
        max_sum = max(max_sum, sum(rev_diff_v))  # Update max sum

        # Pick the better option
        if sum(diff_v) > sum(rev_diff_v):
            v = diff_v
        else:
            v = rev_diff_v

    print(max_sum)


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: 109 ms):
# -*- coding: utf-8 -*-
"""
Created on Fri Feb 21 22:10:53 2025

@author: hp
"""
t = int(input())  # Number of test cases

for _ in range(t):
    n = int(input())  # Length of the sequence
    v = list(map(int, input().split()))  # The sequence

    max_sum = sum(v)  # Track the maximum sum encountered

    while len(v) > 1:
        # Try without reversing
        diff_v = [v[i] - v[i - 1] for i in range(1, len(v))]
        max_sum = max(max_sum, sum(diff_v))  # Update max sum

        # Try with reversing
        v.reverse()
        rev_diff_v = [v[i] - v[i - 1] for i in range(1, len(v))]
        max_sum = max(max_sum, sum(rev_diff_v))  # Update max sum

        # Pick the better option
        if sum(diff_v) > sum(rev_diff_v):
            v = diff_v
        else:
            v = rev_diff_v

    print(max_sum)


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: 109 ms):
# -*- coding: utf-8 -*-
"""
Created on Fri Feb 21 22:10:53 2025

@author: hp
"""
t = int(input())  # Number of test cases

for _ in range(t):
    n = int(input())  # Length of the sequence
    v = list(map(int, input().split()))  # The sequence

    max_sum = sum(v)  # Track the maximum sum encountered

    while len(v) > 1:
        # Try without reversing
        diff_v = [v[i] - v[i - 1] for i in range(1, len(v))]
        max_sum = max(max_sum, sum(diff_v))  # Update max sum

        # Try with reversing
        v.reverse()
        rev_diff_v = [v[i] - v[i - 1] for i in range(1, len(v))]
        max_sum = max(max_sum, sum(rev_diff_v))  # Update max sum

        # Pick the better option
        if sum(diff_v) > sum(rev_diff_v):
            v = diff_v
        else:
            v = rev_diff_v

    print(max_sum)


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: 234 ms):
'''
Observations:

- After a reversal, you must replace the sequence with its difference sequence as otherwise nothing has been done to the sum.
- The different sequence replacement reduces the length of the sequence by 1 so we can only do it a fixed number of times.

Therefore, if we brute-force:
Options are:
1. Nothing (current sum)
2. Reverse + difference
3. Difference
'''

from math import inf
from functools import lru_cache

def get_difference_sequence(path):
    return [path[i] - path[i - 1] for i in range(1, len(path))]

@lru_cache(None)
def backtrack(length, path):
    if length == 0:
        return -inf
    
    # Convert tuple back to list for processing
    path = list(path)
    
    # Reverse + Difference
    reverse_path = path[::-1]
    diff_path = get_difference_sequence(reverse_path)
    curr = sum(diff_path)
    ans = max(curr, backtrack(length - 1, tuple(diff_path)))
    
    # Difference only
    diff_path = get_difference_sequence(path)
    curr = sum(diff_path)
    
    return max(ans, curr, backtrack(length - 1, tuple(diff_path)))

t = int(input())

while t > 0:
    n = int(input())
    a = tuple(map(int, input().split()))
    s = sum(a)
    
    if n == 1:
        print(s)
    else:
        print(max(s, backtrack(n, a)))
    
    t -= 1

Solution 2 (runtime: 93 ms):
for _ in range(int(input())):
    n = int(input())
    l = list(map(int, input().split()))


    def reduction(n, l):
        new_l = []
        summ=0
        for i in range(n - 1):
            new_l.append(l[i + 1] - l[i])
            summ += l[i+1]-l[i]
        return n - 1, new_l, summ


    def two(l):
        if l[0] * l[1] >= 0:
            return abs(l[0] + l[1])
        else:
            return abs(l[0] - l[1])

    if n==1:
        print(l[0])

    elif n==2:
        if l[0] >= 0 and l[1] >= 0:
            print(l[0] + l[1])
        else:
            print(abs(l[0] - l[1]))


    else:
        count =sum(l)
        while n >2:
            n, l, summ = reduction(n,l)
            count = max(count, abs(summ))
            
        print(max(two(l),count))
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 234 ms):
'''
Observations:

- After a reversal, you must replace the sequence with its difference sequence as otherwise nothing has been done to the sum.
- The different sequence replacement reduces the length of the sequence by 1 so we can only do it a fixed number of times.

Therefore, if we brute-force:
Options are:
1. Nothing (current sum)
2. Reverse + difference
3. Difference
'''

from math import inf
from functools import lru_cache

def get_difference_sequence(path):
    return [path[i] - path[i - 1] for i in range(1, len(path))]

@lru_cache(None)
def backtrack(length, path):
    if length == 0:
        return -inf
    
    # Convert tuple back to list for processing
    path = list(path)
    
    # Reverse + Difference
    reverse_path = path[::-1]
    diff_path = get_difference_sequence(reverse_path)
    curr = sum(diff_path)
    ans = max(curr, backtrack(length - 1, tuple(diff_path)))
    
    # Difference only
    diff_path = get_difference_sequence(path)
    curr = sum(diff_path)
    
    return max(ans, curr, backtrack(length - 1, tuple(diff_path)))

t = int(input())

while t > 0:
    n = int(input())
    a = tuple(map(int, input().split()))
    s = sum(a)
    
    if n == 1:
        print(s)
    else:
        print(max(s, backtrack(n, a)))
    
    t -= 1

Solution 2 (runtime: 78 ms):
import sys

# Fast Input
def inp(): return sys.stdin.readline().strip()
def inplist(): return list(map(int, inp().split()))

# Debugging function
def debug(*args):
    print("DEBUG:", *args, file=sys.stderr)

def solve():
    n = int(input())
    a = list(map(int, input().split()))

    if n == 1:
        print(a[0])
        return
    ans = sum(a)
    while n > 1:
        n -= 1
        a = a[::-1]
        a = [a[i+1] - a[i] for i in range(n)]
        ans = max(ans, abs(sum(a)))
    print(ans)

def main():
    t = 1
    t = int(inp())  # Uncomment if multiple test cases exist
    for _ in range(t):
        solve()

if __name__ == "__main__":
    main()
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 234 ms):
'''
Observations:

- After a reversal, you must replace the sequence with its difference sequence as otherwise nothing has been done to the sum.
- The different sequence replacement reduces the length of the sequence by 1 so we can only do it a fixed number of times.

Therefore, if we brute-force:
Options are:
1. Nothing (current sum)
2. Reverse + difference
3. Difference
'''

from math import inf
from functools import lru_cache

def get_difference_sequence(path):
    return [path[i] - path[i - 1] for i in range(1, len(path))]

@lru_cache(None)
def backtrack(length, path):
    if length == 0:
        return -inf
    
    # Convert tuple back to list for processing
    path = list(path)
    
    # Reverse + Difference
    reverse_path = path[::-1]
    diff_path = get_difference_sequence(reverse_path)
    curr = sum(diff_path)
    ans = max(curr, backtrack(length - 1, tuple(diff_path)))
    
    # Difference only
    diff_path = get_difference_sequence(path)
    curr = sum(diff_path)
    
    return max(ans, curr, backtrack(length - 1, tuple(diff_path)))

t = int(input())

while t > 0:
    n = int(input())
    a = tuple(map(int, input().split()))
    s = sum(a)
    
    if n == 1:
        print(s)
    else:
        print(max(s, backtrack(n, a)))
    
    t -= 1

Solution 2 (runtime: 108 ms):
import sys

input = lambda: sys.stdin.readline().rstrip("\r\n")

INF = int(1e18)


def solve():
    N = int(input())
    a = [int(v) for v in input().split()]
    ans = sum(a)
    while len(a) > 1:
        ans = max(ans, abs(a[0] - a[-1]))
        a = [a[i] - a[i - 1] for i in range(1, len(a))]
    return ans


for _ in range(int(input())):
    # solve()
    print(solve())
    # print("YES" if solve() else "NO")
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 234 ms):
'''
Observations:

- After a reversal, you must replace the sequence with its difference sequence as otherwise nothing has been done to the sum.
- The different sequence replacement reduces the length of the sequence by 1 so we can only do it a fixed number of times.

Therefore, if we brute-force:
Options are:
1. Nothing (current sum)
2. Reverse + difference
3. Difference
'''

from math import inf
from functools import lru_cache

def get_difference_sequence(path):
    return [path[i] - path[i - 1] for i in range(1, len(path))]

@lru_cache(None)
def backtrack(length, path):
    if length == 0:
        return -inf
    
    # Convert tuple back to list for processing
    path = list(path)
    
    # Reverse + Difference
    reverse_path = path[::-1]
    diff_path = get_difference_sequence(reverse_path)
    curr = sum(diff_path)
    ans = max(curr, backtrack(length - 1, tuple(diff_path)))
    
    # Difference only
    diff_path = get_difference_sequence(path)
    curr = sum(diff_path)
    
    return max(ans, curr, backtrack(length - 1, tuple(diff_path)))

t = int(input())

while t > 0:
    n = int(input())
    a = tuple(map(int, input().split()))
    s = sum(a)
    
    if n == 1:
        print(s)
    else:
        print(max(s, backtrack(n, a)))
    
    t -= 1

Solution 2 (runtime: 108 ms):
t=int(input())
while t:
	t-=1
	n = int(input())
	a = list(map(int, input().split()))

	total = sum(a)
	while n > 1:
		left = sum(a[:n-1])-sum(a[1:n])
		right = sum(a[1:n])-sum(a[:n-1])

		total = max(total, left, right)
		if left >= right:
			a.reverse()

		for i in range(0, n-1):
			a[i] = a[i+1]-a[i]
		
		n-=1
		a = a[0:n]
		
	print(max(total, a[0]))
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 234 ms):
'''
Observations:

- After a reversal, you must replace the sequence with its difference sequence as otherwise nothing has been done to the sum.
- The different sequence replacement reduces the length of the sequence by 1 so we can only do it a fixed number of times.

Therefore, if we brute-force:
Options are:
1. Nothing (current sum)
2. Reverse + difference
3. Difference
'''

from math import inf
from functools import lru_cache

def get_difference_sequence(path):
    return [path[i] - path[i - 1] for i in range(1, len(path))]

@lru_cache(None)
def backtrack(length, path):
    if length == 0:
        return -inf
    
    # Convert tuple back to list for processing
    path = list(path)
    
    # Reverse + Difference
    reverse_path = path[::-1]
    diff_path = get_difference_sequence(reverse_path)
    curr = sum(diff_path)
    ans = max(curr, backtrack(length - 1, tuple(diff_path)))
    
    # Difference only
    diff_path = get_difference_sequence(path)
    curr = sum(diff_path)
    
    return max(ans, curr, backtrack(length - 1, tuple(diff_path)))

t = int(input())

while t > 0:
    n = int(input())
    a = tuple(map(int, input().split()))
    s = sum(a)
    
    if n == 1:
        print(s)
    else:
        print(max(s, backtrack(n, a)))
    
    t -= 1

Solution 2 (runtime: 171 ms):
import sys
data = sys.stdin.read().splitlines()

line = 2
while (line < len(data)):
    arr = list(map(int, data[line].split()))
    new_arr = arr
    diff = sum(arr)
    # print(arr, "...diff=", diff)
    if len(arr) == 2:
        diff = max(abs(arr[0]-arr[1]), diff)
    elif len(arr) > 2:
        for i in range(len(arr)-2):
            new_arr = [new_arr[i+1]-new_arr[i] for i in range(len(new_arr)-1)]
            diff = max(abs(new_arr[0]-new_arr[-1]), diff, abs(sum(new_arr)))
            # print(new_arr, "...diff=", diff)
    print(diff)
    line += 2
Problem: 2062C - Cirno and Operations
Language: python

Solution 1 (runtime: 234 ms):
'''
Observations:

- After a reversal, you must replace the sequence with its difference sequence as otherwise nothing has been done to the sum.
- The different sequence replacement reduces the length of the sequence by 1 so we can only do it a fixed number of times.

Therefore, if we brute-force:
Options are:
1. Nothing (current sum)
2. Reverse + difference
3. Difference
'''

from math import inf
from functools import lru_cache

def get_difference_sequence(path):
    return [path[i] - path[i - 1] for i in range(1, len(path))]

@lru_cache(None)
def backtrack(length, path):
    if length == 0:
        return -inf
    
    # Convert tuple back to list for processing
    path = list(path)
    
    # Reverse + Difference
    reverse_path = path[::-1]
    diff_path = get_difference_sequence(reverse_path)
    curr = sum(diff_path)
    ans = max(curr, backtrack(length - 1, tuple(diff_path)))
    
    # Difference only
    diff_path = get_difference_sequence(path)
    curr = sum(diff_path)
    
    return max(ans, curr, backtrack(length - 1, tuple(diff_path)))

t = int(input())

while t > 0:
    n = int(input())
    a = tuple(map(int, input().split()))
    s = sum(a)
    
    if n == 1:
        print(s)
    else:
        print(max(s, backtrack(n, a)))
    
    t -= 1

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: 234 ms):
'''
Observations:

- After a reversal, you must replace the sequence with its difference sequence as otherwise nothing has been done to the sum.
- The different sequence replacement reduces the length of the sequence by 1 so we can only do it a fixed number of times.

Therefore, if we brute-force:
Options are:
1. Nothing (current sum)
2. Reverse + difference
3. Difference
'''

from math import inf
from functools import lru_cache

def get_difference_sequence(path):
    return [path[i] - path[i - 1] for i in range(1, len(path))]

@lru_cache(None)
def backtrack(length, path):
    if length == 0:
        return -inf
    
    # Convert tuple back to list for processing
    path = list(path)
    
    # Reverse + Difference
    reverse_path = path[::-1]
    diff_path = get_difference_sequence(reverse_path)
    curr = sum(diff_path)
    ans = max(curr, backtrack(length - 1, tuple(diff_path)))
    
    # Difference only
    diff_path = get_difference_sequence(path)
    curr = sum(diff_path)
    
    return max(ans, curr, backtrack(length - 1, tuple(diff_path)))

t = int(input())

while t > 0:
    n = int(input())
    a = tuple(map(int, input().split()))
    s = sum(a)
    
    if n == 1:
        print(s)
    else:
        print(max(s, backtrack(n, a)))
    
    t -= 1

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()