Mejoramiento

Optimización

> Tutorial de LeekScript

Aquí hablaremos de optimización, el objetivo de la optimización es mejorar el rendimiento de un algoritmo. En general, cuando hablamos de optimización, hablamos de tiempo de ejecución, siendo el objetivo reducir el tiempo necesario para ejecutar una serie de instrucciones.

En LeekScript, este tiempo de ejecución se estima mediante un número: el número de operaciones utilizadas por este cálculo. Vamos a hablar, por tanto, de ciertas buenas prácticas y buenos reflejos para optimizar un programa, sea del lenguaje que sea, así como de ciertas optimizaciones más propias de LeekScript, e íntimamente ligadas a la forma en que se contabilizan las operaciones.

Si aún no lo has hecho, te invito a leer el artículo sobre Tutorial_LeekScript: Operaciones.

Buenos reflejos

• No optimice antes de tener un código que funcione: De hecho, hay muchas posibilidades de que el código que escribimos solo se llame una vez por turno, lo que significa que el tiempo dedicado a optimizar el código no tendrá un efecto notable en el consumo total de las operaciones.

Por ejemplo, guardar 500 operaciones en una función llamada solo una vez solo guardará 500 operaciones. (lógica) Por otro lado, un ahorro de una sola operación, sobre una función que se llama en un bucle de bucle de bucle puede reducir el coste en operaciones de varias decenas de miles de operaciones.

Lo que me lleva al segundo punto:

• identificar donde es caro!

La mitad del trabajo de optimizar un código consiste simplemente en buscar de dónde salen las operaciones (entonces hay que gritar fuerte y decirles que vuelvan). ¿Qué es caro en el código?

Para eso, ningún secreto, ¡mediremos!

En nuestro arsenal, LeekScript proporciona una función que resultará muy útil: getOperations. esta función permite saber el número de operaciones gastadas hasta ahora en el código.

Ejemplo de una herramienta simple para medir el costo de una función:

__operación_depuración global; función inicioOp(){ __operación_depuración = obtenerOperaciones(); } función stopOp(título){ let ops = getOperations()-__debug_operation - 3; debug("Operaciones (" + titulo + "): " + ops); }

inicioOp(); stopOp("prueba vacía"); // prueba vacía: 0

inicioOp(); decir("hola mundo"); stopOp("hola mundo"); // hola mundo: 30

Así podemos confirmar que decir cuesta 30 operaciones, tal y como anuncia la documentación.

Es posible, y te recomiendo encarecidamente que hagas herramientas para medir otras cosas en tu IA, como el número de llamadas a una función, así como su costo promedio por ejemplo, que medirá mejor la evolución de los costos en tu IA. y el impacto de ciertas optimizaciones.

La página Complejidad lo ayudará a comprender por qué un algoritmo es costoso y cómo resolver el problema. En resumen, preferimos evitar en la medida de lo posible anidar bucles entre ellos. También buscaremos limitar el tamaño de nuestros bucles, por ejemplo navegando solo por nuestras celdas accesibles en lugar de navegar por todas las celdas del mapa.

Eliminando bucles que no cambiarán

Imagina el siguiente código:

let TP = getTP();

// ¡Dispara tantas veces como puedas al enemigo! for (var i = 0; i < piso(TP / getWeaponCost(getWeapon())); i++) { useWeapon(getNearestEnemy()); }

La función getNearestEnemy se llamará en cada iteración del bucle, ¡mientras que siempre devolverá el mismo resultado! Para evitar esto, simplemente coloque el resultado en una variable antes de la función. Hacemos lo mismo para floor(TP / getWeaponCost(getWeapon())) que también se evalúa en cada iteración. que dan:

let TP = getTP();

// ¡Dispara tantas veces como puedas al enemigo! var enemigo = getNearestEnemy(); var nbShots = piso(TP / getWeaponCost(getWeapon())); // número de disparos posibles con el arma actual for (var i = 0; i < nbDisparos; i++) { useWeapon(enemigo); }

Características de Leek Wars que son caras

inArray, el inArray es práctico, hace lo que queremos, pero implica un costo importante en operaciones que no necesariamente notamos a primera vista. De hecho, por dentro se ve así:

función enArray(elemento, array){ para (valor var en la matriz) si (valor == elemento) devolver verdadero; falso retorno; }

Este ejemplo es una buena ilustración para hablar de un poco de complejidad. Vemos aquí que el coste real de esta función depende en el peor de los casos del tamaño del array array, al que llamaremos n*. Por tanto, esta función tiene una complejidad de *n, es decir, requerirá hasta n operaciones para encontrar el resultado.

Al usar una tabla asociativa (Mapa), y en c