166
rbbbbbbbbbbbbrbrrbbrbbbrbbbbbbbbbbrbbbbbbrbbbrbbbbbrbbbbbbbrbbbbbbbrbbrbbbbbbbbrbbbbbbbbbbbbbbrrbbbrbbbbbbbbbbbbbbrbrbbbbbbbbbbbrbbbbbbbbbbbbbbrbbbbbbbbbbbbbbbbbbbbbb
 7
rrbrbrb
 1
r
 2
bb
 18
rrrrrrrrrrrrrrrrrb
 8
rbbrbrbr
 1
b
 13
rbbbrbrrbrrbb
 100
brbbbrrrbbrbrbbrbbrbbbbrbbrrbbbrrbbbbrbrbbbbbbbbbbbbbbbbrrrrbbbbrrrbbbbbbbrbrrbrbbbbrrrbbbbrbbrbbbrb
 2
rb
 2
rr
 2
br

70
 1
 0
 1
 8
 1
 0
 3
 34
 0
 1
 0

/*
 * Author- Priyam Vora
 * BTech 2nd Year DAIICT
 */

        import java.io.*;
     
        import java.math.BigInteger;
        import java.util.*;
     
        public class Graph1 {
        	
    	    private static InputStream stream;
        	private static byte[] buf=new byte[1024];
        	private static int curChar;
        	private static int numChars;
        	private static SpaceCharFilter filter;
        	private static PrintWriter pw;
        	private static long count=0;
            public static void main(String args[] ) throws Exception 
            {
            	InputReader(System.in);
        		pw=new PrintWriter(System.out);
        		soln();
        		pw.close();
            }
     
            public static long gcd(long x,long y)
            {
            	if(x%y==0)
            		return y;
            	else
            		return gcd(y,x%y);
            }
            public static int gcd(int x,int y)
            {
            	if(x%y==0)
            		return y;
            	else 
            		return gcd(y,x%y);
            }
            


public static long pow(long n,long p,long m)
{
	 long  result = 1;
	  if(p==0)
	    return 1;
	if (p==1)
	    return n;
	while(p!=0)
	{
	    if(p%2==1)
	        result *= n;
	    if(result>=m)
	    result%=m;
	    p >>=1;
	    n*=n;
	    if(n>=m)
	    n%=m;
	}
	return result;
}
public static long pow(long n,long p)
{
	long  result = 1;
	  if(p==0)
	    return 1;
	if (p==1)
	    return n;
	while(p!=0)
	{
	    if(p%2==1)
	        result *= n;	    
	    p >>=1;
	    n*=n;	    
	}
	return result;

}
public static boolean printSubsets(int set[],int pow)
	{
		int n = set.length;

		// Run a loop for printing all 2^n
		// subsets one by obe
		for (int i = 0; i < (1<<n); i++)
		{
			int a[]=new int[n];
			
			int count=0;

			// Print current subset
			for (int j = 0; j < n; j++)

				// (1<<j) is a number with jth bit 1
				// so when we 'and' them with the
				// subset number we get which numbers
				// are present in the subset and which
				// are not
				if ((i & (1 << j)) > 0)
					{
					
					a[count]=set[j];
					count++;
					//System.out.print(set[j] + " ");
					}
int sum=0;
		for(int t=0;t<count;t++){
		sum+=a[t];	
			//pw.print(a[t]+" ");
		}
		if(sum==pow){
		return true;
		}
		}
		return false;
		//System.out.println(sum+"-sum "+l+" -l");
		}

	 
	// remove N elements in equal steps starting at specific point
	static List<Integer> josephus(int N, int step, int start)
	{
	    if (N < 1 || step < 1 || start < 1) return null;

	    List<Integer> p = new LinkedList<Integer>();
	    for (int i = 0; i < N; i++)
	        p.add(i+1);

	    List<Integer> r = new LinkedList<Integer>();
	    int i = (start - 2) % N;
	    for (int j = N; j > 0; j--) {
	        i = (i + step) % N--;
	        r.add(p.remove(i--));
	    }

	    return r;
	}

	 
	 
	 public static long fact(long n){
		 if(n==0)
			 return 1;
		 else
			 return (long)n*(long)fact(n-1);
		 
	 }


public static int[] radixSort(int[] f)
{
	int[] to = new int[f.length];
	{
		int[] b = new int[65537];
		for(int i = 0;i < f.length;i++)b[1+(f[i]&0xffff)]++;
		for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
		for(int i = 0;i < f.length;i++)to[b[f[i]&0xffff]++] = f[i];
		int[] d = f; f = to;to = d;
	}
	{
		int[] b = new int[65537];
		for(int i = 0;i < f.length;i++)b[1+(f[i]>>>16)]++;
		for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
		for(int i = 0;i < f.length;i++)to[b[f[i]>>>16]++] = f[i];
		int[] d = f; f = to;to = d;
	}
	return f;
} 

public static int nextPowerOf2(final int a)
{
    int b = 1;
    while (b < a)
    {
        b = b << 1;
    }
    return b;
}
     
        
    public static boolean PointInTriangle(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8)
    {
    int s = p2 * p5 - p1 * p6 + (p6 - p2) * p7 + (p1 - p5) * p8;
    int t = p1 * p4 - p2 * p3 + (p2 - p4) * p7 + (p3 - p1) * p8;
     
    if ((s < 0) != (t < 0))
    return false;
     
    int A = -p4 * p5 + p2 * (p5 - p3) + p1 * (p4 - p6) + p3 * p6;
    if (A < 0.0)
    {
    s = -s;
    t = -t;
    A = -A;
    }
    return s > 0 && t > 0 && (s + t) <= A;
    }
     
      public static float area(int x1, int y1, int x2, int y2, int x3, int y3){
    	  return (float)Math.abs((x1*(y2-y3) + x2*(y3-y1)+ x3*(y1-y2))/2.0);
      }
      public static boolean isPrime(int n)
      {
          // Corner cases
          if (n <= 1)  return false;
          if (n <= 3)  return true;
       
          // This is checked so that we can skip 
          // middle five numbers in below loop
          if (n%2 == 0 || n%3 == 0) return false;
       
          for (int i=5; i*i<=n; i=i+6)
              if (n%i == 0 || n%(i+2) == 0)
                 return false;
       
          return true;
      }
     
     
    //merge Sort
            
            public static void Merge_sort(int a[]){
            	int len=a.length;
            	if(len <2)
            		return ;
            	int mid=len/2;
            	int l[]=new int[mid];
            	int r[] =new int[len-mid];
            	for(int i=0;i<mid;i++)
            		l[i]=a[i];
            	for(int i=mid;i<len;i++)
            		r[i-mid]=a[i];
            	
            	Merge_sort(l);
            	Merge_sort(r);
            	Merge(l,r,a);
            }
            	
            public static void Merge(int []l,int[]r,int a[]){
            	int nl=l.length;
            	int nr=r.length;
            	int i=0,j=0,k=0;
            	
            	while(i <nl && j<nr){
            		if(l[i] > r[j]){
            			a[k]=l[i];
            			k++;
            			i++;
            		}
            		else{
            			a[k]=r[j];
            			k++;
            			j++;
            		}
            		
            		while(i<nl){
            			a[k]=l[i];
            			k++;
            			i++;
            		}
            		while(j<nr){
            			a[k]=r[j];
            			k++;
            			j++;
            		}
            	}
            }
      
        	
        public static boolean isSubSequence(String large,String small,int largeLen,int smallLen){
        //base cases
        	if(largeLen==0)
        		return false;
        	if(smallLen==0)
        		return true;
        	  // If last characters of two strings are matching
        	if(large.charAt(largeLen-1)==small.charAt(smallLen-1))
        		isSubSequence(large, small, largeLen-1, smallLen-1);
        	// If last characters are not matching
        	return isSubSequence(large, small, largeLen-1, smallLen);
        }
     
        // To Get Input
         	// Some Buffer Methods
         
         	public static void InputReader(InputStream stream1) {
         		stream = stream1;
         	}
         
         	private static boolean isWhitespace(int c) {
         		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
         	}
         
         	private static boolean isEndOfLine(int c) {
         		return c == '\n' || c == '\r' || c == -1;
         	}
         
         	private static int read() {
         		if (numChars == -1)
         			throw new InputMismatchException();
         		if (curChar >= numChars) {
         			curChar = 0;
         			try {
         				numChars = stream.read(buf);
         			} catch (IOException e) {
         				throw new InputMismatchException();
         			}
         			if (numChars <= 0)
         				return -1;
         		}
         		return buf[curChar++];
         	}
         
         	private static int nextInt() {
         		int c = read();
         		while (isSpaceChar(c))
         			c = read();
         		int sgn = 1;
         		if (c == '-') {
         			sgn = -1;
         			c = read();
         		}
         		int res = 0;
         		do {
         			if (c < '0' || c > '9')
         				throw new InputMismatchException();
         			res *= 10;
         			res += c - '0';
         			c = read();
         		} while (!isSpaceChar(c));
         		return res * sgn;
         	}
          
         	private static long nextLong() {
         		int c = read();
         		while (isSpaceChar(c))
         			c = read();
         		int sgn = 1;
         		if (c == '-') {
         			sgn = -1;
         			c = read();
         		}
         		long res = 0;
         		do {
         			if (c < '0' || c > '9')
         				throw new InputMismatchException();
         			res *= 10;
         			res += c - '0';
         			c = read();
         		} while (!isSpaceChar(c));
         		return res * sgn;
         	}
          
         	private static String nextToken() {
         		int c = read();
         		while (isSpaceChar(c))
         			c = read();
         		StringBuilder res = new StringBuilder();
         		do {
         			res.appendCodePoint(c);
         			c = read();
         		} while (!isSpaceChar(c));
         		return res.toString();
         	}
          
         	private static String nextLine() {
         		int c = read();
         		while (isSpaceChar(c))
         			c = read();
         		StringBuilder res = new StringBuilder();
         		do {
         			res.appendCodePoint(c);
         			c = read();
         		} while (!isEndOfLine(c));
         		return res.toString();
         	}
         
         	private static int[] nextIntArray(int n) {
         		int[] arr = new int[n];
         		for (int i = 0; i < n; i++) {
         			arr[i] = nextInt();
         		}
         		return arr;
         	}
         	  
         	private static long[] nextLongArray(int n) {
         		long[] arr = new long[n];
         		for (int i = 0; i < n; i++) {
         			arr[i] = nextLong();
         		}
         		return arr;
         	}
         
         	private static void pArray(int[] arr){
         		for (int i=0; i<arr.length; i++) {
         			System.out.print(arr[i] + " ");
         		}
         		System.out.println();
         		return;
         	}
         
         	private static void pArray(long[] arr){
         		for (int i=0; i<arr.length; i++) {
         			System.out.print(arr[i] + " ");
         		}
         		System.out.println();
         		return;		
         	}
         	
         	private static void pArray(boolean[] arr){
         		for (int i=0; i<arr.length; i++) {
         			System.out.print(arr[i] + " ");
         		}
         		System.out.println();
         		return;
         	}
     
         
         	private static boolean isSpaceChar(int c) {
         		if (filter != null)
         			return filter.isSpaceChar(c);
         		return isWhitespace(c);
         	}
          
         	private interface SpaceCharFilter {
         		public boolean isSpaceChar(int ch);
         	}
         
            
         	 private static void soln() {
 
         		int n=nextInt();
         		String s=nextLine();
         		int first_r=0,first_b=0;
         		if(s.charAt(0)=='b'){
         			first_b =0;
         			first_r=1;
         		}else
         		{
         			first_r=0;
         			first_b=1;
         		}
         		int extra_b=0,extra_r=0;
         		for(int i=first_r;i<n;i+=2){
         			if(s.charAt(i)!='r')
         				extra_b++;
         		}
         		for(int i=first_b;i<n;i+=2){
         			if(s.charAt(i)!='b')
         				extra_r++;
         				
         		}
         		//System.out.println(extra_b+" "+extra_r);
         		int tot=Math.max(extra_r, extra_b);
         		
         		pw.println(tot);
         		
         	 }
         	
         	 
         	// Returns count of minimum squares that sum to n
         	static int getMinSquares(int n)
         	{
         	    int dp[]=new int[n+1];
         	    dp[0]=0;
         	    dp[1]=1;
         	    dp[2]=2;
         	    dp[3]=3;

         	    for(int i=4;i<=n;i++)
         	    {
         	        dp[i]=i;
         	        for(int x=1;x*x<=i;x++)
         	        {
         	            if(dp[i]<1+dp[i-x*x])
         	            {
         	                dp[i]=1+dp[i-x*x];
         	            }
         	        }
         	    }

         	    return dp[n];
         	}
        }
        
        
        class Graph{
        	private long conse=0,co=0,mac_cons_cat=0;
        	private int V,flag=1, d[], road_cond[][];
        	private Stack <Integer>st=new Stack();
        	private LinkedList<Integer > adj[];
        //	boolean Visited[];
        	Graph(int V){
        		V++;
        
        		
        		//this.mac_cons_cat=max_cat;
        		this.V=(V);
        		adj=new LinkedList[V];
        		//for(int i=0;i<V;i++)
        			//adj[i]=new LinkedList();
        		
        			
        		//Visited=new boolean[V];
        	 
        	}
        	void addEdge(int v,int w){
        		if(adj[v]==null){
        			adj[v]=new LinkedList();
        		}
        		adj[v].add(w);
        	
        	}
        	public long  bfs(int s)
            {
        		co=0;
                // Mark all the vertices as not visited(By default
                // set as false)
                boolean visited[] = new boolean[V];
         
                // Create a queue for BFS
                LinkedList<Integer> queue = new LinkedList<Integer>();
         
                // Mark the current node as visited and enqueue it
                visited[s]=true;
                queue.add(s);
         
                while (queue.size() != 0)
                {
                    // Dequeue a vertex from queue and print it
                    s = queue.poll();
                   // System.out.print(s+" ");
         
                    // Get all adjacent vertices of the dequeued vertex s
                    // If a adjacent has not been visited, then mark it
                    // visited and enqueue it
                    Iterator<Integer> i = adj[s].listIterator();
                    while (i.hasNext())
                    {
                        int n = i.next();
                        if (!visited[n])
                        {
                            visited[n] = true;
                            queue.add(n);
                        co++;
                        }
                    }
                    return co;
                }
                return 0;
            }
        	 public long  dfs(int startVertex){
        		
        		boolean Visited[]=new boolean[V];
        		
        		//flag=1;
        		
        		 if(!Visited[startVertex])  {
        			
        			 co=0; 
        			 dfsUtil(startVertex,Visited);
           		 
        		 }
        		 
        		 return co;
        	 }
        	 public void Connected(int v){
        		 Iterator<Integer> i = adj[v].listIterator();
        		 while(i.hasNext()){
        			 int n=i.next();
        			 long data=(long)d[n]+(long)d[v];
        			 data=data%1000000007;
        			 d[n]=(int)data;
        		 }
        	 }
        	 public int getByte(int v){
        		 return d[v];
        	 }
        	private void dfsUtil(int startVertex, boolean[] Visited) {
        		//System.out.println(pre+" "+startVertex);
        		
        		Visited[startVertex]=true;
        		
        		
        		st.push(startVertex);
        		while(!st.isEmpty()){
        			int top=st.pop();
        			System.out.print(top+" ");
        			
        			//System.out.println(top);
        		Iterator<Integer> i=adj[top].listIterator();
        	
        		while(i.hasNext()){
        			int n=i.next();
        		//	System.out.println(n+"---");
        			 if( !Visited[n]){
        				Visited[n]=true;
        					st.push(n);
        					co++;
        					}
        			 }
        		
        	}
        		}
        }

        class Dsu{
        	private int rank[], parent[] ,n;
        	
        	Dsu(int size){
        		this.n=size+1;
        		rank=new int[n];
        		parent=new int[n];
        	makeSet();
        	}
        	
        	void makeSet(){
        		for(int i=0;i<n;i++){
        			parent[i]=i;
        		}
        	}
        	
        	int find(int x){
        		if(parent[x]!=x){
        			
        			parent[x]=find(parent[x]);
        		}
        		return parent[x];
        	}	
        	
        	void union(int x,int y){
        		int xRoot=find(x);
        		int yRoot=find(y);
        		
        		if(xRoot==yRoot)
        			return;
        		if(rank[xRoot]<rank[yRoot]){
        		parent[xRoot]=yRoot;	
        		}else if(rank[yRoot]<rank[xRoot]){
        			parent[yRoot]=xRoot;
        		}else{
        			parent[yRoot]=xRoot;
        			rank[xRoot]++;
        		}
        		
        	}
        }


