Que dicas gerais você tem para jogar golfe em C #? Estou procurando idéias que possam ser aplicadas para codificar problemas de golfe em geral que sejam pelo menos um pouco específicos para C # (por exemplo, "remover comentários" não é uma resposta). Poste uma dica por resposta.

- emprestado da ideia de marcog;)

Em vez de usar o .ToString()uso +""de números e outros tipos que podem ser convertidos nativamente para uma sequência com segurança.

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

Certa vez, eu coloquei meu programa deliberadamente namespace Systempara reduzir o acesso a uma classe específica. Comparar

using System;using M=System.Math;

para

namespace System{using M=Math;

Use varpara declarar e inicializar variáveis ​​(únicas) para salvar caracteres no tipo:

string x="abc";

torna-se

var x="abc";

Não é particularmente necessário int, é claro.

Se você estiver usando o LINQ, poderá passar um método diretamente para, em Selectvez de criar um lambda.

Então, ao invés de

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

você pode usar

foo.Select(int.Parse)

diretamente.

(Descoberto recentemente ao melhorar uma das respostas C # de Timwi .)

Lembre-se de que o menor programa compilável em C # tem 29 caracteres:

class P
{
    static void Main()
    {   
    }
}

Portanto, comece removendo isso do seu comprimento e julgue sua resposta sobre quanto isso leva. O C # não pode competir com outros idiomas quando se trata de imprimir ou ler entradas, que é o coração da maioria dos [code-golf]problemas; portanto, não se preocupe. Como jogador de golfe em C #, você está realmente competindo contra o idioma.

Algumas outras coisas a ter em mente:

• Reduza todos os loops e ifinstruções para uma única linha, se possível, a fim de remover os colchetes.
• Se for dada a opção entre stdin e linha de comando, use sempre a linha de comando!

Ao invés de

bool a = true;
bool b = false;

Faz

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

Se você precisar de várias variáveis, use isso (sugerido por @VisualMelon )

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

Favorecer o operador ternário sobre if.. elseblocos onde apropriado.

Por exemplo:

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

é mais eficiente:

j=i<1?1:0;

Uso efetivo do uso

Você pode substituir float (que é um apelido para System.Single) zusandoz=System.Single;

Em seguida, substitua z=System.Single;com z=Single;colocando o programa no espaço de nomes System. (Como na resposta de Joey)

Isso pode ser aplicado a outros tipos de valor (use o que eles são um alias), estruturas e classes

Se você precisar usar Console.ReadLine()várias vezes no seu código (mín. 3 vezes), poderá:

Func<string>r=Console.ReadLine;

e depois é só usar

r()

em vez de

Ao ler cada caractere de um argumento de linha de comando, em vez de fazer um loop até o comprimento da string:

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

Você pode salvar um personagem usando um bloco try / catch para encontrar o fim:

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

Isso se aplica a qualquer matriz dentro de uma matriz, como:

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

Use lambdas para definir uma função em C # 6

No C # 6, você pode usar um lambda para definir uma função:

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

Isso é mais curto do que definir uma função como esta:

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

LINQ

Ao invés de usar:

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

para obter um Enumerable com o resultado da função fpara todos os intitens que [0,y]você pode usar

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

se você precisar stringou algo que implemente Enumerableno seu programa, você também pode usá-los

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

Se você precisar usar um genérico Dictionary<TKey, TValue>pelo menos duas vezes no seu código, poderá declarar uma classe de dicionário, como neste exemplo:

class D:Dictionary<int,string>{}

e depois é só usar

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

em vez de repetir Dictionary<int,string>para cada instanciação.

Eu usei essa técnica nesta resposta

Você pode usar floate doubleliterais para salvar alguns bytes.

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

Quando você precisar de alguma intaritmética para retornar a floatou doublevocê pode usar os literais para forçar a conversão.

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

Se você se deparar com uma situação em que precisa converter, poderá salvar alguns bytes usando multiplicação.

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

Lembre-se de onde o privado ou o público são inerentes, como o seguinte:

class Default{static void Main()

em comparação com

public class Default { public static void Main()

Para expressões lambda de uma linha, você pode pular os colchetes e o ponto e vírgula. Para expressões de um parâmetro, você pode pular os parênteses.

Ao invés de

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

Usar

SomeCall(x=>DoSomething);

Looping:

Declarações variáveis:

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

tornar-se:

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

E se você precisar ou trabalhar com a variável i apenas uma vez, poderá começar com -1 (ou 0, dependendo da circunstância do loop) e aumentar inline:

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

para

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

E isso reduz em um caractere e ofusca um pouco o código também. Faça isso apenas com a PRIMEIRA ireferência, da seguinte forma: (as otimizações concedidas a um personagem não são muito, mas podem ajudar)

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

para

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

quando o loop não precisar ser incrementado i(loop de ordem inversa):

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

Há circunstâncias em que um parâmetro de saída pode salvar caracteres. Aqui está um exemplo um pouco artificial, um algoritmo de pontuação de boliche de 10 pinos.

Com uma declaração de retorno:

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

E com um parâmetro de saída:

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

O parâmetro de saída aqui salva um total de 5 caracteres.

Em C #, não temos permissão if(n%2)para verificar se né um número par. Se o fizermos, temos um cannot implicity convert int to bool. Uma manipulação ingênua seria:

if(n%2==0)

Uma maneira melhor é usar:

if(n%2<1)

Eu usei isso para ganhar um byte aqui .

note que isso só funciona para números positivos -1%2==-1, pois é considerado mesmo com esse método.

Interpolação de String

Uma melhoria realmente simples de economia de espaço é a interpolação. Ao invés de:

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

use apenas $para incorporar expressões:

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

Isso, junto com os novos corpos de expressão no C # 6.0, deve tornar qualquer desafio simples de cálculo de string bastante rentável no C #.

Use C # lambda. Como o PPCG permite lambda para entrada / saída, devemos usá-los.

Um método clássico de C # se parece com o seguinte:

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

Como lambda, escreveremos

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

Lambda anônima também é permitida:

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

Remova todo o barulho e foque!

Atualizar:

Podemos melhorar mais um passo com o curry, como o comentário do @TheLethalCoder:

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

Exemplo de curvatura de @Felix Palmen: como calcular a chave WPA?

Será útil quando você tiver exatamente 2 parâmetros, então uma variável vazia não utilizada _será melhor. Veja meta post sobre isso . Eu uso esse truque aqui . Você terá que mudar um pouco a função. Exemplo: Experimente online!

Faça nomes de classe apenas uma letra. Aprimorando as dicas para golfe de código em C # , vamos de

class Default{static void Main()

para

class D{static void Main()

que bate outros 6 caracteres neste caso.

O Computemétodo de instância de System.Data.DataTable, permite avaliar uma expressão de cadeia simples, por exemplo:

C # (compilador Visual C #) , 166 bytes

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

Experimente online!

Não é muito "golfe" por si só, mas às vezes pode ser útil.

Trocando duas Variáveis

Normalmente, para trocar duas variáveis, você deve declarar uma variável temporária para armazenar o valor. Seria algo parecido com isto:

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

São 16 bytes! Existem alguns outros métodos de troca que são melhores.

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

Os três últimos funcionam apenas para valores numéricos e, como apontado apenas pelo ASCII, os dois últimos podem resultar em uma exceção ArithmeticOverflow. Todos os itens acima são 12 bytes, uma economia de 4 bytes em comparação com o primeiro exemplo.

O uso do LinqPad lhe dará a possibilidade de remover toda a sobrecarga do programa, pois você pode executar instruções diretamente. (E deve ser totalmente legal no codegolf ... Ninguém diz que você precisa de um .exe)

A saída é feita usando o .Dump()método de extensão.

(Um caso específico de conhecer a precedência do seu operador !)

Use %para subtração limitada (de certa forma) limitada. Isso pode economizar um par de parênteses em torno de uma subtração, cujo resultado você deseja multiplicar ou dividir por algo; mas tenha cuidado, ele tem sérias limitações.

Ao invés 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)

Considerar

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

Exemplos:

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

Acabei de descobrir isso e sinto que será algo importante lembrar sempre que trabalhar com a ASCII no futuro. (No momento, estou jogando golfe em algum lugar em que estou usando ASCII para representações numéricas compactas, mas preciso multiplicar por 1ou com -1base em outra condição e esses 2 bytes distribuídos)

Se você precisar incluir vários usings que caem da mesma hierarquia, geralmente é mais curto usar o mais longo como namespace:

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

vs:

namespace System.Linq
{
    //Some code
}

Descoberto hoje à noite "nas trincheiras" enquanto aprimora algum código de golfe ... se você tem uma classe para seu processamento, pode fazer o trabalho no construtor para salvar a declaração de um método.

Descobri isso enquanto reduzia um aplicativo de console - como havia static void Main(), todas as funções e variáveis ​​tinham que ser declaradas estáticas. Criei uma classe aninhada com funções-membro e variáveis, com o trabalho principal realizado no construtor. Isso também salva caracteres no código de chamada.

eg Classe com método:

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

Classe com trabalho no construtor:

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

Este exemplo salva 9 caracteres.

Use Actionlike Funcpara definir uma função para uma variável. Actionnão retorna nada ( void), por isso é ótimo para impressão.

Por exemplo:

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

Esta dicas é inspirado @ W0lf grande exemplo de uso de FunccomReadLine .

Declarar cadeias vazias / correspondentes juntas

Se você precisar declarar várias cadeias vazias / correspondentes, poderá salvar alguns bytes com o seguinte:

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

Infelizmente var a="",b=a,c=a;é ilegal, poisimplicitly type variable cannot have multiple declarators