Reverse String II

Given a string and an integer k, you need to reverse the first k characters for every 2k characters counting from the start of the string. If there are less than k characters left, reverse all of them. If there are less than 2k but greater than or equal to k characters, then reverse the first k characters and left the other as original.

Example:

Input: s = "abcdefg", k = 2
Output: "bacdfeg"

Restrictions:

1. The string consists of lower English letters only.
2. Length of the given string and k will in the range [1, 10000] 

   class Solution(object):
       """
       def all_reverse(self, s):
           return s[::-1]
       def reverseStr(self, s, k):
       """
       """
       :type s: str
       :type k: int
       :rtype: str
       """
       """
           if len(s) < k:
               return self.all_reverse(s)
           i, str_list = 1, list(s)
           while(len(s) >= i*k):
               str_list[(i-1)*k : i*k] = self.all_reverse(s[(i-1)*k : i*k])
               i += 2
           
           if len(s) > (i-1)*k:
               str_list[(i-1)*k : len(s)] = self.all_reverse(s[(i-1)*k : len(s)])
               
           ans = ''.join(str_list)
           return ans
       """
       def reverseStr(self, s, k):
           s = list(s)
           for i in range(0, len(s), 2*k):
               s[i:i+k] = reversed(s[i:i+k])
           return ''.join(s)
           

   class Solution {
   public:
   /*
       string reverse_all(string& s){
           return string(s.rbegin(), s.rend());
       }
       
   //使用字符拼接 +=  该方法比下面两种方法快
       string reverseStr(string s, int k) {
           if(k >= s.size())
               return string(s.rbegin(), s.rend());
           string s1, temp;
           int i = 1, pos = 0;
           while(i*k <= s.size()){
               temp = string(s, pos, k);
               if(i%2)
                   s1 += reverse_all(temp);
               else
                   s1 += temp;
               pos += k;
               i += 1;
           }
           if(s.size() > (i-1)*k){
               temp = string(s, pos, s.size() - (i-1)*k);
               if(i%2)
                   s1 += reverse_all(temp);
               else
                   s1 += temp;
           }
           return s1;
       }
   
   //使用replace
       string reverseStr(string s, int k) {
           if(k >= s.size())
               return string(s.rbegin(), s.rend());
           string s1 = s, temp;
           int i = 1, pos = 0;
           while(i*k <= s.size()){
               temp = string(s, pos, k);
               s1.replace(pos, k, reverse_all(temp));
               pos += 2*k;
               i += 2;
           }
           if(s.size() > (i-1)*k){
               temp = string(s, pos, s.size() - (i-1)*k);
               s1.replace(pos, k, reverse_all(temp));
           }
           return s1;
       }
   
   //使用assign, insert
       string reverseStr(string s, int k){
           if(k > s.length())
               return string(s.rbegin(), s.rend());
           string s1, temp;
           int i = k, pos = 0;
           while(i < s.size()){
               temp.assign(s, pos, k);
               if((i/k)%2)
                   s1.insert(pos, string(temp.rbegin(), temp.rend()));
               else
                   s1.insert(pos, temp);
               i += k;
               pos += k;
           }
           if(s.length() > i - k){
               temp.assign(s, pos, s.size()-i+k);
               if((i/k)%2)
                   s1.insert(pos, string(temp.rbegin(), temp.rend()));
               else
                   s1.insert(pos, temp);
           }
       return s1;
       }
   
   // iterator可以直接 + i往前跳i步，同理也可以 -i，但是这样效率应该不高
   // 直接使用reverse函数
       string reverseStr(string s, int k){
           for(int i=0; i<s.size(); i+=2*k)
               reverse(s.begin() + i, min(s.begin()+i+k, s.end()));
           return s;
       }
   */
       string reverseStr(string s, int k){
           /*
           *   0----------k---------2k----------3k
           *   + reversed +          + reversed +
           */
           for(int left=0; left<s.size(); left+=2*k)
               for(int i=left, j=min(left+k-1, (int)s.size()-1); i<j; ++i, --j)
                   swap(s[i], s[j]);
           return s;
       }
   };