Problem:
Score : 300 points

Problem Statement

There are N stones arranged in a row. Every stone is painted white or black.
A string S represents the color of the stones. The i-th stone from the left is white if the i-th character of S is ., and the stone is black if the character is #.

Takahashi wants to change the colors of some stones to black or white so that there will be no white stone immediately to the right of a black stone.
Find the minimum number of stones that needs to be recolored.

Constraints

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

S is a string of length N consisting of . and #.

Input

Input is given from Standard Input in the following format:

N
S

Output

Print the minimum number of stones that needs to be recolored.

Sample Input 1

3
#.#

Sample Output 1

1

It is enough to change the color of the first stone to white.

Sample Input 2

5
#.##.

Sample Output 2

2

Sample Input 3

9
.........

Sample Output 3

0

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

use std::str::FromStr;
use std::fmt::Debug;
use std::cmp;

fn read_as_vec<T>() -> Vec<T>
where T: FromStr, <T as FromStr>::Err : Debug{
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().split_whitespace().map(|c| T::from_str(c).unwrap()).collect()

}

fn read_as_string() -> String{
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().to_string()
}


fn main(){
    let n: usize = read_as_vec()[0];

    let s = read_as_string().chars().collect::<Vec<char>>();
    
    //println!("{:?}", s);
    
    //if they are all black(#)
    if s.iter().all(|ch| *ch == '#'){
        println!("0");
        return;
    }
    //if they are all white(.)
    if s.iter().all(|ch| *ch == '.'){
        println!("0");
        return;
    }

    let num_white = s.iter().filter(|ch| **ch == '.').collect::<Vec<_>>().len();
    let num_black = s.iter().filter(|ch| **ch == '#').collect::<Vec<_>>().len();
    let mut right = (num_white, num_black);
    let mut left = (0, 0);
    //initial value is the cost to change them all black
    let mut min_cost = num_white;

    for c in &s{
        if *c == '.'{
            right.0 -= 1;
            left.0 += 1;
        }else{
            right.1 -= 1;
            left.1 += 1;
        }

        min_cost = cmp::min(min_cost, left.1+right.0);
    }
    
    println!("{}", min_cost);
}