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 Go (1.6) (judge verdict: Runtime Error)

package main

import (
"bufio"
"os"
"strconv"
)

type IO struct {
    scanner *bufio.Scanner
    reader *bufio.Reader
    writer *bufio.Writer
}
func NewIO() IO {
    io := IO{writer: bufio.NewWriter(os.Stdout),
        reader: bufio.NewReader(os.Stdin),
        scanner: bufio.NewScanner(os.Stdin)}
    io.scanner.Split(bufio.ScanWords)
    return io
}
func toInt(buf []byte) (n int) {
    for _, v := range buf {
        n = n*10 + int(v-'0')
    }
    return
}
func (io *IO) NextInt() int {
    io.scanner.Scan()
    return toInt(io.scanner.Bytes())
}
func (io *IO) Next() string {
    value, _ := io.reader.ReadString(' ')
    return value
}
func (io *IO) NextLine() string {
    value, _ := io.reader.ReadString('\n')
    return value
}
func (io *IO) Write(data ...interface{}) {
    for _, el := range data {
        switch el.(type) {
            case int:
                io.writer.WriteString(strconv.Itoa(el.(int)))
            case string:
                io.writer.WriteString(el.(string))
            case rune:
                io.writer.WriteRune(el.(rune))
        }
    }
}
func (io *IO) Writeln(data ...interface{}) {
    io.Write(data...)
    io.writer.WriteRune('\n')
}
func (io *IO) Flush() {
    io.writer.Flush()
}

type pair struct {
    char byte
    cnt int
}

func main() {
    io := NewIO()
    N := io.NextInt()
    str := io.NextLine()
    
    var arr []pair
    for i := 0; i < N; i++ {
        if i == 0 || str[i] != arr[len(arr)-1].char {
            arr = append(arr, pair{char: str[i], cnt: 1})
        } else {
            arr[len(arr)-1].cnt++
        }
    }
    if arr[len(arr)-1].char == '#' {
        arr = arr[:len(arr)-1]
    }
    
    ans := 0
    for i := 0; i < len(arr); i++ {
        if arr[i].char == '#' {
            tambah := arr[i].cnt
            if i < len(arr)-1 && arr[i+1].cnt < tambah {
                tambah = arr[i+1].cnt
            }
            ans += tambah
        }
    }
    io.Writeln(ans)
    io.Flush()
}