Le but de cet article est de rassembler tous les conseils de golf qui peuvent être facilement appliqués à <all languages>un spécifique.

Poster uniquement des réponses indiquant que sa logique peut être appliquée à la plupart des langues

S'il vous plaît, un pourboire par réponse

Fusionner des boucles

Vous pouvez généralement fusionner deux boucles consécutives, ou deux boucles imbriquées, en une seule.

Avant:

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

Après:

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

Juste pour mentionner l'évidence:

Questionnez votre choix d'algorithme et essayez quelque chose de complètement nouveau.

Lorsque vous jouez au golf (des problèmes particulièrement difficiles entraînant des programmes plus longs), vous pouvez trop souvent vous en tenir au chemin que vous avez choisi au préalable sans essayer d’autres options fondamentales . Bien sûr, vous pouvez micro-golfer une ou plusieurs lignes à la fois ou une partie de l’idée générale, mais souvent, ne tentez pas une solution totalement différente.

Cela était particulièrement visible dans Hitting 495 (Kaprekar), où s'écarter de l'algorithme actuel et rechercher des motifs que l'on pouvait appliquer pour obtenir le même résultat était plus court dans de nombreuses langues (mais pas J).

L'inconvénient est que vous pouvez éventuellement résoudre la même chose une demi-douzaine de fois. Mais cela fonctionne vraiment dans toutes les langues sauf HQ9 + (où trouver un autre moyen de sortir Hello World serait un peu futile).

Utiliser le développement piloté par les tests

Si le code doit gérer différentes entrées, alors écrivez des tests complets et facilitez leur exécution très rapidement. Cela vous permet d'essayer des transformations risquées, une étape à la fois. Le golf devient alors comme une refonte avec une intention perverse.

Essayez de réduire les déclarations logiques

Par exemple, si Aet Bsont des booléens et que votre langue considère les booléens comme des nombres dans une certaine mesure A and (not B)et A>Bsont équivalents. Par exemple en Python

if A and not B:
    foo()

est le même que:

if A>B:
    foo()

Initialisez les variables en utilisant les valeurs que vous avez déjà.

