Evite TLE en Python en la programación competitiva

Razones para obtener TLE :

• Es más lento en comparación con otros lenguajes de programación.
• Ofrece entradas/salidas más lentas .
• Tiene una profundidad de recursión más baja que a menudo da TLE en problemas de recursión y gráficos .

Consejos para evitar TLE con Python :

Convertir a un enfoque iterativo :

• Cualquier problema de recursividad se puede convertir en un enfoque iterativo, así que intente utilizar el enfoque iterativo en lugar de la recursividad .
• El uso de Stack y while loop puede ahorrar el tiempo de ejecución del programa.

Programa 1:

A continuación se muestra el código que muestra el tiempo requerido para calcular el factorial de un número en ambos enfoques:

# Program to show the time taken in
# iteration and recursion
  
import time
  
# Recursive function to find factorial
# of the given number N
def factorial(N):
    
      # Base Case
    if N == 0:
        return 1
        
    # Recursive Call
    return N * factorial(N - 1)
  
# Driver Code
if __name__ == '__main__':
    n = 20
  
    # Find the time taken for the
    # recursive approach
    start = time.perf_counter()
    print("Calculated using recursion: ", factorial(n))
      
    end = time.perf_counter()
    print("Time taken in recursion: ", "{0:.9f}".format(end-start))
  
    # Find time taken for iterative
    # approach
    start = time.perf_counter()
    result = 1
      
    while n > 0:
        result *= n
        n -= 1
          
    print("Calculated using the iterative method: ", result)
      
    end = time.perf_counter()
    print("Time taken in iteration: ", "{0:.9f}".format(end-start))

Calculated using recursion:  2432902008176640000
Time taken in recursion:  0.000015925
Calculated using the iterative method:  2432902008176640000
Time taken in iteration:  0.000009279

Establecer el límite de recurrencia :

• Utilice sys.setrecursionlimit() para establecer la profundidad máxima de la pila del intérprete de Python en el valor entero necesario para el programa.
• Provocará una excepción de error de recursión si el nuevo límite es demasiado bajo en la profundidad de recursión actual.

Sintaxis: sys.setrecursionlimit(límite)

Parámetro: límite: un valor entero que se puede usar para establecer el límite de la pila del intérprete de Python.

Retorno: No devuelve nada.

Programa 2:

A continuación se muestra el programa para ilustrar el uso del método sys.setrecursionlimit() :

# Python3 program to explain the 
# sys.setrecursionlimit() method
  
import sys
  
# Print the current recursion limit
# using sys.getrecursionlimit()
print("Original recursion limit was: ")
print(sys.getrecursionlimit())
  
# Set a new recursion limit
sys.setrecursionlimit(10**6)
  
# Print the new recursion limit
print("New recursion limit is: ")
print(sys.getrecursionlimit())

Original recursion limit was: 
1000
New recursion limit is: 
1000000

Utilice siempre una entrada/salida más rápida :

La idea es usar stdin y stdout para entrada y salida rápidas . 

Programa 3:

A continuación se muestra el programa para demostrar el tiempo que tardan stdin y stdout :

# Program to show time taken in fast
# I / O and normal I / O in python
from sys import stdin, stdout
import time
  
# Function for fast I / O
def fastIO():
  
    # Stores the start time
    start = time.perf_counter()
  
    # To read single integer
    n = stdin.readline()
  
    # To input array
    arr = [int(x) for x in stdin.readline().split()]
  
    # Output integer
    stdout.write(str(n))
  
    # Output array
    stdout.write(" ".join(map(str, arr)) + "\n")
  
    # Stores the end time
    end = time.perf_counter()
    print("Time taken in fast IO", end-start)
  
# Function for normal I / O
def normalIO():
  
    # Stores the start time
    start = time.perf_counter()
  
    # Input integer
    n = int(input())
  
    # Input array
    arr = [int(x) for x in input().split()]
  
    # Output integer
    print(n)
  
    # Output array
    for i in arr:
        print(i, end =" ")
    print()
  
    # Stores the end time
    end = time.perf_counter()
    print("Time taken in normal IO: ", end-start)
  
  
# Driver Code
if __name__ == '__main__':
    fastIO()
    normalIO()

Initialising the list with list comprehension is faster

Producción:

Use PyPy2 ya que es más rápido que Python2 y Python3 :

• PyPy es una implementación alternativa de Python a CPython (que es la implementación estándar).
• PyPy a menudo se ejecuta más rápido que CPython porque PyPy es un compilador justo a tiempo, mientras que CPython es un intérprete.
• La última versión de PyPy es PyPy2.7 , que es un intérprete compatible con la sintaxis y las funciones de Python 2.7.
• PyPy 3.6 es una versión beta, PyPy2.7 debe elegirse a partir de ahora porque PyPy3 también es algo más lento que Python3.

Consejos útiles :

1. Usa colecciones . deque ya que proporciona una complejidad de tiempo O(1) para las operaciones append() y pop() en ambos extremos.
2. La comprensión de listas es más rápida que los bucles for.
3. Inicializar la lista con comprensión de lista es mejor que agregar elementos más adelante.

Programa 4:

A continuación se muestra el programa que demuestra el uso de la comprensión de listas:

# Python program to demonstrate
# use of list comprehension
  
import time
  
start = time.perf_counter()
l = []
  
# Slower
for i in range(100):
    l.append(i)
end = time.perf_counter()
t1 = end-start
  
start = time.perf_counter()
  
# Faster
m = [i for i in range(100)]
end = time.perf_counter()
t2 = end-start
  
# Comparing the time
if t2 < t1:
    print("Initialising the list with ", end ="")
    print("list comprehension is faster")

Initialising the list with list comprehension is faster