O objetivo deste post é reunir todas as dicas de golfe que podem ser facilmente aplicadas, <all languages>e não específicas.

Publique apenas respostas que sua lógica possa ser aplicada à maioria dos idiomas

Por favor, uma dica por resposta

Mesclar loops

Geralmente, você pode mesclar dois loops consequentes, ou dois loops aninhados, em um.

Antes:

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

Depois de:

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

Apenas para mencionar o óbvio:

Questione sua escolha de algoritmo e tente algo totalmente novo.

Ao jogar golfe (problemas mais difíceis que resultam em programas mais longos) com muita frequência, você pode seguir o caminho que escolheu primeiro sem tentar outras opções fundamentais . Obviamente, você pode jogar minigolfe em uma ou mais linhas de uma vez ou em parte da idéia geral, mas muitas vezes não tente uma solução totalmente diferente.

Isso foi especialmente perceptível no Hitting 495 (Kaprekar), onde o desvio do algoritmo real e a procura de padrões que você pode aplicar para obter o mesmo resultado eram mais curtos em muitos idiomas (apenas não J).

A desvantagem é que você possivelmente resolve a mesma coisa meia dúzia de vezes. Mas funciona realmente em todos os idiomas, exceto no HQ9 + (onde encontrar outra maneira de produzir o Hello World seria um pouco inútil).

Usar desenvolvimento orientado a testes

Se o código precisar lidar com várias entradas, escreva testes abrangentes e facilite a execução de todos eles muito rapidamente. Isso permite que você tente transformações arriscadas, um passo de bebê por vez. O golfe então se torna como refatoração com intenção perversa.

Tente reduzir instruções lógicas

Por exemplo, se Ae Bsão booleanos e seu idioma trata os booleanos como números até certo ponto A and (not B)e A>Bsão equivalentes. Por exemplo, em Python

if A and not B:
    foo()

é o mesmo que:

if A>B:
    foo()

Inicialize variáveis ​​usando os valores que você já possui.

Em vez de x=1, tente procurar algo que já seja igual a 1.
Por exemplo, o valor de retorno de uma função: printf("..");x=0;-> x=!printf("..");. É mais fácil com 0, porque você sempre pode negar ou quando tudo que você precisa é o valor certo da verdade (e não se importa se é 1 ou 19).

Use unário ~para x+1ex-1

Esse truque se aplica a idiomas que possuem um operador de negação bit a bit unário ~e um operador de negação regular unário -.

Se o seu programa, por acaso, contiver a expressão -x-1, você poderá substituí-lo por ~xpara salvar bytes. Isso não ocorre com muita frequência, mas observe o que acontece se negarmos ( -) ambas as expressões: x+1igual -~x! Da mesma forma, x-1é igual ~-x. (Pense em qual direção o til aponta: a direita é +, a esquerda é -.)

Isso é útil, porque em todos os idiomas que consigo pensar que possuem esses operadores, eles têm maior precedência do que a maioria dos operadores. Isso permite que você salve entre parênteses. Veja como salvamos quatro bytes aqui:

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

Aperte o espaço em branco

Conheça as regras para espaços em branco no seu idioma. Alguns sinais de pontuação ou outros caracteres podem não precisar de espaço em branco ao redor. Considere esta função de shell Bourne :

f () { echo a; echo b; }

