description: As their story unravels, a timeless tale is told once again...
  
  Shirahime, a friend of Mocha's, is keen on playing the music game Arcaea and sharing Mocha interesting puzzles to solve. This day, Shirahime comes up with a new simple puzzle and wants Mocha to solve them. However, these puzzles are too easy for Mocha to solve, so she wants you to solve them and tell her the answers. The puzzles are described as follow.
  
  There are n squares arranged in a row, and each of them can be painted either red or blue.
  
  Among these squares, some of them have been painted already, and the others are blank. You can decide which color to paint on each blank square.
  
  Some pairs of adjacent squares may have the same color, which is imperfect. We define the imperfectness as the number of pairs of adjacent squares that share the same color.
  
  For example, the imperfectness of "BRRRBBR" is 3, with "BB" occurred once and "RR" occurred twice.
  
  Your goal is to minimize the imperfectness and print out the colors of the squares after painting. 
  
  Input
  
  Each test contains multiple test cases. 
  
  The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. Each test case consists of two lines.
  
  The first line of each test case contains an integer n (1≤ n≤ 100) — the length of the squares row.
  
  The second line of each test case contains a string s with length n, containing characters 'B', 'R' and '?'. Here 'B' stands for a blue square, 'R' for a red square, and '?' for a blank square.
  
  Output
  
  For each test case, print a line with a string only containing 'B' and 'R', the colors of the squares after painting, which imperfectness is minimized. If there are multiple solutions, print any of them.
  
  Example
  
  Input
  
  
  5
  7
  ?R???BR
  7
  ???R???
  1
  ?
  1
  B
  10
  ?R??RB??B?
  
  
  Output
  
  
  BRRBRBR
  BRBRBRB
  B
  B
  BRRBRBBRBR
  
  Note
  
  In the first test case, if the squares are painted "BRRBRBR", the imperfectness is 1 (since squares 2 and 3 have the same color), which is the minimum possible imperfectness.