Au lieu de x=1, essayez de rechercher quelque chose qui est déjà égal à 1.
Par exemple, la valeur de retour d'une fonction: printf("..");x=0;-> x=!printf("..");. C'est plus facile avec 0, parce que vous pouvez toujours nier, ou quand tout ce dont vous avez besoin est la bonne valeur de vérité (et ne vous souciez pas de savoir si c'est 1 ou 19).

Utilisez unaire ~pour x+1etx-1

Cette astuce s’applique aux langues qui ont un opérateur de négation ~unaire unaire et un opérateur de négation régulière unaire -.

Si votre programme contient par hasard l'expression -x-1, vous pouvez la remplacer par ~xpour sauvegarder des octets. Cela ne se produit pas très souvent, mais regardez ce qui se passe si nous négons ( -) les deux expressions: x+1égal à -~x! De même, x-1égal ~-x. (Pensez de quelle manière le tilde pointe: droite est +, gauche est -.)

Ceci est utile car, dans toutes les langues auxquelles je peux penser, ces opérateurs ont une priorité plus élevée que la plupart des opérateurs. Cela vous permet d'économiser sur les parenthèses. Regardez comment nous économisons quatre octets ici:

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

Squeeze les espaces

Connaître les règles pour les espaces dans votre langue. Certains signes de ponctuation, ou autres caractères, peuvent ne nécessiter aucun espace. Considérez cette fonction shell Bourne :

f () { echo a; echo b; }

Dans Bourne Shell, ce ();sont des métacaractères et ils n'ont pas besoin d'espaces. Cependant, il {}existe des mots et des espaces, à moins qu'ils ne soient à côté de métacaractères. Nous pouvons jouer au golf à côté de 4 espaces ();, mais nous devons garder l’espace entre {et echo.

f(){ echo a;echo b;}

Dans Common Lisp et PicoLisp , ()sont des métacaractères. Considérez ce code pour trouver la moyenne de deux nombres:

(/ (+ a b) 2)

Nous pouvons jouer au golf 2 espaces.

(/(+ a b)2)

Certaines langues ont des règles étranges et subtiles pour les espaces. Considérez ce programme Ruby, qui affiche la somme et le produit d’une ligne d’entiers.

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

Chacun a &besoin d'un espace devant lui-même. En Ruby, i=$F.map &:to_isignifie i=$F.map(&:to_i)où &passe un paramètre de bloc. Mais, i=$F.map&:to_isignifie i=$F.map.&(:to_i)où &est un opérateur binaire.

Cette bizarrerie se produit dans des langages, tels que Perl ou Ruby, qui utilisent une ponctuation ambiguë. En cas de doute, utilisez un REPL ou écrivez des programmes courts pour tester les règles d’espace.

attribuer de nouveaux noms aux fonctions si utilisé plusieurs fois

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

Noms variables d'une seule lettre

Vous en avez 52; utilisez-les tous! N'ayez pas peur d'essayer différentes approches et de comparer les longueurs. Connaître la langue et les raccourcis / fonctions de bibliothèque disponibles.

Utilisez l'opérateur conditionnel.

Un opérateur conditionnel

bool ? condition_true : condition_false

est plus bénéfique, caractère sage, qu'une déclaration IF .

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

peut être écrit comme

r=a>b?a:b;

Ecrire une explication de votre code

Ecrire une explication vous oblige à examiner à nouveau chaque partie de votre code et à rendre explicites vos pensées et vos choix en écrivant un certain passage. En faisant cela, vous pouvez trouver que différentes approches sont possibles, ce qui peut économiser certains octets, ou que vous avez inconsciemment émis des hypothèses qui ne sont pas nécessairement valables.

Cette astuce est similaire à Questionnez votre choix d’algorithme et essayez quelque chose de tout à fait nouveau ; Cependant, j’ai constaté qu’il est parfois crucial de noter comment chaque partie est censée fonctionner, pour prendre conscience des alternatives.

En prime, les réponses comprenant une explication sont plus intéressantes pour les autres utilisateurs et sont donc plus susceptibles d'être votées.

Vérifiez votre nombre de personnages

Cela sonne comme une évidence, mais en faisant attention, vous pourrez peut-être "sauver" quelques personnages sans rien faire!

Si vous utilisez Windows, vous pouvez saisir \r\nau lieu de simplement \rou \nlorsque vous appuyez sur Entrée - en ajoutant un octet supplémentaire par ligne! Tournez les caractères de contrôle pour vérifier que vous ne le faites pas.

Dans Notepad ++, vous pouvez convertir toutes les \r\nfins de ligne en simplement \ren allant à Edit > EOL Conversion > UNIX/OSX Format.

Assurez-vous également de ne pas inclure d'espaces de fin dans le nombre de vos personnages! Le saut de ligne sur la dernière ligne de votre code est également sans conséquence, vous n'avez donc pas besoin de le compter.

Lire la question attentivement

Le golf de code consiste tout autant à comprendre la question (ce qui est demandé et ce qui n’est pas demandé, même si cela serait implicite dans tout autre paramètre) que de produire un code qui ne peut (que) satisfaire ce qui est demandé.

Toute entrée autre que celle explicitement demandée ne doit pas être traitée. S'il existe des cas de test et aucune exigence générique, votre code peut uniquement fonctionner dans ces cas. Etc.

Utilisez les opérations au niveau des bits pour vérifier les nombres compris entre 0 et 2 ⁿ -1

Peut-être un peu un cas de pointe, mais il pourrait être utile parfois. Il repose sur le fait que tous les nombres auxquels m = 2 ⁿ -1 ont les n bits les plus à droite sont définis sur 1.

Ainsi, 7 ₁₀ == 00000111 ₂ , 15 ₁₀ == 00001111 ₂ , 31 ₁₀ == 00011111 ₂ et ainsi de suite.

Le truc c'est x&~m. Cela retournera vrai chaque fois que xn'est pas compris entre 0 et m(inclus) et faux sinon. Il enregistre 6 octets dans l'expression équivalente la plus courte suivante:, x>=0&&x<=mmais ne fonctionne évidemment que lorsque msatisfait 2 ⁿ -1.

Réutiliser des paramètres de fonction à la place de nouvelles variables

Plus grand / moins que pour enregistrer un chiffre:

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

Rappelez-vous simplement d’échanger le code entre ifle elseet ils feront exactement la même chose (ou inverseront les côtés de l’inégalité)!

Remarque: ceci peut être appliqué avec n'importe quelle puissance de 10 et leurs négatifs:...-100, -10, 10, 100...

(lien source)

Utilisez> et <au lieu de> = et <=

Lors de la vérification par rapport à des valeurs entières codées en dur, utilisez >et <au lieu de >=et <=si possible. Par exemple, en utilisant

if(x>24&&x<51)

2 octets de moins que d'utiliser

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

Évitez les ruptures de boucle prématurées

Si vous parcourez une boucle pour rechercher une ou plusieurs instances d'une vérification booléenne, un programme plus efficace pourrait permettre de sortir de la boucle avec la première valeur vraie. Toutefois, la suppression de la rupture et la mise en boucle de toutes les itérations permettent un code plus court.

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

utiliser -au lieu de!=

pour les comparaisons numériques:

Si a est égal à b, il en a-brésulte une 0fausseté. Quelque chose d'autre que la 0vérité; donc
si utilisé dans un contexte booléen, a-b<=>a!=b

Si vous l'utilisez avec if/elseou avec l'opérateur ternaire, cela peut également vous faire économiser un octet pour l'égalité:
a==b?c:d<=>a-b?d:c

Fractionner les chaînes pour les tableaux longs

La plupart des langues ont le moyen de diviser une chaîne en un tableau de chaînes autour d'un jeton. Cela sera inévitablement plus court qu'un littéral de tableau une fois que la longueur aura atteint un seuil dépendant de la langue, car le temps système supplémentaire par chaîne sera une copie d'un jeton à un caractère plutôt que (au moins) deux délimiteurs de chaîne.

Par exemple dans GolfScript

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

devient

"Foo
Bar
Baz
Quux"n/  # 20 chars

Pour certaines langues, le seuil est aussi bas qu'une chaîne. Par exemple à Java,

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

devient

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

Comprendre ce que les autres ont fait

En plus d'être amusant, si vous examinez le code d'autres personnes, vous pouvez parfois découvrir un bon algorithme auquel vous n'avez pas pensé, ou une astuce (parfois évidente) que vous oubliez.

Parfois, il existe une réponse que vous pouvez traduire dans une autre langue et bénéficier des avantages de cette dernière.

connaître votre priorité d'opérateur

Chaque fois que vous combinez plusieurs expressions, consultez le tableau de priorité des opérateurs de votre langue pour savoir si vous pouvez réorganiser les éléments pour enregistrer les parenthèses.

Exemples:

• Dans toutes les langues que je connais, les opérateurs au niveau des bits ont une priorité plus élevée que les opérateurs booléens: (a&b)&&cne nécessite pas de parenthèses: a&b&&ctout comme (a*b)+cne le fait pas.
• a+(b<<c)peut être réécrit comme a+b*2**c.
  Cela n’économise rien pour cet exemple, mais il le sera s’il cs’agit d’un petit littéral entier (<14).
• Les opérations au niveau des bits ont une priorité inférieure à la plupart des opérations arithmétiques, donc si votre langage convertit implicitement boolean en entier, vous pouvez enregistrer un octet a<b&&c<davec a<b&c<d(sauf si vous avez besoin de l'évaluation du court-circuit).

Des boucles plus courtes

Si vous avez des Xinstructions {dans }votre boucle for, vous pouvez déplacer des X-1instructions (dans )la boucle for après le deuxième point-virgule for(blah;blah;HERE)pour enregistrer 3 octets. (séparez les déclarations en utilisant une virgule ,)

Au lieu de

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

vous pouvez déplacer l'une des déclarations dans les (accolades de la boucle for, )tout en laissant l'autre

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

et économisez 3 octets (sauvegardez 1 octet supplémentaire grâce à @ETHProductions)

Mettre tout simplement,

au lieu de

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

déplacez les déclarations afin que vous vous retrouviez avec cette

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

et économisez 3 octets

Utilisez unaire ~pour a-b-1eta+b+1

En plus des suggestions de @Lynn concernant x+1→ -~x; et x-1→~-x , vous pouvez aussi jouer au golf a-b-1et a+b+1.

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

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

Cela peut ressembler à un conseil que vous n'utiliserez pas très souvent, un peu comme si vous utilisiez ~xau lieu de -x-1ne pas arriver souvent, mais je l'ai déjà utilisé suffisamment de fois pour le voir comme un conseil utile ici. Surtout avec l'indexation par tableau, vous pouvez utiliser les exemples ci-dessus dans certains cas.

Compresse ou / et traînées

Truc simple que j'ai trouvé en essayant de réduire une longue série de conditions enchaînées par ands (ou ors, dans ce cas, remplacez simplement "all" par "any").

Par exemple:

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

Devient

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

Fiez-vous au compilateur pour fournir les performances requises.

Assurez-vous de savoir quelles optimisations sont garanties par le compilateur et à quels niveaux d'optimisation, et utilisez-les généreusement. Et même si les performances ne sont pas une préoccupation , vous pouvez toujours tester avec des optimisations, puis ne négligez qu'un seul caractère, car votre code est toujours valide sur le plan technique sans l'indicateur de compilation.

Considérez la fonction Haskell suivante pour calculer 2 ^ n (en ignorant le fait que Haskell a déjà un opérateur d’exponentiation intégré ou trois) (23 caractères):

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

Le problème est que - c'est terriblement lent, ça tourne dans le temps exponentiel. Cela pourrait rendre votre code non testable ou échouer les contraintes de performance données par la question. Vous pourriez être tenté d'utiliser une variable temporaire ou un littéral de fonction immédiatement appelé pour éviter les appels de fonction répétés (25 caractères):

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

Mais le compilateur peut déjà le faire pour vous, il vous suffit de le définir -Ocomme indicateur de compilateur! Au lieu de dépenser quelques caractères supplémentaires par site pour éliminer manuellement les sous-expressions courantes, il vous suffit d'indiquer au compilateur de faire les optimisations de base à votre place pour un total de un ou deux caractères sur l'ensemble du programme.

Peut-être un peu évident mais ...

Utiliser les valeurs de retour d'opérateur

Gardez à l'esprit que l'opérateur d'affectation renvoie une valeur!

Par exemple, si vous voulez ajouter y à x et vérifier si x est supérieur à quelque chose, vous pouvez faire

if(25<x+=y)

au lieu de

x+=y;if(x>25)

Ou peut-être souhaitez-vous trouver la longueur d'une chaîne après l'avoir coupée:

strlen(s=trim(s))

Plutôt que

s=trim(s);strlen(s)

Utiliser les bizarreries / nouvelles fonctionnalités de la langue / du compilateur / de l'environnement

Ceci est particulièrement utile pour les polyglottes , mais peut s’appliquer à d’autres défis. Parfois, un bogue du compilateur peut ignorer un octet, un bogue d'implémentation peut vous permettre de sauvegarder quelques caractères, ou une fonctionnalité très avancée peut améliorer votre score.

Combinez plusieurs / imbriqués si des vérifications utilisant Et / Ou lorsque cela est possible.

c'est à dire:

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

}

au lieu de:

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

Trouvez de meilleurs moyens d'initialiser vos variables

Quelques autres réponses étaient sur le point de le mentionner déjà, mais dans beaucoup de langues (strictement typées?), Il est plus court d'initialiser xune chaîne vide comme:

x:=""

ou en xtant que rune vide (personnage) comme:

x:=''

que

var x string

et

var x rune

L'utilisation de valeurs préexistantes est évidemment préférable, mais pas si facile.