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

TMTOWTDI

Essa é a dica de golfe Perl mais importante que você precisa conhecer. Sempre que você estiver olhando para uma sequência muito longa de caracteres que você absolutamente precisa ter para realizar sua tarefa, pergunte a si mesmo se não há outra maneira de obter o mesmo efeito usando um recurso diferente. Geralmente existe. Aqui estão apenas algumas:

• ~~impõe um contexto escalar e é 4 caracteres menor que scalar.

• y///cé um caractere mais curto do que lengthquando obtém o comprimento de $_.

• Precisa iterar sobre os caracteres $_? Substitua split//por /./gs. (Ou use /./gse você também quiser pular novas linhas.) Isso funciona com outras variáveis: substitua split//,$xpor $x=~/./gs.

• Todo Perl embutido retorna algo. printretorna 1, por exemplo, para indicar E / S bem-sucedida. Se você precisar inicializar $_com um valor verdadeiro, por exemplo, $_=print$foopermite matar dois coelhos com uma cajadada só.

• Quase todas as declarações no Perl podem ser escritas como uma expressão, permitindo que sejam usadas em uma variedade maior de contextos. Várias instruções podem se tornar várias expressões encadeadas por vírgulas. Os testes podem ser feitos com operadores de curto-circuito ?: && ||e também com ande or, que fazem a mesma coisa, mas com precedência menor do que todos os outros operadores (incluindo a atribuição). Os loops podem ser feitos via mapou grep. Mesmo palavras-chave como next, laste returnpode ser usado em um contexto expressão, mesmo que eles não voltar! Tendo em mente esses tipos de transformações, você tem a oportunidade de substituir blocos de código por expressões que podem ser inseridas em uma variedade maior de contextos.

Abuse as variáveis ​​especiais do Perl!

• Conforme observado em uma resposta anterior, $/e $"são inicializados por padrão para "\n"e " ", respectivamente.

• $,e $\são definidos como undefpadrão e são 3 caracteres mais curtos.

• Definir $\um valor fará com que ele seja anexado a todos print. Por exemplo: perl -ple '$\="=".hex.$/'é um prático conversor hexadecimal para decimal.

• Se você não estiver lendo arquivos da linha de comando, poderá usar a -iopção de linha de comando como um canal extra para inserir uma string. Seu valor será armazenado em $^I.

• $=força o que for atribuído a ele como um número inteiro. Tente executar perl -ple '$_=$==$_'e dar várias entradas. Da mesma forma, $-força seu valor a ser um número inteiro não negativo (ou seja, um traço à esquerda é tratado como um caractere não numérico).

• Você pode usar $.como um sinalizador booleano que é redefinido automaticamente para um valor verdadeiro (diferente de zero) em todas as iterações de um while(<>)loop.

-n e colchetes incomparáveis

É sabido que a opção de linha de comando -npode ser usada para executar o script uma vez para cada linha.

perl --help diz:

  -n                assume "while (<>) { ... }" loop around program

O que não diz explicitamente é que o Perl não assume apenas um loop ao redor do programa; ele literalmente envolve while (<>) { ... }em torno dele.

Dessa forma, os seguintes comandos são equivalentes entre si:

 perl -e 'while(<>){code}morecode'
 perl -ne 'code;END{morecode}'
 perl -ne 'code}{morecode'

-p e colchetes incomparáveis

De maneira semelhante ao acima, o -pcomutador envolve while (<>) { ... ; print }o programa.

Ao usar colchetes incomparáveis, perl -p 'code}{morecode'será impresso apenas uma vez após a execução codede todas as linhas de entrada, seguidas por morecode.

Como não $_é definido quando morecode;printé executado, o separador de registros de saída $\pode ser usado com abuso para imprimir a saída real.

Por exemplo

perl -pe '$\+=$_}{'

lê um número por linha de STDIN e imprime sua soma.

Use $_para eliminar referências escalares. É a variável especial que é usada como padrão pela maioria das funções, e deixar de fora os parâmetros é um atalho para fazer referência a essa variável.

Ao mudar $npara $_, você pode mudar $n=<>;chop$n;print$npara$_=<>;chop;print

Aqui, a printfunção imprime o conteúdo de $_por padrão e choptambém funciona $_.

Use as variáveis ​​especiais do Perl sempre que possível, por exemplo:

• Use em $"vez de" "
• Use em $/vez de"\n"

Eles têm o benefício adicional de serem um identificador de um caractere garantido, com a ajuda do lexer. Isso possibilita colá-lo à palavra-chave a seguir, como em:print$.for@_

A lista de todas as variáveis ​​especiais está disponível aqui: Variáveis ​​Especiais

