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: Wrong Answer)

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 mut 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 cost_all_white = s.iter().filter(|ch| **ch != '.').collect::<Vec<_>>().len();
    let cost_all_black = s.iter().filter(|ch| **ch != '#').collect::<Vec<_>>().len();
    let mut cost_balance = n;
    
    let mut left: usize = 0;
    let mut right: usize = n;
    
    while left +1 < right{
        /*
        println!("-----");
        println!("left = {}, right = {}", left, right);
        */
        let md = (left+right)/2;
        //println!("mid = {}", md);
        
        
        let left_white_cost  = s.iter().take(md).filter(|ch| **ch != '.').collect::<Vec<_>>().len();
        let right_black_cost = s.iter().skip(md).filter(|ch| **ch != '#').collect::<Vec<_>>().len();

        if right_black_cost > left_white_cost{
            //println!("change left {} to {}", left, md);
            left = md;
        }else{
            //println!("change right {} to {}", right, md);
            right = md;
        }
        cost_balance = s.iter().take(md).filter(|ch| **ch != '.').collect::<Vec<_>>().len()+
            s.iter().skip(md).filter(|ch| **ch != '#').collect::<Vec<_>>().len();
    }
    /*
    cost_balance = s.iter().take(left).filter(|ch| **ch != '.').collect::<Vec<_>>().len()+
        s.iter().skip(left).filter(|ch| **ch != '#').collect::<Vec<_>>().len();
    */

    /*
    println!("left ={}", left);
    println!("cost_balance = {}", cost_balance);

    println!("anser = {}", cmp::min(cost_balance, cmp::min(cost_all_white, cost_all_black)));
     */
    s.reverse();

    let ans1 = s.into_iter().skip_while(|ch| *ch == '#').filter(|ch| *ch == '#').collect::<Vec<char>>().len();
    let mut ans;
    ans = cmp::min(cost_all_white, cost_all_black);
    ans = cmp::min(cost_balance, ans);
    ans = cmp::min(ans1, ans);
    println!("{}", ans);
}