ShaysXIA/CodeInsightBench huggingface dataset:
Problem: 2060D - Subtract Min Sort
Language: python

Solution 1 (runtime: 186 ms):
x=int(input())
for _ in range(x):
    y=int(input())
    l=list(map(int,input().split()))
    res=0
    n=l.copy()
    n.sort()
    if l==n:
        print("YES")
    else:
        if l[0]>l[1]:
            print("NO")
        else:
            z=0
            b=l[1]-l[0]
            for i in range(2,len(l)):
                if (b>l[i]):
                    z=1
                    print("NO")
                    break
                b=l[i]-b
                
            if z==0:
                print("YES")
                
                

Solution 2 (runtime: 281 ms):
t = int(input())
for _ in range(t):
    n = int(input())
    a = list(map(int, input().split()))
    if a[0] > a[1]:
        print('NO')
        continue
    for i in range(n - 1):
        if a[i] <= a[i + 1]:
            mn = min(a[i], a[i + 1])
            a[i] -= mn
            a[i + 1] -= mn
        else:
            print('NO')
            break
    else:
        print('YES')
Problem: 2060D - Subtract Min Sort
Language: python

Solution 1 (runtime: 186 ms):
x=int(input())
for _ in range(x):
    y=int(input())
    l=list(map(int,input().split()))
    res=0
    n=l.copy()
    n.sort()
    if l==n:
        print("YES")
    else:
        if l[0]>l[1]:
            print("NO")
        else:
            z=0
            b=l[1]-l[0]
            for i in range(2,len(l)):
                if (b>l[i]):
                    z=1
                    print("NO")
                    break
                b=l[i]-b
                
            if z==0:
                print("YES")
                
                

Solution 2 (runtime: 312 ms):
tc=int(input())
for _ in range(tc):
    n=int(input())
    a=[int(x) for x in input().split()]
    i=0
    b=True
    while i<n-1:
        if i+2<n and a[i+2]>=a[i+1]-a[i] and a[i+1]-a[i]>=0:
            a[i+2]=a[i+2]-(a[i+1]-a[i])
            pass            
        elif i+2==n and 1000000001>=a[i+1]-a[i] and a[i+1]-a[i]>=0:
            pass
        else:
            b=False
            break
        i+=2
    if b:
        print("YES")
    else:
        print("NO")
Problem: 2060D - Subtract Min Sort
Language: python

Solution 1 (runtime: 186 ms):
x=int(input())
for _ in range(x):
    y=int(input())
    l=list(map(int,input().split()))
    res=0
    n=l.copy()
    n.sort()
    if l==n:
        print("YES")
    else:
        if l[0]>l[1]:
            print("NO")
        else:
            z=0
            b=l[1]-l[0]
            for i in range(2,len(l)):
                if (b>l[i]):
                    z=1
                    print("NO")
                    break
                b=l[i]-b
                
            if z==0:
                print("YES")
                
                

Solution 2 (runtime: 234 ms):
for _ in range(int(input())):
    
    n = int(input())
    nums = list(map(int,input().split()))
    
    ok = True
    
    for i in range(n-1):
        if nums[i]>nums[i+1]:
            ok = False
            break
        nums[i+1]-=nums[i]
    
    if ok:
        print("YES")
    else:
        print("NO")
Problem: 2060D - Subtract Min Sort
Language: python

Solution 1 (runtime: 186 ms):
x=int(input())
for _ in range(x):
    y=int(input())
    l=list(map(int,input().split()))
    res=0
    n=l.copy()
    n.sort()
    if l==n:
        print("YES")
    else:
        if l[0]>l[1]:
            print("NO")
        else:
            z=0
            b=l[1]-l[0]
            for i in range(2,len(l)):
                if (b>l[i]):
                    z=1
                    print("NO")
                    break
                b=l[i]-b
                
            if z==0:
                print("YES")
                
                

