Imprime los nombres de los equipos en orden creciente de sus clasificaciones

Dada una array 2D de strings arr[][4] , que representa los puntajes de M partidos de fútbol jugados en un torneo que involucra a N equipos, la tarea es imprimir los nombres de los equipos en orden ascendente de sus rangos. 

• Las reglas de un partido son las siguientes:
  • Cada equipo juega 2 partidos.
  • El equipo ganador obtiene 2 puntos y el equipo perdedor 0.
  • En caso de empate, ambos equipos comparten un punto cada uno.
• Si GD, GA y GF representan diferencia de goles , goles en contra y goles a favor, respectivamente. La clasificación de un equipo se decide en el siguiente orden de prioridad:
  • Puntos > GD > GF > Orden lexicográfico de los nombres.

Ejemplos:

Entrada: arr[][] = { { “España”, “Inglaterra”, “3″, “0″ }, { “Inglaterra”, “Francia”, “1″, “1″ }, { “España”, “Francia”, “0”, “2” } }, N = 3, M = 3
Salida: Francia España Inglaterra 
Explicación:  Tabla de puntos después de 3 partidos cada uno:

equipos	Partidos Jugados	novia	Georgia	GD	Puntos	Clasificación
España	2	3	2	1	2	2
Inglaterra	2	1	4	-3	1	3
Francia	2	3	1	2	3	1

Entrada:  arr[][] = { { “España”, “Inglaterra”, “3″, “0″ }, { “Inglaterra”, “Francia”, “1″, “1″ }, { “España”, “España”, “0”, “2” } }, N = 3, M = 3
Salida: Entrada no válida

Enfoque: el problema se puede resolver clasificando un diccionario por múltiples atributos. 
Siga los pasos a continuación para resolver el problema:

• Recorra la lista arr[][] e imprima “No válido” si arr[i][0] es igual a arr[i][1] y rompa.
• Inicialice una tabla de diccionario para almacenar GA, GF y GD para un equipo en particular.
• Recorra la lista arr[][] y realice las siguientes operaciones:
  • Incremente GF para arr[i][0], table[arr[i][0]][0] por arr[i][2] y GA para arr[i][0], table[arr[i] [0]][1] por arr[i][3].
  • Incremente GF para arr[i][1] , table[arr[i][1]][0] por arr[i][3] y GA para arr[i][1] , table[arr[i] [1]][1] por arr[i][2].
  • Actualice GD para arr[i][0], table[arr[i][0]] por table[arr[i][0][2] – table[arr[i][0][3].
  • Actualice GD para arr[i][1], table[arr[i][1]] por table[arr[i][1][2] – table[arr[i][1][3].
  • Si arr[i][2] == arr[i][3], entonces incremente table[arr[i][0][0] y table[arr[i][1]][0] ambos en 1 .
  • Si arr[i][2] > arr[i][3], entonces incremente table[arr[i][0][0] en 2 .
  • Si arr[i][2] < arr[i][3], entonces incremente table[arr[i][1][0] en 2 .
• Ahora, ordene la tabla del diccionario según los puntos de prioridad > GD > GF y nombres como:
  • tabla = ordenado(tabla.elements(), clave=lambda r: (-r[1][0], -r[1][1], -r[1][2], r[0]))
• Finalmente, imprima los nombres de los equipos en una tabla ordenada.

A continuación se muestra la implementación del enfoque anterior:

# Python program for the above approach
 
# Function to find the ranking of teams
def RankTeams(arr):
 
    # Traverse the list arr
    for i in range(len(arr)):
       
        # arr[i][0] is equal to arr[i][1]
        if(arr[i][0] == arr[i][1]):
            print("Invalid")
            return
           
        # Convert the goal to integer
        arr[i][2] = int(arr[i][2])
        arr[i][3] = int(arr[i][3])
 
    # Stores the list of GD, GA, and GF
    table = {}
     
    # Traverse the list
    for i in range(len(arr)):
       
        # Store the list of GA, GF
        # and GD of first team
        li1 = [0] * 4
         
        # Store the list of GA, GF
        # and GD of second team
        li2 = [0] * 4
 
        # If arr[i][0] is in table
        if arr[i][0] in table:
            li1 = table[arr[i][0]]
             
        # If arr[i][1] is in table
        if arr[i][1] in table:
            li2 = table[arr[i][1]]
 
        # Increment GF by arr[i][2]
        li1[2] += arr[i][2]
         
        # Increment GA by arr[i][3]
        li1[3] += arr[i][3]
 
        # Increment GF by arr[i][3]
        li2[2] += arr[i][3]
         
        # Increment GA by arr[i][2]
        li2[3] += arr[i][2]
 
        # Update GD
        li1[1] = li1[2] - li1[3]
        li2[1] = li2[2] - li2[3]
 
        # If tie
        if(arr[i][2] == arr[i][3]):
            li1[0] += 1
            li2[0] += 1
 
        # If arr[i][0] wins
        elif(arr[i][2] > arr[i][3]):
            li1[0] += 2
 
        # If arr[i][1] wins
        elif(arr[i][2] < arr[i][3]):
            li2[0] += 2
 
        # Update list in table
        table[arr[i][0]] = li1
        table[arr[i][1]] = li2
 
    # Traverse the sorted table in the given priority
    for key, value in sorted(table.items(),
                             key = lambda r: (-r[1][0],
                                            -r[1][1],
                                            -r[1][2],
                                            r[0])):
        # Print the team name
        print(key, end ='\n')
 
 
# Driver Code
 
# Input
arr = [['Spain', 'England', '3', '0'],
       ['England', 'France', '1', '1'],
       ['Spain', 'France', '0', '2']]
 
RankTeams(arr)

France
Spain
England

Complejidad de tiempo: O(N * log(N))
Espacio auxiliar: O(N)