No shell Bourne, ();são metacaracteres e não precisam de espaço em branco circundante. No entanto, {}são palavras e precisam de espaço em branco, a menos que estejam ao lado de metacaracteres. Podemos jogar fora 4 espaços ao lado ();, mas devemos manter o espaço entre {e echo.

f(){ echo a;echo b;}

No Common Lisp e no PicoLisp , ()são metacaracteres. Considere este código para encontrar a média de dois números:

(/ (+ a b) 2)

Podemos jogar fora 2 espaços.

(/(+ a b)2)

Alguns idiomas têm regras estranhas e sutis para espaços em branco. Considere este programa Ruby, que imprime a soma e o produto de uma linha de números inteiros.

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

Cada &um precisa de um espaço antes de si. Em Ruby, i=$F.map &:to_isignifica i=$F.map(&:to_i)onde &passa um parâmetro de bloco. Mas, i=$F.map&:to_isignifica i=$F.map.&(:to_i)onde &está um operador binário.

Essa estranheza acontece em idiomas, como Perl ou Ruby, que usam pontuação ambígua. Em caso de dúvida, use um REPL ou escreva programas curtos para testar as regras de espaço em branco.

atribuir novos nomes às funções, se usados ​​várias vezes

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

Nomes de variáveis ​​de letra única

Você tem 52 deles; use todos eles! Não tenha medo de tentar abordagens diferentes e comparar comprimentos. Conheça o idioma e os atalhos / funções da biblioteca específicos disponíveis.

Use o operador condicional.

Um operador condicional

bool ? condition_true : condition_false

é mais benéfico, em termos de caráter, do que uma declaração IF .

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

pode ser escrito como

r=a>b?a:b;

Escreva uma explicação do seu código

Escrever uma explicação obriga a examinar cuidadosamente cada parte do seu código novamente e a tornar explícitos seus pensamentos e escolhas ao escrever uma determinada passagem. Ao fazer isso, você pode descobrir que são possíveis abordagens diferentes, que podem economizar alguns bytes, ou que você subconscientemente fez suposições que não necessariamente são válidas.

Essa dica é semelhante a Questionar sua escolha de algoritmo e tentar algo totalmente novo ; no entanto, descobri que o passo de realmente escrever como cada parte deve funcionar às vezes é crucial para tomar consciência de alternativas.

Como bônus, as respostas, incluindo uma explicação, são mais interessantes para outros usuários e, portanto, têm mais chances de serem votadas.

Verifique novamente a contagem de caracteres

Parece um acéfalo, mas tomando cuidado, você poderá "salvar" alguns personagens sem realmente fazer nada!

Se você estiver usando o Windows, poderá estar inserindo em \r\nvez de apenas \rou \nquando clicar em Retornar - adicionando um byte extra por linha! Gire os caracteres de controle apenas para verificar se você não está fazendo isso.

No Notepad ++, você pode converter todas as \r\nterminações de linha apenas \rem Edit > EOL Conversion > UNIX/OSX Format.

Também não inclua nenhum espaço em branco à direita na contagem de caracteres! O feed de linha na linha de fundo do seu código também é irrelevante, de modo que também não precisará ser contado.

Leia a pergunta com atenção

O golfe por código tem tanto a ver com entender a pergunta (o que é perguntado e o que não é perguntado, mesmo que isso esteja implícito em qualquer outra configuração) quanto a produção de código que (pode) satisfazer apenas o que é perguntado.

Qualquer entrada diferente da solicitada explicitamente não precisa ser tratada. Se houver alguns casos de teste e nenhum requisito genérico, seu código poderá funcionar apenas nesses casos. Etc.

Use operações bit a bit para verificar números entre 0 e qualquer 2 ⁿ -1

Pode ser um pouco complicado, mas às vezes pode ser útil. Ele se baseia no fato de que todos os números aos quais m = 2 ⁿ -1 se aplica têm os n bits mais à direita definidos como 1.

Portanto, 7 ₁₀ == 00000111 ₂ , 15 ₁₀ == 00001111 ₂ , 31 ₁₀ == 00011111 ₂ e assim por diante.

O truque é x&~m. Isso retornará verdadeiro sempre que nãox estiver entre 0 e (inclusive) e falso caso contrário. Ele salva 6 bytes da próxima expressão equivalente mais curta:, mas obviamente só funciona quando satisfaz 2 ⁿ -1.mx>=0&&x<=mm

Reutilizar parâmetros de função em vez de novas variáveis

Maior / Menor que para salvar um dígito:

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

Lembre-se de trocar o código de ifpara elsee eles farão exatamente a mesma coisa (ou mudarão os lados da desigualdade)!

Nota: isso pode ser aplicado com qualquer potência de 10 e seus negativos:...-100, -10, 10, 100...

(link de origem)

Use> e <em vez de> = e <=

Ao verificar valores inteiros codificados, use >e em <vez de >=e sempre <=que possível. Por exemplo, usando

if(x>24&&x<51)

É 2 bytes mais curto que o uso

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

Evite quebras prematuras de loop

Se estiver executando um loop para verificar se há 1 ou mais instâncias de uma verificação booleana, pode ser um programa mais eficiente sair do loop no primeiro valor verdadeiro. No entanto, remover a quebra e fazer um loop em todas as iterações permite um código mais curto.

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;
}

use em -vez de!=

para comparações numéricas:

Se a for igual a b, a-bresulta em 0, o que é falso. Qualquer outra coisa que não 0seja verdade; portanto,
se usado em um contexto booleano, a-b<=>a!=b

Se você usá-lo com if/elseou com o operador ternário, isso também poderá economizar um byte para a igualdade:
a==b?c:d<=>a-b?d:c

Dividir strings para matrizes longas

A maioria dos idiomas tem uma maneira de dividir uma string em uma matriz de strings em torno de um token de algum tipo. Isso inevitavelmente será mais curto que um literal de matriz quando o comprimento atingir um limite dependente do idioma, porque a sobrecarga extra por sequência será uma cópia de um token de um caractere em vez de (pelo menos) dois delimitadores de sequência.

Por exemplo, no GolfScript

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

torna-se

"Foo
Bar
Baz
Quux"n/  # 20 chars

Para alguns idiomas, o limite é tão baixo quanto uma sequência. Por exemplo, em Java,

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

torna-se

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

Entenda o que outras pessoas fizeram

