def da_no_prob(util_mtrx,method,alpha=-1):
    try:
        method_input = ["maximax","maximin","hurwicz","laplace","savage_niehans"]
        #Definiton Maximax - Regel

        it = iter(util_mtrx)
        the_len = len(next(it))

        if not all(len(l) == the_len for l in it):
            raise TypeError

        if method not in method_input:
            raise NameError

        if method == "maximax":
            #Bildung einer Maximum Liste -> Alle max Werte in einer Liste.

            max_lst = [max(i) for i in util_mtrx]
            max_lst_lst= []
            max_max_lst = max(max_lst)
            #max_lst_lst = [ max_lst.index(i)+1 for i in max_lst if i == max_max_lst ]
            print(max_lst_lst)
            #Bildung eines leeren Dictionaries:
            dict_res_val = dict()

            dict_res_val["result"] = max_lst.index(max(max_lst))+1# index aus der Maxliste
            dict_res_val["value"] = max(max_lst)# Result ist dsa maximum aus der MaxListe

            return(dict_res_val)

        #Definition Maximin-Regel
        elif method =="maximin":
            min_lst =[min(i)for i in util_mtrx]

            #Dictionary Implementation
            #Bildung von einem leeren Dictionary
            dict_res_val = dict()
            dict_res_val["result"] = min_lst.index(max(min_lst))+1
            dict_res_val["value"] = max(min_lst)

            return(dict_res_val)


        #Definition Hurwiczs-Regel
        elif method =="hurwicz":
            if (0<=alpha<=1):
                #Bildung einer Liste aus allen Maximum Werten per List-Comprehension
                max_lst = [max(i) for i in util_mtrx]

                #Bildung einer Liste as allen Minimum Werten per List-Comprehension
                min_lst = [min(i) for i in util_mtrx]

                # Jeden Wert in der Maximum Liste mit Alpha multiplizieren per List-Comprehension
                max_alpha_lst = [i * alpha for i in max_lst]

                # Jeden Wert in der Minimum Liste mit 1-Alpha multiplizieren per List-Comprehension
                min_alpha_lst = [i * (1-alpha) for i in min_lst]

                #Vektoren berechnung der beiden Listen per List-Comprehension
                value_lst = [i+j for i,j in zip(max_alpha_lst,min_alpha_lst)]

                dict_res_val = dict()

                dict_res_val["result"] = value_lst.index(max(value_lst))+1
                dict_res_val["value"] = max(value_lst)

                return(dict_res_val)
            else:
                raise ValueError


        #Definiton LaPlace Regel
        elif method == "laplace":
            #Bildung einer Liste in der alle Durchschnittswerte / Alternative enthalten sind.
            laplace_lst = [sum(i) / len(i) for i in util_mtrx]

            #Dictionary Implementation
            #Bildung von einem leeren Dictionary
            dict_res_val = dict()

            dict_res_val["result"] = laplace_lst.index(max(laplace_lst)) +1 #array offset
            dict_res_val["value"] = max(laplace_lst)

            return(dict_res_val)
        #Definition Savage-Niehans-Regel
        elif method == "savage_niehans":

            #Zippen der util_mtrx mit um die Matrix / Liste zu rotieren -> Werte von A_i sind jetzt Listen von UE_j
            zip_lst = list(zip(*util_mtrx))

            #Ermittlung und Bildung der Maxwerte von UE_j.
            max_lst_zip = [max(i) for i in zip_lst]

            #Erstellung der Regretmatrix
            reg_mat = list()

            for i in util_mtrx:
                reg_mat_list = [abs(z-j) for j,z in zip(max_lst_zip, i)]
                reg_mat.append(reg_mat_list)

            print(reg_mat)

            #print("RegretMatrix:")
            #print(reg_mat)

            max_reg_mat = [max(i) for i in reg_mat]

            #print("MaxRegretMatrix:")
            #print(max_reg_mat)

            dict_res_val = dict()

            dict_res_val["result"] = max_reg_mat.index(min(max_reg_mat)) + 1 #arrayOffset
            dict_res_val["value"] = min(max_reg_mat)

            return(dict_res_val)


        #try:
            da_no_prob(util_mtrx,method,alpha)


    except NameError:
            print("Bitte achten Sie auf Funktionendefinition = da_no_prob(util_mtrx,method,alph")

    except TypeError:
            print("Please keep attention for function definiton")

    except ValueError:
            print("ValueError: Alpha is between 0 and 1")


print(da_no_prob([[100,10000],[5000,11000],[10000,0]],"savage_niehans",0.9))