Não use qw. Isso é desperdício de dois caracteres que poderiam ser usados ​​da melhor maneira. Por exemplo, não escreva o seguinte.

@i=qw(unique value);

Em vez disso, use palavras de barras.

@i=(unique,value);

Ou, se você não pode usar palavras de barra, use a globsintaxe.

@i=<unique value>;

glob A sintaxe também pode ser usada para efeitos interessantes.

@i=<item{1,2,3}>;

Use modificadores de instrução em vez de instruções compostas.

Instruções compostas tendem a exigir parênteses para o argumento e chaves para o bloco, enquanto modificadores de instruções não precisam de nenhuma.

Comparar:

• $a++,$b++while$n-- vs while($n--){$a++;$b++}
• chop$,if$c vs if($c){chop$,}

Observe que o último exemplo está vinculado $c&&chop$,, mas começa realmente a brilhar na maioria das operações com várias instruções. Basicamente, qualquer coisa que perca precedência do operador &&.

Não use strict. (não me cite, o contexto PCG.SE é meio importante) E, mais importante, não codifique como se estivesse sob rigoroso. Os suspeitos do costume:

• não mydeclare variáveis ​​se puder evitá-lo. As únicas variáveis ​​que realmente precisam mysão aquelas que você deseja definir com escopo lexical. Isso quase não ocorre no golfe, onde você não precisa de proteção de escopo e tende a controlar totalmente a recursão.
• não cite cadeias de caracteres de uma palavra: ( exemplo ). Porém, verifique se você não possui uma função com o mesmo nome.

Tenho certeza de que alguns deles têm nomes formais e simplesmente não os conheço.

• Se você tiver um loop while (ou um loop for, você pode transformá-lo em um loop while), poderá definir o "while" após o comando: print $n++ while ($n < 10)
• Se você precisar ler tudo, desde STDIN em uma string: $var = join('',<>)
• Como o CeilingSpy apontou, usar $ / em vez de \ n é mais rápido em algumas situações: print ('X'*10) . "\n";é maior queprint ('X'*10) . $/;
• A sayfunção do Perl é menor que print, mas você precisará executar o código em -Evez de-e
• Use intervalos como a..zou mesmo aa..zz. Se necessário como uma string, use join.
• Incrementando strings: $z = 'z'; print ++$z;será exibidoaa

É tudo o que consigo pensar agora. Eu posso adicionar um pouco mais tarde.

Use caracteres que não sejam palavras como nomes de variáveis

Usando $%vez de $apode permitir que você coloque o nome da variável para a direita ao lado de um if, forou whileconstruir como em:

@r=(1,2,3,4,5);$%=4; print$_*$%for@r

Muitos podem ser usados, mas verifique os documentos e a resposta do @ BreadBox para quais têm efeitos mágicos!

Use map quando não puder usar modificadores de instrução

Se você não pode usar modificadores de declaração de acordo com a resposta de @ JB , o mapa pode salvar um byte:

for(@c){} vs. map{}@c;

e é útil se você deseja fazer iterações aninhadas, pois é possível colocar forloops postfix dentro do arquivo map.

Use todas as variáveis ​​mágicas de expressão regular

O Perl possui variáveis ​​mágicas para 'texto antes da correspondência' e 'texto após correspondência', portanto, é possível dividir em grupos de dois com potencialmente menos caracteres:

($x,$y)=split/,/,$_;
($x,$y)=/(.+),(.+)/;
/,/; # $x=$`, $y=$'
# Note: you will need to save the variables if you'll be using more regex matches!

Isso também pode funcionar bem como um substituto para substr:

$s=substr$_,1;
/./;# $s=$'

$s=substr$_,4;
/.{4}/;# $s=$'

Se você precisar do conteúdo da partida, $&pode ser usado, por exemplo:

# assume input like '10 PRINT "Hello, World!"'
($n,$c,$x)=split/ /,$_;
/ .+ /; # $n=$`, $c=$&, $x=$'

Substituir subs por nomes longos por um nome mais curto

Se você ligar, digamos printquatro ou mais vezes em seu código (isso obviamente varia com a duração da rotina que você está chamando), substitua-o por um subnome mais curto:

sub p{print@_}p;p;p;p

vs.

print;print;print;print

Substituir incrementadores / decrementadores condicionais

Se você tiver um código como:

$i--if$i>0

você pode usar:

$i-=$i>0

em vez disso, salve alguns bytes.

Converter em número inteiro

Se você não está atribuindo a uma variável e não pode usar a dica da caixa de pão , pode usar a expressão 0|:

rand 25 # random float eg. 19.3560355885212

