Este codigo verifica si una sucesion de grados es una sucesion grafica mediante el algoritmo de Havel-Hakimi

havel-hakimi.py

"""
This function counts how many pairs degrees have the succcession list
"""
def numbers_pairs_degrees(succession_list):
    n = 0
    for degree in succession_list:
        if degree % 2 != 0:
            n += 1
    return n
    

"""
This function sums all degrees of a succession list
"""
def sum_of_degrees(succession_list):
    n = 0
    for degree in succession_list:
        n += degree
    return n


"""
This function check if a succession list satisfy the three basic property of a graphic succession list
"""
def meet_three_properties(succession_list):
    if sum_of_degrees(succession_list) % 2 == 0:
        #If sum of all degrees is a pair number
        print "La suma de los grado de  sucesion es un numero par"
        if numbers_pairs_degrees(succession_list) % 2 == 0:
            #If number of impairs degrees is pair
            print "La cantidad de grados impares es par"
            if succession_list[0] < len(succession_list):
                #If the biger degree of de list is less than the total of degrees of the list
                print "El grado mas alto de la lista es menor que la cantidad de grados de la lista"            
                return True
            else:
                print "El grado mas alto de la lista es mayor que la cantidad de grados de la lista"
                return False
        else:
            print "La cantidad de grados impares es impar"
            return False
    else:
        print "La suma de los grado de la sucesion es un numero impar"
        return False

def all_degree_zero(succession_list):
    all_zero = True
    for degree in succession_list:
        if degree != 0:
            all_zero = False
            break
    return all_zero
        
def any_negative_degree(succession_list):
    nd = False
    for degree in succession_list:
        if degree < 0:
            nd = True
            break
    return nd

def substract_1_degress_list(succession_list, k):
    for i  in range(k):
        succession_list[i]-=1


def havel_hakimi(succession_list, k=0):
    if  all_degree_zero(succession_list):
        return 0
    elif any_negative_degree(succession_list):
        return -1
    elif k==0:
        print "-------------------------------------------------------------------------------"
        print "Inicio:\t\t\t\t\t\t\t",succession_list
        k=succession_list[0]
        succession_list.pop(0)
        print "Sucesion despues de eleminar el primer elemento:\t",succession_list
        return havel_hakimi(succession_list,k)
    elif k > 0:
        print "-------------------------------------------------------------------------------"
        substract_1_degress_list(succession_list,k)
        print "Sucesion despues de la resta:\t\t\t\t",succession_list
        succession_list.sort()
        succession_list.reverse()    
        print "Sucesion despues de ordenar:\t\t\t\t",succession_list
        k=succession_list[0]
        succession_list.pop(0)
        print "Sucesion despues de eleminar el primer elemento:\t",succession_list
        return havel_hakimi(succession_list,k)
        

succession_tuple = input("Ingrese  sucesion de grados (numeros separados por comas [,]) : ")
succession_list = []
for degree in succession_tuple:
    succession_list.append(degree)

#Se organiza  lista descendientemente
succession_list.sort()
succession_list.reverse()
print "-------------------------------------------------------------------------------"

if meet_three_properties(succession_list):
    print "\nSe puede proceder a aplicar el algoritmo Havel-Hakimi\n"
    is_a_graphic_succesion = havel_hakimi(succession_list)
    if is_a_graphic_succesion == 0:
        print "\nSi es una sucesion grafica"
    else:
        print "\nNo es una sucesion grafica"
else:
    print "\nNo se puede proceder a aplicar el algoritmo Havel-Hakimi\n"