A - Strictly Increasing?
Source: atcoder
Difficulty: 100

Problem Statement
You are given a positive integer
N
and a sequence of positive integers
A = (A_1,A_2,\dots,A_N)
of length
N
.
Determine whether
A
is strictly increasing, that is, whether
A_i < A_{i+1}
holds for every integer
i
with
1 \leq i < N
.
Constraints
2 \leq N \leq 100
1 \leq A_i \leq 1000 \ (1 \leq i \leq N)
All input values are integers.
Input
The input is given from Standard Input in the following format:
N
A_1
A_2
\dots
A_N
Output
If
A
is strictly increasing, print
Yes
; otherwise, print
No
.
The judge is case-insensitive. For example, if the correct answer is
Yes
, any of
yes
,
YES
, and
yEs
will be accepted.
Sample Input 1
3
1 2 5
Sample Output 1
Yes
A_1 < A_2
and
A_2 < A_3
, so
A
is strictly increasing.
Sample Input 2
3
3 9 5
Sample Output 2
No
A_1 < A_2
, but
A_2 < A_3
does not hold, so
A
is not strictly increasing.
Sample Input 3
10
1 1 2 3 5 8 13 21 34 55
Sample Output 3
No
A_1 < A_2
does not hold, so
A
is not strictly increasing.

C++ solution:
#include<stdio.h>
#include<math.h>


int verificaOrdem(int Vet[], int tam){
    int Menor = 0, cont =0;
    for(int i = 0; i<tam; i++){
        if(Vet[i]>Menor)
            Menor = Vet[i];
        else cont++;
    }
    return cont;
}

int main(){
    int N;

    scanf("%d", &N);
    int A[N];

    for (int i = 0; i < N; i++)
    {
        scanf("%d", &A[i]);

    }

    if (verificaOrdem(A, N)>0)
        printf("No\n");
    else printf("Yes\n");

    return 0;
    
}

Go solution:
package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"sort"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)
var wr = bufio.NewWriter(os.Stdout)

func out(x ...interface{}) {
	fmt.Fprintln(wr, x...)
}

func outSlice[T any](s []T) {
	if len(s) == 0 {
		return
	}
	for i := 0; i < len(s)-1; i++ {
		fmt.Fprint(wr, s[i], " ")
	}
	fmt.Fprintln(wr, s[len(s)-1])
}

func getI() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

func getF() float64 {
	sc.Scan()
	i, e := strconv.ParseFloat(sc.Text(), 64)
	if e != nil {
		panic(e)
	}
	return i
}

func getInts(N int) []int {
	ret := make([]int, N)
	for i := 0; i < N; i++ {
		ret[i] = getI()
	}
	return ret
}

func getS() string {
	sc.Scan()
	return sc.Text()
}

// min, max, asub, absなど基本関数
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

// min for n entry
func nmin(a ...int) int {
	ret := a[0]
	for _, e := range a {
		ret = min(ret, e)
	}
	return ret
}

// max for n entry
func nmax(a ...int) int {
	ret := a[0]
	for _, e := range a {
		ret = max(ret, e)
	}
	return ret
}

func chmin(a *int, b int) bool {
	if *a < b {
		return false
	}
	*a = b
	return true
}

func chmax(a *int, b int) bool {
	if *a > b {
		return false
	}
	*a = b
	return true
}

func asub(a, b int) int {
	if a > b {
		return a - b
	}
	return b - a
}

func abs(a int) int {
	if a >= 0 {
		return a
	}
	return -a
}

func lowerBound(a []int, x int) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] >= x
	})
	return idx
}

func upperBound(a []int, x int) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] > x
	})
	return idx
}

func main() {
	defer wr.Flush()
	sc.Split(bufio.ScanWords)
	sc.Buffer([]byte{}, math.MaxInt32)
	// this template is new version.
	// use getI(), getS(), getInts(), getF()
	N := getI()
	a := getInts(N)
	ok := true
	for i := 1; i < N; i++ {
		if a[i] <= a[i-1] {
			ok = false
		}
	}
	if ok {
		out("Yes")
	} else {
		out("No")
	}
}

