El objetivo de esta publicación es reunir todos los consejos de golf que se pueden aplicar fácilmente en <all languages>lugar de uno específico.

Solo publique respuestas de que su lógica se puede aplicar a la mayoría de los idiomas

Por favor, un consejo por respuesta

Fusionar bucles

Por lo general, puede fusionar dos bucles consecuentes, o dos bucles anidados, en uno.

Antes de:

for (i=0; i<a; i++) foo();
for (i=0; i<b; i++) bar();

Después:

for (i=0; i<a+b; i++) i<a?foo():bar();

Solo por mencionar lo obvio:

Cuestione su elección de algoritmo e intente algo completamente nuevo.

Al jugar al golf (especialmente problemas más difíciles que resultan en programas más largos) con demasiada frecuencia, puede seguir el camino que eligió por primera vez sin probar otras opciones fundamentales . Por supuesto, puede micro golf una o unas pocas líneas a la vez o una parte de la idea general, pero a menudo no intenta una solución totalmente diferente.

Esto fue especialmente notable en Hitting 495 (Kaprekar) donde desviarse del algoritmo real y buscar patrones que puede aplicar para obtener el mismo resultado fue más corto en muchos idiomas (simplemente no J).

La desventaja es que posiblemente resuelves lo mismo media docena de veces. Pero funciona en todos los idiomas, excepto HQ9 + (donde encontrar otra forma de generar Hello World sería un poco inútil).

Utilice el desarrollo basado en pruebas

Si el código debe manejar varias entradas, escriba pruebas exhaustivas y facilite ejecutarlas todas muy rápidamente. Esto le permite probar transformaciones arriesgadas paso a paso. El golf se convierte en una refactorización con intención perversa.

Intenta reducir las declaraciones lógicas

Por ejemplo, si Ay Bson booleanos y su idioma trata los booleanos como números en cierta medida, A and (not B)y A>Bson equivalentes. Por ejemplo en Python

if A and not B:
    foo()

es lo mismo que:

if A>B:
    foo()

Inicialice variables usando valores que ya tiene.

En lugar de x=1, intente buscar algo que ya sea igual a 1.
Por ejemplo, el valor de retorno de una función: printf("..");x=0;-> x=!printf("..");. Es más fácil con 0, porque siempre puedes negarlo, o cuando todo lo que necesitas es el valor de verdad correcto (y no te importa si es 1 o 19).

Use unary ~para x+1yx-1

Este truco se aplica a los idiomas que tienen un operador de negación bit a bit unario ~y un operador de negación regular unario -.

Si su programa, por casualidad, contiene la expresión -x-1, puede reemplazarlo ~xpara guardar bytes. Esto no ocurre con demasiada frecuencia, pero observe lo que sucede si negamos ( -) ambas expresiones: ¡ x+1igual -~x! Del mismo modo, x-1es igual ~-x. (Piense en qué dirección apunta la tilde: derecha es +, izquierda es -).

Esto es útil, porque en todos los idiomas que puedo pensar que tienen estos operadores, tienen mayor prioridad que la mayoría de los operadores. Esto le permite ahorrar entre paréntesis. Mira cómo ahorramos cuatro bytes aquí:

(x+1)*(y-1)     ==>    -~x*~-y

Exprimir espacios en blanco

Conozca las reglas para espacios en blanco en su idioma. Es posible que algunos signos de puntuación u otros caracteres no necesiten espacios en blanco circundantes. Considere esta función de shell Bourne :

f () { echo a; echo b; }