Solution 2 (runtime: 467 ms):
for i in range(int(input())):
    N = int(input())
    A = [int(x) for x in input().split()]
    for i in range(N-1):
        minimum = min(A[i], A[i+1])
        A[i] -= minimum
        A[i+1] -= minimum
    print("YES" if A==sorted(A) else "NO")
Problem: 2060D - Subtract Min Sort
Language: python

Solution 1 (runtime: 186 ms):
x=int(input())
for _ in range(x):
    y=int(input())
    l=list(map(int,input().split()))
    res=0
    n=l.copy()
    n.sort()
    if l==n:
        print("YES")
    else:
        if l[0]>l[1]:
            print("NO")
        else:
            z=0
            b=l[1]-l[0]
            for i in range(2,len(l)):
                if (b>l[i]):
                    z=1
                    print("NO")
                    break
                b=l[i]-b
                
            if z==0:
                print("YES")
                
                

Solution 2 (runtime: 218 ms):
# cook your dish here

t = int(input())

for _ in range(t):
    n = int(input())
    a = list(map(int, input().split()))
    
    for i in range(1, n):
        mn = min(a[i - 1], a[i])
        a[i - 1] -= mn
        a[i] -= mn
            
    
    if a == sorted(a):
        print("Yes")
    else:
        print("NO")
Problem: 2060D - Subtract Min Sort
Language: python

Solution 1 (runtime: 186 ms):
x=int(input())
for _ in range(x):
    y=int(input())
    l=list(map(int,input().split()))
    res=0
    n=l.copy()
    n.sort()
    if l==n:
        print("YES")
    else:
        if l[0]>l[1]:
            print("NO")
        else:
            z=0
            b=l[1]-l[0]
            for i in range(2,len(l)):
                if (b>l[i]):
                    z=1
                    print("NO")
                    break
                b=l[i]-b
                
            if z==0:
                print("YES")
                
                

Solution 2 (runtime: 265 ms):
cases=int(input(''))
sol=[]
for i in range(0,cases):
    elem=int(input())
    a=list(map(int,input().split()))
    count=0
    for j in range (0,len(a)-1):
        if(a[j]>a[j+1]):
            count+=1
            break
        m=min(a[j],a[j+1])
        a[j]=a[j]-m
        a[j+1]=a[j+1]-m
    if(count>0):
        sol.append('NO')
    else:
        sol.append('YES')
for a in sol:
    print(a)
Problem: 2060D - Subtract Min Sort
Language: python

Solution 1 (runtime: 186 ms):
x=int(input())
for _ in range(x):
    y=int(input())
    l=list(map(int,input().split()))
    res=0
    n=l.copy()
    n.sort()
    if l==n:
        print("YES")
    else:
        if l[0]>l[1]:
            print("NO")
        else:
            z=0
            b=l[1]-l[0]
            for i in range(2,len(l)):
                if (b>l[i]):
                    z=1
                    print("NO")
                    break
                b=l[i]-b
                
            if z==0:
                print("YES")
                
                

Solution 2 (runtime: 249 ms):
t = int(input())
for _ in range(t):
    n = int(input())
    a = list(map(int,input().split()))
    if a[0]>a[1]:
        print('NO')
    else:
        for i in range(1,n-1):
            a[i]-=a[i-1]
            if a[i]>a[i+1]:
                print('NO')
                break
        else:
            print('YES')
Problem: 2060D - Subtract Min Sort
Language: python

Solution 1 (runtime: 186 ms):
x=int(input())
for _ in range(x):
    y=int(input())
    l=list(map(int,input().split()))
    res=0
    n=l.copy()
    n.sort()
    if l==n:
        print("YES")
    else:
        if l[0]>l[1]:
            print("NO")
        else:
            z=0
            b=l[1]-l[0]
            for i in range(2,len(l)):
                if (b>l[i]):
                    z=1
                    print("NO")
                    break
                b=l[i]-b
                
            if z==0:
                print("YES")
                
                

