Existem atalhos úteis que podem ser usados em Java?
Como mostrado abaixo, import
já adiciona pelo menos 17 caracteres a um programa.
import java.io.*;
Entendo que a solução simples seria usar outra linguagem, mas parece ser um desafio real reduzir os programas Java.
As dicas devem ser específicas para Java: se forem aplicáveis à maioria das linguagens do tipo C, elas pertencem à lista mais geral de dicas .
package
pode ser pulado.Respostas:
Use o java possível mais recente. O Java 8 permite o uso de expressões lambda, portanto, se você precisar de algo parecido com objetos funcionais.
Defina funções reduzidas para itens que você usa muito. Por exemplo, você tem cem chamadas para
exampleClassInstance.doSomething(someParameter)
, defina uma nova funçãovoid d(ParameterType p){exampleClassInstance.doSomething(p)}
e use-a para economizar alguns caracteres.Se você estiver usando um nome longo específico de classe mais de uma vez, como
em vez disso, defina uma nova classe:
Se você estiver usando apenas um método específico dessa classe (mas ainda precisar instancia-lo), poderá definir uma versão reduzida dentro da nova classe ao mesmo tempo.
Use os parâmetros do tipo de função para encurtar as coisas, sempre que possível, assim:
Use em
for(;;)
vez dewhile(true)
.Não use modificadores de acesso, a menos que seja absolutamente necessário.
Não use
final
para nada.Nunca coloque um bloco depois de um
for
loop (mas um loop foreachfor(x:y)
é diferente). Instruções adicionais devem ser colocadas dentro dafor
própria instrução, comofor(int i=0;i<m;a(i),b(++i))c(i);
.Use atribuição em linha, incremento, instanciação. Use classes inline anônimas, quando apropriado. Use lambdas, se possível. Aninhar chamadas de função. É garantido que algumas funções retornam seu objeto pai, mas essas são realmente destinadas a serem encadeadas.
Seu
main
métodothrows Exception
s, não os pega.Error
é mais curto queException
. Se, por algum motivo, você realmente precisarthrow
enviar mensagens para a pilha, use umError
, mesmo que seja uma situação perfeitamente normal.Se alguma condição exigir rescisão imediata, use em
int a=1/0;
vez dethrow null;
ouSystem.exit(0);
. Em tempo de execução, isso gera umArithmeticException
. Se você já possui uma variável numérica no seu código, use-a. (Se você já possuiimport static java.lang.System.*;
, vá comexit(0);
.)Em vez de implementar interfaces, como
List<E>
, estenda uma classe filho imediata (ou não tão imediata, se houver alguma vantagem em fazê-lo), comoAbstractList<E>
, que fornece implementações padrão da maioria dos métodos e requer apenas a implementação de algumas peças-chave.Escreva seu código primeiro à mão, com novas linhas, recuo e nomes de variáveis completos. Depois de ter o código em funcionamento, você pode encurtar nomes, mover declarações e adicionar métodos de atalho. Ao escrevê-lo por muito tempo, você terá mais oportunidade de simplificar o programa como um todo.
Compare otimizações alternativas a um pedaço de código, porque a estratégia mais ideal pode mudar drasticamente com alterações muito pequenas no código. Por exemplo:
Arrays.sort(a)
, a maneira mais eficiente de fazê-lo é chamá-lo com seu nome completojava.util.Arrays.sort(a)
,.void s(int[]a){java.util.Arrays.sort(a);}
. Ainda deve usar o nome completo nesse caso. (Se você precisar de mais de uma sobrecarga, provavelmente está fazendo errado.)for
ciclo curto no golfe, na ausência de um método de biblioteca de fácil acesso), você poderá tirar proveito daArrays.copyOf
tarefa. Quando mais de um método é usado e há 3 ou mais chamadas, fazerimport static java.util.Arrays.*;
é a maneira mais eficiente de se referir a esses métodos. Depois disso, somente se você tiver mais de 8 chamadas separadas,sort
deverá usar um método de atalho para isso e apenas em 5 ou mais chamadas é necessário um atalhocopyOf
.A única maneira real de realizar essa análise no código é realmente realizar modificações potenciais nas cópias do código e comparar os resultados.
Evite usar o
someTypeValue.toString();
método, basta anexarsomeTypeValue+""
.Se você precisar de janelas, não use o Swing, use AWT (a menos que você realmente precise de algo do Swing). Compare
import javax.swing.*;
eimport java.awt.*;
. Além disso, componentes do balanço têm umJ
anexado ao seu nome (JFrame
,JLabel
, etc), mas componentes AWT não (Frame
,Label
, etc)fonte
Use em
interface
vez declass
.No java 8, métodos estáticos foram adicionados às interfaces. Nas interfaces, todos os métodos são públicos por padrão. Consequentemente
agora pode ser reduzido para
o que é obviamente mais curto.
Por exemplo, usei esse recurso no Hello, World! desafio.
fonte
Com varargs, você pode "converter" um parâmetro em uma matriz do mesmo tipo:
ao invés de
fonte
Com uma importação estática :
você pode salvar alguns clichês mais tarde, mas precisa de várias invocações para obter um retorno:
fonte
Java
!import static java.lang.System.*
.var o=System.out;
o que só deve ser usado duas vezes antes que compensavar o=System.out.println
?O argumento para
main
não precisa ser chamadoargs
, e você pode cortar alguns espaços em branco:vai fazer muito bem.
fonte
Se você precisar usar as expressões booleanas
true
oufalse
, substitua-as por1>0
e1<0
respectivamente.Por exemplo:
Este exemplo de pesquisa linear pode ser reduzido para
fonte
true/false
, basta adicionarboolean t=1>0,f=1<0;
. Em vez de1>0
, uset
e salve dois caracteres por uso. O1>0
método de pagamento sobre pagamento é de 10 usos.boolean t=1>0,f=!t;
- um char mais curto!true
/false
diretamente de qualquer maneira:f|=a[i++]==42;
economiza bastante.boolean
, mas como não consegui encontrar nenhum exemplo no momento em que escrevi (normalmente não codigo em Java), acabei de escrever um exemplo simples.Se você estiver usando muito algum método, atribua sua classe residente a uma variável. Por exemplo, atribua
System.out
a uma variável:Também para
Integer.parseInt()
:Isso quase certamente acionará um aviso de ide sobre "acessar método estático a partir da variável"
fonte
((Integer)1).parseInt("1")
funciona tambémnew Integer("1")
é ainda mais curto. Mas o que Justin quis dizer com sua resposta é que você pode reutilizar variáveis que já possui para chamadas estáticas. Como explico no final desta resposta.Em vez de usar a
import static java.lang.System.*
técnica para economizar emprintln()
instruções, descobri que definir o método a seguir é muito mais eficaz para salvar caracteres:Isso ocorre porque pode ser invocado
p(myString)
e nãoout.println(myString)
com um retorno de personagem muito mais rápido e mais dramático.fonte
Isso pode parecer óbvio, mas existem opções mais curtas para algumas
Math
funções:fonte
Se você precisar
Integer.MAX_VALUE
(2147483647), use-1>>>1
.Integer.MIN_VALUE
(-2147483648) está melhor escrito1<<31
.fonte
Se você precisar pegar um número de um argumento (ou qualquer outra string), normalmente verá algo como:
Muitas vezes, você não precisa de um
Integer
. Muitos desafios não usam grandes números. ComoShort
eByte
irá unbox para umint
, use o mais apropriadovalueOf()
e salve alguns bytes.Mantenha sua variável real como uma
int
, pois é mais curta que ambasbyte
eshort
:Se você precisar fazer isso para vários números, poderá combinar com este método :
fonte
int n=new Byte(a[0]);
é três mais curto. Se o número for maior, uselong n=new Long(a[0])
, ainda é melhor queint
s na maioria dos casos.Não use
public class
. O método principal precisa ser público, mas sua classe não. Este código funciona:Você pode executar
java S
mesmo queclass S
não seja uma classe pública. ( Atualização: Eu estava usando o Java 7 quando escrevi esta dica. No Java 8, seu método principal deve estar em uma interface . No Java 5 ou 6, seu método principal deve estar em uma enumeração .)Muitos programadores de Java não sabem disso! Cerca de metade das respostas a uma pergunta do Stack Overflow sobre main na classe não pública afirmam erroneamente que o método principal deve estar em uma classe pública. Agora você sabe melhor. Excluir o
public
empublic class
e salvar 7 caracteres.fonte
interface s{static void main(String[]...
é mais curta. Se você deve ter um arquivo de origem compilável e o método principal. Como em uma interface Java 1.8, todos os métodos são públicos, assim você pode pular o modificador no (s) método (s).Algumas pequenas dicas sobre golfe com códigos
Essas dicas eram um pouco pequenas para respostas separadas, portanto, usarei essa resposta para dicas muito pequenas de codegolf que encontrei ou que surgiram e ainda não foram mencionadas nas outras dicas:
Removendo o último caractere de uma String:
Em alguns casos, você sabe qual é o último caractere de antemão e também sabe que esse caractere ocorre apenas uma vez na String. Nesse caso, você pode usar
.split
:Atalhos de codificação:
Todas as codificações têm um nome canônico usado na
java.nio
API, bem como um nome canônico usado nas APIsjava.io
ejava.lang
. Aqui está uma lista completa de todas as codificações suportadas em Java. Portanto, sempre use o menor dos dois; o segundo é geralmente mais curto (comoUTF-8
vsutf8
,Windows-1252
vsCp1252
, etc.), mas nem sempre (UTF-16BE
vsUnicodeBigUnmarked
).Booleano aleatório:
Primes:
Existem várias maneiras diferentes de verificar primos ou obter todos os primos, mas a resposta de @ SaraJ aqui é a mais curta. Aqui está um copiar e colar como referência:
NOTA: Geralmente, você pode mesclá-lo com outros loops existentes, dependendo de como deseja usá-lo, para não precisar de um método separado. Isso economizou muitos bytes nesta resposta, por exemplo.
Truncamento inteiro em vez de Math.floor / Math.ceil:
Se você estiver usando duplos / flutuadores positivos e desejar
floor
, não use,Math.floor
mas use um(int)
-cast (pois o Java trunca em números inteiros):O mesmo truque pode ser aplicado aos duplos / flutuadores negativos que você deseja
ceil
:Use em
&1
vez de%2
se livrar dos parênteses:Como a Precedência do operador de
&
é menor que os operadores aritméticos padrão como*/+-
e%
, em alguns casos, você pode se livrar do parêntese.Observe que isso realmente não ajuda nas verificações booleanas, porque você ainda precisa de parênteses, elas são apenas movidas um pouco:
BigIntegers e criando variáveis para chamadas de método estático:
Ao usar o BigIntegers, crie-o apenas uma vez e depois reutilize-o. Como você deve saber, o BigInteger contém campos estáticos para
ZERO
,ONE
eTEN
. Portanto, quando você usa apenas esses três, não precisa de um,import
mas pode usá-lojava.Math.BigInteger
diretamente.OBSERVAÇÃO: você deve usar
=null
para quet
seja inicializado para poder usart.
.Às vezes, você pode adicionar vários BigIntegers para criar outro para salvar bytes. Então, digamos que você queira ter os BigIntegers
1,10,12
por algum motivo:Como corretamente apontado nos comentários, o truque com
BigInteger t=null;
as chamadas de método estático também pode ser usado com outras classes.Por exemplo, esta resposta de 2011 pode ser jogada no golfe:
getBytes()
ao invés detoCharArray()
Quando você deseja fazer um loop sobre os caracteres de uma String, geralmente você faz isso:
Fazer um loop sobre os caracteres pode ser útil ao imprimi-los ou anexá-los a uma String ou algo semelhante.
No entanto, se você usar apenas os caracteres para alguns cálculos de número unicode, poderá substituir
char
porint
e ANDtoCharArray()
porgetBytes()
:Ou ainda mais curto no Java 8+:
No Java 10+, o loop sobre o caractere a ser impresso também pode ser feito em 22 bytes:
Item aleatório de a
List
:Verifique se uma String contém espaços iniciais / finais
Por que isso funciona, quando
!=
em Strings é procurar referência em vez de valor em Java? PorqueString#trim
retornará " Uma cópia dessa sequência com o espaço em branco à esquerda e à direita removido, ou essa sequência se não tiver espaço em branco à esquerda ou à direita . " Eu usei isso, depois que alguém me sugeriu isso, nesta resposta minha .Palíndromo:
Para verificar se uma String é um palíndromo (tendo em mente os comprimentos pares e ímpares de Strings), este é o mais curto (
.contains
funciona aqui porque sabemos que a própria String e sua forma invertida têm o mesmo comprimento):.contains(...)
em vez de.equals(...+"")
agradecer ao comentário de @assylias aqui .Ou é 0 ou ambos são 0?
Eu acho que a maioria já conhece este: se você quiser verificar se é
a
oub
é zero, multiplique para salvar bytes:E se você quiser verificar se ambos
a
eb
são zero, você poderia usar um bit a bit-OR, ou adicioná-los juntos se eles são sempre positivos:Par = 1, ímpar = -1; ou vice-versa
A razão de eu adicionar este foi depois de ver
k+(k%2<1?1:-1)
nos esta resposta :n
Tempos de loop no programa completoSe tivermos um desafio em que um programa completo é obrigatório e precisamos repetir uma quantidade específica de vezes, podemos fazer o seguinte:
O mesmo se aplica quando temos que usar esse intervalo como entrada:
Os créditos a @JackAmmo neste comentário .
try-finalmente em vez de try-catch (exceção e) ao retornar e quando usá-lo
Se você não pode usar um,
throws Exception
mas precisacatch
fazer algo antes de retornar, pode usarfinally
:Como exemplo de quando usar a
try-catch
, posso me referir a esta resposta minha (o crédito para o golfe indireto vai para @KamilDrakari ). Nesse desafio, temos que fazer um loop diagonal sobre uma matriz NxM, portanto, precisamos determinar se a quantidade de colunas ou a quantidade de linhas é a mais baixa que a máxima no loop for (o que é bastante caro em termos de bytes :)i<Math.min(a.length,a[0].length)
. Portanto, simplesmente capturar oArrayIndexOutOfBoundsException
usocatch-finally
é mais curto que essa verificação e, assim, salva bytes:NOTA: Isso só funcionou por causa do
return r;
no finalmente. Fui sugerido para modificar a primeira célula, como @KamilDrakari fez em sua resposta em C # para salvar bytes. No entanto, em Java, isso significa que terei que alterá-lo param->{try{for(int i=1;;m[0][0]=f(m[0][0],m[i][i++]));}catch(Exception e){}}
(73 bytes), na verdade aumentando a contagem de bytes em vez de diminuir se eu pudesse usá-lofinally
.Math.pow (2, n)
Quando você quer um poder de 2, uma abordagem pouco inteligente é muito mais curta:
Combinando verificações bit a bit e lógicas em vez de usar parênteses
Eu acho que agora é bem conhecido
&
e|
pode ser usado em vez de&&
e||
nas verificações lógicas Java (booleanas). Em alguns casos, você ainda gostaria de usar em&&
vez de&
evitar erros, comoindex >= 0 && array[index].doSomething
. Se o&&
for alterado para&
aqui, ele ainda avaliará a parte em que usa o índice na matriz, causando umArrayIndexOutOfBoundsException
, portanto, o uso de&&
neste caso, em vez de&
.Até agora, o básico de
&&
/||
vs&
/|
em Java.Quando você deseja verificar
(A or B) and C
, o menor pode parecer usar os operadores bit a bit como este:No entanto, como os operadores bit a bit têm precedência de operador sobre as verificações lógicas, você pode combinar os dois para salvar um byte aqui:
Use em
n+=...-n
vez de(long)...
Quando você tem um tempo entre in e output em um lambda, por exemplo, ao usar
Math.pow
, é possível salvar um byte usando emn+=...-n
vez de(long)...
.Por exemplo:
Isso salvou um byte em esta resposta da mina , e até dois bytes, combinando
-n-1
a+~n
em esta resposta da mina .fonte
positive integers
? Além disso, não tenho certeza se a implementação do teto funciona .since Java automatically floors on integers
; Eu acho que o termo adequado é truncamento , não piso .String t="";for(int i=s.length();--i>=0;t+=s.charAt(i));return s.equals(t);
s.equals(new StringBuffer(s).reverse()+"")
.Para o golfe que não requer entrada, você pode usar blocos estáticos e executá-lo sem nenhum método principal, basta compilá-lo com o Java 6.
fonte
java
na linha de comando / em um arquivo de manifesto qual classe carregar.Todos sabemos sobre o xor (
^
) bit a bit , mas também é um xor lógico.Então
(a||b)&&!(a&&b)
simplesmente se tornaa^b
.Agora podemos usar o xor.
Além disso , os operadores
|
e&
também trabalham , basta lembrar que a precedência do operador muda.fonte
&
e|
também. Pode ser útil se suas condições já estiverem entre parênteses ou se você já estiver trabalhando com booleanos.!=
em vez de^
para XOR, e==
para xnorVocê não precisa usar
Character.toLowerCase(char c)
. Em vez disso, use(c|32)
. Em vez deCharacter.toUpperCase(char c)
usar(c&~32)
. Isso funciona apenas com letras ASCII.fonte
c|~32
tenderia a resultar em -1 ... melhor de usarc-32
.Converter String em número
Existem várias maneiras de converter uma String em um valor numérico:
ABC.parseABC :
ABC.valueOf :
ABC.decode :
novo ABC :
Portanto, para jogar golfe com código, é melhor usar o construtor ao converter uma String em um valor numérico.
O mesmo se aplica a
Double
;Float
; eByte
.Isso nem sempre se aplica quando você pode reutilizar uma primitiva já presente como objeto.
Como exemplo, digamos que temos o seguinte código:
Você pode usar em
.decode
vez do construtor mais curto reutilizando o parâmetro como objeto:fonte
Não use
Random
!Em geral, se você precisar de números aleatórios,
Random
é uma maneira horrível de fazer isso *. Muito melhor usar em seuMath.random()
lugar. Para usarRandom
, você precisa fazer isso (digamos que precisamos de umint
):Compare isso com:
e:
O primeiro método utiliza
41+15n
caracteres (n
é o número de chamadas). O segundo são25n
caracteres e o terceiro é43+7n
.Portanto, se você precisar apenas uma ou duas vezes, use o
Math.random()
método inline . Para três ou mais chamadas, você salvará usando uma função. Qualquer um salva os caracteres no primeiro uso novamenteRandom
.Se você já está usando
Math.random()
paradouble
, lembre-se que em quatro usos, ainda é uma poupança para puxá-lo para fora em:Para 33 caracteres, você economiza 10 em cada chamada para
r()
Atualizar
Se você precisar de um número inteiro e quiser economizar na transmissão, não o faça! O Java é auto-convertido se você executar uma operação em vez de uma atribuição. Comparar:
* A menos que você precise semear o PRNG para obter resultados previsíveis. Então, não vejo muita maneira de contornar isso.
fonte
Random#nextGaussian
.(int)(Math.random()*9)
possui um viés de módulo muito pequeno, poisMath.random()
retorna 2 53 valores possíveis e 2 53 não é um múltiplo de 9. A probabilidade de cada número está dentro de 1/9 mais ou menos 5 / (9 * 2 ** 53), um erro tão pequeno, é quase exatamente 1/9.9
apenas como exemplo, poderia ser qualquer coisa. Estou relativamente certo de quenextInt()
(ou qualquer outroRandom
método) também tem um pequeno viés, apenas devido ao funcionamento do PRNG do Java.new java.util.Random().nextBoolean()
você pode usarMath.random()<.5
.Não sei se você consideraria esse Java 'puro', mas o Processamento permite criar programas com pouca configuração inicial (concluída automaticamente).
Para saída do console, você pode ter algo tão simples quanto:
para saída gráfica, um pouco mais:
fonte
size
; o padrão será um quadrado de 100 por 100 pixels. Na maioria dos sistemas operacionais, o quadro em torno dele será duas vezes maior, com o quadrado centralizado e o restante da área preenchida com o conteúdo retirado da área de trabalho.setup()
edraw()
usar o "modo estático". Você também pode usar cores hexadecimais de 6 dígitos e o intérprete as alterará, o que às vezes compensa (#FF8000
<255,128,0
), e se você estiver usando a escala de cinzas, apenas um número precisará ser especificado (255
<255,255,255
)Encurtando o retorno
Você pode reduzir as instruções de retorno de strings por um byte com:
para
E, se você começar sua declaração de retorno entre parênteses, poderá fazer o mesmo com eles:
para
Eu acho que citações são consideradas parênteses? Na verdade, eu peguei isso no AppleScript, o que é engraçado, e achei que valeria a pena mencionar.
fonte
return-n;
vez dereturn -n;
ou emreturn~n;
vez dereturn ~n;
. Bem como aspas simples, em vez de aspas duplas:return'A';
Não tenha medo de usar notação científica
Se você estiver lidando com duplos ou flutuadores, poderá usar notação científica para números. Portanto, em vez de escrever,
double a=1000
você pode alterá-lodouble a=1e3
para salvar 1 byte.fonte
Tente usar em
int
vez deboolean
Em alguns casos, descobri que é mais curto retornar um valor inteiro de um método que normalmente retornaria um booleano, semelhante ao que pode ser feito nos programas C.
Logo de cara
int
é 4 bytes menor queboolean
. Cada vez que você escreve, emreturn 0
vez dereturn 1<0
, salva 2 bytes adicionais e o mesmo porreturn 1
mais dereturn 1>0
.A armadilha aqui é que cada vez que você deseja usar o valor de retorno diretamente como um booleano, custa 2 bytes (
if(p(n))
v.if(p(n)>0)
). Isso pode ser compensado pelo uso da aritmética booleana. Dado um cenário artificial em que você deseja escrevervocê pode escrever
para salvar 2 bytes.
fonte
0
e1
não constitui falso / verdadeiro em Java (e o JLS também não os considera dessa maneira). Portanto, se o golfe está pedindo especificamente por verdade / falsidade, você precisa fazer um booleano (e, infelizmente, torná-lo umaboolean
função, jogando ainda mais bytes nele).t[0]+=p(n):10?0;
Isso é válido?t[0]+=p(n)?10:0;
. (Se você usar enum em vez de classe , salve um caractere.
Mas você precisa introduzir pelo menos uma instância enum (F, G, H neste exemplo) que precisa ser recompensada.
fonte
enum M{;public static void main(String[]a){...}
sem problemas.class M{
tem exatamente o mesmo comprimento queenum M{;
. Nesse caso, eu iria com oclass
porque é mais bonita (IMO)enum{
trabalhou sem;
depois; seu único IDE gemendo que há um compilador erro butthe aceitaQuando você tem um método que deve retornar a
boolean
ouBoolean
, ou seja:Você pode alterar o tipo
boolean
/Boolean
returnObject
para salvar 1 byte:Além disso, como você deve ter notado, pode usar uma
<1
verificação em vez de==0
salvar um byte. Embora isso seja mais uma dica geral de código de golfe em vez de específica para Java.Isso é usado principalmente quando o número inteiro não pode ser negativo, como verificar o comprimento:
ao invés de
fonte
c(-21)
retornatrue
com o atual.c(-20)
vez de-21
?-21 % 5 = 4
e-20 % 5 = 0
.-21
.-21 % 5 != 4
em Java, que é o meu ponto. O divisível por cinco função iria funcionar corretamente se o módulo sempre voltava não negativo, mas isso não acontece. Veja este exemplo de trecho .%
, então eu esqueci Java retorna o resto em vez do módulo, daí a diferença ..Como desenhar em Java ...
Aqui está a placa da caldeira de tinta GUI mais curta possível:
Golfe por 111 bytes:
fonte
Evite
StringBuilder
sAnexar itens a um
String
ocupa muito menos bytes.Se você precisar reverter uma sequência e imprimi-la imediatamente, use a
StringBuffer
.Se você precisar reverter uma string e fazer outra coisa que não imprimi-la, use um
for
loop cada.fonte
StringBuffer
para reverter seqüências.String b="";for(char c:"Hello, World!".toCharArray()){b=c+b;}
{}
loop foreach se quiser usar esse método.String s:"".split("")
vez dechar c:"".toCharArray()
.java.util.stream.Stream
já importou e se precisa encadear outra chamada para o resultado (comoB.chartAt(42)
) ou se apenas precisa passar o resultado para uma função (comof(B)
), usarfor(:)
é igual aStream.of("Hello, World!".split("")).reduce("",(a,b)->b+a)
.String b=new StringBuffer("Hello, World!").reverse()+"";
(.toString
substituído por+""
), e sua segunda linha pode se tornar:String B="";for(String c:"Hello, World!".split(""))B=c+B;
(char
paraString
e.toCharArray()
para.split("")
).Use Java 10's
var
Se você definir uma única variável de um tipo específico, use
var
.Exemplos
Não pode ser usado em nenhum dos seguintes exemplos
var
não pode ser usado em muitos exemplosfonte
Na maioria dos casos, seu programa será de thread único, ou seja, terá apenas um thread em execução. Você pode explorar esse fato
return
usando o método principal quando precisar sair instantaneamente.Compare-o com o encerramento "adequado" do programa:
Ou apontando para
null
:Ou dividindo por 0:
fonte
Às vezes, uma única instrução for-loop pode ser substituída. Considere o seguinte código:
Este é um loop for simples, que é uma solução para esta pergunta .
Como sabemos que
i
não será grande o suficiente para causar erros no StackOverflow, podemos substituir o loop for por recursão:Podemos simular um loop usando um operador ternário na declaração de retorno para causar recursão.
Essa redução é bastante específica, mas posso imaginar mais situações em que isso seria útil.
fonte
Usando
...
(varags) como parâmetroEm alguns casos, é mais curto usar um varargs Java como parâmetro em vez de outros frouxos.
Por exemplo:
Seria golfe por mais para isso:
Mas pode ser jogado um byte adicional para isso:
Observe que todos os três números inteiros são acessados apenas uma vez no próprio método. Como
int
é bastante curto, só é benéfico se você os usar apenas uma vez dentro do método e tiver três ou mais deles como parâmetro.Com parâmetros mais longos, isso geralmente é mais útil. Por exemplo, esta foi minha resposta original para esse desafio (calcular ocorrências do caractere de entrada na string de entrada):
E eu fui recomendado a jogar com isso:
Mas acabei jogando isso usando
...
:NOTA: Se a pergunta / desafio solicitar uma entrada flexível, ela
...
poderá ser reduzida para, é[]
claro. Se a pergunta / desafio solicitar especificamente, digamos, trêsString
entradas e não permitir umString
array contendo três valores, você poderá usar emString...
vez deString a,String b,String c
.fonte
String[]
vez de usar varargs? (economiza mais 1 byte)