Das Ziel dieses Beitrags ist es, alle Golftipps zu sammeln, die einfach <all languages>und nicht nur für einen bestimmten angewendet werden können .

Schreiben Sie nur Antworten, deren Logik auf die meisten Sprachen angewendet werden kann

Bitte einen Tipp pro Antwort

Loops zusammenführen

Normalerweise können Sie zwei aufeinanderfolgende Schleifen oder zwei verschachtelte Schleifen zu einer zusammenführen.

Vor:

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

Nach:

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

Nur um das Offensichtliche zu erwähnen:

Stellen Sie Ihre Wahl des Algorithmus in Frage und probieren Sie etwas völlig Neues aus.

Beim Golfen (besonders bei schwereren Problemen, die zu längeren Programmen führen) bleiben Sie möglicherweise allzu oft auf dem Weg, den Sie zuerst gewählt haben, ohne andere grundlegende Optionen auszuprobieren. Natürlich können Sie eine oder mehrere Linien gleichzeitig oder einen Teil der Gesamtidee mikro-golf spielen, aber oftmals versuchen Sie es nicht mit einer völlig anderen Lösung.

Dies machte sich insbesondere in Hitting 495 (Kaprekar) bemerkbar, wo die Abweichung vom tatsächlichen Algorithmus und die Suche nach Mustern, die Sie anwenden können, um zum gleichen Ergebnis zu gelangen, in vielen Sprachen kürzer waren (nur nicht J).

Der Nachteil ist, dass Sie möglicherweise ein halbes Dutzend Mal dasselbe lösen. Aber es funktioniert in wirklich allen Sprachen außer HQ9 + (wo die Suche nach einem anderen Weg zur Ausgabe von Hello World etwas sinnlos wäre).

Verwenden Sie testgetriebene Entwicklung

Wenn der Code mit verschiedenen Eingaben umgehen muss, schreiben Sie umfassende Tests und machen Sie es einfach, sie alle sehr schnell auszuführen. Auf diese Weise können Sie riskante Transformationen Schritt für Schritt ausprobieren. Golfen wird dann wie ein Refactoring mit perverser Absicht.

Versuchen Sie, logische Aussagen zu reduzieren

Zum Beispiel, wenn Aund BBoolesche Werte sind und Ihre Sprache Boolesche Werte bis zu einem gewissen Grad wie Zahlen behandelt A and (not B)und A>Bgleichwertig ist. Zum Beispiel in Python

if A and not B:
    foo()

ist das gleiche wie:

if A>B:
    foo()

Initialisieren Sie Variablen mit Werten, die Sie bereits haben.

x=1Versuchen Sie stattdessen , nach etwas zu suchen, das bereits 1 entspricht.
Beispiel: Der Rückgabewert einer Funktion: printf("..");x=0;-> x=!printf("..");. Mit 0 ist es am einfachsten, weil Sie immer negieren können oder wenn Sie nur den richtigen Wahrheitswert benötigen (und es ist egal, ob es 1 oder 19 ist).

Verwenden Sie unary ~für x+1undx-1

Dieser Trick gilt für Sprachen mit einem unären bitweisen Negationsoperator ~und einem unären regulären Negationsoperator -.

Wenn Ihr Programm zufällig den Ausdruck enthält -x-1, können Sie ihn durch ersetzen ~x, um Bytes zu sparen. Dies kommt nicht allzu oft vor, aber sehen Sie, was passiert, wenn wir -beide Ausdrücke negieren ( ): x+1gleich -~x! Ebenso ist x-1gleich ~-x. (Überlegen Sie, in welche Richtung die Tilde zeigt: rechts ist +, links ist- .)

Dies ist nützlich, da in allen Sprachen, die ich mir vorstellen kann, diese Operatoren eine höhere Priorität haben als die meisten Operatoren. Auf diese Weise können Sie in Klammern speichern. Sehen Sie hier, wie wir vier Bytes sparen:

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

Whitespace drücken

Kennen Sie die Regeln für Leerzeichen in Ihrer Sprache. Einige Satzzeichen oder andere Zeichen benötigen möglicherweise kein umgebendes Leerzeichen. Betrachten Sie diese Bourne-Shell- Funktion:

f () { echo a; echo b; }

