Lo scopo di questo post è quello di raccogliere tutti i suggerimenti per il golf che possono essere facilmente applicati <all languages>piuttosto che uno specifico.

Posta solo risposte che la sua logica può essere applicata alla maggior parte delle lingue

Per favore, un consiglio per risposta

Unisci loop

Di solito è possibile unire due loop successivi, o due loop nidificati, in uno solo.

Prima:

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

Dopo:

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

Solo per citare l'ovvio:

Metti in discussione la tua scelta di algoritmo e prova qualcosa di completamente nuovo.

Quando giochi a golf (soprattutto problemi più difficili che portano a programmi più lunghi) troppo spesso potresti rimanere sul percorso che hai scelto per la prima volta senza provare altre opzioni fondamentali . Ovviamente, puoi micro-golf una o poche righe alla volta o una parte dell'idea generale, ma spesso non provi una soluzione totalmente diversa.

Ciò è stato particolarmente evidente in Hitting 495 (Kaprekar) in cui deviare dall'algoritmo reale e cercare modelli che è possibile applicare per ottenere lo stesso risultato è stato più breve in molte lingue (ma non J).

Il rovescio della medaglia è che possibilmente risolvi la stessa cosa mezza dozzina di volte. Funziona davvero in tutte le lingue tranne HQ9 + (dove trovare un altro modo per produrre Hello World sarebbe leggermente inutile).

Utilizzare lo sviluppo guidato dai test

Se il codice deve gestire vari input, quindi scrivere test completi e rendere più semplice eseguirli tutti molto rapidamente. Questo ti consente di provare trasformazioni rischiose un piccolo passo alla volta. Il golf diventa quindi come il refactoring con intento perverso.

Prova a ridurre le affermazioni logiche

Ad esempio, se Ae Bsono booleani e la tua lingua tratta i booleani come numeri in una certa misura A and (not B)e A>Bsono equivalenti. Ad esempio in Python

if A and not B:
    foo()

equivale a:

if A>B:
    foo()

Inizializza le variabili usando i valori che hai già.

Invece di x=1, prova a cercare qualcosa che sia già uguale a 1.
Ad esempio, il valore restituito di una funzione: printf("..");x=0;-> x=!printf("..");. È più facile con 0, perché puoi sempre negare, o quando tutto ciò di cui hai bisogno è il giusto valore di verità (e non importa se è 1 o 19).

Usa unario ~per x+1ex-1

Questo trucco si applica alle lingue che hanno un operatore di negazione bit per bit unario ~e un operatore di negazione regolare unario -.

Se il tuo programma, per caso, contiene l'espressione -x-1, puoi sostituirla con ~xper salvare byte. Questo non succede troppo spesso, ma guarda cosa succede se neghiamo ( -) entrambe le espressioni: x+1uguale a -~x! Allo stesso modo, è x-1uguale ~-x. (Pensa in che modo indica la tilde: destra è +, sinistra è -.)

Questo è utile, perché in tutte le lingue mi viene in mente che hanno questi operatori, hanno una precedenza maggiore rispetto alla maggior parte degli operatori. Ciò ti consente di risparmiare tra parentesi. Guarda come salviamo quattro byte qui:

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

Spremi spazio bianco

Conosci le regole per gli spazi bianchi nella tua lingua. Alcuni segni di punteggiatura o altri caratteri potrebbero non aver bisogno di spazi bianchi circostanti. Considera questa funzione della shell Bourne :

f () { echo a; echo b; }