En Bourne shell, ();son metacaracteres y no necesitan espacios en blanco circundantes. Sin embargo, {}son palabras y necesitan espacios en blanco a menos que estén al lado de metacaracteres. Podemos jugar al golf 4 espacios al lado ();, pero debemos mantener el espacio entre {y echo.

f(){ echo a;echo b;}

En Common Lisp y PicoLisp , ()son metacaracteres. Considere este código para encontrar el promedio de dos números:

(/ (+ a b) 2)

Podemos jugar al golf 2 espacios.

(/(+ a b)2)

Algunos idiomas tienen reglas extrañas y sutiles para los espacios en blanco. Considere este programa Ruby, que imprime la suma y el producto de una línea de enteros.

#!ruby -an
i=$F.map &:to_i
puts"#{i.reduce &:+} #{i.reduce &:*}"

Cada uno &necesita un espacio antes de sí mismo. En Ruby, i=$F.map &:to_isignifica i=$F.map(&:to_i)donde &pasa un parámetro de bloque. Pero, i=$F.map&:to_isignifica i=$F.map.&(:to_i)donde& está un operador binario.

Esta rareza ocurre en idiomas, como Perl o Ruby, que usan signos de puntuación ambiguos. Si tiene dudas, use un REPL o escriba programas cortos para probar las reglas de espacios en blanco.

asignar funciones a nuevos nombres si se usan varias veces

x = SomeLongFunctionName
x(somedata)
x(somemoredata)
etc

Nombres de variables de una letra

Tienes 52 de ellos; úsalos todos! No tenga miedo de probar diferentes enfoques y comparar longitudes. Conozca el idioma y los accesos directos específicos / funciones de biblioteca disponibles.

Usa el operador condicional.

Un operador condicional

bool ? condition_true : condition_false

es más beneficioso, en cuanto al carácter, que una declaración IF .

if(a>b){r=a;}else{r=b;}

Se puede escribir como

r=a>b?a:b;

Escribe una explicación de tu código

Escribir una explicación te obliga a mirar a fondo cada parte de tu código nuevamente y a hacer explícitos tus pensamientos y elecciones al escribir cierto pasaje. Al hacerlo, puede encontrar que son posibles diferentes enfoques que pueden ahorrar algunos bytes, o que inconscientemente hizo suposiciones que no necesariamente son válidas.

Este consejo es similar a Cuestionar el algoritmo de su elección y probar algo completamente nuevo ; Sin embargo, he descubierto que el paso de escribir realmente cómo se supone que funciona cada parte es a veces crucial para tomar conciencia de las alternativas.

Como beneficio adicional, las respuestas que incluyen una explicación son más interesantes para otros usuarios y, por lo tanto, es más probable que se voten positivamente.

Comprueba tu cuenta de personaje

Suena como una obviedad, pero al tener cuidado, ¡podrías "salvar" a algunos personajes al no hacer nada!

Si está utilizando Windows, puede estar ingresando en \r\nlugar de solo \ro \ncuando presiona Retorno, ¡agregando un byte adicional por línea! Gire los caracteres de control solo para verificar que no está haciendo esto.

En Notepad ++ puede convertir todas las \r\nterminaciones de línea simplemente \ryendo aEdit > EOL Conversion > UNIX/OSX Format .

¡También asegúrate de no incluir ningún espacio en blanco al final de tu cuenta de personaje! El avance de línea en la línea inferior de su código también es intrascendente, por lo que tampoco será necesario contarlo.

Lee la pregunta detenidamente

El golf de código se trata tanto de entender la pregunta (qué se pregunta y qué no) pregunta, aunque esté implícito en cualquier otro entorno) como producir código que (puede) solo satisfaga lo que se pregunta.

No es necesario manejar ninguna entrada que no sea la que se solicita explícitamente. Si hay algunos casos de prueba y ningún requisito genérico, su código solo puede funcionar en esos casos. Etc.

Use operaciones bit a bit para verificar números entre 0 y 2 ⁿ -1

Puede ser un caso marginal, pero a veces puede ser útil. Se basa en el hecho de que todos los números a los que se aplica m = 2 ⁿ -1 tienen los n bits más a la derecha establecidos en 1.

Entonces, 7 ₁₀ == 00000111 ₂ , 15 ₁₀ == 00001111 ₂ , 31 ₁₀ == 00011111 ₂ y así sucesivamente.

El truco es x&~m. Esto devolverá verdadero siempre xque no esté entre 0 e m(inclusive), y falso de lo contrario. Ahorra 6 bytes de la siguiente expresión equivalente más corta: x>=0&&x<=mpero obviamente solo funciona cuando mcumple 2 ⁿ -1.

Reutilice parámetros de función en lugar de nuevas variables

