Leaders

#include <iostream>
#include <vector>
 
int main() {
	int n;
	std::string breeds;
	std::cin >> n >> breeds;
	std::vector<int> cows(n);
 
	int first_guernsey = n, last_guernsey = 0;
	int first_holstein = n, last_holstein = 0;
	int res = 0;
 
	for (int i = 0; i < n; i++) {
		std::cin >> cows[i];
		cows[i]--;
 
		if (breeds[i] == 'G') {
			first_guernsey = std::min(first_guernsey, i);
			last_guernsey = std::max(last_guernsey, i);
		} else {
			first_holstein = std::min(first_holstein, i);
			last_holstein = std::max(last_holstein, i);
		}
	}
 
	// comprobar si first_guernsey es o no la líder
	if (cows[first_guernsey] >= last_guernsey) {
 
		/*
		 * con first_guernsey como líder,
		 * comprobar qué holstein (distinta de first_holstein) es una
		 * colíder válida al visitar a la líder de las guernsey
		 */
		for (int i = 0; i < first_guernsey; i++) {
			if (i != first_holstein && breeds[i] == 'H' && cows[i] >= first_guernsey) {
				res++;
			}
		}
	}
 
	// comprobar si first_holstein es o no la líder
	if (cows[first_holstein] >= last_holstein) {
 
		/*
		 * con first_holstein como líder,
		 * comprobar qué guernsey (distinta de first_guernsey) es una
		 * colíder válida al visitar a la líder de las holstein
		 */
		for (int i = 0; i < first_holstein; i++) {
			if (i != first_guernsey && breeds[i] == 'G' && cows[i] >= first_holstein) {
				res++;
			}
		}
	}
 
	// comprobar si la Guernsey más temprana y la
	// Holstein más temprana pueden ser ambas líderes válidas al mismo tiempo
	if ((cows[first_guernsey] >= last_guernsey ||
	     (first_guernsey <= first_holstein &&
	      cows[first_guernsey] >= first_holstein)) &&
	    (cows[first_holstein] >= last_holstein ||
	     (first_holstein <= first_guernsey &&
	      cows[first_holstein] >= first_guernsey))) {
		res++;
	}
 
	std::cout << res << '\n';
}

import java.io.*;
import java.util.*;
 
public class Leaders {
	public static void main(String[] args) throws Exception {
		Kattio io = new Kattio();
 
		int n = io.nextInt();
		String breeds = io.next();
		int[] cows = new int[n];
 
		int firstGuernsey = n, lastGuernsey = 0;
		int firstHolstein = n, lastHolstein = 0;
		int res = 0;
 
		for (int i = 0; i < n; i++) {
			cows[i] = io.nextInt() - 1;
 
			if (breeds.charAt(i) == 'G') {
				firstGuernsey = Math.min(firstGuernsey, i);
				lastGuernsey = Math.max(lastGuernsey, i);
			} else {
				firstHolstein = Math.min(firstHolstein, i);
				lastHolstein = Math.max(lastHolstein, i);
			}
		}
 
		// comprobar si first_guernsey es o no la líder
		if (cows[firstGuernsey] >= lastGuernsey) {
 
			/*
			 * con first_guernsey como líder,
			 * comprobar qué holstein (distinta de first_holstein) es una
			 * colíder válida al visitar a la líder de las guernsey
			 */
			for (int i = 0; i < firstGuernsey; i++) {
				if (i != firstHolstein && breeds.charAt(i) == 'H' &&
				    cows[i] >= firstGuernsey) {
					res++;
				}
			}
		}
 
		// comprobar si first_holstein es o no la líder
		if (cows[firstHolstein] >= lastHolstein) {
 
			/*
			 * con first_holstein como líder,
			 * comprobar qué guernsey (distinta de first_guernsey) es una
			 * colíder válida al visitar a la líder de las holstein
			 */
			for (int i = 0; i < firstHolstein; i++) {
				if (i != firstGuernsey && breeds.charAt(i) == 'G' &&
				    cows[i] >= firstHolstein) {
					res++;
				}
			}
		}
 
		// comprobar si la Guernsey más temprana y la
		// Holstein más temprana pueden ser ambas líderes válidas al mismo tiempo
		if ((cows[firstGuernsey] >= lastGuernsey ||
		     (firstGuernsey <= firstHolstein &&
		      cows[firstGuernsey] >= firstHolstein)) &&
		    (cows[firstHolstein] >= lastHolstein ||
		     (firstHolstein <= firstGuernsey &&
		      cows[firstHolstein] >= firstGuernsey))) {
 
			res++;
		}
 
		io.println(res);
		io.close();
	}
 
	// BeginCodeSnip{Kattio}
}

n = int(input())
breeds = input()
cows = [x - 1 for x in map(int, input().split())]
 
first_guernsey = n
last_guernsey = 0
first_holstein = n
last_holstein = 0
res = 0
 
for i in range(n):
	if breeds[i] == "G":
		first_guernsey = min(first_guernsey, i)
		last_guernsey = max(last_guernsey, i)
	else:
		first_holstein = min(first_holstein, i)
		last_holstein = max(last_holstein, i)
 
# comprobar si first_guernsey es o no la líder
if cows[first_guernsey] >= last_guernsey:
 
	"""
	con first_guernsey como líder,
	comprobar qué holstein (distinta de first_holstein) es una
	colíder válida al visitar a la líder de las guernsey
	"""
	for i in range(first_guernsey):
		if i != first_holstein and breeds[i] == "H" and cows[i] >= first_guernsey:
			res += 1
 
# comprobar si first_holstein es o no la líder
if cows[first_holstein] >= last_holstein:
 
	"""
	con first_holstein como líder,
	comprobar qué guernsey (distinta de first_guernsey) es una
	colíder válida al visitar a la líder de las holstein
	"""
	for i in range(first_holstein):
		if i != first_guernsey and breeds[i] == "G" and cows[i] >= first_holstein:
			res += 1
 
# comprobar si la Guernsey más temprana y la
# Holstein más temprana pueden ser ambas líderes válidas al mismo tiempo
if (
	cows[first_guernsey] >= last_guernsey
	or (first_guernsey <= first_holstein and cows[first_guernsey] >= first_holstein)
) and (
	cows[first_holstein] >= last_holstein
	or (first_holstein <= first_guernsey and cows[first_holstein] >= first_guernsey)
):
	res += 1
 
print(res)