É um ano bissexto?

41

Este desafio é bastante simples. Você receberá uma entrada que será de um ano entre 1801 e 2400 e a saída, se for um ano bissexto ou não.

Sua entrada não terá novas linhas ou espaços finais:

1954

Você produzirá da maneira que desejar, que diga claramente ao usuário se é ou não um ano bissexto (aceitarei y ou n para sim / não)

Você pode obter uma lista dos anos bissextos aqui: http://kalender-365.de/leap-years.php Gostaria de observar que os anos bissextos nem sempre são quatro anos. 1896 é um ano bissexto, mas 1900 não é. Os anos seguintes a este "salto" são:

1900
2100
2200
2300

Casos de teste:

1936 ->  y
1805 ->  n
1900 ->  n
2272 ->  y
2400 ->  y 

EDIT: Isso é baseado em um calendário gregoriano padrão: http://www.epochconverter.com/date-and-time/daynumbers-by-year.php

Kevin Cruijssen
fonte
9
Você deve ser mais claro: um determinado ano é um ano bissexto se e somente se for (divisible by 4)∧((divisible by 100)→(divisible by 400)).
LegionMammal978
Sua entrada não terá novas linhas ou espaços à direita. Dang-lo, isso teria me salvou 2 bytes ...
Dennis
2
Você deve estender o intervalo de entrada aceito para 1601 a 2400 AD. Isso abrange dois ciclos gregorianos de 400 anos (que iniciam de forma prolítica na segunda-feira).
David R Tribble
2
Falsificar se ano bissexto e verdade se não um ano bissexto contam como "informa claramente o usuário se é ou não"?
Lirtosiast 28/05
@ Lirtosiast Acho que sim. Muitos usuários assumem isso.
aloisdg diz Reinstate Monica

Respostas:

22

APL, 16 14 12 caracteres

Retorna 0para um ano bissexto, 1para um ano não bissexto.

≥/⌽×4 25 4⊤⎕

Experimente esta solução em tryapl.org . Observe que eu mudei a solução para o {≥/⌽×4 25 4⊤⍵}dfn porque o tryapl.com não suporta ( aceite a entrada do usuário). Observe que é uma caixa vazia, não um caractere ausente.

A mesma solução em J:

4 25 4>:/@|.@:*@#:]

Explicação

Diádico (codificação) representa seu argumento correto na base especificada por seu argumento esquerdo. Eu uso base 4 25 4nesta solução. Isso representa o ano y como um polinômio

y mod 400 = 100 a + 4 b + c  onde b <100 ec <4.

Deixe proposições a, β, e y representam se , um b, e c são diferentes de zero: proposição γ é falso, se y é divisível por quatro, βγ é falso, se y é divisível por 100 e ctβγ seja false se y é dividível por 400.

Uma tabela de verdade ( *representando “não se importa”) onde a proposição Δ representa se y for um ano bissexto obtém:

α β γ | Δ
0 0 0 | 1
1 0 0 | 0
* 1 0 | 1
* * 1 | 0

A declaração a seguir expressa Δ em α , β e γ :

Δ = ¬ (( αβ ) → γ )).

Devido à estrutura desta afirmação, pode-se expressar ΔΔ como a redução em ≥/⌽α β γque ≥ implementa ←. Isso leva à resposta que estou explicando agora.

FUZxxl
fonte
16

Pitão, 11 bytes

!%|F_jQ*TT4

Este programa completo lê de STDIN e imprime True por anos bissextos e False de outra forma.

Obrigado a @Jakube por sugerir Pyth e basicamente portar meu código CJam.

Verifique você mesmo os casos de teste no Pyth Compiler / Executor .

Como funciona

     jQ*TT   Returns the evaluated input in base 10 × 10.
  |F_        Swaps the digit order and reduces using logical OR.
             So far, we've achieved 1954 -> [19, 54] -> 54 || 19.
!%        4  Returns the logical NOT of the result modulo 4.
             This prints True for multiples of 4 and False otherwise.
Dennis
fonte
15

CJam, 12 bytes

rS+2m<~e|4%!

Este programa completo lê STDIN e imprime 1 por anos bissextos e 0 caso contrário.

Verifique você mesmo os casos de teste no interpretador CJam .

Como funciona