solution:     import java.io.*;
      import java.util.*;
      import java.math.*;
      import java.lang.*;
       
  
  
  
       //@Manan Parmar
      public class Solution2 implements Runnable {
          public void run() {
              
          InputReader sc = new InputReader(System.in);
          PrintWriter out = new PrintWriter(System.out);
          
          
          //code
          int t1=sc.nextInt();
          while(t1--!=0)
          {
             int n=sc.nextInt();
             String s=sc.next();
             char c[]=s.toCharArray();
             //char c[]=new char[n];
             int count=0;
             for(int i=0;i<n;i++)
             {
                  if(c[i]!='?')
                  {
                      if(i>0&&c[i-1]=='?')
                      {
                          char x='R';
                          if(c[i]=='R')
                              x='B';
                          for(int j=i-1;j>=0;j--)
                          {
                              if(c[j]!='?')
                                  break;
                              c[j]=x;
                              if(x=='B')
                                  x='R';
                              else
                                  x='B';
                          }
                      }
                      if(i<n-1&&c[i+1]=='?')
                      {
                          char x='R';
                          if(c[i]=='R')
                              x='B';
                          for(int j=i+1;j<n;j++,i++)
                          {
                              if(c[j]!='?')
                                  break;
                              c[j]=x;
                              if(x=='B')
                                  x='R';
                              else
                                  x='B';
                          }
                      }
                  }
                  else
                      count++;
             }
             if(count==n)
             {
                  for(int i=0;i<n;i++)
                      if(i%2==0)
                          c[i]='B';
                      else
                          c[i]='R';
             }
             out.println(c);
          }
  
          out.close();
          }
      
      class pairComparator implements Comparator<Pair>
          {
              public int compare(Pair p1,Pair p2)
              {
                  return p1.a-p2.a;
              }
          }
              class Pair{
              int id;
              int a;
  
              public Pair(int id,int a)
              {
                  this.id=id;
                  this.a=a;
              }   
          }
        
       
  
      //========================================================================
          
          boolean isPrime(int n) 
          { 
              // Corner case 
              if (n <= 1) 
                  return false; 
        
              // Check from 2 to n-1 
              for (int i = 2; i < n; i++) 
                  if (n % i == 0) 
                      return false; 
        
              return true; 
          } 
          int lcm(int number1, int number2) {
              if (number1 == 0 || number2 == 0) {
                  return 0;
              }
              int absNumber1 = Math.abs(number1);
              int absNumber2 = Math.abs(number2);
              int absHigherNumber = Math.max(absNumber1, absNumber2);
              int absLowerNumber = Math.min(absNumber1, absNumber2);
              int lcm = absHigherNumber;
              while (lcm % absLowerNumber != 0) {
                  lcm += absHigherNumber;
              }
              return lcm;
          }
          void quickSort(int a[],int l,int r)
          {
              if(l<r)
              {
                  int pindex=partition(a,l,r);
                  quickSort(a,l,pindex-1);
                  quickSort(a,pindex+1,r);
              }
  
          }
          int partition(int a[],int l,int r)
          {
              int pivot = a[r],pindex=l;
              for(int i=l;i<r;i++)
              {
                  if(a[i]<pivot)
                  {
                      int temp=a[i];
                      a[i]=a[pindex];
                      a[pindex]=temp;
                      pindex++;
                  }
              }
              int temp1=a[r];
              a[r]=a[pindex];
              a[pindex]=temp1;
              return pindex;
          }
          int binarySearch(int arr[], int x) 
          { 
              int l = 0, r = arr.length - 1; 
              while (l <= r) { 
                  int m = l + (r - l) / 2; 
        
                  // Check if x is present at mid 
                  if (arr[m] >= x)
                      if(m!=0&&arr[m-1]<x) 
                          return m;
                      else if(m==0)
                          return m; 
        
                  // If x greater, ignore left half 
                  if (arr[m] < x) 
                      l = m + 1; 
        
                  // If x is smaller, ignore right half 
                  else
                      r = m - 1; 
              } 
        
              // if we reach here, then element was 
              // not present 
              return -1; 
          } 
          boolean check(char a,char b)
          {
              if(a==b)
                  return true;
              else
                  return false;
          }
          long binarySearch(long arr[], long x) 
          { 
              int l = 0, r = arr.length - 1,q=0; 
              while (l<=r) { 
                  int m = l + (r - l) / 2; 
                  if (arr[l] >=x) 
                  {
                      q=1;
                      return l; 
                  }
                  if (arr[m] < x) 
                      l=m+1; 
                  else
                      r=m;
              } 
              return -1;
          }
  
          static class InputReader {
              private InputStream stream;
              private byte[] buf = new byte[1024];
              private int curChar;
              private int numChars;
              private SpaceCharFilter filter;
              private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
       
              public InputReader(InputStream stream) {
                  this.stream = stream;
              }
             
              public 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++];
              }
           
              public String nextLine() {
                  String str = "";
                  try {
                      str = br.readLine();
                  }
                  catch (IOException e) {
                      e.printStackTrace();
                  }
                  return str;
              }
              public 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;
              }
             
              public 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;
              }
             
              public double nextDouble() {
                  int c = read();
                  while (isSpaceChar(c))
                      c = read();
                  int sgn = 1;
                  if (c == '-') {
                      sgn = -1;
                      c = read();
                  }
                  double res = 0;
                  while (!isSpaceChar(c) && c != '.') {
                      if (c == 'e' || c == 'E')
                          return res * Math.pow(10, nextInt());
                      if (c < '0' || c > '9')
                          throw new InputMismatchException();
                      res *= 10;
                      res += c - '0';
                      c = read();
                  }
                  if (c == '.') {
                      c = read();
                      double m = 1;
                      while (!isSpaceChar(c)) {
                          if (c == 'e' || c == 'E')
                              return res * Math.pow(10, nextInt());
                          if (c < '0' || c > '9')
                              throw new InputMismatchException();
                          m /= 10;
                          res += (c - '0') * m;
                          c = read();
                      }
                  }
                  return res * sgn;
              }
             
              public String readString() {
                  int c = read();
                  while (isSpaceChar(c))
                      c = read();
                  StringBuilder res = new StringBuilder();
                  do {
                      res.appendCodePoint(c);
                      c = read();
                  }
                  while (!isSpaceChar(c));
                 
                  return res.toString();
              }
           
              public boolean isSpaceChar(int c) {
                  if (filter != null)
                      return filter.isSpaceChar(c);
                  return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
              }
           
              public String next() {
                  return readString();
              }
             
              public interface SpaceCharFilter {
                  public boolean isSpaceChar(int ch);
              }
          }
  
          public static void main(String args[]) throws Exception {
              new Thread(null, new Solution2(),"Main",1<<27).start();
          }
      }
  