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

def subtract_min(nums):
    lst = nums
    if lst[0] > lst[1]:
        return "NO"
    
    for i in range(len(lst) - 1):
        subtract = min(lst[i], lst[i + 1])
        lst[i] -= subtract
        lst[i + 1] -= subtract
        if lst[i] == lst[-2]:
            break

    if lst == sorted(lst):
        return "yes"
        
    return "no"

def main():
    n = int(input().strip()) 
    for _ in range(n):
        size = int(input().strip())  
        lst = list(map(int, input().strip().split())) 
        if len(lst) != size:
            continue         

        print(subtract_min(lst)) 
        
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: 202 ms):
for _ in range(int(input())):
     n = int(input())
     a=list(map(int,input().split()))
     bol = True
     for i in range(n-1):
          if a[i] >a[i+1]:
               bol =False
               break
          else:
               a[i+1] = a[i+1]- a[i]
     print("YES" if bol 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: 327 ms):
test_cases = int(input())

for t in range(test_cases):
    _ = input()
    nums = [int(n) for n in input().split(' ')]
    res = True

    for i in range(len(nums) - 1):
        
        # if i do the operation for all (a, b) where a <= b,
        # it is always sure to be in non-decreasing order
        a, b = nums[i], nums[i+1]
        a -= min(nums[i], nums[i+1])
        b -= min(nums[i], nums[i+1])
        nums[i], nums[i+1] = a, b
        
        # break if theyre not in non-decreasing order after the operation
        if a > b:
            res = False
            break
    
    print("YES" if res 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):

def substract_min_sort():
    t = int(input())
    for _ in range(t):
        n = int(input())
        nums = list(map(int, input().split()))
        can_sort = True
        for j in range(n - 1):
            m = min(nums[j], nums[j + 1])
            nums[j] -= m
            nums[j + 1] -= m
            if j > 0 and nums[j] < nums[j - 1]:
                can_sort = False
                break   
        if can_sort:
            for k in range(n - 1):
                if nums[k] > nums[k + 1]:
                    can_sort = False
                    break
        print("YES" if can_sort else "NO")
substract_min_sort()
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):
# Vaibhav Varshney
import math
import bisect
 
def li():
    return list(map(int,input().split()))
def mi():
    return map(int,input().split())
 
def solve():
    n = int(input())
    a = li()
    diff = a[1]-a[0]
    if (diff<0):
        print("NO")
        return
    for i in range(2,n):
        diff = a[i]-diff
        if(diff<0):
            print("NO")
            return
    print("YES")    
        
    
def main():
    t = int(input())
    for _ in range(t):
        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: 217 ms):
# -*- coding: utf-8 -*-
"""
Created on Fri Feb 21 21:15:24 2025

@author: hp
"""

case = input()

ans = []
for i in range(int(case)):
    value = input()
    v = input().split()
    if int(len(v)) == int(value):
        flag = 1
        answer = 0 
        for j in range(len(v)):
            if j < int(value)-1:
                if j == 0:
                    answer = int(v[j+1]) - int(v[j])
                else:
                    answer = int(v[j+1]) - answer
            
            if answer < 0:
                flag=-1
                
        if flag == 1:
            ans.append("yes")
        
        else:
            ans.append("no")
            

for m in ans:
    print(m)
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):
t = int(input())

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

    k = 0
    while k < n - 1 and a[k] <= a[k + 1]:
        a[k + 1] -= a[k]
        a[k] = 0
        k += 1

    if k == n - 1:
        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: 249 ms):
def c(a):
    for i in range(len(a)-1):
        if a[i] > a[i+1]:
            return False
    return True


t = int(input())
for _ in range(t):
    n = int(input())
    l = list(map(int, input().split()))
    f = c(l)
    if f:
        print('yes')
        continue
    for i in range(len(l)-2):
        m = min(l[i], l[i+1])
        if l[i] - m <= l[i+1] - m and l[i+1] - m <= l[i+2]:
            l[i] -=m
            l[i+1] -=m
    f = c(l)
    if f:
        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: 171 ms):
t = int(input())

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

    possible = True

    for i in range(1, n):
        curr = a[i-1]
        next_num = a[i]

        a[i-1] -= curr
        a[i] -= curr

        if a[i-1] > a[i]:
            possible = False

    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: 155 ms):
import sys
input = sys.stdin.readline

def inp():
    return int(input())

def inlt():
    return list(map(int, input().split()))

def insr():
    s = input()
    return list(s[:len(s) - 1])

def invr():
    return map(int, input().split())

def main():
    t = inp()
    
    def solve():
        n = invr()
        a = inlt()

        """
        use the op when a_i+1 <= a_i
        can use the op at most n - 1 times

        the op doesn't change the relationship between a_i and a_i+1
        but can change the relationship between a_i+1 and a_i+2

        if a_i+1 > a_i+2
            then use op(a_i)

        if a_i+1 still > a_i+2 then not possible
        else continue with new a
        """
        if a[1] < a[0]:
            print("NO")
        else:
            for i in range(1, len(a) - 1):
                if a[i] - a[i-1] > a[i+1]:
                    print("NO")
                    break
                a[i] = a[i] - a[i-1]
            else:
                print("YES")
    
    for _ in range(t):
        solve()

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):
for _ in range(int(input())):

    n=int(input())

    l=list(map(int,input().split()))

    



    f=1

    for i in range(n-1):

        

        if l[i]>l[i+1]:

            f=0

            break

    

        l[i+1]-=l[i]

        

                

                

                

        

    if f:

        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: 389 ms):
