Какие общие советы у вас есть для игры в гольф в C #? Я ищу идеи, которые могут быть применены к проблемам с гольф-кодом в целом, которые, по крайней мере, несколько специфичны для C # (например, «удалить комментарии» не является ответом). Пожалуйста, оставьте один совет за ответ.

- позаимствовано у идеи Маркога;)

Вместо использования .ToString()используйте +""для чисел и других типов, которые могут быть безопасно преобразованы в строку.

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

Однажды я специально поместил свою программу, namespace Systemчтобы сократить доступ к определенному классу. сравнить

using System;using M=System.Math;

в

namespace System{using M=Math;

Используйте varдля объявления и инициализации (одиночных) переменных, чтобы сохранить символы типа:

string x="abc";

становится

var x="abc";

intКонечно, это не обязательно .

При использовании LINQ вы можете передать метод напрямую Selectвместо создания лямбды.

Итак, вместо

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

вы можете использовать

foo.Select(int.Parse)

непосредственно.

(Обнаружен недавно при улучшении одного из ответов Тимви на C # .)

Помните, что самая маленькая компилируемая программа на C # состоит из 29 символов:

class P
{
    static void Main()
    {   
    }
}

Итак, начните с удаления этого из вашей длины и судите свой ответ о том, сколько это займет. C # не может конкурировать с другими языками, когда речь идет о печати или чтении ввода, что является сердцем большинства[code-golf] проблем, поэтому не беспокойтесь об этом. Как игрок в C #, вы действительно соревнуетесь с языком.

Несколько других вещей, которые нужно иметь в виду:

• Уменьшите все петли и if операторы до одной строки, если это возможно, чтобы снять скобки.
• Если задана опция между stdin и командной строкой, всегда используйте командную строку!

Вместо

bool a = true;
bool b = false;

делать

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

Если вам нужно несколько переменных, используйте это (предложено @VisualMelon )

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

Пользуйся троичным оператором if ..else блоками, где это уместно.

Например:

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

эффективнее:

j=i<1?1:0;

Эффективное использование использования

Вы можете заменить float (это псевдоним System.Single) с zпомощьюz=System.Single;

Затем замените z=System.Single;с z=Single;помощью размещения программы в пространстве именSystem . (Как и с ответом Джои)

Это может быть применено для других типов значений (используйте то, для чего они являются псевдонимами), структур и классов.

Если вам нужно использовать Console.ReadLine()несколько раз в вашем коде (минимум 3 раза), вы можете сделать:

Func<string>r=Console.ReadLine;

а потом просто использовать

r()

вместо

При чтении каждого символа аргумента командной строки, а не зацикливания до длины строки:

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

Вы можете сохранить символ, используя блок try / catch, чтобы найти конец:

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

Это относится к любому массиву в массиве, например:

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

Используйте лямбда-выражения для определения функции в C # 6

В C # 6 вы можете использовать лямбду для определения функции:

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

Это короче, чем определение такой функции:

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

LINQ

Вместо того, чтобы использовать:

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

чтобы получить Перечислимый с результатом функции fдля каждого intв [0,y]вы можете использовать

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

если вам нужно stringили что-то, что реализуется Enumerableв вашей программе, вы можете использовать их тоже

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

Если вам нужно использовать универсальный Dictionary<TKey, TValue>по крайней мере два раза в вашем коде, вы можете объявить класс словаря, как в этом примере:

class D:Dictionary<int,string>{}

а потом просто использовать

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

вместо повторения Dictionary<int,string> для каждого экземпляра.

Я использовал эту технику в этом ответе

Вы можете использовать floatи doubleлитералы, чтобы сохранить несколько байтов.

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

Когда вам нужна некоторая intарифметика для возврата floatили doubleвы можете использовать литералы для принудительного преобразования.

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

Если вы когда-нибудь столкнетесь с ситуацией, когда вам нужно выполнить приведение, вы можете сохранить несколько байтов, используя вместо этого умножение.

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

Помните, где частное или публичное присуще, например, следующее:

class Default{static void Main()

по сравнению с

public class Default { public static void Main()

Для однострочных лямбда-выражений можно пропустить скобки и точку с запятой. Для однопараметрических выражений вы можете пропустить круглые скобки.

Вместо

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

использование

SomeCall(x=>DoSomething);

Циклический:

Переменные объявления:

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

стали:

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

И если у вас есть необходимость или работа с переменной i только один раз, вы можете начать с -1 (или 0 в зависимости от обстоятельств цикла) и увеличить значение inline:

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

в

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

И это уменьшает на один символ, а также немного запутывает код. Сделайте это только для ПЕРВОЙ iссылки, например, так: (если оптимизация одного символа невелика, но она может помочь)

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

в

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

когда цикл не должен увеличиваться i(обратный цикл заказа):

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

Существуют обстоятельства, когда выходной параметр может сохранять символы. Вот немного надуманный пример - алгоритм 10-пинового боулинга.

С возвратом заявления:

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

И с выходным параметром:

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

Выходной параметр здесь сохраняет в общей сложности 5 символов.

В C # нам не разрешено if(n%2)проверять, nявляется ли число четным. Если мы это сделаем, мы получим cannot implicity convert int to bool. Наивная обработка будет делать:

if(n%2==0)

Лучше всего использовать:

if(n%2<1)

Я использовал это, чтобы получить один байт здесь .

обратите внимание, что это работает только для положительных чисел, так как -1%2==-1это считается даже с этим методом.

Строковая интерполяция

По-настоящему простым экономящим место улучшением является интерполяция. Вместо:

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

просто используйте $встроенные выражения:

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

Это, вместе с новыми телами выражений в C # 6.0, должно сделать любую простую задачу вычисления строк довольно удобной в C #.

Используйте C # лямбду. Поскольку PPCG позволяет использовать лямбда для ввода / вывода, мы должны их использовать.

Классические методы C # выглядят так:

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

Как лямбда напишем

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

Анонимная лямбда тоже допускается:

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

Убери весь шум и сфокусируйся!

Обновить:

Мы можем улучшить один шаг больше с выделкой , как @TheLethalCoder комментарий:

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

Пример curring от @Felix Palmen: Как вычислить ключ WPA?

Будет полезно, когда у вас будет ровно 2 параметра, тогда _лучше использовать пустую неиспользуемую переменную . Смотрите мета-пост об этом . Я использую этот трюк здесь . Вам придется немного изменить функцию. Пример: попробуйте онлайн!

Сделайте имена классов только одной буквой. Улучшение на Советы для кода игры в гольф в C # мы идем от

class Default{static void Main()

в

class D{static void Main()

который выбивает еще 6 символов в этом случае.

Метод Computeinstance System.Data.DataTable, позволяет оценить простое строковое выражение, например:

C # (компилятор Visual C #) , 166 байт

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

Попробуйте онлайн!

Не очень "гольф" как таковой, но иногда может быть полезным.

Обмен двух переменных

Обычно, чтобы поменять местами две переменные, вы должны объявить временную переменную для хранения значения. Это будет выглядеть примерно так:

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

Это 16 байтов! Есть некоторые другие методы обмена, которые лучше.

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

Последние три работают только для числовых значений, и, как указано только в ASCII, последние два могут привести к исключению ArithmeticOverflow. Все вышеперечисленное имеет размер 12 байт, что позволяет сэкономить 4 байта по сравнению с первым примером.

Использование LinqPad даст вам возможность удалить все накладные расходы программы, поскольку вы можете выполнять операторы напрямую. (И это должно быть полностью законно в Codegolf ... Никто не говорит, что вам нужен .exe)

Вывод осуществляется с использованием .Dump()метода расширения.

(Частный случай знания вашего приоритета оператора !)

Используйте %для плотного (несколько) ограниченного вычитания. Это может сэкономить вам пару скобок вокруг вычитания, результат которого вы хотите умножить или разделить на что-то; но будьте осторожны, у него есть серьезные ограничения.

Вместо

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)

Рассмотреть возможность

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

Примеры:

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

Я только что обнаружил это, и я чувствую, что это будет полезно помнить при работе с ASCII в будущем. (В настоящее время я играю в гольф где-то, где я использую ASCII для компактных числовых представлений, но нужно умножить на 1или -1на основе другого условия, и это полосатый 2 байта)

Если вам нужно включить несколько usings, которые выпадают из одной и той же иерархии, часто короче использовать самый длинный в качестве namespace:

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

против:

namespace System.Linq
{
    //Some code
}

Обнаружен сегодня вечером "в окопах", улучшая при этом некоторый гольф-код ... если у вас есть класс для обработки, вы можете выполнить работу в конструкторе, чтобы сохранить объявление метода.

Я обнаружил это при сокращении консольного приложения - как было static void Main() , все функции и переменные должны были быть объявлены как статические. Я создал вложенный класс с функциями-членами и переменными, основная работа была выполнена в конструкторе. Это также сохраняет символы в коде вызова.

например, класс с методом:

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

Класс с работой в конструкторе:

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

Этот пример сохраняет 9 символов.

Используйте Actionкак, Funcчтобы установить функцию для переменной. Actionничего не возвращает ( void), так что это отлично подходит для печати.

Например:

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

Эти советы вдохновлены @ W0lf отличным примером использования FuncсReadLine .

Объявлять пустые / совпадающие строки вместе

Если вам нужно объявить несколько пустых / совпадающих строк, вы можете сохранить несколько байтов следующим образом:

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

К сожалению, var a="",b=a,c=a;это незаконно, так какimplicitly type variable cannot have multiple declarators