Solution 2 (runtime: 218 ms):
def solve():
    import sys
    
    input_data = sys.stdin.read().strip().split()
    t = int(input_data[0])
    index = 1
    
    results = []
    for _ in range(t):
        n = int(input_data[index])
        index += 1
        
        # Read the array of integers
        a = list(map(int, input_data[index:index+n]))
        index += n
        
        # Perform the "subtract min" operation in a single left-to-right pass
        for i in range(n - 1):
            if a[i] <= a[i + 1]:
                # Subtract a[i] from a[i+1], and make a[i] zero
                a[i+1] -= a[i]
                a[i] = 0
        
        # Check if the final array is non-decreasing
        if all(a[i] <= a[i+1] for i in range(n-1)):
            results.append("YES")
        else:
            results.append("NO")
    
    # Output one result per test case
    print("\n".join(results))
    
solve()
Problem: 2060D - Subtract Min Sort
Language: python

Solution 1 (runtime: 186 ms):
x=int(input())
for _ in range(x):
    y=int(input())
    l=list(map(int,input().split()))
    res=0
    n=l.copy()
    n.sort()
    if l==n:
        print("YES")
    else:
        if l[0]>l[1]:
            print("NO")
        else:
            z=0
            b=l[1]-l[0]
            for i in range(2,len(l)):
                if (b>l[i]):
                    z=1
                    print("NO")
                    break
                b=l[i]-b
                
            if z==0:
                print("YES")
                
                

Solution 2 (runtime: 218 ms):
from itertools import accumulate, pairwise
import math
import bisect
import heapq
from collections import Counter, defaultdict
from functools import cache
def solve():
    n = int(input())
    arr = [int(x) for x in input().split()]
    """
    4 5 4 5 4 5 4 5
    0 1 4 5 4 5 4 5
    0 0 3 4 4 5 4 5
    0 0 0 1 1 2 4 5
    
    2 3 4 1
    0 1 4 1
    
    
    """
    left = prev = 0
    for i in range(n - 1):
        cur = 0
        while left < i:
            prev = max(0, arr[left] - prev)
            left += 1
        if arr[i] - prev > arr[i + 1]:
            print("NO")
            return
    print("YES")
for _ in range(int(input())):
    solve()
Problem: 2060D - Subtract Min Sort
Language: python

Solution 1 (runtime: 186 ms):
x=int(input())
for _ in range(x):
    y=int(input())
    l=list(map(int,input().split()))
    res=0
    n=l.copy()
    n.sort()
    if l==n:
        print("YES")
    else:
        if l[0]>l[1]:
            print("NO")
        else:
            z=0
            b=l[1]-l[0]
            for i in range(2,len(l)):
                if (b>l[i]):
                    z=1
                    print("NO")
                    break
                b=l[i]-b
                
            if z==0:
                print("YES")
                
                

Solution 2 (runtime: 218 ms):
#include <bits/stdc++.h>
using namespace std;
int a[200005];
map<int,int> mp;
int main() {
	int t;cin>>t;
	while(t--){
		int n;
		cin>>n;
		bool flag=false;
		for(int i=1;i<=n;i++)
			cin>>a[i];
		for(int i=1;i<n;i++)
		{
			if(a[i]>a[i+1])
			{
				flag=true;
				break;
			}
			a[i+1]-=a[i];
		}
		if(flag)
			cout<<"NO"<<endl;
		else
			cout<<"YES"<<endl;
	}
	return 0;
}
Problem: 2060D - Subtract Min Sort
Language: python

Solution 1 (runtime: 186 ms):
x=int(input())
for _ in range(x):
    y=int(input())
    l=list(map(int,input().split()))
    res=0
    n=l.copy()
    n.sort()
    if l==n:
        print("YES")
    else:
        if l[0]>l[1]:
            print("NO")
        else:
            z=0
            b=l[1]-l[0]
            for i in range(2,len(l)):
                if (b>l[i]):
                    z=1
                    print("NO")
                    break
                b=l[i]-b
                
            if z==0:
                print("YES")
                
                

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

    for i in range(n-1):
        temp = min(a[i], a[i+1])
        a[i] -= temp
        a[i+1] -= temp

    possible = True
    for i in range(n-1):
        if a[i] > a[i+1]:
            possible = False
            break

    if possible:
        print("YES")
    else:
        print("NO")
