#include <stdio.h>
#include <string.h>

int MaxSum(int* a,int n)
{
     int i=0;
    int initSum=a[0];
    int aSum=0;
    for(i=0;i<n;i++){
        aSum=aSum+a[i];
        if(aSum<0 && i != n-1){
            aSum=a[i+1];
            i++;
        }
        if(aSum>initSum){
            initSum=aSum;
        }
    }
  return initSum;
}
//start 提示：本行为自动阅卷起始唯一标识，请勿删除或增加。
//完成下面main函数，自行测试下
int main()
{   
    //wirte your code here;
int a[]={1,-2,3,10,-4,7,2,-5};
    printf("%d",sumMax(a,8));
    return 0;  
} 
//end   提示：本行为自动阅卷结束唯一标识，请勿删除或增加。

   from collections import deque

    queue = deque([1, 2]) 
    queue.append('last')

    self.assertEqual([1,2,'last'], list(queue))

    popped_value = queue.popleft()
    self.assertEqual(1, popped_value)
    self.assertEqual([2,'last'], list(queue))

    cards = {}.fromkeys(
        ('red warrior', 'green elf', 'blue valkyrie', 'yellow dwarf',
         'confused looking zebra'),
        42)

    value1 = 'one'
    value2 = 2
    string = "The values are {0} and {1}".format(value1, value2)
    self.assertEqual("The values are one and 2", string)

    decimal_places = 4
    string = "The square root of 5 is {0:.{1}f}".format(math.sqrt(5), \
        decimal_places)
    self.assertEqual('The square root of 5 is 2.2361', string)

    string = "the,rain;in,spain"
    pattern = re.compile(',|;')

    words = pattern.split(string)

   string = r'\n'

    self.assertEqual("Guido", 'guido'.capitalize())

    self.assertEqual("Guido Van Rossum", 'guido van rossum'.title())

self.assertEqual((), tuple())  # Sometimes less confusing
self.assertEqual(("S","u","r","p","r","i","s","e","!"), tuple("Surprise!"))

    def _tail(self):
        # Prefixing a method with an underscore implies private scope
        return "wagging"

    def __password(self):
        return 'password'  # Genius!


    # But this still is!
    self.assertEqual(__, rover._Dog__password())

    scotsmen = set(['MacLeod', 'Wallace', 'Willie'])
    warriors = set(['MacLeod', 'Wallace', 'Leonidas'])

    self.assertEqual(set(["Willie"]), scotsmen - warriors)
    self.assertEqual(set(['MacLeod','Wallace','Willie','Leonidas']), scotsmen | warriors)
    self.assertEqual(set(['MacLeod','Wallace']), scotsmen & warriors)
    self.assertEqual(set(['Willie','Leonidas']), scotsmen ^ warriors)

def test_we_can_compare_subsets(self):
    self.assertEqual(True, set('cake') <= set('cherry cake'))
    self.assertEqual(True, set('cake').issubset(set('cherry cake')))

    self.assertEqual(False, set('cake') > set('pie'))

def test_generator_expressions_are_a_one_shot_deal(self):
    dynamite = ('Boom!' for n in range(3))

    attempt1 = list(dynamite)
    attempt2 = list(dynamite)

    self.assertEqual(['Boom!','Boom!','Boom!'], list(attempt1))
    self.assertEqual([], list(attempt2))

def generator_with_coroutine(self):
    result = yield
    yield result

def test_generators_can_take_coroutines(self):
    generator = self.generator_with_coroutine()

    # THINK ABOUT IT:
    # Why is this line necessary?
    #
    # Hint: Read the "Specification: Sending Values into Generators"
    #       section of http://www.python.org/dev/peps/pep-0342/
    next(generator)

    self.assertEqual(__, generator.send(1 + 2)) 

def test_you_can_also_access_the_value_out_using_getattr_and_dict(self):
self.assertEqual('Fido', fido.__dict__["_name"])

class Dog4(object):
    def __init__(self):
        self._name = None

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, a_name):
        self._name = a_name

def test_args_must_match_init(self):
        self.assertRaises(TypeError, self.Dog5)  # Evaluates self.Dog5()

class MyInt(int):
    pass

def test_subclasses_of_built_in_classes_can_be_be_monkey_patched(self):
    self.MyInt.is_even = lambda self: (self % 2) == 0

#               Animal
#              /     \
#            Pig   Spider  Nameable
#              \      |      /
#                 Spiderpig

    mro = type(self.Spiderpig()).__mro__
    self.assertEqual('Spiderpig', mro[0].__name__)
    self.assertEqual('Pig', mro[1].__name__)
    self.assertEqual('Spider', mro[2].__name__)
    self.assertEqual('Animal', mro[3].__name__)
    self.assertEqual('Nameable', mro[4].__name__)
    self.assertEqual('object', mro[5].__name__)

    def __init__(self):
        self._name = None

    def get_name_from_instance(self):
        return self._name

    def set_name_from_instance(self, name):
        self._name = name

    @classmethod
    def get_name(cls):
        return cls._name

    @classmethod
    def set_name(cls, name):
        cls._name = name


    self.assertEqual("Fido", fido.get_name_from_instance())
    self.assertEqual("Rover", self.Dog3.get_name())

def test_classes_and_instances_do_not_share_instance_attributes(self):
    fido = self.Dog3()
    fido.set_name_from_instance("Fido")
    fido.set_name("Rover")
    self.assertEqual("Fido", fido.get_name_from_instance())
    self.assertEqual("Rover", self.Dog3.get_name())

def test_classes_and_instances_do_share_class_attributes(self):
    fido = self.Dog3()
    fido.set_name("Fido")
    self.assertEqual("Fido", fido.get_name())
    self.assertEqual(__, self.Dog3.get_name())

class MinimalCatcher(object):
    class DuffObject(object):
        pass

    def __init__(self):
        self.no_of_getattr_calls = 0

    def __getattr__(self, attr_name):
        self.no_of_getattr_calls += 1
        return self.DuffObject

    def my_method(self):
        pass

    def __delattr__(self, attr_name):
        self.last_deletion = attr_name
    del sale.jellies
    self.assertEqual("jellies", sale.last_deletion)

A. 红黑树
B. B树
C. AVL树
D. B+树