Mayor / menor que para guardar un dígito:

//use:
if(n>9){A}else{B}
//instead of:
if(n<10){B}else{A}

¡Solo recuerde cambiar el código de ifa elsey ellos harán exactamente lo mismo (o cambiarán los lados de la desigualdad)!

Nota: esto se puede aplicar con cualquier potencia de 10 y sus negativos:...-100, -10, 10, 100...

(enlace fuente)

Use> y <en lugar de> = y <=

Al comparar con valores enteros codificados, use >y en <lugar de >=y <=donde sea posible. Por ejemplo, usando

if(x>24&&x<51)

Es 2 bytes más corto que usar

if(x>=25&&x<=50)

Evite las interrupciones prematuras del bucle

Si se ejecuta a través de un bucle para verificar 1 o más instancias de una verificación booleana, podría hacer que un programa más eficiente salga del bucle en el primer valor verdadero. Sin embargo, eliminar la ruptura y recorrer todas las iteraciones permite un código más corto.

int main() {
bool m = false;
int n = 1000;
for (int i = 0; i < n; i++) {
if (i >= 100) {
m = true;
break; // remove this line
}
} 
return 0;
}

utilizar - lugar de!=

para comparaciones numéricas:

Si a es igual a b, a-bresulta en 0, lo cual es falso. Cualquier otra cosa que no 0sea ​​la verdad; así que
si se usa en un contexto booleano, a-b<=>a!=b

Si lo usa con if/elseo con el operador ternario, esto también puede ahorrarle un byte para la igualdad:
a==b?c:d<=>a-b?d:c

Cadenas divididas para matrices largas

La mayoría de los idiomas tienen una forma de dividir una cadena en una serie de cadenas alrededor de un token de algún tipo. Esto inevitablemente será más corto que un literal de matriz una vez que la longitud alcance un umbral dependiente del idioma, porque la sobrecarga adicional por cadena será una copia de un token de un carácter en lugar de (al menos) dos delimitadores de cadena.

Ej. En GolfScript

["Foo""Bar""Baz""Quux"]  # 23 chars

se convierte

"Foo
Bar
Baz
Quux"n/  # 20 chars

Para algunos idiomas, el umbral es tan bajo como una cadena. Por ejemplo, en Java,

new String[]{"Foo"}  // 19 chars

se convierte

"Foo".split("~")  // 16 chars

Comprende lo que otras personas hicieron

Además de ser divertido, si examina el código de otras personas, a veces puede descubrir un buen algoritmo en el que no pensó, o un truco (a veces obvio) que pasa por alto.

A veces hay una respuesta existente que puede traducir a otro idioma y beneficiarse de los beneficios del otro idioma.

conozca su precedencia de operador

Siempre que combine varias expresiones, verifique la tabla de precedencia de operadores para su idioma para ver si puede reordenar cosas para guardar paréntesis.

Ejemplos:

• En todos los idiomas que conozco, los operadores bit a bit tienen una precedencia más alta que los operadores booleanos: (a&b)&&cno necesita paréntesis: a&b&&cal igual (a*b)+cque no.
• a+(b<<c)puede reescribirse como a+b*2**c.
  Eso no guarda nada para este ejemplo, pero lo hará si ces un literal entero pequeño (<14).
• Las operaciones bit a bit tienen una precedencia más baja que la mayoría de las operaciones aritméticas, por lo que si su lenguaje convierte implícitamente boolean a int, puede guardar un byte a<b&&c<dcon a<b&c<d(a menos que necesite la evaluación de cortocircuito)

For-loop más cortos

Si tiene Xdeclaraciones {dentro de }su ciclo for, puede mover las X-1declaraciones (dentro )del ciclo for después del segundo punto for(blah;blah;HERE)y coma para guardar 3 bytes. (separe las declaraciones usando una coma, )

En lugar de

for(int i=0;i<9;){s+=s.length();println(i++);}

puede mover una de las declaraciones a las (llaves del ciclo for )mientras deja la otra fuera

for(int i=0;i<9;println(i++))s+=s.length();

y ahorre 3 bytes (ahorró 1 byte más gracias a @ETHProductions)

