Euler 93

  int number = 0;
  int maxi = 0;
  vector<char> oper({'+','-','*','/','\\'});
  vector<int> best;
  vector<int> pool(4);
  //Problem 92
  for(pool[0]=0;pool[0]<10;pool[0]++)
    for(pool[1]=pool[0]+1;pool[1]<10;pool[1]++)
      for(pool[2]=pool[1]+1;pool[2]<10;pool[2]++)
        for(pool[3]=pool[2]+1;pool[3]<10;pool[3]++){
//          if(pool[0]==1 && pool[1]==2 && pool[2]==5 && pool[3]==8){
//            cout << pool[0]<<pool[1]<<pool[2]<<pool[3]<<endl;
            vector<bool> possible(10000,false);
            for(int a=0;a<4;a++){
              double n = pool[a];
              for(int b=0;b<4;b++){
                if(b!=a){
                  for(int e = 0;e<5;e++){
                    double ne=n;
                    if(e==0){
                      n+=pool[b];
                    }
                    else if(e==1){
                      n=abs(n-pool[b]);
                    }
                    else if(e==2){
                      n*=pool[b];
                    }
                    else if(e==3 && pool[b]!=0){
                      n /= pool[b];
                    }
                    else if(e==4 && n!=0){
                      n=pool[b]/n;
                    }else
                      continue;
                    for(int c=0;c<4;c++){
                      if(c!=a && c!=b){
                        for(int f = 0;f<5;f++){
                          double nf=n;
                          if(f==0){
                            n+=pool[c];
                          }
                          else if(f==1){
                            n=abs(n-pool[c]);
                          }
                          else if(f==2){
                            n*=pool[c];
                          }
                          else if(f==3 && pool[c]!=0){
                            n /= pool[c];
                          }
                          else if(f==4 && n!=0){
                            n=pool[c]/n;
                          }else
                            continue;
                          for(int d=0;d<4;d++){
                            if(d!=a && d!=b && d!=c){
                              for(int g = 0;g<5;g++){
                                double ng=n;
                                if(g==0){
                                  n+=pool[d];
                                }
                                else if(g==1){
                                  n=abs(n-pool[d]);
                                }
                                else if(g==2){
                                  n*=pool[d];
                                }
                                else if(g==3 && pool[d]!=0){
                                  n /=pool[d];
                                }
                                else if(g==4 && n!=0){
                                  n=pool[d]/n;
                                }else
                                  continue;
                                if((int)n==n){
                                  possible[(int)n]=true;
//                                  if(n<60)
//                                    cout << n<<":"<<pool[a]<<oper[e]<<pool[b]<<oper[f]<<pool[c]<<oper[g]<<pool[d]<<endl;
                                }
                                n=ng;
                              }

                            }
                          }
                          n=nf;
                        }

                      }
                    }


                    double cd;
                    for(int c=0;c<4;c++){
                      if(c!=a && c!=b){
                        for(int d=0;d<4;d++){
                          if(d!=a && d!=b && d!=c){
                            for(int g = 0;g<5;g++){
                              if(g==0){
                                cd=pool[c]+pool[d];
                              }
                              else if(g==1){
                                cd=abs(pool[d]-pool[c]);
                              }
                              else if(g==2){
                                cd=pool[c]*pool[d];
                              }
                              else if(g==3 && pool[c]!=0){
                                cd = pool[d] / (double)pool[c];
                              }
                              else if(g==4 && pool[d]!=0){
                                cd = pool[c] / (double)pool[d];
                              }
                              else
                                continue;

                              for(int f = 0;f<5;f++){
                                double ncd;
                                if(f==0){
                                  ncd = n+cd;
                                }
                                else if(f==1){
                                  ncd = abs(n-cd);
                                }
                                else if(f==2){
                                  ncd = n*cd;
                                }
                                else if(f==3 && cd!=0){
                                  ncd = n/cd;
                                }
                                else if(f==4 && n!=0){
                                  ncd = cd/n;
                                }
                                else
                                  continue;
                                if((int)ncd==ncd){
                                  possible[(int) ncd]=true;
//                                  cout<<ncd<<':'<<pool[a]<<oper[e]<<pool[b]<<oper[f]<<'('<<pool[c]<<oper[g]<<pool[d]<<')'<<endl;
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                    n=ne;
                  }
                }
              }
            }
            int i = 1;
            while(possible[i])
              i++;
            if(i>maxi){
              best=pool;
              maxi=i;
            }
//          }
        }

  for(int i=0;i<4;i++){
    number+=best[i];
    if(i!=3)
      number*=10;
  }
finish:
  cout << number<< " " << maxi <<  endl;