import sys

from collections import defaultdict, Counter



number = lambda: int(sys.stdin.readline().strip())

numbers = lambda: list(map(int, sys.stdin.readline().strip().split()))

words = lambda: sys.stdin.readline().strip().split()

word = lambda: sys.stdin.readline().strip()

yn = lambda condition: 'YES' if condition else 'NO'



def solve():

    n =number()

    arr = numbers()

    check = sorted(arr)

    if check == arr:

        print('YES')

        return 

    elif n == 1:

        print('YES')

        return

    else:

        for i in range(n-1):

            if arr[i] <= arr[i+1]:

                m = min(arr[i],arr[i+1])

                arr[i] -= m

                arr[i+1] -= m

            else:

                print('NO')

                return 

    print('YES')

        

    

    return





test_cases = number()

for _ in range(test_cases):

    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: 203 ms):
t = int(input())

for _ in range(t):

    n = int(input())

    nums = list(map(int,input().split()))

    flag = False

    first = nums[0]

    for i in range(n-1):

        res = min(nums[i],nums[i+1])

        nums[i] = nums[i] - res

        nums[i+1] = nums[i+1] - res

    temp = sorted(nums)

    if temp != nums:

        print('NO')

    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: 171 ms):
import sys,random,cmath

from math import inf,factorial,gcd

from collections import defaultdict, Counter



xors = random.randint(1, 1000000000)

con = lambda x: x^xors

number = lambda: int(sys.stdin.readline().strip())

numbers = lambda: list(map(int, sys.stdin.readline().strip().split()))

words = lambda: sys.stdin.readline().strip().split()

word = lambda: sys.stdin.readline().strip()

yn = lambda condition: 'YES' if condition else 'NO'



def solve():

    n = number()

    nums = numbers()

    arr = [0]

    for i in range(1,len(nums)):

        if nums[i] >= nums[i-1]:

            if i>1:

                arr.append(nums[i]-arr[-1])

                arr[-2] = 0

            else:

                arr.append(nums[i]-nums[i-1])

        elif i < 2 or arr[-1] > nums[i]:

            print('NO')

            return

        else:

            arr.append(nums[i]-arr[-1]) 

            arr[-2] = 0

    print('YES')        

    

    return



test_cases = number()

for _ in range(test_cases):

    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: 217 ms):
def inp():

    return int(input())





def inlt():

    return list(map(int,input().split()))





def insr():

    s = input()

    return list(s[:len(s) - 1])





def invr():

    return map(int,input().split())





def is_sort(arr):

    for i in range(len(arr) - 1):

        curr_min = min(arr[i], arr[i + 1])

        arr[i] -= curr_min

        arr[i + 1] -= curr_min

        if arr[i] > arr[i + 1]:

            return "NO"

    return "YES"

    # count_up = 0

    # count_down = 0

    # for i in range(1, len(arr)):

    #     if arr[i] >= arr[i - 1]:

    #         count_up += 1

    #     else:

    #         count_down += 1

    # if count_up > count_down:

    #     print("YES")

    # else:

    #     print("NO")





def main():

    t = inp()

    games = []

    for _ in range(t):

        _ = inp()

        games.append(inlt())



    for game in games:

        print(is_sort(game))





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

import sys

sys.stdin = open('input.txt', 'r')

'''



for _ in range(int(input())):

    n = int(input())

    x = list(map(int, input().split()))

    action = False

    for i in range(n-1):

        m = min(x[i], x[i+1])

        x[i] -=m

        x[i+1] -=m

    if x == sorted(x):

        print('YES')

    else:

        print('NO')

    #print(x)

    #print()
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):
t = int(input())



for _ in range(t):

    n = int(input())

    a = list(map(int, input().split()))

    j = 0 

    i = 1

    while i < n:

        if a[i-1] > a[i]:

            j = i 

        i += 1

    if j == 0:

        print("YES")

        continue

    for i in range(0, j):

        minN = min(a[i], a[i+1])

        a[i] -= minN

        a[i+1] -= minN

    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: 437 ms):
num = int(input())



for _ in range(num):

    eh_possivel = True

    tam_array = int(input()) 

    lista = list(map(int, input().split()))

 

    for i in range(len(lista) - 1):

        menor = min(lista[i], lista[i + 1])

        lista[i] = lista[i] - menor

        lista[i + 1] = lista[i + 1] - menor

        if lista[i] > lista[i + 1]:

            eh_possivel = False

            break 

    if eh_possivel:

        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: 311 ms):
t=int(input())

for i in range(t):

    n=int(input())

    a=list(map(int, input().split()))

    i=0

    ans='YES'

    while i<len(a)-1:

        s=min(a[i],a[i+1])

        a[i]=a[i]-s

        a[i+1]=a[i+1]-s

        if a[i]<=a[i+1]:

           ans='YES'

        else:

            ans='NO'

            break

        i+=1

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


for _ in range(int(input())):

	n = int(input())

	a = list(map(int,input().split(' ')))

	minim = float('-inf')

	complete = False



	for i in range(n-1):

		curr = a[i]

		nx = a[i+1]

		if nx-curr>=0:

			a[i+1] = nx-curr

		else:

			print("NO")

			complete = True

			break

	if not complete:

		print("YES")