En pocas palabras,

en lugar de

for(blah;blah;){blah 1;blah 2;...;blah X}

mueve las declaraciones para que termines con esto

for(blah;blah;blah 2,...,blah X)blah 1;

y guardar 3 bytes

Use unary ~para a-b-1ya+b+1

Además de las sugerencias de @Lynn con respecto a x+1→ -~x; y x-1→~-x , también puedes jugar al golf a-b-1y a+b+1.

a-b-1    // 5 bytes
a+~b     // 4 bytes

a+b+1    // 5 bytes
a-~b     // 4 bytes

Puede parecer un consejo que no usará con tanta frecuencia, algo así como usarlo en ~xlugar de -x-1no suceder con frecuencia, pero lo he usado suficientes veces para verlo como un consejo útil aquí. Especialmente con la indexación de matrices, puede usar estos anteriores en algunos casos.

Comprimir o / y rayas

Truco simple que se me ocurrió al tratar de exprimir una larga racha de condiciones encadenadas por ands (o ors, en este caso simplemente sustituya 'all' por 'any').

P.ej:

if a>0 and a<10 and a+b==4 and a+3<1:

Se convierte

if all([a>0,a<10,a+b==4,a+3<1]):

Confíe en el compilador para proporcionar el rendimiento requerido.

Asegúrese de saber qué optimizaciones están garantizadas por el compilador y en qué niveles de optimización, y úselas generosamente. E incluso si el rendimiento no es un requisito de preocupación , aún puede probar con optimizaciones activadas y luego solo descontar un carácter porque su código aún es técnicamente válido sin el indicador del compilador.

Considere la siguiente función de Haskell para calcular 2 ^ n (ignorando el hecho de que Haskell ya tiene un operador de exponenciación incorporado o tres) (23 caracteres):

p 0=1;p x=p(x-1)+p(x-1)

El problema es que es terriblemente lento, se ejecuta en tiempo exponencial. Esto puede hacer que su código no sea comprobable o que falle cualquier restricción de rendimiento dada por la pregunta. Es posible que tenga la tentación de utilizar una variable temporal o un literal de función invocado inmediatamente para evitar llamadas repetidas a funciones (25 caracteres):

p 0=1;p x=(\y->y+y)$p$x-1

Pero el compilador ya puede hacer eso por usted, ¡solo necesita establecerlo -Ocomo un indicador del compilador! En lugar de gastar algunos caracteres adicionales por sitio para eliminar subexpresiones comunes manualmente, solo dígale al compilador que haga optimizaciones básicas para usted para un total de uno o dos caracteres en todo el programa.

Quizás algo obvio pero ...

Hacer uso de los valores de retorno del operador

¡Tenga en cuenta que el operador de asignación devuelve un valor!

Por ejemplo, si desea agregar y a x y luego verificar si x es mayor que algo, puede hacer

if(25<x+=y)

en lugar de

x+=y;if(x>25)

O tal vez desee encontrar la longitud de una cadena después de recortarla:

strlen(s=trim(s))

Más bien que

s=trim(s);strlen(s)

Utilice la versión de idioma / compilador / peculiaridades del entorno / nuevas características

Esto es especialmente útil para los políglotas , pero se puede aplicar a otros desafíos. A veces, un error del compilador puede salir de un byte, un error de implementación puede permitirle guardar algunos caracteres, o una característica realmente innovadora puede mejorar su puntaje.

Combine múltiples / anidados si las comprobaciones utilizando Y / O cuando sea posible.

es decir:

if (a && (b || c)) {

}

en lugar de:

if (a) {
    if (b) {
        //Do Stuff
    } elseif (c) {
        //Do same stuff
    }
}

Encuentre mejores formas de inicializar sus variables

Algunas otras respuestas estuvieron a punto de mencionar esto, pero en muchos idiomas (¿estrictamente escritos?), Es más corto inicializar xcomo una cadena vacía como:

x:=""

o xcomo runa vacía (char) como:

x:=''

que

var x string

y

var x rune

Obviamente, se prefiere usar valores preexistentes, pero no es tan fácil.