r   e# Read from STDIN.
S+  e# Append a space.
2m< e# Rotate two characters to the left.
~   e# Evaluate.
    e# So far, we achieved "1954" -> "54 19" -> 54 19.
e|  e# Logical OR; keep the leftmost non-zero integer.
4%! e# Logical NOT of the kept integer modulo 4.
    e# This pushes 1 for multiples of 4 and 0 otherwise.
Dennis
fonte
Eu tenho mais algumas alternativas de 12 bytes. Talvez você possa encontrar algo neles para reduzi-lo a 11? r2/~~\e|i4%!, r2/~~\~e|4%!, r2/:~~\e|4%!, r2/S*~\e|4%!E 13 byter2/:~W%:e|4%!
Martin Ender
@ MartinBüttner: Há também r2/:i:\e|4%!(12) e r2/:i(fe|~4%!(13). Eu até tentei o GolfScript (que não requer r), mas or4é interpretado como um único token. Se ao menos a entrada tivesse uma nova linha à direita ...
Dennis
14

Javascript (ES6), 21 caracteres

A regra padrão é que yé um ano bissexto se 4 se divide ye se 100 não se divide you se 400 se dividem y. Em código,

y%4 == 0 && (y%100 != 0 || y%400 == 0)

Não há necessidade de 100 e 400. Em vez disso, basta verificar se 16 ou 4 divide y, com 16 escolhido se 25 divide y, 4 caso contrário. Golfed, isso se torna

!(y%(y%25?4:16))

Uma função javascript que implementa isso tem 21 caracteres:

l=y=>!(y%(y%25?4:16))


Perl, 28 26 caracteres

Mesma ideia, mas em perl.

$_=$_%($_%25?4:16)?"n":"y"

Execute usando as -lpopções. Por exemplo,

perl -lpe '$_=$_%($_%25?4:16)?"n":"y"'

Com o teste definido como entrada, isso produz

1936
y
1805
n
1900
n
2272
y
2400
y
David Hammen
fonte
Eu tinha usado sua sugestão na minha resposta, não vi a sua. Agora eu voltei. Nota: Você deve especificar o EcmaScript 6, caso contrário, alguém reclamará 'não está funcionando no Chrome'
edc65
@ edc65: Bem, ele deve especificar o EcmaScript 6 porque é o EcmaScript 6. A notação de função de seta ( y=>...) é um recurso do ES6.
Tim Čas
Isso não deveria ser duas respostas?
dfeuer 01/03
9

Pip , 13 bytes

Este foi mais interessante do que parecia à primeira vista. Demorou algum tempo para finalizar, mas finalmente consegui substituir aquelas referências longas com 400with 4e a hvariável (= 100).

!(a%h?aa/h)%4

Saídas 1para o ano bissexto, 0para o ano não bissexto. Explicação:

               a is command-line argument (implicit)
  a%h?aa/h     If a is divisible by 100, divide it by 100; otherwise, leave it alone
 (        )%4  The result mod 4 is 0 if it's a leap year, nonzero otherwise
!              Negate and (implicitly) print
DLosc
fonte
9

Pitão, 19 15 14 bytes

xFm!%Q^d2[2TyT

Muito fácil. Experimente on-line: demonstração ou equipamento de teste

edit: Missed, que você pode imprimir valores Truthy / Falsy, em vez de n/y. -4 bytes

editar 2: Usou a idéia da raiz quadrada de Martin. -1 byte

Explicação

                 implicit: Q = input number
         [         generate a list with the numbers:
          2          2
           T         10
            yT       2*10 = 20
  m              map each number d to:
   !%Q^d2          not(Q mod d^2) // True if Q % d^2 == 0 otherwise False
xF               fold by xor
Jakube
fonte
9

Regex, 83 62 38

Agradecemos a Toby pelas dicas sobre como combinar as duas metades da regex.

Se focarmos apenas no intervalo 1801..2400 e assumirmos que a entrada é um número inteiro:

(?!00)([02468][048]|[13579][26])(00)?$

Teste em Ruby ( ^= \Ae $= \Zporque Ruby) para o intervalo desejado:

r = /(?!00)([02468][048]|[13579][26])(00)?\Z/
(1801..2401).each do |year|
  leap = year % 4 == 0 && ((year % 100 != 0) || (year % 400 == 0))
  leap_regex = !year.to_s[r].nil?
  if leap != leap_regex
    print 'Assertion broken:', year, " ", leap, " ", leap_regex, "\n"
  end
end

(Bônus) para algo que deve funcionar não apenas para 1801..2400, mas para qualquer ano não negativo:

^\d*(0000|(?!00)([13579][26]|(^|[02468])[048])(00)?)$

Teste em Ruby ( ^= \Ae $= \Zporque Ruby) nos primeiros 100000 anos:

r = /\A\d*(0000|(?!00)([13579][26]|(\A|[02468])[048])(00)?)\Z/
100000.times do |year|
  leap = year % 4 == 0 && ((year % 100 != 0) || (year % 400 == 0))
  leap_regex = !year.to_s[r].nil?
  if leap != leap_regex
    print 'Assertion broken:', year, " ", leap, " ", leap_regex, "\n"
  end
end
rr-
fonte
11
Se você tiver, (?!)pode combinar as duas metades: (?!00)([02468][048]|[13579][26])(00)?$- para 38. Porém, isso não funcionará por anos de um dígito.
Toby Speight
9

JavaScript ( ES6 ) 27

A regra: (y%4==0) && (y%100!=0 || y%400==0)

Golfe: !(y%100<1&&y%400||y%4)(principalmente usando a lei de De Morgans )

Uma função que implementa a regra:

l=y=>!(y%100<1&&y%400||y%4)

Um teste (executado no Firefox) apenas para ter certeza:

l=y=>!(y%100<1&&y%400||y%4)

for(o=[],i=0;i<700;i++)
  y=i+1800,
  x=l(y),
  o[i/100|0]=(o[i/100|0]||'')+y+(x?' <b>Y</b>':' <i>N</i>')+'\n'
    
R.innerHTML='<td>'+o.join('</td><td>')+'</td>'
console.log(o[1])
td { white-space: pre; font-family: monospace; padding: 8px}

b { color: red; }
i { color: blue; }
<table>
  <tr id=R></tr>
</table>

edc65
fonte
3
Você pode reduzir isso em seis caracteres se usar em !(y%(y%25?4:16))vez de !(y%100<1&&y%400||y%4). Para aqueles incomodados pelo operador ternário, você pode usar !(y%(4<<2*!(y%25)))e ainda salvar três caracteres !(y%100<1&&y%400||y%4).
David Hammen
11
A sugestão de David Hammen é idêntica à sua resposta, então eu acho que você deve manter o comprimento de 27.
lirtosiast
9

TI-BASIC, 20 17 16 13

Por ser tokenizado, o TI-BASIC geralmente é competitivo em desafios simples de matemática, mas não este, pois não existe um comando "divisível". Talvez seja afinal, mas ainda é mais longo que CJam e Pyth.

Isso usa o método de David Hammond.

not(fPart(Ans/4/4^not(fPart(sub(Ans

Código antigo com 16 bytes:

not(fPart(Ans/16not(fPart(sub(Ansnot(fPart(Ans/4

Ungolfed:

not(fPart(Ans/16) and not(fPart(Ans/100) and not(fPart(Ans/4))))

fPart(é "parte fracionária"; exponenciação tem maior precedência que divisão. No TI-BASIC, os close-parens são opcionais.

Uso o comportamento não documentado do sub(comando, geralmente usado para obter uma substring: quando seu argumento é um número em vez de uma string, ele divide o número por 100. Ele funcionará em uma calculadora da série TI-83 ou 84.

20 -> 17 reorganizando o código para permitir a remoção de parentes próximos; 17 -> 16 substituindo 400 por 16; 16 -> 13 usando a idéia de David Hammond.

lirtosiast
fonte
9

Stackylogic, 226 bytes (não concorrente)

Sim isso está certo. Eu fiz um programa em Stackylogic (não-TC), que foi inventado por Helka Homba, para o desafio encontrado aqui . Isso é feito após o desafio, portanto não competitivo.

O Stackylogic possui apenas entrada binária, portanto, 10 (ou mais, mais dígitos serão ignorados) deve ser usado o binário de bits (o bit menos significativo inserido primeiro). Qualquer data fora do intervalo especificado pode falhar, pois simplesmente verifica qual é o número inserido: ele não cobre datas desnecessárias

Não é apenas este o meu primeiro desafio com stackylogic, mas o primeiro desafio com stackylogic.

Prepare-se para esta bagunça:

1
0
1?
010
1?0
010
1?10
?1010
001010
?1010
?1010
?010
?10
?0
0
?
110
?10
11010
?010
11010
?1010
001010
?1010
?1010
?1010
?1010
?010
?0
110
?10
11010
?010
1010
01010
01010
?010
?0
110
?0
110
?0
110
1?0
?10
0?10
?10
?0
01
?
?<
0

Isso demorou tanto para ser feito, porque o Stackylogic é a linguagem mais confusa que encontrei e extremamente ilegível: você precisa saber como o resto do programa foi executado antes de poder ler a seção atual que está sendo editada. Eu até tive que adicionar espaços para facilitar a leitura enquanto o criava.

Pouca explicação

Esta é uma explicação simples do que faz.

O Stackylogic não possui funções matemáticas, tornando isso mais difícil. Eu tive que codificar a maior parte, para verificar se era um número específico.

Primeiro, este programa fará uma NOR dos bits menos significativos, descartando-os no processo. isto significa que, se for divisível por 4, prosseguirá para a parte principal do programa, caso contrário, será gerado 0.

Segundo, o ponteiro é transportado para o labirinto da stackylogic, a partir daqui, se os próximos dois bits forem zero, ele produzirá instantaneamente 1 (então é divisível por 16 e, portanto, um ano bissexto apesar de quaisquer outras condições), outras sábio, ele verificará se nenhum dos números é divisível por 4, mas não um ano bissexto, entre 1801 e 2400.

Para explicar em detalhes, envolveria tornar este post muito mais longo do que já é

Limão destrutível
fonte
8

Montador do IBM System Z - 56 bytes.

(96 bytes de origem. Anteriormente 712 384 202 bytes de origem, executável de 168 bytes).

Versão menor ainda. Não salva mais os registros de chamadas, alterações no armazenamento literal, modo de endereçamento alterado.

 l        CSECT      
         using l,15 
         l  5,y     
         n 5,f      
         bnz r      
         xr 4,4     
         l 5,y      
         d 4,c      
         ch 4,i     
         bne i      
         n 5,f      
         bnz r      
i        dc h'0'    
r        b  *       
y        dc f'2004' 
f        dc f'3'    
c        dc f'100'  
         end 

Nova versão. Isso será ABEND com um S0C1 se for um ano bissexto, e repetido se não for. Espero que isso cumpra o requisito de indicar o resultado.

l        CSECT             
         ASMDREG           
         SYSSTATE archlvl=2
         IEABRCX  DEFINE   
         save  (14,12)     
         larl  r9,s        
         using s,r9        
         st 13,w+4         
         la 13,w           
         st 13,w+8         
         la 5,2004         
         st 5,y            
         n 5,=f'3'         
         bnz r             
         xr r4,r4          
         l 5,y             
         d r4,=f'100'      
         ch r4,=h'0'       
         bne i             
         n 5,=f'3'         
         bnz r             
i        dc h'0'           
r        b  0              
s        dc 0d'0'          
y        ds f              
w        ds 18f            
         ltorg             
         end  

OK, então não é o mais curto (embora possa ser uma vez que analisemos o código executado real mais o tamanho do interpretador ...)

leapyear CSECT                                                
         ASMDREG                                              
         SYSSTATE archlvl=2                                   
         IEABRCX  DEFINE                                      

         save  (14,12)                                        

         larl  r9,staticArea                                  
         using staticArea,r9                                  
         st r13,w_savea+4       .Save callers savearea        
         la r13,w_savea         .Address my savearea          
         st r13,w_savea+8         . and save it               

         open  (O,OUTPUT)             .open file              

         la r5,1936             .r5 = input year              
         st r5,years            .Save year                    

         cvd r5,double          .Convert year to p-decimal    
         mvc edarea,=xl8'4020202020202120' .Move in edit mask 
         ed edarea,double+4      .Make packed decimal year printable                              
         mvc outrec(4),edarea+4  .Move year string to output area                             
         bas r10,isitleap       .Call leap year routine       

         close (O)              .Close files            
         b return               .Branch to finish

isitleap ds 0h                                                      
         mvi outrec+5,c'N'      .Set default value                                   
         n r5,=f'3'             .Are last 2 bits 0 (Divisible by 4)?
         bnz notleap            .No - not leap                      
         xr r4,r4               .Clear R4                           
         l r5,years             .Reload r5 with year                
         d r4,=f'100'           .divide r4/r5 pair by 100           
         ch r4,=h'0'            .Remainder 0?                       
         bne isleap             .No - leap year                     
         n r5,=f'3'             .Quotient divisible by 4?           
         bnz notleap            .No - not leap                      

isleap   ds    0h                                                   
         mvi outrec+5,c'Y'      .Move in leap year indicator                                    

notleap  ds    0h                                                   
         put O,outrec           .Print output record                                    
         br r10                 .Return to caller                   

* Program termination                                               
return   ds 0h                                                      
         l r13,w_savea+4         .Restore callers savearea          
         return (14,12),,rc=0    .Restore registers and return    
* storage areas                                                     
staticarea  dc 0d'0'                                                
outrec      ds cl10                                                 
years       ds f                                                    
w_savea     ds 18f                save area                         
edarea      ds cl8                    .edit area                    
double      ds d                                                    
* Macros and literals                                               
         print nogen                                                
O        dcb   recfm=F,lrecl=6,dsorg=PS,ddname=O,macrf=PM           
         print gen                                                  
*                                                                   
         ltorg                         literal storage              
         end  

Saída:

ABEND S0C1 por um ano bissexto, S222 (quando o tempo da CPU acabar), se não.

1936 Y 1805 N 1900 N 2272 Y 2400 Y

(quando executado várias vezes)

Steve Ives
fonte
Até 376 bytes, tornando o tamanho mínimo das áreas de armazenamento (13 bytes), removendo a área de teste 'leapflag' e incluindo apenas um único ano (em vez de 5) no programa.
Steve Ives
384 bytes, fornecendo uma saída ligeiramente formatado:
Steve Ives
11
+1 para uma escolha interessante e educacional do idioma. :-)
Toby Speight
Eu poderia economizar alguns bytes abandonando a convenção e não me incomodando em salvar os registros de chamadas no início, visto que o programa nunca retorna ao chamador. Esta é uma forma muito ruim.
Steve Ives
7

CJam, 18 16 bytes

q~[YAK]f{2#%!}:^

1(de verdade) por anos bissextos e 0(falsamente) de outra forma.

Execute todos os casos de teste aqui.

Explicação

q~                 e# Read and eval input.
  [YAK]            e# Push an array containing 2, 10, 20 (the square roots of the
                   e# relevant divisors).
       f{    }     e# Map this block onto that array, also passing in the input year.
         2#        e# Square the divisor.
           %!      e# Modulo followed by logical negation. Gives 1 if the year is divisible
                   e# by the given divisor and 0 otherwise.
                   e# At this point we have one of the following arrays:
                   e#   [0 0 0] - not a leap year
                   e#   [1 0 0] - a leap year
                   e#   [1 1 0] - not a leap year
                   e#   [1 1 1] - a leap year
              :^   e# Reduce XOR onto this array, which gives 1 if there is an odd number
                   e# of 1s and 0 if there's an even number.
Martin Ender
fonte
6

Mathematica, 40 27 bytes, 17 caracteres

#∣4∧(#∣100<U+F523>#∣400)

Usa 17 caracteres, mas 27 bytes. Obrigado a @alephalpha pela dica. Observe que as barras verticais são na verdade U + 2223 para divisões. O <U+F523>deve ser substituído pelo caractere correspondente.

LegionMammal978
fonte
2
Este é um daqueles quebra-cabeças em que o Mathematica oferece uma solução que parece meio barata: LeapYearQ [#] &
zeldredge
11
Você pode usar para representar Divisible:, #∣4&&(!#∣100||#∣400)&21 caracteres, 27 bytes UTF-8.
Alephalpha # 26/15
@zeldredge Ainda assim, isso não é mais curto que a solução APL.
FUZxxl
@alephalpha Como alternativa, você pode usar U+F523( \[Implies]) para obter #∣4&&(#∣100<U+F523>#∣400)&19 caracteres (mas ainda 27 bytes).
LegionMammal978
Esta é uma brecha padrão; você está usando uma função que faz exatamente a funcionalidade necessária. Isso é verboten.
FUZxxl
6

R, 29

!(Y=scan())%%4&Y%%100|!Y%%400

Execução de teste

> !(Y=scan())%%4&Y%%100|!Y%%400
1: 1936
2: 1805
3: 1900
4: 2272
5: 2400
6: 2200
7: 
Read 6 items
[1]  TRUE FALSE FALSE  TRUE  TRUE FALSE
MickyT
fonte
5

C, 81

Eu posso fazer mais curto, mas este adere perfeitamente aos tipos 'char', sem analisar o argumento (por exemplo, com atoi):

main(c,v)char**v;{char*p=*v+9;p-=2*(96==*p+p[1]);putchar("ynnn"[(2**p^p[1])&3]);}

Ele deve ser chamado com um nome de 4 caracteres, porque assume a premissa padrão de que os argumentos seguem imediatamente o nome do programa, separados por NULs. Além disso, assume que o argumento único é codificado em ASCII e não possui espaço à esquerda.

Explicação:

main(c,v)
char**v;
{
    char *p = *v+9;
    if (p[0] + p[1] == '0'+'0')
        p -= 2;
    putchar("ynnn"[((*p << 1) ^ p[1])&3]);
}

*v+9é a posição do dígito 'dezenas' em v[1]+2.

Se os caracteres 'dezenas' e 'unidades' forem adicionados a 96, terminamos com 00, portanto, faça backup de dois caracteres, para que 'dezenas' e 'unidades' aponte para o número do século.

Agora xor 'units' com o dobro das 'dezenas', mod 4. Isso funciona porque 10==±2 mod 4, portanto, o bit inferior das 'dezenas' pode alternar apenas o bit 1 das 'unidades'. Usamos o resultado como um índice em nossa tabela de remanescentes, imprimindo yapenas se o resultado modular for zero.

Toby Speight
fonte
4

Befunge -98, (41 bytes)

&:4%#v_:aa*%#v_28*%|
"y",;<;@,"n";>;  ;#[

Simplicidade é incrível.

MegaTom
fonte
4

sed, 55

s/00$//
y/0123456789/yNnNyNnNyN/
/N.$/y/ny/yn/
s/.\B//g
  • A primeira linha divide séculos precisos por 100.
  • A segunda linha fornece 'N' para dígitos ímpares, 'y' para 4s e 'n' para não-4s.
  • A terceira linha troca 'y' e 'n' se houver um dígito penúltimo ímpar (porque 10 é 2 mod 4)
  • A linha final exclui tudo, exceto o último caractere

Observe que anos não bissextos podem ser impressos como nou Ndependendo de serem pares ou ímpares. Considero isso uma interpretação criativa da regra que permite alternativas ao 'sim' e 'não' sem especificar que elas devem ser consistentes.

Toby Speight
fonte
4

Python2 - 37

g=lambda x:(x%4or x%400and x%100<1)<1

Observe que se aé um número inteiro não negativo, a<1é uma maneira curta de escrever not bool(a). O último <1converte efetivamente a expressão entre parênteses em um booleano e nega o resultado.

A aplicação da função ga um número inteiro nentre 1801 e 2400 retornará Truese nfor um ano bissexto ou Falsenão.

mathmandan
fonte
3

KDB (Q), 27 bytes

{0=x mod(4 400)0=x mod 100}

Explicação

               0=x mod 100      / boolean of 100 divisibility
        (4 400)                 / 0b -> 4, 1b -> 400
 0=x mod                        / boolean of 4/400 divisibility
{                         }     / lambda

Teste

q){0=x mod(4 400)0=x mod 100}1936 1805 1900 2272 2400
10011b
WooiKent Lee
fonte
3

Julia, 30 28 bytes

y->(y%4<1&&y%100>0)||y%400<1

Isso cria uma função sem nome que aceita um argumento inteiro e retorna um valor booleano. Para chamá-lo, dê um nome, por exemplo f=y->....

Ungolfed:

function f(y)
    (y % 4 == 0 && y % 100 != 0) || y % 400 == 0
end

Exemplo:

julia> for y in [1936, 1805, 1900, 2272, 2400] println(f(y)) end
true
false
false
true
true
true
Alex A.
fonte
3

PHP - 45 bytes

$b=$argv[1]%400;echo !$b|!($b%4)&!!($b%100);

Nada realmente especial, apenas abusando do malabarismo de tipos.

Ponte norte
fonte
3

C #, 23 bytes

y=>y%25<1?y%16<1:y%4<1;

Experimente online!

Fonte completa, incluindo casos de teste:

using System;

namespace CountingLeapYears
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<int,bool>s=y=>y%25<1?y%16<1:y%4<1;
            Console.WriteLine(s(1936)); //y
            Console.WriteLine(s(1805)); //n
            Console.WriteLine(s(1900)); //n
            Console.WriteLine(s(2272)); //y
            Console.WriteLine(s(2400)); //y
        }
    }
}
adrianmp
fonte
3

C, 37 34 30 bytes

l(y){y=y%(y%25?4:16)?110:121;}

Wandbox

o79y
fonte
3

T-SQL 37 22 bytes

Economizou 15 bytes graças ao comentário de BradC.

A variável codificada habitual por falta de a stdin.

por exemplo

DECLARE @ NVARCHAR(4) = '2016'

Então a solução é:

PRINT ISDATE(@+'0229')
S.Karras
fonte
11
Se estou lendo o desafio corretamente, acho que você pode salvar um monte de bytes apenas retornando o 1ou 0diretamente:PRINT ISDATE(@+'0229')
BradC
3

Java 8, 49 45 22 20 bytes

n->n%(n%25<1?16:4)<1

-2 bytes graças a @ OlivierGrégoire .

Experimente online.

Algumas soluções de 22 bytes:

n->n%25<1?n%16<1:n%4<1

Experimente online.

n->(n%25<1?n%16:n%4)<1

Experimente online.

java.time.Year::isLeap

Experimente online.

Explicação:

n->                // Method with integer parameter and boolean return-type
   n%          <1  //  Return whether the integer is divisible by:
     (n%25<1?      //   If the input is divisible by 25:
             16    //    Check if its divisible by 16
            :      //   Else:
             4)    //    Check if its divisible by 4 instead
Kevin Cruijssen
fonte
Outra alternativa 22 bytes: java.time.Year::isLeap.
Olivier Grégoire
2
E uma solução de 20 bytes:n->n%(n%25<1?16:4)<1
Olivier Grégoire
@ OlivierGrégoire Nice 20-byter! E não percebeu que o builtin também tinha 22 bytes. :)
Kevin Cruijssen 10/01
2

Javascript ES6, 32, 29, 26

Qualquer uma das seguintes linhas funciona:

f=y=>new Date(y,2,0).getDate()&1
g=y=>!(y&3)^!(y%100)>!(y%400)
h=y=>!(y&3|y%100<1&&y%400)
Qwertiy
fonte
2

C, 57 bytes

Retorna a entrada do stdin, com ou sem espaços à direita / nova linha. Só funciona em pequenas máquinas endian (sim, como todo mundo está no BE atualmente). Saídas Y ou N.

main(y){scanf("%d",&y);y=y%(y%100?4:400)?78:89;puts(&y);}

Explicação

Ungolfed:

int main(int y) {
   scanf("%d", &y);
   y = y % (y % 100 ? 4 : 400) ? 'N' : 'Y';
   puts(&y);
}

Primeiro, scanflê o ano como um número inteiro em y. Então, y é modulado com 4 ou 400, dependendo se o ano é divisível por 100. Se o restante for zero, o código ASCII para Y é atribuído a y, caso contrário, ele obtém o código ASCII para N. O valor de y é agora 0x000000??, onde 0x??está o caractere atribuído. Por estar em uma máquina little-endian, na memória isso é armazenado como ?? 00 00 00. Esta é uma cadeia C terminada em NULL, contendo apenas os caracteres atribuídos. O endereço de y é passado para put e o caractere é impresso (com uma nova linha à direita).

Andrea Biondo
fonte
11
"Você produzirá da maneira que desejar, que diga claramente ao usuário se é ou não um ano bissexto." Você pode salvar alguns bytes retornando 1 ou 0 em vez de 'Y' ou 'N'? (Eu realmente não sei C em tudo, apenas adivinhando.)
Alex A.
@AlexA. Obrigado pela edição - agora eu sei como destacar a sintaxe :) eu considerei isso. Os códigos ASCII são dois dígitos, portanto, não há ganho com isso (a propósito, estou usando Y e N maiúsculas para salvar 2 bytes, pois as minúsculas têm 3 dígitos). Eles são seqüenciais, de modo que podem ser úteis. Infelizmente, devido a precedência do operador, fico com a mesma contagem de bytes: main(y){scanf("%d",&y);y=!(y%(y%100?4:400))+48;puts(&y);}. Eu posso descer até 48 bytes se conseguir gerar uma linha vazia por anos bissextos e qualquer caractere (ASCII 1-99), mas sinto que isso está um pouco distorcendo as regras. O que você acha?
Andrea Biondo 28/05
Eu devo ter feito algo errado ao contar caracteres. É 57, não 59 :)
Andrea Biondo
11
Sim, eu diria que está dobrando as regras, mas você pode comentar sobre a pergunta e pedir confirmação ao OP. Uma boa ferramenta para contar bytes é esta - acho que muitas pessoas aqui o usam.
Alex A.
Não, eu vou deixar como está :) #
Andrea Biondo 28/05
2

PowerShell, 31 bytes

Estou animado para dizer que joguei este mais curto do que o embutido!

param($a)!($a%(4,16)[!($a%25)])

Resultados verdadeiros para os anos bissextos e falsos caso contrário.

Construídas em:

[datetime]::IsLeapYear($args[0])

No entanto, se eu quisesse esticar a declaração 'informa claramente ao usuário se é ou não um ano bissexto' e fazer algo fora do padrão, eu poderia salvar 3 bytes e usar:

param($a)$a%(4,16)[!($a%25)]

Isso produz 0anos bissextos e 1 ou superior para anos não bissextos, o que eu não gosto, pois prefiro retornar um valor mais padrão de verdade para os anos bissextos.

ThePoShWolf
fonte
2

LOLCODE, 228 202 159 bytes

HOW IZ I f YR a
MOD OF a AN 100
O RLY?
YA RLY
MOD OF a AN 4
O RLY?
YA RLY
b R 1
OIC
NO WAI
MOD OF a AN 400
O RLY?
YA RLY
b R 0
NO WAI
b R 1
OIC
OIC
IF U SAY SO

Ungolfed:

HAI 1.3 BTW "HAI" does nothing functionally in current versions and does not throw an error if you omit it.
HOW IZ I leap YR input
    I HAS A output
    DIFFRINT MOD OF input AN 100 AN 0 BTW Thanks @LeakyNun, In LOLCODE any non-empty values, i.e. 0, "", etc. default to WIN.
    O RLY?
        YA RLY
            BOTH SAEM MOD OF a AN 4 AN 0
            O RLY?
                YA RLY
                    output R WIN BTW "WIN" is true, but in the actual program I used 1 as a truthy value because it's shorter.
            OIC
        NO WAI
            DIFFRINT MOD OF a AN 400 AN 0
            O RLY?
                YA RLY
                    output R FAIL BTW "Fail" is false, but in the actual program I used 0 as a falsy value.
                NO WAI
                    output R WIN
            OIC
    OIC
    FOUND YR output BTW This statement is implied in the golfed version.
IF U SAY SO BTW "KTHXBYE", just like "HAI" has no functional purpose and throws no error on omission.
KTHXBYE

Em Python não-destruído, porque LOLCODE é confuso:

def leap:
    if(year % 100 != 0):
        if(year % 4 == 0):
            output = true
    else:
        if(year % 400 != 0):
            output = false
        else:
            output = true
    return(output)
OldBunny2800
fonte
Seria mais curto definir uma função?
Leaky Nun
provavelmente, mas vou editá-lo mais tarde.
OldBunny2800
Você atualizou o código principal para ser uma função, mas não o código não-bloqueado?
Destrutível Lemon
Pensei LOLCODE tem o tipo de coerção automática, o que significa que qualquer valor diferente de zero é equivalente a WIN..
Leaky Nun
É, mas como eu poderia usar isso? Acho que não estou fazendo nenhum casting.
OldBunny2800