Problem: 2060D - Subtract Min Sort
Language: python

Solution 1 (runtime: 186 ms):
x=int(input())
for _ in range(x):
    y=int(input())
    l=list(map(int,input().split()))
    res=0
    n=l.copy()
    n.sort()
    if l==n:
        print("YES")
    else:
        if l[0]>l[1]:
            print("NO")
        else:
            z=0
            b=l[1]-l[0]
            for i in range(2,len(l)):
                if (b>l[i]):
                    z=1
                    print("NO")
                    break
                b=l[i]-b
                
            if z==0:
                print("YES")
                
                

Solution 2 (runtime: 202 ms):
#include <bits/stdc++.h>
using namespace std;
void solve()
{
    int n;
    cin >> n;
    vector<int> A(n);
    for(int i=0;i<n;i++) {
        cin >> A[i];
    }

    for(int i=1;i<n;i++) {
        int min_v=min(A[i-1],A[i]);
        A[i-1]-=min_v;
        A[i]-=min_v;
    }

    for(int i=0;i<n-1;i++) {
        if(A[i]) {
            cout << "NO\n";
            return;
        }
    }
    cout << "YES\n";
}
int main()
{
    int t;
    cin >> t;
    while(t--) {
        solve();
    }
    return 0;
}
Problem: 2060D - Subtract Min Sort
Language: python

Solution 1 (runtime: 186 ms):
x=int(input())
for _ in range(x):
    y=int(input())
    l=list(map(int,input().split()))
    res=0
    n=l.copy()
    n.sort()
    if l==n:
        print("YES")
    else:
        if l[0]>l[1]:
            print("NO")
        else:
            z=0
            b=l[1]-l[0]
            for i in range(2,len(l)):
                if (b>l[i]):
                    z=1
                    print("NO")
                    break
                b=l[i]-b
                
            if z==0:
                print("YES")
                
                

Solution 2 (runtime: 202 ms):
def solve_test_case():
    n = int(input())
    loads = list(map(int, input().split()))
    if n <= 1:
        print("YES")
        return

    for i in range(n - 1):
        transfer = min(loads[i], loads[i+1])
        loads[i] -= transfer
        loads[i+1] -= transfer

    for i in range(n - 1):
        if loads[i] > loads[i+1]:
            print("No")
            return

    print("YES")
    return

def main():
    T = int(input())
    for _ in range(T):
        solve_test_case()

if __name__ == "__main__":
    main()
Problem: 2060D - Subtract Min Sort
Language: python

Solution 1 (runtime: 186 ms):
x=int(input())
for _ in range(x):
    y=int(input())
    l=list(map(int,input().split()))
    res=0
    n=l.copy()
    n.sort()
    if l==n:
        print("YES")
    else:
        if l[0]>l[1]:
            print("NO")
        else:
            z=0
            b=l[1]-l[0]
            for i in range(2,len(l)):
                if (b>l[i]):
                    z=1
                    print("NO")
                    break
                b=l[i]-b
                
            if z==0:
                print("YES")
                
                

Solution 2 (runtime: 233 ms):
t = int(input())
for i in range(t):
    n = int(input())
    nums = list(map(int, input().split()))
    left = 0
    check = True
    while left < n-1:
        if nums[left] > nums[left+1]:
            check = False
            break
        else:
            nums[left+1] -= nums[left]
            nums[left] = 0
            left += 1


    if check:
        print('Yes')
    else:
        print('No')
Problem: 2060D - Subtract Min Sort
Language: python

Solution 1 (runtime: 186 ms):
x=int(input())
for _ in range(x):
    y=int(input())
    l=list(map(int,input().split()))
    res=0
    n=l.copy()
    n.sort()
    if l==n:
        print("YES")
    else:
        if l[0]>l[1]:
            print("NO")
        else:
            z=0
            b=l[1]-l[0]
            for i in range(2,len(l)):
                if (b>l[i]):
                    z=1
                    print("NO")
                    break
                b=l[i]-b
                
            if z==0:
                print("YES")
                
                

