// stack::top
#include <iostream>       // std::cout
#include <stack>          // std::stack

class Solution {
public:
    int reverse(int x) {
        int result=0;
        std::stack<int> s;
        int b;
        if(x/10>0){
            b=x%10;
            s.push(b);
            x=(x-b)/10;
        }
        int n=1;
        while(!s.empty()){
            result+=s.top()*n;
            s.pop();
            n*=10;
        }
        return result;
    }
};
int main(){
    Solution solution;
    int r;
    r=solution.reverse(123);
    std::cout<<r;
}

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        map<char,vector<int>> mymap;
        for(int i=0;i<s.size();i++){
            mymap[s[i]].push_back(i);
        }
        int maxLength=0;
        int tempLength=0;
        for(map<char,vector<int>>::iterator it=mymap.begin();it!=mymap.end();it++){
            vector<int> temp=it->second;
            for(int j=1;j<temp.size();j++){
                if((temp[j]-temp[j-1])>tempLength){
                    tempLength=temp[j]-temp[j-1];
                }
            }
            temp.empty();
            if(tempLength>maxLength)
                maxLength=tempLength;
        }
        return  maxLength;
    }
};

class Solution {
public:
    int firstMissingPositive(vector<int>& nums) {
        if(nums.size()==0)
            return 1;
        std::sort(nums.begin(),nums.end());
        int result;
        if(nums[0]>1||nums[nums.size()-1]<=0)
            return 1;
        else{
            int left=0;
            int right=nums.size()-1;
            int mid;
            while(left<right){
                mid=left+(right-left)/2;
                if(nums[mid]<0)
                    left=mid+1;
                else
                    right=mid;
            }
            int pos=left;
            int i=pos;
            if(nums[i]==0)
                i=pos+1;
            if(nums[i]>1){
                return 1;
            }
            else{
            while(nums.size()-1>i){
                if(nums[i+1]-nums[i]==1||nums[i+1]==nums[i])
                    i++;
                else{
                    result=nums[i]+1;
                    return result;
                }
            }
            result=nums[nums.size()-1]+1;
            }
        }
        return result;
    }
};

 1 class Solution {
 2 public:
 3     int maxSubArray(vector<int>& nums) {
 4         if(nums.size()==1)
 5             return nums[0];
 6         int res=maxSubSum(nums,0,nums.size()-1);
 7         return res;
 8     }
 9     int maxSubSum(vector<int>& a,int left,int right){
10         int maxLeftSum,maxRightSum;
11         int maxLeftBorderSum,maxRightBorderSum;
12         int leftBorder=0,rightBorder=0;
13         int Center,i;
14         if(left==right){
15             return a[left] ;
16         }
17         Center=(left+right)/2;
18         maxLeftSum=maxSubSum(a,left,Center);
19         maxRightSum=maxSubSum(a,Center+1,right);
20 
21         maxLeftBorderSum=a[Center];
22         for(i=Center;i>=left;i--){
23             leftBorder+=a[i];
24             if(leftBorder>maxLeftBorderSum)
25                 maxLeftBorderSum=leftBorder;
26         }
27         maxRightBorderSum=a[Center+1];
28         for(i=Center+1;i<=right;i++){
29             rightBorder+=a[i];
30             if(rightBorder>maxRightBorderSum)
31                 maxRightBorderSum=rightBorder;
32         }
33         int t=(maxLeftSum>maxRightSum)?maxLeftSum:maxRightSum;
34         int result=((maxLeftBorderSum+maxRightBorderSum)>t)?(maxRightBorderSum+maxLeftBorderSum):t;
35         return result;
36     }
37 };