TopCoder SRM 281

SRM 281 - Problem Set & Analysis by lovro can be see here.

The following is my solution, all programs are pass system test.

The Problems

IntegerGenerator

This following is my algorithm :

->    decide if string current is "valid input", and put it into a vector<int> cur

->    sort allowed

->    for i = cur.end() to cur.begin() i--

            find element  E in allowed which is the smallest number larger than cur[i] and let cur[i] = E

            let elements after pos i in cur = allow[0] (smaillest number in allowed)

-> if the cur is the largest number in allowed which has length cur.lenght() then

        let return number ret.length = cur.length+1 and ret = smallest number with length cur.length+1

string IntegerGenerator::nextInteger(vector <int> allowed, string current)
 {
     vector<int> allow = allowed;
     vector<int> cur;
     int i,j,k;
     int num;
     if(current[0]=='0') return "INVALID INPUT";
     for(i=0;i<current.size();i++){
         num = current[i] - '0';
         if(std::find(allow.begin(),allow.end(),num)!=allow.end()){
             cur.push_back(num);
         }
         else{
             return "INVALID INPUT";
         }
     }
     std::sort(allow.begin(),allow.end());
     bool find = false;
     for(i=cur.size()-1;i>=0;i--){
         find = false;
         for(j=0;j<allow.size();j++){
             if(allow[j]>cur[i]){
                 find = true;
                 cur[i] = allow[j];
                 for(k=i+1;k<cur.size();k++) cur[k] = allow[0];
                 break;
             }
         }
         if(find) break;
     }
     char *result = new char[cur.size()+4];
     memset(result,0,cur.size()+4);
     string ret;
     if(find){
         for(i=0;i<cur.size();i++){
             result[i] = cur[i]+'0';
         }
         ret = result;
         return ret;
     }
     else{
         if(allow[0]!=0){
             for(i=0;i<cur.size()+1;i++){
                 result[i] = allow[0]+'0';
             }
             ret = result;
             return ret;
         }else{
             result[0] = allow[1]+'0';
             for(i=1;i<cur.size()+1;i++){
                 result[i] = '0';
             }
             ret = result;
             return ret;
         }
     }
 }

BinarySearchable

        If a number E in vector<int> sequence is binarysearchable, it must satisfy two rules:

        -> all numbers in the left of E must < E

        -> all numbers in the right of E must > E

int BinarySearchable::howMany(vector <int> sequence)
 {
     int i,j;
     int k = 0;
     bool left =true;
     bool right = true;
     for(i=0;i<sequence.size();i++){
         left = true;
         for(j=0;j<i;j++){
             if(sequence[j]>sequence[i]){
                 left = false;
                 break;
             }
         }
         right = true;
         for(j=i+1;j<sequence.size();j++){
             if(sequence[i]>sequence[j]){
                 right = false;
                 break;
             }
         }
         if(left&&right) k++;
     }
     return k;
 }