Language: Java

import java.io.*;
import java.math.*;
import java.util.*;

public class s824230885 {

    static class InputIterator {
        ArrayList<String> inputLine = new ArrayList<String>(1024);
        int index = 0;
        int max;
        String read;

        InputIterator() {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            try {
                while ((read = br.readLine()) != null) {
                    inputLine.add(read);
                }
            } catch (IOException e) {
            }
            max = inputLine.size();
        }

        boolean hasNext() {
            return (index < max);
        }

        String next() {
            if (hasNext()) {
                return inputLine.get(index++);
            } else {
                throw new IndexOutOfBoundsException("There is no more input");
            }
        }
    }

    static HashMap<Integer, String> CONVSTR = new HashMap<Integer, String>();
    static InputIterator ii = new InputIterator();
    static PrintWriter out = new PrintWriter(System.out);

    static void flush() {
        out.flush();
    }

    static void myout(Object t) {
        out.println(t);
    }

    static void myerr(Object t) {
        System.err.print("debug:");
        System.err.println(t);
    }

    static String next() {
        return ii.next();
    }

    static boolean hasNext() {
        return ii.hasNext();
    }

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

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

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

    static ArrayList<String> nextStrArray() {
        return myconv(next(), 8);
    }

    static ArrayList<String> nextCharArray() {
        return myconv(next(), 0);
    }

    static ArrayList<Integer> nextIntArray() {
        ArrayList<String> input = nextStrArray();
        ArrayList<Integer> ret = new ArrayList<Integer>(input.size());
        for (int i = 0; i < input.size(); i++) {
            ret.add(Integer.parseInt(input.get(i)));
        }
        return ret;
    }

    static ArrayList<Long> nextLongArray() {
        ArrayList<String> input = nextStrArray();
        ArrayList<Long> ret = new ArrayList<Long>(input.size());
        for (int i = 0; i < input.size(); i++) {
            ret.add(Long.parseLong(input.get(i)));
        }
        return ret;
    }

    static String myconv(Object list, int no) {
        String joinString = CONVSTR.get(no);
        if (list instanceof String[]) {
            return String.join(joinString, (String[]) list);
        } else if (list instanceof ArrayList) {
            return String.join(joinString, (ArrayList) list);
        } else {
            throw new ClassCastException("Don't join");
        }
    }

    static ArrayList<String> myconv(String str, int no) {
        String splitString = CONVSTR.get(no);
        return new ArrayList<String>(Arrays.asList(str.split(splitString)));
    }

    public static void main(String[] args) {
        CONVSTR.put(8, " ");
        CONVSTR.put(9, "\n");
        CONVSTR.put(0, "");
        solve();
        flush();
    }

    static void solve() {
        int N = nextInt();
        ArrayList<Integer> list = nextIntArray();
        int max = 0;
        int output = 0;
        for (int i = 0; i < N; i++) {
            if (max <= list.get(i)) {
                max = list.get(i);
                output++;
            }
        }
        myout(output);
    }
}


Example test case(s):
input: 4
6 5 6 8

output: 3