Solution 2 (runtime: 187 ms):
import sys, math, collections, bisect, heapq, functools, itertools
sys.setrecursionlimit(10 ** 5)
inp = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = 10 ** 20
MX = 10 ** 5 + 10
orda = ord('a')
fmax = lambda x, y: (x if x > y else y)
fmin = lambda x, y: (x if x < y else y)

def solve():
    N = int(inp())
    a = list(map(int, inp().split()))

    for i in range(1, N):
        m = fmin(a[i - 1], a[i])
        a[i - 1], a[i] = a[i - 1] - m, a[i] - m

    if any(a[i] > a[i + 1] for i in range(N - 1)):
        return 'NO'
    
    return 'YES'
    
def main():
    for _ in range(int(inp())):
        print(solve())

if __name__ == '__main__':
    main()
Problem: 2060D - Subtract Min Sort
Language: python

Solution 1 (runtime: 186 ms):
x=int(input())
for _ in range(x):
    y=int(input())
    l=list(map(int,input().split()))
    res=0
    n=l.copy()
    n.sort()
    if l==n:
        print("YES")
    else:
        if l[0]>l[1]:
            print("NO")
        else:
            z=0
            b=l[1]-l[0]
            for i in range(2,len(l)):
                if (b>l[i]):
                    z=1
                    print("NO")
                    break
                b=l[i]-b
                
            if z==0:
                print("YES")
                
                

Solution 2 (runtime: 171 ms):
#!/usr/bin/env python3
import sys
import math, random
import functools, itertools, collections, heapq, bisect
from collections import Counter, defaultdict as dd, deque

input = sys.stdin.readline

m9 = 10**9 + 7  # 998244353
yes, no = "YES", "NO"
d4 = [(1,0),(0,1),(-1,0),(0,-1)]
d8 = [(1,0),(1,1),(0,1),(-1,1),(-1,0),(-1,-1),(0,-1),(1,-1)]
d6 = [(2,0),(1,1),(-1,1),(-2,0),(-1,-1),(1,-1)]  # hexagonal layout
abc = "abcdefghijklmnopqrstuvwxyz"
abc_map = {c:i for i,c in enumerate(abc)}
MAXINT = sys.maxsize
e18 = 10**18 + 10

# if testing locally, print to terminal with a different color
OFFLINE_TEST = False
CHECK_OFFLINE_TEST = True
# CHECK_OFFLINE_TEST = False  # uncomment this on Codechef
if CHECK_OFFLINE_TEST:
    import getpass

    OFFLINE_TEST = getpass.getuser() == "htong"


def log(*args):
    if CHECK_OFFLINE_TEST and OFFLINE_TEST:
        print("\033[36m", *args, "\033[0m", file=sys.stderr)


def solve(*args):
    # screen input
    if OFFLINE_TEST:
        log("----- solving ------")
        log(*args)
        log("----- ------- ------")
    return solve_(*args)


def read_matrix(rows):
    return [list(map(int, input().split())) for _ in range(rows)]


def read_strings(rows):
    return [input().strip() for _ in range(rows)]


def minus_one(arr):
    return [x - 1 for x in arr]


def minus_one_matrix(mrr):
    return [[x - 1 for x in row] for row in mrr]


# ---------------------------- template ends here ----------------------------

def solve_():
    n=int(input())
    *arr,=map(int,input().split())
    for i in range(n-1):
        if arr[i+1]-arr[i]<0:print(no);return
        arr[i+1]-=arr[i]
    print(yes)
for _ in range(int(input())):
    solve()
Problem: 2060D - Subtract Min Sort
Language: python

Solution 1 (runtime: 186 ms):
x=int(input())
for _ in range(x):
    y=int(input())
    l=list(map(int,input().split()))
    res=0
    n=l.copy()
    n.sort()
    if l==n:
        print("YES")
    else:
        if l[0]>l[1]:
            print("NO")
        else:
            z=0
            b=l[1]-l[0]
            for i in range(2,len(l)):
                if (b>l[i]):
                    z=1
                    print("NO")
                    break
                b=l[i]-b
                
            if z==0:
                print("YES")
                
                

