Problem:
Score : 300 points

Problem Statement

Given is a string S of length N-1.
Each character in S is < or >.

A sequence of N non-negative integers, a_1,a_2,\cdots,a_N, is said to be good when the following condition is satisfied for all i (1 \leq i \leq N-1):

If S_i= <: a_i<a_{i+1}

If S_i= >: a_i>a_{i+1}

Find the minimum possible sum of the elements of a good sequence of N non-negative integers.

Constraints

2 \leq N \leq 5 \times 10^5

S is a string of length N-1 consisting of < and >.

Input

Input is given from Standard Input in the following format:

S

Output

Find the minimum possible sum of the elements of a good sequence of N non-negative integers.

Sample Input 1

<>>

Sample Output 1

3

a=(0,2,1,0) is a good sequence whose sum is 3.
There is no good sequence whose sum is less than 3.

Sample Input 2

<>>><<><<<<<>>><

Sample Output 2

28

Solution in Rust (1.15.1) (judge verdict: Accepted)

#[allow(unused_imports)]
use std::char::*;
#[allow(unused_imports)]
use std::cmp::*;
use std::io::*;
use std::str::FromStr;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

//const MAX:usize = 100006;

fn main() {
    let s:Vec<char> = read::<String>().chars().collect();
    let mut v:Vec<(bool,u64)> = vec![];

    let mut f:bool = if s[0]=='<' {true} else {false};
    let mut cnt:u64 = 0;

    for &ch in s.iter() {
        let g:bool = if ch=='<' {true} else {false};
        if f != g {
            v.push((f, cnt));
            cnt=1;
            f=g;
        } else {
            cnt += 1;
        }
    }
    v.push((f, cnt));

    let mut ans:u64 = 0;
    for i in 0..v.len() {
        let i = i as usize;
        let f = v[i].0;
        let cnt = v[i].1;
        //println!("{} {}", f, cnt);
        // '<' の場合は、右隣りの'>'の連続数と比較する
        if f {
            if i == v.len()-1 {
                ans += cnt*(cnt+1)/2;
                continue;
            }
            if cnt <= v[i+1].1 {
                ans += cnt*(cnt-1)/2;
            } else {
                ans += cnt*(cnt+1)/2;
            }
        }
        // '>' の場合は、左隣りの'<'の連続数と比較する
        else {
            if i == 0 {
                ans += cnt*(cnt+1)/2;
                continue;
            }
            if cnt < v[i-1].1 {
                ans += cnt*(cnt-1)/2;
            } else {
                ans += cnt*(cnt+1)/2;
            }
        }
    }

    println!("{}", ans);
}