Write a function that takes a string as input and returns the string reversed.

Example:
Given s = "hello", return "olleh".

class Solution(object):

    def reverseString(self, s):

        """

        :type s: str

        :rtype: str

        """

        return s[::-1]

    # easy

541. 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 reverseStr(self, s, k):

        """

        :type s: str

        :type k: int

        :rtype: str

        """

        n_s = ""

        i = 0

        while(i<len(s)):

            n_s = n_s + s[i:i+k][::-1] + s[i+k:i+2*k]

            i+=2*k

        return n_s

        # range(length) or range(start,end,step), while range(length,step) does not exist

657. Judge Route Circle

Initially, there is a Robot at position (0, 0). Given a sequence of its moves, judge if this robot makes a circle, which means it moves back to the original place.

The move sequence is represented by a string. And each move is represent by a character. The valid robot moves are R (Right), L (Left), U (Up) and D (down). The output should be true or false representing whether the robot makes a circle.

Example 1:

Input: "UD"

Output: true

Example 2:

Input: "LL"

Output: false

class Solution(object):

    def judgeCircle(self, moves):

        """

        :type moves: str

        :rtype: bool

        """

        moveDic = {'L':0,'R':0,'U':0,'D':0}

        for i in moves:

            moveDic[i] += 1

        if moveDic['L']==moveDic['R'] and moveDic['U']==moveDic['D']:

            return True

        else:

            return False

696. Count Binary Substrings

Give a string s, count the number of non-empty (contiguous) substrings that have the same number of 0's and 1's, and all the 0's and all the 1's in these substrings are grouped consecutively.

Substrings that occur multiple times are counted the number of times they occur.

Example 1:

Input: "00110011"

Output: 6

Explanation: There are 6 substrings that have equal number of consecutive 1's and 0's: "0011", "01", "1100", "10", "0011", and "01".


Notice that some of these substrings repeat and are counted the number of times they occur.


Also, "00110011" is not a valid substring because all the 0's (and 1's) are not grouped together.

Example 2:

Input: "10101"

Output: 4

Explanation: There are 4 substrings: "10", "01", "10", "01" that have equal number of consecutive 1's and 0's.

Note:

• s.length will be between 1 and 50,000.
• s will only consist of "0" or "1" characters.

class Solution(object):

    def countBinarySubstrings(self, s):

        """

        :type s: str

        :rtype: int

        """

        counts = map(len, s.replace('01','0 1').replace('10','1 0').split())

        return sum(map(min, zip(counts, counts[1:])))

    # briliant idea

    # string.replace('','')

    # zip() can zip elements of two iterable into a list of tuple elementwisely