Java solution:
import java.util.*; import java.io.*; import java.math.*;
import java.util.concurrent.*;
import java.text.*;
public class Main{
	//見なくていいよ　ここから------------------------------------------
	static class InputIterator{
		ArrayList<String> inputLine = new ArrayList<>(1024);
		int index = 0; int max; String read;
		InputIterator(){
			try{
				BufferedReader br = new BufferedReader(new InputStreamReader(System.in, "UTF-8"));
				while((read = br.readLine()) != null){
					inputLine.addAll(Arrays.asList(read.split(" ")));
				}
			}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<>();
	static InputIterator ii = new InputIterator();//This class cannot be used in reactive problem.
	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(Arrays.deepToString(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> nextCharArray(){return myconv(next(), 0);}
	static ArrayList<String> nextStrArray(int size){
		ArrayList<String> ret = new ArrayList<>(size);
		for(int i = 0; i < size; i++){
			ret.add(next());
		}
		return ret;
	}
	static ArrayList<Integer> nextIntArray(int size){
		ArrayList<Integer> ret = new ArrayList<>(size);
		for(int i = 0; i < size; i++){
			ret.add(Integer.parseInt(next()));
		}
		return ret;
	}
	static ArrayList<Long> nextLongArray(int size){
		ArrayList<Long> ret = new ArrayList<>(size);
		for(int i = 0; i < size; i++){
			ret.add(Long.parseLong(next()));
		}
		return ret;
	}
	@SuppressWarnings("unchecked")
	static String myconv(Object list, int no){//only join
		StringBuilder sb = new StringBuilder("");
		String joinString = CONVSTR.get(no);
		if(list instanceof String[]){
			return String.join(joinString, (String[])list);
		}else if(list instanceof long[]){
			long[] tmp = (long[])list;
			if(tmp.length == 0){
				return "";
			}
			sb.append(String.valueOf(tmp[0]));
			for(int i = 1; i < tmp.length; i++){
				sb.append(joinString).append(String.valueOf(tmp[i]));
			}
			return sb.toString();
		}else if(list instanceof int[]){
			int[] tmp = (int[])list;
			if(tmp.length == 0){
				return "";
			}
			sb.append(String.valueOf(tmp[0]));
			for(int i = 1; i < tmp.length; i++){
				sb.append(joinString).append(String.valueOf(tmp[i]));
			}
			return sb.toString();
		}else if(list instanceof ArrayList){
			ArrayList tmp = (ArrayList)list;
			if(tmp.size() == 0){
				return "";
			}
			sb.append(tmp.get(0));
			for(int i = 1; i < tmp.size(); i++){
				sb.append(joinString).append(tmp.get(i));
			}
			return sb.toString();
		}else{
			throw new ClassCastException("Don't join");
		}
	}
	static ArrayList<String> myconv(String str, int no){//only split
		String splitString = CONVSTR.get(no);
		return new ArrayList<String>(Arrays.asList(str.split(splitString)));
	}
	static ArrayList<String> myconv(String str, String no){
		return new ArrayList<String>(Arrays.asList(str.split(no)));
	}
	public static void main(String[] args){
		CONVSTR.put(8, " "); CONVSTR.put(9, "\n"); CONVSTR.put(0, "");
		solve();flush();
	}
	//見なくていいよ　ここまで------------------------------------------
	//このコードをコンパイルするときは、「-encoding UTF-8」を指定すること
	static void solve(){//ここがメイン関数
		int N = nextInt();
		ArrayList<Integer> list = nextIntArray(N);
		for(int i = 0; i < N - 1; i++){
			if(list.get(i) >= list.get(i + 1)){
				myout("No");
				return;
			}
		}
		myout("Yes");
	}
	//メソッド追加エリア　ここから



	//メソッド追加エリア　ここまで
}

JavaScript solution:
// https://atcoder.jp/contests/abc395/tasks/abc395_a

// the number of input lines
const line_num = 2;

function main(input) {
    const lines = input.trim().split("\n");
    const n = Number(lines[0]);
    const a = lines[1].split(" ").map(Number);

    // check a is simple increasing
    let isSimpleIncreasing = true;
    for (let i = 0; i < n - 1; i++) {
        if (a[i] >= a[i + 1]) {
            isSimpleIncreasing = false;
            break;
        }
    }

    if (isSimpleIncreasing) {
        console.log("Yes");
    } else {
        console.log("No");
    }
}

// *この行以降は編集しないでください（標準入力が3行になったら実行）*
process.stdin.setEncoding("utf8");

let inputLines = [];
process.stdin.on("data", (chunk) => {
    inputLines.push(...chunk.trim().split("\n"));
    if (inputLines.length >= line_num) {
        process.stdin.pause(); // 入力を停止
        main(inputLines.join("\n"));
    }
});

Python solution:
N=int(input())
A=list(map(int,input().split()))

found = True
for i in range(N-1):
    if A[i]>=A[i+1]:
       found = False

print("Yes" if found else "No")

Ruby solution:
module StrictlyIncreasing
  def solve(a)
    if a[..-2].zip(a[1..]).all?{|x, y| x < y}
      :Yes
    else
      :No
    end
  end

  module_function :solve
end

gets
a = gets.chomp.split(/\s+/).map(&:to_i)

puts StrictlyIncreasing.solve(a)