3_sum_closest

class Solution:
    """
    @param numbers: Give an array numbers of n integer
    @param target: An integer
    @return: return the sum of the three integers, the sum closest target.
    """

    def threeSumClosest(self, number, target):
        # write your code here
        if len(number) == 3:
            return sum(number)
        number.sort()
        counter = 0
        i = 0
        while i < len(number) - 1:
            if number[i] == number[i + 1]:
                if counter < 3:
                    counter += 1
                    i += 1
                else:
                    number.pop(i)
            else:
                counter = 0
                i += 1
        diff = [2 ** 31, 0]
        for i in range(len(number) - 2):
            summation = number[i] + number[i + 1] + number[i + 2]
            if summation > target:
                min_R = i  # return bigger number
                break
            elif summation == target:
                return target
            if i == len(number) - 3:
                return number[len(number) - 3] + number[len(number) - 2] + number[len(number) - 1]
        max_L = min_R
        min_R = min_R + 2
        if min_R > 2:
            min_R -= 1
        min_in_law = number[0] + number[1]
        max_in_law = number[len(number) - 2] + number[len(number) - 1]
        max_R = min_R
        min_L = max_L
        for r in range(len(number) - 1, min_R - 1, -1):
            if number[r] + min_in_law < target:
                if r < len(number) - 1:
                    max_R = r + 1
                else:
                    max_R = r
                break
            elif number[r] + min_in_law == target:
                return target
        for l in range(0, max_L + 1):
            if number[l] + max_in_law > target:
                if l > 0:
                    min_L = l - 1
                else:
                    min_L = l
                break
            elif number[l] + max_in_law == target:
                return target
        for leftmost in range(min_L, max_L + 1):
            tempminR = 0
            tnumber = number[min_L:]
            for i in range(len(number) - 1):
                summation = tnumber[i] + tnumber[i + 1] + tnumber[i + 2]
                if summation > target:
                    tempminR = i + 2  # return bigger number
                    break
                elif summation == target:
                    return target
                if i == len(tnumber) - 3:
                    tempminR = i + 2
            if tempminR > 1:
                tempminR -= 1
            for rightmost in range(max(min_R, leftmost + 2, tempminR + min_L), max_R + 1):
                temptarget = target - number[rightmost] - number[leftmost]
                for m in range(leftmost + 1, rightmost):
                    if abs(temptarget - number[m]) < diff[0]:
                        diff[0] = abs(temptarget - number[m])
                        diff[1] = number[m] + number[rightmost] + number[leftmost]
        return diff[1]