Além de ser divertido, se você examinar o código de outras pessoas, às vezes poderá descobrir um bom algoritmo no qual não pensou ou um truque (às vezes óbvio) que você ignora.

Às vezes, existe uma resposta que você pode traduzir para outro idioma e se beneficiar dos benefícios do outro idioma.

conheça a precedência do seu operador

Sempre que você combinar várias expressões, verifique a tabela de precedência do operador em seu idioma para ver se você pode reorganizar coisas para salvar parênteses.

Exemplos:

• Em todos os idiomas que eu conheço, os operadores bit a bit têm uma precedência mais alta que os operadores booleanos: (a&b)&&cnão precisa de parênteses: a&b&&cassim como (a*b)+cnão.
• a+(b<<c)pode ser reescrito como a+b*2**c.
  Isso não salva nada neste exemplo, mas será cum literal inteiro pequeno (<14).
• Operações bit a bit tem uma precedência mais baixa do que a maioria das operações aritméticas, por isso, se o seu idioma lança implicitamente boolean para int, você pode salvar um byte em a<b&&c<dcom a<b&c<d(a menos que você precisa a avaliação curto-circuito)

Loops mais curtos

Se você tiver Xinstruções {dentro }do loop for, poderá movê- X-1las (dentro )do loop for após o segundo ponto for(blah;blah;HERE)e vírgula para salvar 3 bytes. (separe as instruções usando uma vírgula ,)

Ao invés de

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

você pode mover uma das instruções para o (aparelho do loop for )enquanto deixa a outra de fora

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

e salve 3 bytes (economizou mais 1 byte graças a @ETHProductions)

Simplificando,

ao invés de

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

mova as declarações para que você acabe com isso

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

e economize 3 bytes

Use unário ~para a-b-1ea+b+1

Além das sugestões de @Lynn sobre x+1→ -~x; e x-1→~-x , você também pode jogar golfe a-b-1e a+b+1.

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

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

Pode parecer uma dica que você não usará com tanta frequência, como usar em ~xvez de -x-1não acontecer com frequência, mas eu a usei o suficiente para vê-la como uma dica útil aqui. Especialmente com a indexação de matriz, você pode usá-las acima em alguns casos.

Comprimir ou estrias

Truque simples que inventei ao tentar espremer uma longa faixa de condições encadeadas por ands (ou ors, nesse caso, basta substituir 'all' por 'any').

Por exemplo:

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

Torna-se

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

Confie no compilador para fornecer o desempenho necessário.

Certifique-se de saber quais otimizações são garantidas pelo compilador e em quais níveis de otimização e use-as livremente. E mesmo que o desempenho não seja um requisito de preocupação , você ainda pode testar com otimizações ativadas e descontar apenas um caractere porque seu código ainda é tecnicamente válido sem o sinalizador do compilador.

Considere a seguinte função Haskell para calcular 2 ^ n (ignorando o fato de que Haskell já possui um operador de exponenciação interno ou três) (23 caracteres):

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

O problema é - é terrivelmente lento, é executado em tempo exponencial. Isso pode tornar seu código não testável ou falhar em qualquer restrição de desempenho fornecida pela pergunta. Você pode ficar tentado a usar uma variável temporária ou uma literal de função imediatamente chamada para evitar chamadas de função repetidas (25 caracteres):

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

Mas o compilador já pode fazer isso por você, basta definir -Ocomo um sinalizador do compilador! Em vez de gastar alguns caracteres extras por site para eliminar subexpressões comuns manualmente, basta dizer ao compilador para fazer otimizações básicas para você, com um total geral de um ou dois caracteres em todo o programa.

Talvez um pouco óbvio, mas ...

Fazer uso dos valores de retorno do operador

Lembre-se de que o operador de atribuição retorna um valor!

Por exemplo, se você deseja adicionar y a x e verificar se x é maior que algo, você pode fazer

if(25<x+=y)

ao invés de

x+=y;if(x>25)

Ou talvez você queira encontrar o comprimento de uma sequência após apará-la:

strlen(s=trim(s))

Ao invés de

s=trim(s);strlen(s)

Utilize a versão do idioma / peculiaridades do compilador / ambiente / novos recursos

Isso é especialmente útil para poliglotas , mas pode ser aplicado a outros desafios. Às vezes, um bug do compilador pode obter um byte, um bug de implementação pode permitir que você salve alguns caracteres, ou um recurso realmente avançado pode melhorar sua pontuação.

Combine múltiplo / aninhado se verifica usando E / ou quando possível.

ou seja:

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

}

ao invés de:

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

Encontre maneiras melhores de inicializar suas variáveis

Algumas outras respostas chegaram perto de mencionar isso, mas em muitos idiomas (estritamente digitados?), É mais curto inicializar xcomo uma string vazia como:

x:=""

ou xcomo runa vazia (char) como:

x:=''

do que

var x string

e

var x rune

Usar valores preexistentes é obviamente preferido, mas não tão fácil.