Welche allgemeinen Tipps haben Sie zum Golfen in C #? Ich bin auf der Suche nach Ideen, die sich auf Code-Golf-Probleme im Allgemeinen anwenden lassen, die zumindest etwas spezifisch für C # sind (z. B. "Kommentare entfernen" ist keine Antwort). Bitte posten Sie einen Tipp pro Antwort.

- von Marcog's Idee entlehnt;)

Anstatt die .ToString()Verwendung +""für Zahlen und andere Typen zu verwenden, die sicher in eine Zeichenfolge umgewandelt werden können.

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

Ich habe mein Programm einmal absichtlich eingefügt, namespace Systemum den Zugriff auf eine bestimmte Klasse zu verkürzen. Vergleichen Sie

using System;using M=System.Math;

zu

namespace System{using M=Math;

Verwenden Sie diese Option varzum Deklarieren und Initialisieren von (einzelnen) Variablen, um Zeichen in folgendem Typ zu speichern:

string x="abc";

wird

var x="abc";

Ist intnatürlich nicht besonders notwendig .

Wenn Sie LINQ verwenden, können Sie eine Methode direkt an übergeben, Selectanstatt ein Lambda zu erstellen.

Also statt

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

Sie können verwenden

foo.Select(int.Parse)

direkt.

( Wurde kürzlich entdeckt, als eine der C # -Antworten von Timwi verbessert wurde .)

Denken Sie daran, dass das kleinste kompilierbare Programm in C # 29 Zeichen umfasst:

class P
{
    static void Main()
    {   
    }
}

Entfernen Sie das also zunächst aus Ihrer Länge und beurteilen Sie Ihre Antwort danach, wie viel es kostet. C # kann nicht mit anderen Sprachen konkurrieren, wenn es um das Drucken oder Lesen von Eingaben geht. Dies ist das Herzstück der meisten [code-golf]Probleme. Machen Sie sich also keine Sorgen. Als C # -Golfer treten Sie wirklich gegen die Sprache an.

Ein paar andere Dinge zu beachten:

• Reduzieren Sie ifnach Möglichkeit alle Schleifen und Anweisungen auf eine einzige Zeile, um die Klammern zu entfernen.
• Wenn Sie die Option zwischen stdin und Kommandozeile haben, verwenden Sie immer die Kommandozeile!

Anstatt von

bool a = true;
bool b = false;

machen

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

Wenn Sie mehrere Variablen benötigen, verwenden Sie diese (vorgeschlagen von @VisualMelon )

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

Ziehen Sie gegebenenfalls den ternären Operator den if.. else-Blöcken vor.

Zum Beispiel:

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

ist effizienter:

j=i<1?1:0;

Effektive Nutzung von

Sie können durch using ersetzenfloat (was ein Alias ​​für ist System.Single)zz=System.Single;

Dann ersetzen Sie z=System.Single;mit z=Single;durch das Programm im Namensraum platzieren System. (Wie bei Joeys Antwort)

Dies kann für andere Werttypen (verwenden Sie einen Alias ​​für diese), Strukturen und Klassen angewendet werden

Wenn Sie Console.ReadLine()Ihren Code mehrmals verwenden müssen (mindestens dreimal), können Sie Folgendes tun:

Func<string>r=Console.ReadLine;

und dann einfach benutzen

r()

stattdessen

Wenn Sie jedes Zeichen eines Befehlszeilenarguments lesen, anstatt eine Schleife bis zur Länge der Zeichenfolge auszuführen:

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

Sie können ein Zeichen speichern, indem Sie einen try / catch-Block verwenden, um das Ende zu finden:

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

Dies gilt für jedes Array innerhalb eines Arrays wie:

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

Verwenden Sie Lambdas, um eine Funktion in C # 6 zu definieren

In C # 6 können Sie ein Lambda verwenden, um eine Funktion zu definieren:

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

Dies ist kürzer als die Definition einer Funktion wie folgt:

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

LINQ

Anstelle von:

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

erhalten eine Enumerable mit dem Ergebnis der Funktion ffür jede intin [0,y]die Sie verwenden können

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

Wenn Sie stringetwas benötigen , das Enumerablein Ihrem Programm implementiert ist , können Sie es auch verwenden

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

Wenn Sie Dictionary<TKey, TValue>in Ihrem Code mindestens zwei Mal eine generische Klasse verwenden müssen, können Sie eine Dictionary-Klasse deklarieren, wie im folgenden Beispiel:

class D:Dictionary<int,string>{}

und dann einfach benutzen

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

anstatt Dictionary<int,string>für jede Instanziierung zu wiederholen .

Ich habe diese Technik in dieser Antwort verwendet

Sie können floatund doubleLiterale verwenden, um einige Bytes zu speichern.

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

Wenn Sie eine intArithmetik benötigen , um a zurückzugeben, floatoder doublewenn Sie die Konvertierung mithilfe der Literale erzwingen möchten.

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

Wenn Sie jemals in eine Situation geraten, in der Sie eine Umwandlung vornehmen müssen, können Sie einige Bytes sparen, indem Sie stattdessen die Multiplikation verwenden.

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

Denken Sie daran, wo private oder öffentliche inhärente Elemente vorhanden sind, z.

class Default{static void Main()

verglichen mit

public class Default { public static void Main()

Bei einzeiligen Lambda-Ausdrücken können Sie die Klammern und das Semikolon überspringen. Bei Ein-Parameter-Ausdrücken können Sie die Klammern überspringen.

Anstatt von

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

Verwenden

SomeCall(x=>DoSomething);

Looping:

Variablendeklarationen:

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

werden:

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

Und wenn Sie die Variable i nur einmal benötigen oder damit arbeiten müssen, können Sie bei -1 (oder 0, je nach Schleifenumstand) beginnen und inline erhöhen:

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

zu

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

Und das reduziert sich um ein Zeichen und verschleiert den Code leicht. Tun Sie das nur mit der ERSTEN iReferenz, wie folgt: (Zugegebene Ein-Zeichen-Optimierungen sind nicht viel, aber sie können helfen.)

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

zu

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

Wenn die Schleife nicht erhöht werden muss i(umgekehrte Reihenfolge):

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

Unter bestimmten Umständen kann ein Ausgabeparameter Zeichen speichern. Hier ist ein leicht konstruiertes Beispiel, ein 10-Pin-Bowling-Score-Algorithmus.

Mit einer Rückgabeerklärung:

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

Und mit einem Ausgabeparameter:

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

Der Ausgabeparameter hier speichert insgesamt 5 Zeichen.

In C # dürfen wir nicht if(n%2)prüfen, ob nes sich um eine gerade Zahl handelt. Wenn wir das tun, bekommen wir eine cannot implicity convert int to bool. Ein naiver Umgang wäre:

if(n%2==0)

Ein besserer Weg ist zu verwenden:

if(n%2<1)

Ich habe diese ein Byte zu gewinnen hier .

Beachten Sie, dass dies nur für positive Zahlen funktioniert, da -1%2==-1dies auch bei dieser Methode berücksichtigt wird.

String-Interpolation

Eine wirklich einfache platzsparende Verbesserung ist die Interpolation. Anstatt von:

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

Verwenden Sie einfach, $um Ausdrücke einzufügen:

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

Zusammen mit den neuen Ausdruckskörpern in C # 6.0 sollte dies jede einfache Zeichenfolgenberechnung in C # zum Kinderspiel werden lassen.

Verwenden Sie C # Lambda. Da PPCG Lambda für die Eingabe / Ausgabe zulässt, sollten wir sie verwenden.

Eine klassische C # -Methode sieht folgendermaßen aus:

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

Als Lambda werden wir schreiben

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

Anonymes Lambda ist ebenfalls erlaubt:

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

Entfernen Sie alle Störungen und konzentrieren Sie sich!

Aktualisieren:

Wir können mit einem Schritt weiter verbessern currying als @TheLethalCoder Kommentar:

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

Beispiel für die Aktualisierung durch @Felix Palmen: Wie wird der WPA-Schlüssel berechnet?

Es ist hilfreich, wenn Sie genau 2 Parameter haben, dann ist eine leere, nicht verwendete Variable _besser. Siehe Meta-Post dazu . Ich benutze diesen Trick hier . Sie müssen die Funktion etwas ändern. Beispiel: Online ausprobieren!

Machen Sie Klassennamen nur einen Buchstaben. Verbesserung der Tipps für Code-Golfing in C #, von dem wir ausgehen

class Default{static void Main()

zu

class D{static void Main()

was in diesem Fall weitere 6 Zeichen ausschaltet.

Das Compute Instanzmethode von System.Data.DataTable, kann ein einfacher Zeichenfolgenausdruck ausgewertet werden, z.

C # (Visual C # -Compiler) , 166 Byte

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

Probieren Sie es online!

Per se nicht sehr "golfig", aber manchmal nützlich.

Zwei Variablen tauschen

Um zwei Variablen auszutauschen, müssen Sie normalerweise eine temporäre Variable deklarieren, um den Wert zu speichern. Es würde ungefähr so ​​aussehen:

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

Das sind 16 Bytes! Es gibt einige andere Methoden zum Tauschen, die besser sind.

//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);

Die letzten drei funktionieren nur für numerische Werte, und wie nur in ASCII angegeben, können die letzten beiden zu einer ArithmeticOverflow-Ausnahme führen. Alle oben genannten Werte sind 12 Byte, was einer Einsparung von 4 Byte gegenüber dem ersten Beispiel entspricht.

Mit LinqPad haben Sie die Möglichkeit, den gesamten Programmaufwand zu reduzieren, da Sie Anweisungen direkt ausführen können. (Und es sollte in Codegolf völlig legal sein ... Niemand sagt, Sie brauchen eine .exe)

Die Ausgabe erfolgt über die .Dump()Erweiterungsmethode.

(Ein besonderer Fall , in dem Sie die Priorität Ihres Betreibers kennen !)

Verwenden % für eine (etwas) begrenzte Subtraktion bei enger Bindung. Dies erspart Ihnen ein paar Klammern um eine Subtraktion, deren Ergebnis Sie multiplizieren oder durch etwas dividieren möchten. Aber seien Sie vorsichtig, es hat ernsthafte Einschränkungen.

Anstatt von

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)

Erwägen

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

Beispiele:

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

Ich habe dies gerade erst entdeckt und denke, es wird eine wertvolle Sache sein, sich daran zu erinnern, wann immer wir in Zukunft mit ASCII arbeiten. (Ich spiele gerade irgendwo Golf, wo ich ASCII für kompakte numerische Darstellungen verwende, aber mit einer anderen Bedingung multiplizieren 1oder -1darauf aufbauen muss, und diese gestreiften 2 Bytes.)

Wenn Sie mehrere usings einschließen müssen, die alle aus derselben Hierarchie stammen, ist es häufig kürzer, die längste als Folgendes zu verwenden namespace:

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

vs:

namespace System.Linq
{
    //Some code
}

Wird heute Abend "in den Schützengräben" entdeckt, während ein Teil des Golfcodes verbessert wird. Wenn Sie eine Klasse für Ihre Verarbeitung haben, können Sie die Arbeit im Konstruktor erledigen, um die Deklaration einer Methode zu sparen.

Ich entdeckte dies, als ich eine Konsolenanwendung reduzierte - wie es eine gab static void Main() , mussten alle Funktionen und Variablen als statisch deklariert werden. Ich habe eine verschachtelte Klasse mit Elementfunktionen und Variablen erstellt, wobei die Hauptarbeit im Konstruktor ausgeführt wurde. Dadurch werden auch Zeichen im aufrufenden Code gespeichert.

zB Klasse mit Methode:

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

Klasse mit Arbeit im Konstruktor:

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

In diesem Beispiel werden 9 Zeichen gespeichert.

Verwenden Sie Actionlike Func, um einer Variablen eine Funktion zuzuweisen. ActionGibt nothing ( void) zurück, daher eignet es sich hervorragend zum Drucken.

Zum Beispiel:

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

Diese Tipps sind inspiriert von @W0lf tollem Anwendungsbeispiel FuncmitReadLine .

Deklarieren Sie leere / übereinstimmende Zeichenfolgen zusammen

Wenn Sie mehrere leere / übereinstimmende Zeichenfolgen deklarieren müssen, können Sie einige Bytes wie folgt speichern:

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

Ist leider var a="",b=a,c=a;illegal, wieimplicitly type variable cannot have multiple declarators