In der Bourne-Shell ();sind Metazeichen und benötigen keine umgebenden Leerzeichen. Es handelt sich jedoch {}um Wörter, die Leerzeichen benötigen, sofern sie nicht neben Metazeichen stehen. Wir können 4 Felder daneben weggolfen ();, müssen aber den Abstand zwischen {und einhalten echo.

f(){ echo a;echo b;}

In Common Lisp und PicoLisp , ()sind Metazeichen. Betrachten Sie diesen Code, um den Durchschnitt von zwei Zahlen zu ermitteln:

(/ (+ a b) 2)

Wir können 2 Plätze weg Golf spielen.

(/(+ a b)2)

Einige Sprachen haben seltsame und subtile Regeln für Leerzeichen. Betrachten Sie dieses Ruby-Programm, das die Summe und das Produkt einer Reihe von ganzen Zahlen ausgibt.

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

Jeder &braucht einen Platz vor sich. In Ruby i=$F.map &:to_ibedeutet, i=$F.map(&:to_i)wo &ein Blockparameter übergeben wird. Aber i=$F.map&:to_ibedeutet i=$F.map.&(:to_i)wo& ist ein binärer Operator.

Diese Verrücktheit tritt in Sprachen wie Perl oder Ruby auf, die mehrdeutige Interpunktion verwenden. Verwenden Sie im Zweifelsfall eine REPL oder schreiben Sie kurze Programme, um die Whitespace-Regeln zu testen.

weisen Sie Funktionen neue Namen zu, wenn Sie diese mehrmals verwenden

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

Variablennamen mit einem Buchstaben

Sie haben 52 von ihnen; benutze sie alle! Haben Sie keine Angst, verschiedene Ansätze auszuprobieren und Längen zu vergleichen. Kennen Sie die Sprache und die spezifischen verfügbaren Verknüpfungen / Bibliotheksfunktionen.

Verwenden Sie den bedingten Operator.

Ein bedingter Operator

bool ? condition_true : condition_false

ist charakterbezogen vorteilhafter als eine IF- Anweisung .

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

kann geschrieben werden als

r=a>b?a:b;

Schreiben Sie eine Erklärung Ihres Codes

Das Schreiben einer Erklärung zwingt Sie dazu, jeden Teil Ihres Codes noch einmal gründlich zu betrachten und Ihre Gedanken und Entscheidungen beim Schreiben einer bestimmten Passage explizit zu treffen. Dabei stellen Sie möglicherweise fest, dass verschiedene Ansätze möglich sind, mit denen einige Bytes eingespart werden können, oder dass Sie unbewusst Annahmen getroffen haben, die nicht unbedingt zutreffen.

Dieser Tipp ähnelt der Frage nach dem Algorithmus Ihrer Wahl und probieren Sie etwas völlig Neues aus . Ich habe jedoch festgestellt, dass der Schritt des tatsächlichen Aufschreibens, wie jedes Teil funktionieren soll, manchmal entscheidend ist, um Alternativen zu erkennen.

Als Bonus sind Antworten mit einer Erklärung für andere Benutzer interessanter und werden daher eher positiv bewertet.

Überprüfe die Anzahl deiner Charaktere

Klingt wie ein Kinderspiel, aber wenn Sie vorsichtig sind, können Sie möglicherweise ein paar Zeichen "speichern", indem Sie nichts tun!

Wenn Sie Windows verwenden, geben Sie möglicherweise ein, \r\nanstatt nur \roder \nwenn Sie die Eingabetaste drücken, und fügen ein zusätzliches Byte pro Zeile hinzu! Drehen Sie die Steuerzeichen, um zu überprüfen, ob Sie dies nicht tun.

In Notepad ++ können Sie alle \r\nZeilenenden in konvertieren , \rindem Sie zu gehen Edit > EOL Conversion > UNIX/OSX Format.

Stellen Sie außerdem sicher, dass Sie in Ihrer Zeichenzahl kein abschließendes Leerzeichen einfügen! Der Zeilenvorschub in der untersten Zeile Ihres Codes spielt ebenfalls keine Rolle, sodass er auch nicht gezählt werden muss.

Lesen Sie die Frage sorgfältig durch

Beim Code-Golfen geht es genauso darum, die Frage zu verstehen (was gefragt wird und was nicht , auch wenn dies in einer anderen Umgebung impliziert wird), wie Code zu produzieren, der (möglicherweise) nur das erfüllt, was gefragt wird.

Andere Eingaben als die explizit angeforderten müssen nicht verarbeitet werden. Wenn es einige Testfälle und keine allgemeinen Anforderungen gibt, funktioniert Ihr Code möglicherweise nur in diesen Fällen. Usw.

Verwenden Sie bitweise Operationen zum Überprüfen von Zahlen zwischen 0 und 2 ⁿ -1

Könnte ein bisschen ein Randfall sein, aber es könnte sich manchmal als nützlich erweisen. Es beruht auf der Tatsache, dass für alle Zahlen, für die m = 2 ⁿ –1 gilt, die am weitesten rechts liegenden n Bits auf 1 gesetzt sind.

Also, 7 ₁₀ == 00000111 ₂ , 15 ₁₀ == 00001111 ₂ , 31 ₁₀ == 00011111 ₂ und so weiter.

Der Trick ist x&~m. Dies wird true zurück , wenn xist nicht zwischen 0 und m(einschließlich), und andernfalls false. Es speichert 6 Bytes vom nächstkürzeren äquivalenten Ausdruck x>=0&&x<=m:, funktioniert aber offensichtlich nur, wenn m2 ⁿ -1 erfüllt sind .

Funktionsparameter anstelle neuer Variablen wiederverwenden

Größer / Kleiner als, um eine Ziffer zu speichern:

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

Denken Sie daran, den Code von ifauf zu tauschen , elseund sie werden genau dasselbe tun (oder die Seiten der Ungleichung vertauschen )!

Hinweis: Dies kann mit jeder Potenz von 10 und ihren Negativen angewendet werden:...-100, -10, 10, 100...

(Quelllink)

Verwenden Sie> und <anstelle von> = und <=

Verwenden Sie bei der Prüfung auf fest codierte Ganzzahlwerte >und <anstelle von >=und, <=wo dies möglich ist. Zum Beispiel mit

if(x>24&&x<51)

Ist 2 Bytes kürzer als mit

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

Vermeiden Sie vorzeitige Unterbrechungen der Schleife

Wenn Sie eine Schleife durchlaufen, um nach einer oder mehreren Instanzen einer Booleschen Prüfung zu suchen, kann dies dazu führen, dass ein effizienteres Programm die Schleife beim ersten wahren Wert verlässt. Das Entfernen der Unterbrechung und das Durchlaufen aller Iterationen ermöglichen jedoch kürzeren Code.

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

Verwenden Sie -anstelle von!=

für numerische Vergleiche:

Wenn a gleich b ist, a-bergibt sich 0, was falsch ist. Alles andere als 0wahr ist; also,
wenn in einem booleschen Kontext verwendet, a-b<=>a!=b

Wenn Sie es mit if/elseoder mit dem ternären Operator verwenden, können Sie auch ein Byte für die Gleichheit sparen:
a==b?c:d<=>a-b?d:c

Split-Strings für lange Arrays

Die meisten Sprachen haben die Möglichkeit, eine Zeichenfolge in eine Reihe von Zeichenfolgen um ein Token herum aufzuteilen. Dies ist zwangsläufig kürzer als ein Array-Literal, sobald die Länge einen sprachabhängigen Schwellenwert erreicht, da der zusätzliche Overhead pro Zeichenfolge eine Kopie eines Ein-Zeichen-Tokens ist und nicht (mindestens) zwei Zeichenfolgenbegrenzer.

ZB in GolfScript

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

wird

"Foo
Bar
Baz
Quux"n/  # 20 chars

Bei einigen Sprachen ist der Schwellenwert nur eine Zeichenfolge. ZB in Java,

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

wird

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

Verstehe, was andere Leute getan haben

Wenn Sie sich den Code anderer ansehen, können Sie nicht nur Spaß machen, sondern auch einen guten Algorithmus entdecken, über den Sie nicht nachgedacht haben, oder einen Trick (manchmal einen offensichtlichen), den Sie übersehen.

Manchmal gibt es eine Antwort, die Sie in eine andere Sprache übersetzen und von den Vorteilen der anderen Sprache profitieren können.

Kennen Sie Ihre Operator-Priorität

Wenn Sie mehrere Ausdrücke kombinieren, überprüfen Sie die Operator-Rangfolge-Tabelle für Ihre Sprache, um festzustellen, ob Sie die Reihenfolge ändern können, um Klammern zu speichern.

Beispiele:

• In allen mir bekannten Sprachen haben bitweise Operatoren eine höhere Priorität als boolesche Operatoren: Sie (a&b)&&cbenötigen keine Klammern, a&b&&cgenauso wie (a*b)+cnicht.
• a+(b<<c)kann umgeschrieben werden als a+b*2**c.
  Das speichert nichts für dieses Beispiel, aber es wird cein kleines Integer-Literal (<14) sein.
• Bitweise Operationen haben eine niedrigere Priorität als die meisten arithmetischen Operationen. Wenn Ihre Sprache also implizit Boolesche Operationen in int umwandelt, können Sie ein Byte a<b&&c<dmit sparen a<b&c<d(es sei denn, Sie benötigen die Kurzschlussbewertung).

Kürzere for-Schleifen

Wenn Sie XAnweisungen {innerhalb }Ihrer for-Schleife können Sie bewegen X-1Aussagen (innerhalb )der for-Schleife nach dem zweiten Semikolon for(blah;blah;HERE)3 Bytes zu speichern. (trennen Sie die Anweisungen mit einem Komma ,)

Anstatt von

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

Sie können eine der Anweisungen in die (geschweiften Klammern der for-Schleife verschieben, )während Sie die andere weglassen

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

und speichere 3 Bytes (1 weiteres Byte dank @ETHProductions)

Einfach ausgedrückt,

Anstatt von

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

Verschieben Sie die Anweisungen, damit Sie am Ende damit fertig sind

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

und sparen Sie 3 Bytes

Verwenden Sie unary ~für a-b-1unda+b+1

Zusätzlich zu @Lynns Vorschlägen zu x+1→ -~x; und x-1→~-x können Sie auch Golf a-b-1und a+b+1.

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

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

Es mag wie ein Tipp aussehen, den Sie nicht so oft verwenden, ein bisschen wie das Verwenden von ~xanstelle von -x-1kommt nur selten vor, aber ich habe ihn oft genug verwendet, um ihn hier als nützlichen Tipp anzusehen. Insbesondere bei der Array-Indizierung können Sie diese oben in einigen Fällen verwenden.

Komprimieren Sie oder / und Streifen

Ein einfacher Trick, den ich mir ausgedacht habe, als ich versucht habe, eine lange Reihe von Zuständen, die durch ands (oder ors) verkettet sind, zu überwinden. In diesem Fall ersetzen Sie einfach 'all' durch 'any'.

Z.B:

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

Wird

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

Verlassen Sie sich auf den Compiler, um die erforderliche Leistung zu erbringen.

Stellen Sie sicher, dass Sie wissen, welche Optimierungen vom Compiler garantiert werden und auf welchen Optimierungsstufen, und verwenden Sie sie großzügig. Und selbst wenn die Leistung kein Problem darstellt , können Sie sie mit eingeschalteten Optimierungen testen und dann nur ein Zeichen rabattieren, da Ihr Code noch technisch ist ohne das Compiler-Flag gültig ist.

Betrachten Sie die folgende Haskell-Funktion, um 2 ^ n zu berechnen (ignorieren Sie die Tatsache, dass Haskell bereits einen oder drei Exponentiationsoperatoren enthält) (23 Zeichen):

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

Das Problem ist - es ist schrecklich langsam, es läuft in exponentieller Zeit. Dies kann dazu führen, dass Ihr Code nicht mehr getestet werden kann oder die in der Frage angegebenen Leistungseinschränkungen nicht erfüllt werden. Sie könnten versucht sein, eine temporäre Variable oder ein sofort aufgerufenes Funktionsliteral zu verwenden, um wiederholte Funktionsaufrufe (25 Zeichen) zu vermeiden:

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

Aber der Compiler kann das schon für Sie tun, Sie müssen nur -Oein Compiler-Flag setzen! Anstatt ein paar zusätzliche Zeichen pro Site zu verwenden, um häufig verwendete Unterausdrücke manuell zu entfernen, müssen Sie den Compiler lediglich anweisen, grundlegende Optimierungen für eine Gesamtsumme von ein oder zwei Zeichen im gesamten Programm vorzunehmen.

Vielleicht etwas offensichtlich, aber ...

Verwenden Sie Operator-Rückgabewerte

Beachten Sie, dass der Zuweisungsoperator einen Wert zurückgibt!

Wenn Sie beispielsweise y zu x hinzufügen und dann prüfen möchten, ob x größer als etwas ist, können Sie dies tun

if(25<x+=y)

Anstatt von

x+=y;if(x>25)

Oder Sie möchten die Länge eines Strings nach dem Trimmen ermitteln:

strlen(s=trim(s))

Eher, als

s=trim(s);strlen(s)

Verwenden Sie die Sprachversion / den Compiler / die Umgebungsmerkmale / die neuen Funktionen

Dies ist besonders nützlich für Mehrsprachige , kann aber auch auf andere Herausforderungen angewendet werden. Manchmal kann ein Compiler-Fehler ein Byte weiterspielen, ein Implementierungs-Fehler kann es Ihnen ermöglichen, ein paar Zeichen zu sparen, oder eine wirklich brandneue Funktion kann Ihre Punktzahl verbessern.

Kombinieren Sie mehrere / verschachtelte, wenn möglich, Überprüfungen mit und / oder.

dh:

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

}

Anstatt von:

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

Finden Sie bessere Möglichkeiten, um Ihre Variablen zu initialisieren

Einige andere Antworten haben dies bereits erwähnt, aber in vielen (streng getippten?) Sprachen ist es kürzer, xals leere Zeichenfolge zu initialisieren :

x:=""

oder xals leere Rune (char) wie:

x:=''

als

var x string

und

var x rune

Die Verwendung bereits vorhandener Werte wird offensichtlich bevorzugt, ist jedoch nicht so einfach.