int rand 25 # random int

0|rand 25 # random int

rand 25|0 # random int

~~rand 25 # random int

No entanto, vale a pena notar que você não precisa usar um número inteiro para acessar um índice de matriz:

@letters = A..Z;
$letters[rand 26]; # random letter

redoadiciona comportamento de loop a um bloco sem forou while. {redo}é um loop infinito.

Não coloque parênteses em chamadas de função.

O Perl permite chamar uma função conhecida (principal ou predefinida) usando a NAME LISTsintaxe. Isso permite que você solte o &sigilo (se você ainda o estiver usando) e os parênteses.

Por exemplo: $v=join'',<>

Documentação completa

Tente usar o valor de uma expressão de atribuição, da seguinte maneira:

# 14 characters
$n=pop;$o=$n&1

# 13 characters, saves 1
$o=($n=pop)&1

Isso funciona porque $nhá 2 caracteres no Perl. Você pode alterar $npara ()sem nenhum custo e economizar 1 ponto e vírgula movendo a atribuição entre parênteses.

Você pode executar várias instruções diferentes dentro da lógica ternária aninhada.

Suponha que você tenha um grande if- elsifcomunicado. Pode ser qualquer lógica e qualquer número de instruções.

if( $_ < 1 ) {
    $a=1;
    $b=2;
    $c=3;
    say $a.$b.$c;
} elsif($_ < 2 ) {
    $a=3;
    $b=2;
    $c=1;
    say $a.$b.$c;
} elsif( $_ < 3) {
    $a=2;
    $b=2;
    $c=2;
    say $a.$b.$c;
}

Você pode usar (cmd1, cmd2, cmd3)dentro do operador ternário para executar todos os comandos.

$_ < 1 ?
    ($a=1,$b=2,$c=3,say$a.$b.$c):
$_ < 2 ?
    ($a=3,$b=2,$c=1,say$a.$b.$c):
$_ < 3 ?
    ($a=2,$b=2,$c=2,say$a.$b.$c):
0; #put the else here if we have one

Aqui está um exemplo fictício:

perl -nE'$_<1?($a=1,$b=2,$c=3,say$a.$b.$c):$_<2?($a=3,$b=2,$c=1,say$a.$b.$c):$_<3?($a=2,$b=2,$c=2,say$a.$b.$c):0;' <(echo 2)

Use em select(undef,undef,undef,$timeout)vez deTime::HiRes

(Retirado de https://stackoverflow.com/a/896928/4739548 )

Muitos desafios exigem que você durma com maior precisão do que números inteiros. select()O argumento de tempo limite pode fazer exatamente isso.

select($u,$u,$u,0.1)

é muito mais eficiente que:

import Time::HiRes qw(sleep);sleep(0.1)

O primeiro tem apenas 20 bytes, enquanto o último ocupa 39. No entanto, o primeiro exige que você não esteja usando $ue nunca o definiu.

Se você vai usá-lo muito, a importação Time::HiRescompensa, mas se você precisar apenas uma vez, o uso select($u,$u,$u,0.1)salva 19 bytes, o que é definitivamente uma melhoria na maioria dos casos.

Encurte suas declarações de impressão

A menos que o desafio especifique o contrário, não é necessário rastrear novas linhas.
Nosso 'desafio' diz 'gera um número aleatório de 0 a 9 para STDOUT'. Podemos pegar este código (28 bytes):

$s=int(rand(10));print"$s\n"

E reduza para isso (25 bytes):

$s=int(rand(10));print $s

simplesmente imprimindo a variável. Este último se aplica apenas a esse desafio especificamente (19 bytes):

print int(rand(10))

mas isso só funciona quando você não precisa fazer nada com a variável entre atribuição e impressão.

Use globs como literais de string

Ocasionalmente (geralmente quando se lida com desafios de quine ou de fonte restrita ), você se beneficia muito da capacidade de aninhar literais de strings. Normalmente, você faria isso com q(…). No entanto, dependendo de quais caracteres você precisa dentro da string, você poderá salvar um byte e usar <…>o operador glob. (Observe que o que está dentro dos colchetes angulares não pode parecer um identificador de arquivo e não pode ser expandido para uma lista de nomes de arquivos, o que significa que muitos caracteres não funcionarão corretamente.)

Use a expressão regexe.

Uma ilustração decente disso é o seguinte código que forma a entrada em onda senoidal:

s/./print" "x(sin($i+=.5)*5+5).$&/eg;

Como você pode ver, é uma maneira bastante compacta de iterar caracteres na entrada padrão. Você pode usar outra regex para alterar a maneira como as coisas são correspondidas.