Solution 2 (runtime: 249 ms):
import math

t = int(input())
for _ in range(t):
	n = int(input())
	f = 1
	arr = list(map(int,input().split()))
	for i in range(n-1):
		if arr[i] == 0:
			continue
		m = min(arr[i],arr[i+1])
		arr[i]-=m
		arr[i+1]-=m
		
		if arr[i] == 0 and arr[i+1] == 0:
			continue
		elif arr[i+1] == 0:
			print("NO")
			f = 0
			break
	if f==1:
		print("YES")
Problem: 2060D - Subtract Min Sort
Language: python

Solution 1 (runtime: 186 ms):
x=int(input())
for _ in range(x):
    y=int(input())
    l=list(map(int,input().split()))
    res=0
    n=l.copy()
    n.sort()
    if l==n:
        print("YES")
    else:
        if l[0]>l[1]:
            print("NO")
        else:
            z=0
            b=l[1]-l[0]
            for i in range(2,len(l)):
                if (b>l[i]):
                    z=1
                    print("NO")
                    break
                b=l[i]-b
                
            if z==0:
                print("YES")
                
                

Solution 2 (runtime: 311 ms):
t = int(input())

for _ in range(t):
    n = int(input())
    a = list(map(int, input().split()))

    o = all(a[i] <= a[i+1] for i in range(len(a)-1))
    if o:
        print("YES")
        continue

    for i in range(0, n-2):
        m = min(a[i], a[i+1])
        a[i] = a[i] - m
        a[i+1] = a[i+1] - m
    o = all(a[i] <= a[i+1] for i in range(len(a)-1))
    if o:
        print("YES")
    else:
        print("NO")
Problem: 2060D - Subtract Min Sort
Language: python

Solution 1 (runtime: 186 ms):
x=int(input())
for _ in range(x):
    y=int(input())
    l=list(map(int,input().split()))
    res=0
    n=l.copy()
    n.sort()
    if l==n:
        print("YES")
    else:
        if l[0]>l[1]:
            print("NO")
        else:
            z=0
            b=l[1]-l[0]
            for i in range(2,len(l)):
                if (b>l[i]):
                    z=1
                    print("NO")
                    break
                b=l[i]-b
                
            if z==0:
                print("YES")
                
                

Solution 2 (runtime: 264 ms):
for i in range(int(input())):
    n = int(input())
    array = list(map(int, input().split()))
    ans = "YES"
    # 1 3 2
    for i in range(n - 1):
        mn = min(array[i], array[i + 1])
        array[i] -= mn
        array[i + 1] -= mn
    for i in range(1, n):
        if array[i] < array[i - 1]:
            ans = "NO"
            break
    print(ans)
Problem: 2060D - Subtract Min Sort
Language: python

Solution 1 (runtime: 186 ms):
x=int(input())
for _ in range(x):
    y=int(input())
    l=list(map(int,input().split()))
    res=0
    n=l.copy()
    n.sort()
    if l==n:
        print("YES")
    else:
        if l[0]>l[1]:
            print("NO")
        else:
            z=0
            b=l[1]-l[0]
            for i in range(2,len(l)):
                if (b>l[i]):
                    z=1
                    print("NO")
                    break
                b=l[i]-b
                
            if z==0:
                print("YES")
                
                

Solution 2 (runtime: 202 ms):
L=[]
Q=[]
n=int(input())
for i in range(n):
     b=int(input())
     Q.append(b)
     a=list(map(int,input().split()))
     L.append(a)
for i in L:
     for t in range(len(i)-1):
          s=min(i[t],i[t+1])
          i[t]=i[t]-s
          i[t+1]=i[t+1]-s
for i in L:
     if all(i[j] <= i[j + 1] for j in range(len(i) - 1)):
          print("YES")
     else:
          print("NO")