Quels conseils généraux avez-vous pour jouer au golf en C #? Je recherche des idées pouvant être appliquées aux problèmes de code de golf en général, qui sont au moins quelque peu spécifiques à C # (par exemple, "supprimer les commentaires" n'est pas une réponse). Merci de poster un pourboire par réponse.

- emprunté à l'idée de marcog;)

Au lieu d'utiliser .ToString()use +""pour les nombres et d'autres types pouvant être nativement transtypés en toute sécurité sur une chaîne.

.ToString() <-- 11 chars
+""         <--  3 chars

Une fois, j'ai délibérément placé mon programme namespace Systemafin de pouvoir raccourcir l'accès à une classe spécifique. Comparer

using System;using M=System.Math;

à

namespace System{using M=Math;

À utiliser varpour déclarer et initialiser des variables (simples) afin de sauvegarder des caractères sur le type:

string x="abc";

devient

var x="abc";

N'est pas particulièrement nécessaire pour int, bien sûr.

Si vous utilisez LINQ, vous pouvez passer directement à une méthode au Selectlieu de créer un lambda.

Donc, au lieu de

foo.Select(x=>int.Parse(x))

vous pouvez utiliser

foo.Select(int.Parse)

directement.

(Découvert récemment en améliorant l'une des réponses C # de Timwi .)

Rappelez-vous que le plus petit programme compilable en C # comporte 29 caractères:

class P
{
    static void Main()
    {   
    }
}

Commencez donc par retirer cela de votre longueur et déterminez votre réponse en fonction du temps écoulé. C # ne peut pas rivaliser avec d’autres langues en matière d’impression ou de lecture, ce qui est au cœur de la plupart des [code-golf]problèmes, ne vous inquiétez donc pas. En tant que golfeur C #, vous êtes vraiment en concurrence avec la langue.

Quelques autres points à garder à l'esprit:

• ifSi possible, réduisez toutes les boucles et toutes les instructions en une seule ligne afin de supprimer les crochets.
• Si vous avez le choix entre stdin et la ligne de commande, utilisez toujours la ligne de commande!

Au lieu de

bool a = true;
bool b = false;

faire

var a=0<1;
var b=1<0;

Si vous avez besoin de plusieurs variables, utilisez ceci (suggéré par @VisualMelon )

bool a=0<1,b=!a;

Privilégier l’opérateur ternaire sur if.. les elseblocs le cas échéant.

Par exemple:

if(i<1)
    j=1;
else
    j=0;

est plus efficace:

j=i<1?1:0;

Utilisation efficace de l'utilisation

Vous pouvez remplacer float (qui est un alias pour System.Single) par zutiliserz=System.Single;

Puis remplacez z=System.Single;par z=Single;en plaçant le programme dans l'espace de noms System. (Comme avec la réponse de Joey)

Ceci peut être appliqué à d'autres types de valeur (utilisez ce pour quoi ils sont un alias), structs et classes

Si vous devez utiliser Console.ReadLine()plusieurs fois dans votre code (3 fois au minimum), vous pouvez faire:

Func<string>r=Console.ReadLine;

et puis juste utiliser

r()

au lieu

Lors de la lecture de chaque caractère d'un argument de ligne de commande, plutôt que de boucler jusqu'à la longueur de la chaîne:

static void Main(string[]a){
    for(int i=0;i<a[0].Length;)Console.Write(a[0][i++]);
}

Vous pouvez sauvegarder un personnage en utilisant un bloc try / catch pour trouver la fin:

static void Main(string[]a){
    try{for(int i=0;;)Console.Write(a[0][i++]);}catch{}
}

Ceci s'applique à n'importe quel tableau dans un tableau tel que:

• string[]
• int[][]
• IList<IList<T>>

Utilisez lambdas pour définir une fonction en C # 6

En C # 6, vous pouvez utiliser un lambda pour définir une fonction:

int s(int a,int b)=>a+b;

C'est plus court que de définir une fonction comme celle-ci:

int s(int a,int b){return a+b;}

LINQ

À la place d'utiliser:

Enumerable.Range(0,y).Select(i=>f(i))

pour obtenir un Enumerable avec le résultat de fonction fpour chaque inten que [0,y]vous pouvez utiliser

new int[y].Select((_,i)=>f(i))

si vous avez besoin de stringtout ce qui est implémenté Enumerabledans votre programme, vous pouvez aussi les utiliser

var s="I need this anyway";
s.Select((_,i)=>f(i))

Si vous devez utiliser un générique Dictionary<TKey, TValue>au moins deux fois dans votre code, vous pouvez déclarer une classe de dictionnaire, comme dans cet exemple:

class D:Dictionary<int,string>{}

et puis juste utiliser

D d=new D{{1,"something"},{2,"something else"}};

au lieu de répéter Dictionary<int,string>pour chaque instanciation.

J'ai utilisé cette technique dans cette réponse

Vous pouvez utiliser floatet doublelittéraux pour sauver quelques octets.

var x=2.0;
var y=2d;         // saves 1 byte

Lorsque vous avez besoin d’ intarithmétique pour renvoyer un floatou doublevous pouvez utiliser les littéraux pour forcer la conversion.

((float)a+b)/2;  // this is no good
(a+b)/2.0;       // better
(a+b)/2f;        // best      

Si vous rencontrez un jour une situation dans laquelle vous devez effectuer un transtypage, vous pouvez économiser quelques octets en utilisant la multiplication.

((double)x-y)/(x*y);
(x*1d-y)/(x*y);      // saves 5 bytes

Rappelez-vous les endroits où le privé ou le public sont inhérents, tels que:

class Default{static void Main()

par rapport à

public class Default { public static void Main()

Pour les expressions lambda sur une ligne, vous pouvez ignorer les crochets et le point-virgule. Pour les expressions à un paramètre, vous pouvez ignorer les parenthèses.

Au lieu de

SomeCall((x)=>{DoSomething();});

Utilisation

SomeCall(x=>DoSomething);

En boucle:

Déclarations de variables:

int max;
for(int i=1;i<max;i++){
}

devenir:

int max,i=1;
for(;i<max;i++){
}

Et si vous avez besoin de ou travaillez avec la variable i une seule fois, vous pouvez commencer à -1 (ou 0 en fonction de la situation de la boucle) et incrémenter en ligne:

int max,i=1;
for(;i<max;i++){
  Console.WriteLine(i);
}

à

int max,i=1;
for(;i<max;){
  Console.WriteLine(++i);
}

Et cela réduit d'un caractère et obscurcit également légèrement le code. Faites seulement cela avec la iréférence FIRST , comme ceci : (accordé à un caractère, les optimisations ne sont pas importantes, mais elles peuvent aider)

int max,i=1;
for(;i<max;i++){
  Console.WriteLine(i + " " + i);
}

à

int max,i=1;
for(;i<max;){
  Console.WriteLine(++i + " " + i);
}

quand la boucle n'a pas à s'incrémenter i(boucle dans l'ordre inverse):

for(int i=MAX;--i>0;){
      Console.WriteLine(i);
}

Dans certaines circonstances, un paramètre de sortie peut enregistrer des caractères. Voici un exemple légèrement artificiel, un algorithme de score de quilles à 10 quilles.

Avec une déclaration de retour:

........10........20........30........40........50........60........70........80........90.......100.......110.......120.......130.......140.......150..
public double c(int[]b){int n,v,i=0,X=10;double t=0;while(i<19){n=b[i]+b[i+1];v=b[i+2];t+=(n<X)?n:X+v;if(b[i]>9)t+=b[i+(i>16|v!=X?3:4)];i+=2;}return t;}

Et avec un paramètre de sortie:

........10........20........30........40........50........60........70........80........90.......100.......110.......120.......130.......140.......
public void d(int[]b,out double t){int n,v,i=0,X=10;t=0;while(i<19){n=b[i]+b[i+1];v=b[i+2];t+=(n<X)?n:X+v;if(b[i]>9)t+=b[i+(i>16|v!=X?3:4)];i+=2;}}

Le paramètre de sortie enregistre ici un total de 5 caractères.

En C #, nous n'avons pas le droit if(n%2)de vérifier si nest un nombre pair. Si nous le faisons, nous obtenons un cannot implicity convert int to bool. Une manipulation naïve serait à faire:

if(n%2==0)

Une meilleure façon consiste à utiliser:

if(n%2<1)

J'ai utilisé cela pour gagner un octet ici .

notez que cela ne fonctionne que pour les nombres positifs, car -1%2==-1cela est considéré même avec cette méthode.

Interpolation de chaîne

L'interpolation est une amélioration très simple et peu encombrante. Au lieu de:

string.Format("The value is ({0})", (method >> 4) + 8)

il suffit d'utiliser $des expressions en ligne:

$"The value is ({(method >> 4) + 8})"

Ceci, combiné aux nouveaux corps d'expression en C # 6.0, devrait permettre à tout défi de calcul de chaîne simple de devenir golfable en C #.

Utilisez C # lambda. Puisque PPCG autorise lambda pour les entrées / sorties, nous devrions les utiliser.

Une méthode C # classique ressemble à ceci:

bool Has(string s, char c)
{
    return s.Contains(c);
}

En tant que lambda, nous écrirons

Func<string, char, bool> Has = (s, c) => s.Contains(c);

Les lambda anonymes sont aussi autorisés:

(s, c) => s.Contains(c)

Enlevez tout le bruit et concentrez-vous!

Mise à jour:

Nous pouvons améliorer un pas de plus avec taitement comme @TheLethalCoder commentaire:

s => c => s.Contains(c);

Exemple de mise en circulation par @Felix Palmen: Comment calculer la clé WPA?

Ce sera utile lorsque vous avez exactement 2 paramètres, alors une variable vide non utilisée _sera meilleure. Voir meta post à ce sujet . J'utilise cette astuce ici . Vous devrez changer un peu la fonction. Exemple: Essayez-le en ligne!

Faites des noms de classe une seule lettre. Amélioration des astuces pour jouer au code avec C # nous allons de

class Default{static void Main()

à

class D{static void Main()

ce qui assomme 6 autres caractères dans ce cas.

le Compute méthode d'instance de System.Data.DataTable, permet d'évaluer une expression de chaîne simple, par exemple:

C # (compilateur Visual C #) , 166 octets

namespace System.Data
{
    class P
    {
        static void Main()
        {
            Console.Write(new DataTable().Compute("30*2+50*5/4",""));
        }
    }
}

Essayez-le en ligne!

Pas très "golfy" en soi, mais parfois pourrait être utile.

Échange de deux variables

Normalement, pour échanger deux variables, vous devez déclarer une variable temporaire pour stocker la valeur. Cela ressemblerait à quelque chose du genre:

var c=a;a=b;b=c;

C'est 16 octets! Il existe d'autres méthodes d'échange qui sont meilleures.

//Using tuples
(a,b)=(b,a);
//Bitwise xoring 
a=a^b^(b=a);
//Addition and subtraction
a=a+b-(b=a);
//Multiplication and division
a=a*b/(b=a);

Les trois derniers ne fonctionnent que pour les valeurs numériques et, comme souligné par ASCII uniquement, les deux derniers peuvent entraîner une exception ArithmeticOverflow. Tous ces éléments représentent 12 octets, soit une économie de 4 octets par rapport au premier exemple.

L'utilisation de LinqPad vous donnera la possibilité de supprimer tout le temps système car vous pouvez exécuter des instructions directement. (Et cela devrait être tout à fait légal dans codegolf ... Personne ne dit que vous avez besoin d'un fichier .exe)

La sortie est effectuée à l'aide de la .Dump()méthode d'extension.

(Un cas particulier de connaître votre priorité d'opérateur !)

Utilisation % option pour une soustraction étroite (légèrement) limitée. Cela peut vous éviter une paire de parenthèses autour d'une soustraction, le résultat que vous voulez multiplier ou diviser par quelque chose; mais attention, il y a de sérieuses limitations.

Au lieu de

char b='5'; // b is some ASCII input
int a=(b-48)*c; // we want to find the numerical value of b, and multiply it by something ('0'==48)

Considérer

char b='5'; // b is some ASCII input
int a=b%48*c; // only good for ASCII within 48 of '0' (positive only)!

Exemples:

'5'%'0'*2 -> 10
'5'%'0'*-1 -> -5
'5'%'0'/2 -> 2

Je viens tout juste de découvrir cela, et j’ai l’impression que ce sera une chose précieuse à ne pas oublier lors de tout travail futur avec ASCII. (Je joue actuellement au golf quelque part où j'utilise ASCII pour des représentations numériques compactes, mais que je dois multiplier par 1ou -1sur une autre condition, et cette bande de 2 octets rayée)

Si vous devez inclure plusieurs usingobjets appartenant tous à la même hiérarchie, il est souvent plus court d'utiliser le plus long en tant que namespace:

using System;
using System.Linq;
//Some code

contre:

namespace System.Linq
{
    //Some code
}

Découvert ce soir "dans les tranchées" tout en améliorant un code de golf ... si vous avez une classe pour votre traitement, vous pouvez faire le travail dans le constructeur pour enregistrer en déclarant une méthode.

J'ai découvert cela en réduisant une application console - car il y avait un static void Main() , toutes les fonctions et variables devaient être déclarées statiques. J'ai créé une classe imbriquée avec des fonctions membres et des variables, le travail principal étant effectué dans le constructeur. Cela enregistre également les caractères dans le code d'appel.

p.ex. Classe avec méthode:

class a
{
    public void b()
    {
        new c().d("input");
    }
}
class c
{
    public void d(string e)
    {
        System.Console.Write(e.Replace("in", "out"));
    }
}

Classe avec travail dans le constructeur:

class a
{
    public void b()
    {
        new c("input");
    }
}
class c
{
    public c(string e)
    {
        System.Console.Write(e.Replace("in", "out"));
    }
}

Cet exemple enregistre 9 caractères.

Utilisez Actionlike Funcpour définir une fonction sur une variable. Actionne renvoie rien ( void), il est donc idéal pour l'impression.

Par exemple:

Action<string>w=Console.WriteLine;
w("Hello World");

Ces conseils sont inspirés par @W0lf, un excellent exemple d’utilisation de FuncavecReadLine .

Déclarer des chaînes vides / correspondantes ensemble

Si vous devez déclarer plusieurs chaînes vides / correspondantes, vous pouvez enregistrer quelques octets avec les éléments suivants:

string a="";string b="";string c=""; // 36 bytes
var a="";var b="";var c="";          // 27 bytes
string a="",b="",c="";               // 22 bytes
string a="",b=a,c=a;                 // 20 bytes

Malheureusement, var a="",b=a,c=a;c'est illégal, commeimplicitly type variable cannot have multiple declarators