Problem: 2060D - Subtract Min Sort
Language: Java 21


Submission (verdict: Time limit exceeded on test 8):
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
public class  MyCPTemplate{
    static final int MOD = (int) (1e9 + 7);static final int INF = (int) (1e9) + 10;
    // safe use long
    static void solve() throws IOException{
        int n = fr.nextInt();
        ArrayList<Integer> a = new ArrayList<>();

        for(int i =0;i<n;i++){
            a.add(fr.nextInt());
        }

        while(a.size()>1){
            if(a.get(0)>a.get(1)){
                out.println("no");
                return;
            }

            if(a.get(0)<a.get(1)){
                a.set(1,a.get(1)-a.get(0));
                a.removeFirst();
            }
            else{
                a.removeFirst();
                a.removeFirst();
            }

        }

        out.println("yes");
    }


    public static void main(String[] args) throws Exception {
        int t = 1;
        t = fr.nextInt();
        while (t-->0){
            solve();
        }

        out.close();
    }


    //------------------------------------------------------------------------------------------------------------------//
    static void debug(Object... argObjects) throws IOException {out.println(Arrays.deepToString(argObjects));}
    static FastReader fr = new FastReader();
    static FastWriter out = new FastWriter();
    static class Pair<F extends Comparable<F>,S extends Comparable<S>> implements Comparable<Pair<F,S>>{
        public F first;
        public S second;
        public Pair(){}
        public Pair(F k,S v){
            first = k;
            second = v;
        }
        public String toString(){
            return "(" + first + ", " + second + ")";
        }

        @Override
        public int compareTo(Pair<F, S> that) {
            int cmp = this.first.compareTo(that.first);
            if (cmp == 0) {
                return this.second.compareTo(that.second);
            }
            return cmp;
        }
    }
    static class FastReader {

        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in),1<<18);
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
    static class FastWriter {
        private final BufferedWriter bw;

        public FastWriter() {
            bw = new BufferedWriter(new OutputStreamWriter(System.out), 1 << 18);
        }

        // Print a single value
        public void print(String s) throws IOException {
            bw.write(s);
        }

        public void print(int x) throws IOException {
            bw.write(Integer.toString(x));
        }

        public void print(long x) throws IOException {
            bw.write(Long.toString(x));
        }

        public void print(double x) throws IOException {
            bw.write(Double.toString(x));
        }
        public void print(Object obj) throws IOException{
            bw.write(obj.toString());
        }

        // Print a value with a newline
        public void println(String s) throws IOException {
            bw.write(s);
            bw.newLine();
        }
        public void println() throws IOException {
            bw.newLine();
        }

        public void println(int x) throws IOException {
            bw.write(Integer.toString(x));
            bw.newLine();
        }

        public void println(long x) throws IOException {
            bw.write(Long.toString(x));
            bw.newLine();
        }

        public void println(double x) throws IOException {
            bw.write(Double.toString(x));
            bw.newLine();
        }
        public void println(Object obj) throws IOException {
            bw.write(obj.toString());
            bw.newLine();
        }



        // Print arrays
        public void printArray(int[] arr) throws IOException {
            for (int x : arr) {
                print(x + " ");
            }
            println("");
        }

        public void printArray(int[][] arr) throws IOException{
            for(int[] a: arr){
                for(int i:a){
                    print(i+" ");
                }
                println();
            }
        }


        public void printArray(long[] arr) throws IOException {
            for (long x : arr) {
                print(x + " ");
            }
            println("");
        }

        // Print collections
        public <T> void printCollection(Collection<T> col) throws IOException {
            for (T x : col) {
                print(x.toString() + " ");
            }
            println("");
        }

        // Flush the buffer
        public void flush() throws IOException {
            bw.flush();
        }

        // Close the writer
        public void close() throws IOException {
            bw.close();
        }
    }



    /*
         Random stuff to try when stuck:
            -if it's 2C then it's dp
            -for combo/probability problems, expand the given form we're interested in
            -make everything the same then build an answer (constructive, make everything 0 then do something)
            -something appears in parts of 2 --> model as graph
            -assume a greedy then try to show why it works
            -find way to simplify into one variable if multiple exist
            -treat it like fmc (note any passing thoughts/algo that could be used so you can revisit them)
            -find lower and upper bounds on answer
            -figure out what ur trying to find and isolate it
            -see what observations you have and come up with more continuations
            -work backwards (in constructive, go from the goal to the start)
            -turn into prefix/suffix sum argument (often works if problem revolves around adjacent array elements)
            -instead of solving for answer, try solving for complement (ex, find n-(min) instead of max)
            -draw something
            -simulate a process
            -dont implement something unless if ur fairly confident its correct
            -after 3 bad submissions move on to next problem if applicable
            -do something instead of nothing and stay organized
            -write stuff down
            -check for some values which might be incorrect --> ((long)sqrt(n) does not always give the max number t*t<=n, adjust t).
         Random stuff to check when wa:
            -if code is way too long/cancer then reassess
            -switched N/M
            -int overflow
            -switched variables
            -wrong MOD
            -hardcoded edge case incorrectly
         Random stuff to check when tle:
            -continue instead of break
            -condition in for/while loop bad
         Random stuff to check when rte:
            -switched N/M
            -long to int/int overflow
            -division by 0
            -edge case for empty list/data structure/N=1
      */
}