Nella shell Bourne, ();sono metacaratteri e non hanno bisogno di spazi bianchi circostanti. Tuttavia, {}sono parole e hanno bisogno di spazi bianchi a meno che non siano accanto ai metacaratteri. Possiamo giocare a golf di 4 spazi accanto ();, ma dobbiamo mantenere lo spazio tra {e echo.

f(){ echo a;echo b;}

In Common Lisp e PicoLisp , ()sono metacaratteri. Considera questo codice per trovare la media di due numeri:

(/ (+ a b) 2)

Possiamo golf 2 spazi.

(/(+ a b)2)

Alcune lingue hanno regole strane e sottili per gli spazi bianchi. Considera questo programma Ruby, che stampa la somma e il prodotto di una linea di numeri interi.

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

Ognuno ha &bisogno di uno spazio prima di se stesso. In Ruby i=$F.map &:to_isignifica i=$F.map(&:to_i)dove &passa un parametro di blocco. Ma i=$F.map&:to_isignifica i=$F.map.&(:to_i)dov'è &un operatore binario.

Questa stranezza accade in lingue, come Perl o Ruby, che usano punteggiatura ambigua. In caso di dubbi, utilizzare un REPL o scrivere brevi programmi per testare le regole degli spazi bianchi.

assegnare funzioni nuovi nomi se usato più volte

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

Nomi delle variabili a lettera singola

Ne hai 52; usali tutti! Non abbiate paura di provare approcci diversi e confrontare lunghezze. Conoscere la lingua e le specifiche scorciatoie / funzioni di libreria disponibili.

Usa l'operatore condizionale.

Un operatore condizionale

bool ? condition_true : condition_false

è più vantaggioso, personaggio saggio, di un IF dichiarazione .

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

può essere scritto come

r=a>b?a:b;

Scrivi una spiegazione del tuo codice

Scrivere una spiegazione ti costringe a guardare di nuovo accuratamente ogni parte del tuo codice e a rendere espliciti i tuoi pensieri e le tue scelte scrivendo un certo passaggio. In tal modo, potresti scoprire che sono possibili approcci diversi che possono salvare alcuni byte o che hai inconsciamente fatto ipotesi che non necessariamente valgono.

Questo suggerimento è simile a Domanda la tua scelta dell'algoritmo e prova qualcosa di completamente nuovo ; tuttavia, ho scoperto che il passaggio di scrivere effettivamente come dovrebbe funzionare ogni parte è talvolta cruciale per prendere coscienza delle alternative.

Come bonus, le risposte che includono una spiegazione sono più interessanti per gli altri utenti e quindi hanno maggiori probabilità di essere votate.

Controlla nuovamente il numero dei tuoi personaggi

Sembra un gioco da ragazzi, ma facendo attenzione potresti essere in grado di "salvare" alcuni personaggi senza effettivamente fare nulla!

Se stai usando Windows, potresti inserire \r\ninvece di solo \ro \nquando premi Invio - aggiungendo un byte extra per riga! Ruota i personaggi di controllo solo per ricontrollare che non lo stai facendo.

In Notepad ++ puoi convertire tutte le \r\nterminazioni di riga semplicemente \raccedendo a Edit > EOL Conversion > UNIX/OSX Format.

Assicurati anche di non includere spazi bianchi finali nel conteggio dei personaggi! Anche il feed di riga nell'ultima riga del codice è irrilevante, quindi non dovrà essere conteggiato neanche.

Leggi attentamente la domanda

Il golf di codice riguarda tanto la comprensione della domanda (cosa viene chiesto e ciò che non viene chiesto, anche se ciò sarebbe implicito in qualsiasi altra impostazione) quanto la produzione di codice che (può) soddisfare solo ciò che viene chiesto.

Qualsiasi input diverso da quello che viene esplicitamente richiesto non deve essere gestito. Se ci sono alcuni casi di test e nessun requisito generico, il tuo codice potrebbe funzionare solo in quei casi. Eccetera.

Utilizzare le operazioni bit per bit per controllare i numeri compresi tra 0 e 2 ⁿ -1

Potrebbe essere un po 'un caso limite, ma a volte potrebbe tornare utile. Si basa sul fatto che tutti i numeri a cui si applica m = 2 ⁿ -1 hanno gli n bit più a destra impostati su 1.

Quindi, 7 ₁₀ == 00000111 ₂ , 15 ₁₀ == 00001111 ₂ , 31 ₁₀ == 00011111 ₂ e così via.

Il trucco è x&~m. Ciò restituirà true ogni volta che nonx è compreso tra 0 e (compreso) e false in caso contrario. Salva 6 byte dalla successiva espressione equivalente più breve:, ma ovviamente funziona solo quando soddisfa 2 ⁿ -1.mx>=0&&x<=mm

Riutilizzare i parametri della funzione anziché le nuove variabili

Maggiore / minore di per salvare una cifra:

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

Ricorda solo di scambiare il codice da ifa elsee faranno esattamente la stessa cosa (o cambieranno i lati della disuguaglianza)!

Nota: questo può essere applicato con qualsiasi potenza di 10 e relativi negativi:...-100, -10, 10, 100...

(link alla fonte)

Usa> e <invece di> = e <=

Quando si esegue il confronto con valori interi con codice fisso, utilizzare >e <anziché >=e <=dove possibile. Ad esempio, usando

if(x>24&&x<51)

È 2 byte più corto dell'uso

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

Evitare interruzioni anticipate del circuito

Se si esegue un ciclo per verificare 1 o più istanze di un controllo booleano, è possibile che un programma più efficiente esca dal ciclo sul primo valore vero. Tuttavia, la rimozione dell'interruzione e il ciclo attraverso tutte le iterazioni consente un codice più breve.

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

utilizzare -invece di!=

per confronti numerici:

Se a è uguale a b, il a-brisultato 0è falso. Nient'altro che 0sia vero; quindi
se usato in un contesto booleano, a-b<=>a!=b

Se lo usi con if/elseo con l'operatore ternario, questo può anche farti risparmiare un byte per l'uguaglianza:
a==b?c:d<=>a-b?d:c

Dividi stringhe per lunghe matrici

La maggior parte delle lingue ha un modo per dividere una stringa in una matrice di stringhe attorno a un token di qualche tipo. Questo sarà inevitabilmente più breve di un array letterale una volta che la lunghezza raggiungerà una soglia dipendente dalla lingua, poiché l'overhead aggiuntivo per stringa sarà una copia di un token a un carattere anziché (almeno) due delimitatori di stringa.

Ad esempio in GolfScript

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

diventa

"Foo
Bar
Baz
Quux"n/  # 20 chars

Per alcune lingue, la soglia è bassa quanto una stringa. Ad esempio in Java,

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

diventa

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

Comprendi cosa hanno fatto gli altri

Oltre ad essere divertente, se esamini il codice di altre persone, a volte puoi scoprire un buon algoritmo a cui non hai pensato, o un trucco (a volte ovvio) che trascuri.

A volte esiste una risposta che puoi tradurre in un'altra lingua e trarre vantaggio dalle chicche dell'altra lingua.

conoscere la precedenza del proprio operatore

Ogni volta che combini diverse espressioni, controlla la tabella delle priorità dell'operatore per la tua lingua per vedere se puoi riordinare le cose per salvare le parentesi.

Esempi:

• In tutte le lingue che conosco, gli operatori bit a bit hanno una precedenza maggiore rispetto agli operatori booleani: (a&b)&&cnon ha bisogno di parentesi: a&b&&cproprio come (a*b)+cnon lo è.
• a+(b<<c)può essere riscritto come a+b*2**c.
  Questo non salva nulla per questo esempio, ma sarà se cè un intero piccolo letterale (<14).
• Le operazioni bit a bit hanno una precedenza inferiore rispetto alla maggior parte delle operazioni aritmetiche, quindi se la tua lingua lancia implicitamente booleano su int, puoi salvare un byte a<b&&c<dcon a<b&c<d(a meno che tu non abbia bisogno della valutazione del corto circuito)

Anelli più corti

Se sono presenti Xistruzioni {all'interno }del ciclo for, è possibile spostare le X-1istruzioni (all'interno )del ciclo for dopo il secondo punto for(blah;blah;HERE)e virgola per salvare 3 byte. (separare le dichiarazioni utilizzando una virgola ,)

Invece di

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

puoi spostare una delle istruzioni tra (parentesi graffe del for-loop )lasciando l'altra fuori

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

e salva 3 byte (risparmia un altro byte grazie a @ETHProductions)

In poche parole,

invece di

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

spostare le dichiarazioni in modo da finire con questo

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

e salva 3 byte

Usa unario ~per a-b-1ea+b+1

Oltre ai suggerimenti di @Lynn riguardanti x+1→ -~x; e x-1→~-x , puoi anche giocare a golf a-b-1e a+b+1.

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

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

Potrebbe sembrare un suggerimento che non userai molto spesso, un po 'come usare ~xinvece di -x-1non succedere spesso, ma l'ho usato abbastanza volte per vederlo come un suggerimento utile qui. Soprattutto con l'indicizzazione di array è possibile utilizzare questi sopra in alcuni casi.

Comprimi o / e strisce

Semplice trucco che ho trovato quando ho cercato di stringere una lunga serie di condizioni incatenate da ands (o ors, in questo caso basta sostituire 'all' con 'any').

Per esempio:

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

diventa

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

Affidati al compilatore per fornire le prestazioni richieste.

Assicurati di sapere quali ottimizzazioni sono garantite dal compilatore e a quali livelli di ottimizzazione e utilizzale liberamente. E anche se le prestazioni non sono un requisito preoccupante , puoi comunque testare con ottimizzazioni attivate e quindi scartare solo un carattere perché il tuo codice è ancora tecnicamente valido senza il flag del compilatore.

Considera la seguente funzione Haskell per calcolare 2 ^ n (ignorando il fatto che Haskell ha già un operatore di esponenziazione incorporato o tre) (23 caratteri):

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

Il problema è che è tremendamente lento, funziona in tempo esponenziale. Ciò potrebbe rendere il tuo codice non testabile o non riuscire a limitare le prestazioni fornite dalla domanda. Potresti essere tentato di utilizzare una variabile temporanea o una funzione letterale immediatamente invocata per evitare ripetute chiamate di funzione (25 caratteri):

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

Ma il compilatore può già farlo per te, devi solo impostarlo -Ocome flag di compilatore! Invece di spendere pochi caratteri extra per sito per eliminare manualmente le sottoespressioni comuni, basta dire al compilatore di fare ottimizzazioni di base per te per un totale complessivo di uno o due caratteri nell'intero programma.

Forse un po 'ovvio ma ...

Utilizzare i valori di ritorno dell'operatore

Tieni presente che l'operatore di assegnazione restituisce un valore!

Ad esempio, se si desidera aggiungere y a x e quindi verificare se x è maggiore di qualcosa, è possibile farlo

if(25<x+=y)

invece di

x+=y;if(x>25)

O forse vuoi trovare la lunghezza di una stringa dopo averla tagliata:

strlen(s=trim(s))

Piuttosto che

s=trim(s);strlen(s)

Utilizza le versioni lingua / compilatore / stranezze ambiente / nuove funzionalità

Ciò è particolarmente utile per i poliglotti , ma può essere applicato ad altre sfide. A volte, un bug del compilatore può golfare un byte, un bug di implementazione può consentire di salvare alcuni caratteri o una funzionalità davvero all'avanguardia può migliorare il tuo punteggio.

Combina multipli / nidificati se controlla usando E / O quando possibile.

vale a dire:

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

}

invece di:

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

Trova modi migliori per inizializzare le tue variabili

Alcune altre risposte si sono avvicinate al menzionarlo già, ma in molte lingue (tipizzate in modo rigoroso?), È più breve inizializzare xcome stringa vuota come:

x:=""

o xcome runa vuota (char) come:

x:=''

di

var x string

e

var x rune

L'uso di valori preesistenti è ovviamente preferito, ma non così facile.