Acorta tu ciclo infinito
Cuando tiene que usar un bucle infinito, puede pensar en usar a while, pero usar una etiqueta en su lugar es más corto en 2 bytes:
while''do end
::a::goto a
Usa el menor espacio posible
Hay una cosa simple que podría (ab) usar para eliminar aún más espacios de su código. Las especificaciones de Lua son claras sobre el nombre que le das a las variables: tienen que comenzar con una letra. Implica que, a veces, puede omitir espacios entre números y funciones / variables
x=0>1 and 0or 1print(x)
La posibilidad de eliminar el espacio depende de la letra que sigue al número, aquí está la letra que no le permitirá hacer esto:
a,b,c,d,e,f -- They would be interpreted as hexadecimal
x -- only fail when after a 0, other number are fine
-- (0x indicates the following is an hexadecimal number)
Al usar esto y prestar atención a cómo llama a sus variables, puede hacer que la mayoría de sus códigos fuente estén libres de espacio.
Tomando un ejemplo que ya está aquí, y siguiendo este consejo, aquí hay un byte más que podría eliminar :).
print(a and-1 or-2)
print(a and-1or-2)
Use el método de entrada correcto
Si observamos el estándar y el costo de cada tipo principal de entrada, esto es lo que tenemos:
function f(x)x end
io.read()
arg[1]
Cada uno de este método nos permite tomar 1 entrada, siendo la función la que tiene el costo más alto (pero nos permite tomar una tabla como entrada)
Ahora podemos ver que usar el argumento de la línea de comandos es el camino a seguir si desea jugar al golf, pero tenga en cuenta: puede ser aún más corto
arg[1]
...
El ...son un poco especial en Lua, que es una variable que contiene el contenido descomprimido del argo los parámetros descomprimidos en caso de una función variadic.
Cuando tenga que obtener más de una entrada y usar cada una de ellas, puede ser bueno guardarlas en una variable. Aquí hay algunas formas de guardar 2 entradas en variables
a=arg[1]b=arg[2] -- highly un-efficient, costs 8 bytes by variable
a,b=unpack(arg) -- costs 15, but at least doesn't depends on the number of argument
a,b=... -- only costs 7
y aquí están las llamadas más cortas que podrías haber hecho sin las variables:
... -- using a allow a gain of 1-2 bytes at each use
arg[2] -- using b allow a gain of 4-5 bytes at each use
Desde el punto donde tiene 3 argumentos, o cuando usa 2 argumentos, con uno usado dos veces, ¡ya está ganando bytes debido a a,b=...! :)
Casi nunca uso si!
Casi no hay casos en los que el uso de una declaración if / elseif / if cueste menos que un ternario. La base para tal afirmación es realmente pesada:
-- exemple with dumb values
if 1>0then v=1 else v=0 end
v=1>0 and 1or 0
Con un ejemplo simple, ya guarda 12 bytes, cuando tiene que hacer otras cosas, se vuelve cada vez más importante, ¡así que tenga en cuenta eso!
Además, los ternaries en lua son especiales , hay alguna condición en su funcionamiento, para los interesados, lo explicaré a continuación:
Los ternarios en lua son de la forma <condition> and <case true: have to be a true value> or <case false: can be anything>
En primer lugar, veamos la tabla de verdad de or. A orse puede considerar como una función: siempre devuelve un valor, aquí está el valor que devuelve:
x | y ||x or y
------||-------
0 | 0 || y
0 | 1 || y
1 | 0 || x
1 | 1 || x
Eso es lo que nos permite construir nuestro ternario.
El andes lo que nos permitirá evaluar la condición, siempre devolverá ysi x and yse evalúa como TRUE.
El problema con esto es que fallará si queremos que se devuelva un nilo falsecuando la condición sea false. Por ejemplo, lo siguiente siempre devolverá 5, a pesar de que la condición sea verdadera.
v = true and false or 5
Aquí hay una evaluación paso a paso de un ternario para explicar cómo funciona (será útil para cuando tenga que anidarlos :))
-- let's use our dumb ternary
= true and false or 5
-- and statement will be evaluated first, leading to
= false or 5
-- and we saw how the or works
= 5