(Inspirado pelo Riddler da semana passada no FiveThirtyEight.com. Postagem na caixa de areia .)

Dado um ano entre 2001 e 2099, calcule e retorne o número de dias durante o ano civil em que mm * dd = yy(onde yyé o ano de 2 dígitos ).

2018, por exemplo, possui 5:

• 18 de janeiro (1 * 18 = 18)
• 9 de fevereiro (2 * 9 = 18)
• 6 de março (3 * 6 = 18)
• 3 de junho (6 * 3 = 18)
• 2 de setembro (9 * 2 = 18)

A entrada pode ser um ano numérico de 2 ou 4 dígitos.

A saída deve ser um número inteiro. O espaço à direita ou o retorno opcional é bom.

Lista completa de entrada / saída:

Input = Output
 2001 = 1     2021 = 3     2041 = 0     2061 = 0     2081 = 2
 2002 = 2     2022 = 3     2042 = 4     2062 = 0     2082 = 0
 2003 = 2     2023 = 1     2043 = 0     2063 = 3     2083 = 0
 2004 = 3     2024 = 7     2044 = 3     2064 = 2     2084 = 5
 2005 = 2     2025 = 2     2045 = 3     2065 = 1     2085 = 1
 2006 = 4     2026 = 2     2046 = 1     2066 = 3     2086 = 0
 2007 = 2     2027 = 3     2047 = 0     2067 = 0     2087 = 1
 2008 = 4     2028 = 4     2048 = 6     2068 = 1     2088 = 3
 2009 = 3     2029 = 1     2049 = 1     2069 = 1     2089 = 0
 2010 = 4     2030 = 6     2050 = 3     2070 = 3     2090 = 5
 2011 = 2     2031 = 1     2051 = 1     2071 = 0     2091 = 1
 2012 = 6     2032 = 3     2052 = 2     2072 = 6     2092 = 1
 2013 = 1     2033 = 2     2053 = 0     2073 = 0     2093 = 1
 2014 = 3     2034 = 1     2054 = 4     2074 = 0     2094 = 0
 2015 = 3     2035 = 2     2055 = 2     2075 = 2     2095 = 1
 2016 = 4     2036 = 6     2056 = 4     2076 = 1     2096 = 4
 2017 = 1     2037 = 0     2057 = 1     2077 = 2     2097 = 0
 2018 = 5     2038 = 1     2058 = 0     2078 = 2     2098 = 1
 2019 = 1     2039 = 1     2059 = 0     2079 = 0     2099 = 2
 2020 = 5     2040 = 5     2060 = 6     2080 = 4

Este é um desafio do código-golfe , com a menor contagem de bytes em cada idioma.

Pré-calcular e simplesmente procurar as respostas normalmente é excluído de acordo com nossas regras de brecha , mas estou explicitamente permitindo esse desafio. Ele permite algumas estratégias alternativas interessantes, embora não seja provável que uma lista de pesquisa de 98 99 itens seja a mais curta.

Excel, 48 bytes

Viva! Finalmente, algo em que o Excel é realmente bom.

=COUNT(VALUE(ROW(1:12)&"/"&A1/ROW(1:12)&"/"&A1))

Recebe a entrada de A1 na forma de um número inteiro de 1 a 99 representando o ano e sai para onde quer que você insira essa fórmula. É uma fórmula de matriz, então use Ctrl-Shift-Enter em vez de Enter para inseri-lo.

Isso tira vantagem do fato de COUNTignorar erros; portanto, todos os erros causados ​​pelo mês que não divide o ano (levando o Excel a analisar algo como 2/12.5/25ou a data que não é válida, por exemplo 2/29/58, são ignorados silenciosamente.

Python 2 , 44 bytes

[k/32%13*(k%32)for k in range(96,509)].count

Experimente online!

Uma função anônima fornecida como um objeto de método. Produz todos os produtos de (month, day)pares (m, d)como codificado por k=32*m+dcom 0≤m≤12, 0≤d≤31, envolvendo em torno. Elimina os dias 29 e 31 de fevereiro, excluindo-os do intervalo.

Java (JDK 10) , 65 bytes

y->{int m=13,c=0;for(;m-->1;)if(y%m<1&y/m<29+m%2*3)c++;return c;}

Experimente online!

Créditos

• 8 bytes economizados graças a l4m2 .
• 4 bytes salvos graças a Asone Tuhid em sua resposta Ruby .

PowerShell , 94 bytes

param($a)for($x=Date 1/1/$a;$x-le(Date 12/9/$a);$x=$x.AddDays(1)){$z+=$x.Month*$x.Day-eq$a};$z

Experimente online!

Recebe a entrada como um ano de dois dígitos e constrói um forloop de 1/1/yearpara 12/9/year(porque 12/10 e além nunca contarão e isso economiza um byte). A cada iteração, incrementamos $zse o .Monthtempo .Dayfor igual ao nosso ano de entrada. Fora do loop, $zé deixado no pipeline e a saída é implícita.

Editar - isso depende da cultura. O código acima funciona para en-us. O formato da data pode precisar ser alterado para outras culturas.

Ruby , 46 42 bytes

->y{(1..12).count{|j|y%j<1&&y/j<29+j%2*3}}

Experimente online!

JavaScript (Node.js) , 48 44 43 bytes

F=(x,h)=>h>12?0:F(x,-~h)+(x/h<3*h%6+28>x%h)

Experimente online!

JavaScript (Node.js) , 59 58 bytes

x=>[a=0,...'030101001010'].map((k,m)=>x%m|x/m>31-k||a++)|a

Experimente online!

Gelatina , 15 bytes

31x12_2¦3RĖP€Fċ

Experimente online!

Pegue um número no intervalo [0,100[como entrada.

JavaScript (ES6), 91 bytes

Eu estava curioso para saber como a codificação seria comparada a uma computação iterativa. Definitivamente, é mais longo (veja a resposta de @ Shaggy ), mas não muito mais.

Edit : É, no entanto, muito mais longo que uma fórmula mais direta (consulte a resposta na l4m2 ).

Recebe a entrada como um número inteiro em [1..99] .

n=>(k=parseInt('8ijkskercdtbnqcejh6954r1eb2kc06oa3936gh2k0d83d984h'[n>>1],36),n&1?k>>3:k&7)

Experimente online!

Quão?

Anos ímpares têm significativamente menos chance de ter mm * dd = aa do que anos pares. Mais concretamente, anos ímpares têm 0 a 3 correspondências, enquanto anos pares têm 0 a 7 correspondências. Isso nos permite codificar cada par de anos com apenas 5 bits, o que pode ser convenientemente representado como um único caractere na base 36.

Perl 6 , 40 bytes

{+grep {$_%%$^m&&29+$m%2*3>$_/$m},1..12}

Experimente online!

Python 2 e 3 , 55 52 bytes

lambda y:sum(y%i<(y/i<29+i%2*3)for i in range(1,13))

Experimente online!

Utilitários Bash + GNU , 57

• 1 byte salvo graças a @SophiaLechner

seq -f1/1/$1+%gday 0 365|date -f- +%m*%d-%y|bc|grep -c ^0

Observe que o seqcomando sempre produz uma lista de 366 datas - para os anos que não são bissextos, o 1º de janeiro do próximo ano será incluído. No entanto, no período de 2001 a 2099, MM * DD nunca será AA para 1º de janeiro do próximo ano em nenhum desses anos, portanto esse dia extra não afetará o resultado.

Experimente online!

T-SQL, 123 121 bytes

De acordo com nossas regras de IO , a entrada é obtida através da tabela preexistente t com um campo inteiro y , que contém um ano de 2 dígitos.

WITH c AS(SELECT 1m UNION ALL SELECT m+1FROM c WHERE m<12)
SELECT SUM(ISDATE(CONCAT(m,'/',y/m,'/',y)))FROM c,t WHERE y%m=0

A quebra de linha é apenas para legibilidade. Inspirado em grande parte pela solução Excel da Sophia .

• A linha superior gera uma tabela de números de 12 itens c, que é associada à tabela de entrada t .
• Se isso passar, misturo um candidato a data usando CONCAT(), o que implica varcharconversões implícitas de tipo de dados. Caso contrário, eu teria que fazer várias declarações CASTou CONVERT.
• Foi encontrada a função de avaliação perfeita ISDATE(), que retorna 1 para datas válidas e 0 para datas inválidas.
• Embrulhe em uma soma e pronto.
• EDIT : Moveu a divisão inteira check ( y%m=0) na WHEREcláusula para salvar 2 bytes, obrigado @RazvanSocol.

Infelizmente, não é muito menor que a versão da tabela de pesquisa (usando a string da versão do osdavison ):

Pesquisa T-SQL, 129 bytes

SELECT SUBSTRING('122324243426133415153317223416132126011504033106131204241006003213011306002122042005101305111014012',y,1)FROM t

EDIT : deixando o original acima, mas podemos salvar alguns bytes usando algumas novas funções:

• STRING_SPLIT está disponível no MS SQL 2016 e acima.
• CONCAT_WS está disponível no MS SQL 2017 e acima.
• Como acima, substituído IIFporWHERE

MS-SQL 2017, 121 118 bytes

SELECT SUM(ISDATE(CONCAT_WS('/',value,y/value,y)))
FROM t,STRING_SPLIT('1-2-3-4-5-6-7-8-9-10-11-12','-')
WHERE y%value=0

MS-SQL 2017, edição mais barata: 109 bytes

SELECT SUM(ISDATE(CONCAT_WS('/',number,y/number,y)))
FROM t,spt_values WHERE number>0AND y%number=0AND'P'=TYPE

Requer que você esteja no masterbanco de dados, que contém uma tabela do sistema spt_valuesque (quando filtrada por TYPE='P') fornece números de 0 a 2048.

Julia 0.6 , 49 44 42 bytes

y->sum(y/i∈1:28+3(i%2⊻i÷8)for i=1:12)

Experimente online!

-5 bytes inspirados na resposta Ruby de Asone Tuhid.
-2 bytes substituindo contagem por soma

Explicação:

Para cada mês, ide 1 a 12, calcule y/ie verifique se é um dos dias desse mês. Meses com 31 dias são 1, 3, 5, 7, 8, 10, 12 - portanto, são ímpares abaixo de 8 e pares iguais ou superiores a 8. Portanto, i%2ou i÷8( ou seja, que é 0 para i <8 e 1 para i> = 8 aqui) deve ser 1, mas não os dois - então nós os XORamos. Se o resultado xor for verdadeiro, verificamos as datas , 1:28+3ou seja 1:31, apenas as datas 1:28.

1:28é suficiente para o resto dos meses (essa melhoria inspirada na resposta Ruby de Asone Tuhid ) porque:

• para fevereiro, a única possibilidade seria 2*29 = 58, mas 2058não é um ano bissexto, portanto, podemos assumir que fevereiro sempre tem 28 dias.

• os outros meses com 30 dias são o mês 4 e superior - para o qual i*29(e i*30) seria superior a 100, o que pode ser ignorado.

Finalmente, contamos o número de vezes que y/iessa lista de dias pertence (usando booleano sumaqui) e retornamos.

JavaScript, 91 85 82 81 77 bytes

Recebe a entrada como uma sequência de 2 dígitos (ou um número inteiro de 1 ou 2 dígitos).

Aproveita o fato de que new Dateserá transferido para o próximo mês e continuará fazendo isso, se você passar um valor de dia que excede o número de dias no mês em que você passa para ele, na primeira iteração, ele tenta construir o data yyyy-01-345que se torna yyyy-12-11, ou yyyy-12-10em anos bissextos. Não precisamos verificar as datas depois disso, pois isso 12*11+resulta em um número de três dígitos.

y=>(g=d=>d&&([,M,D]=new Date(y,0,d).toJSON().split(/\D/),D*M==y)+g(--d))(345)

3 bytes salvos graças ao Arnauld .

Teste-o

f=
y=>(g=d=>d&&([,M,D]=new Date(y,0,d).toJSON().split(/\D/),D*M==y)+g(--d))(345)
o.innerText=[...Array(99)].map((_,x)=>(2001+x++)+` = `+f(x)).join`\n`

pre{column-count:5;width:480px;}

<pre id=o></pre>

Python 2 , 89 84 68 58 bytes

f=lambda y,d=62:d-59and((d/31+1)*(d%31+1)==y)+f(y,-~d%372)

Experimente online!

Excel, 83 bytes

{=SUM(IF(MONTH(DATE(A1,1,0)+ROW(1:366))*DAY(DATE(A1,1,0)+ROW(1:366))=A1-2000,1,0))}

A entrada está na célula A1no formato yyyy. Esta é uma fórmula de matriz e é inserida com Ctrl+ Shift+ Enterpara obter os colchetes {}. É bastante direto e sem nenhuma esperteza.

Quando em uma fórmula de matriz, DATE(A1,1,0)+ROW(1:366)fornece uma matriz de 366 valores de data. Em anos não bissextos, isso incluirá 1º de janeiro do próximo ano, mas isso não é um problema, porque 1*1=1só contaria como falso positivo se o próximo ano for 2001, mas, como o intervalo de anos exigido 2001 - 2099, nunca surgirá como um questão.

Se você colocou um pouco mais simples ~, a fórmula é muito mais fácil de seguir:

{=SUM(IF(MONTH(~)*DAY(~)=A1-2000,1,0))}

Eu tentei usar em COUNTIF()vez de, SUM(IF())mas o Excel nem me deixou entrar como uma fórmula de matriz, muito menos me deu um resultado. I fez encontrar um Sheets Google solução usando CountIf(), mas o mesmo método de outra forma que acabou por ser 91 bytes, principalmente porque ele usa ArrayFormula()em vez de simplesmente { }.

=CountIf(ArrayFormula(Month(Date(A1,1,0)+Row(1:366))*Day(Date(A1,1,0)+Row(1:366))),A1-2000)

Retina 0.8.2 , 55 bytes

..
$*
(?<=^(1{1,12}))(?=(?(?<=^11$)\1{0,27}|\1{0,30})$)

Experimente online! Leva um ano de dois dígitos; adicione 1 byte para oferecer suporte a anos de 4 dígitos. Explicação: O primeiro estágio simplesmente se converte em unário. O segundo estágio inicia correspondendo de 1 a 12 caracteres antes da posição de correspondência, representando o mês e, em seguida, tenta olhar para a frente por um número inteiro de repetições daquele mês. No entanto, o lookahead contém uma condicional, que escolhe entre 27 ou 30 repetições adicionais, dependendo do mês. A contagem de posições de partida é o resultado desejado.

R , 22 122 bytes

x=scan();substr("122324243426133415153317223416132126011504033106131204241006003213011306002122042005101305111014012",x,x)

Experimente online!

Decidiu ir com uma abordagem de tabela de pesquisa. O ano de entrada precisa ter 2 dígitos.

C (gcc), 65 60 59 bytes

d(a,t,e){for(t=0,e=13;e-->1;)t+=a%e<1&a/e<(e-2?32:29);a=t;}

Porta da resposta Java do user202729 . Experimente online aqui . Agradecimentos a Jonathan Frech por jogar 1 byte.

J , 29 bytes

1#.(,x*i."+29+3*2~:x=.i.13)=]

Experimente online!

Como funciona

1#.(,x*i."+29+3*2~:x=.i.13)=]    Input: year (2-digit, 1..99)
                   x=.i.13       array of 0..12; assign to x
                2~:              1 1 0 1 .. 1
              3*                 3 3 0 3 .. 3
           29+                   32 32 29 32 .. 32
       i."+                      for each item of above, generate a row 0 .. n
    ,x*                          each row times 0 .. 12 and flatten
                           =]    1 for each item == input, 0 otherwise
1#.                              sum

Tentei muito menos de 2 vezes a solução Jelly :)

Nota

Se alguém realmente deseja codificar os dados de 99 dígitos, aqui estão algumas informações:

Divida os 99 dígitos em pedaços de 2 dígitos. Então o primeiro dígito é <4e o segundo <8, o que significa que cinco bits podem codificar dois números. Em seguida, todos os dados podem ser codificados em 250 bits ou 32 bytes.

Python 3 , 158 162 215 241 bytes

Removido 4 Obrigado a Stephen por jogar golfe nos condicionais.

Removido 53 agradecimentos Stephen por apontar o espaço em branco

Removido 26 graças ao link fornecido por caird

Eu sou muito novo nisso. Não conseguia pensar em como fazer isso sem que os dias do mês fossem descritos.

r=range
def n(Y):
 a,b,c=31,30,0
 for x in r(12):
  for y in r([a,(28if Y%4else 29),a,b,a,b,a,a,b,a,b,a][x]):
   if(x+1)*(y+1)==int(str(Y)[2:]):c+=1
 return c

Experimente online!

Quarto (gforth) , 60 59 bytes

: f 0 13 1 do over i /mod swap 32 i 2 = 3 * + 0 d< - loop ;

Experimente online!

Esta versão aproveita o fato de que não pode haver mais de um dia correspondente por mês e que o ano deve ser divisível por mês para que ele corresponda.

Explicação

Repete ao longo dos meses, verifica se o ano é divisível por mês e se o quociente é <31 (28 de fevereiro). Os meses após março não podem corresponder para dias superiores a 25, para que possamos assumir todos os meses (exceto fevereiro) tem 31 dias para o objetivo do quebra-cabeça.

Código Explicação

: f                   \ start new word definition
  0                   \ set up counter
  13 1 do             \ start a counted loop from 1 to 12
    over i /mod       \ get the quotient and remainder of dividing year by month
    swap              \ default order is remainder-quotient, but we want to swap them
    32 i 2= 3 * +     \ we want to compare to 32 days unless month is Feb
    0 d<=             \ treat the 4 numbers on the stack as 2 double-length numbers
                      \ and compare [1]
    -                 \ subtract result from counter (-1 is true in Forth)
  loop                \ end loop
;                     \ end word definition    

[1] - A seguir, o conceito de números de comprimento duplo, que são armazenados na pilha como dois números de comprimento único (da forma xy, em que o valor de double = y * 2^(l) + xonde l é o tamanho em bits de um único no com a qual você está trabalhando).

Nesse caso, comparei o quociente e o restante com 32 (ou 29) 0. Se o restante fosse maior que 0 (ano não divisível por mês), o primeiro dobro seria automaticamente maior que 32 (ou 29) 0 e o resultado seria falso. Se o restante for 0, ele resolverá efetivamente uma verificação regular do quociente <= 32 (ou 29)

Quarto (gforth) , 61 bytes

: f 0 13 1 do i 2 = 3 * 32 + 1 do over i j * = - loop loop ; 

Experimente online!

Economizou alguns bytes ao perceber que apenas fevereiro é importante em termos de número correto de dias no mês

Explicação

As comparações adiante (pelo menos adiante) retornam -1 para verdadeiro e 0 para falso

0                     \ place 0 on top of the stack to use as a counter
13 1 do               \ begin the outer loop from 1 to 12
  i 2 = 3 *           \ if i is 2 place -3 on top of the stack, otherwise 0
  32 + 1 do           \ begin the inner loop from 1 to 31 (or 28)
    over              \ copy the year from stack position 2 and place it on top of the stack
    i j * = -         \ multiply month and day compare to year, subtract result from counter 
  loop                \ end the inner loop
loop                  \ end the outer loop

Java (JDK 10) , 79 72 70 bytes

y->{int a=0,m=13;for(;m-->1;)a+=y%m<1&&y/m<(m==2?29:32)?1:0;return a;}

Experimente online!

JavaScript (Node.js) , 108 bytes

a=>'0122324243426133415153317223416132126011504033106131204241006003213011306002122042005101305111014012'[a]

f=a=>'0122324243426133415153317223416132126011504033106131204241006003213011306002122042005101305111014012'[a]
o.innerText=[...Array(99)].map((_,x)=>(2001+x++)+` = `+f(x)).join`\n`

pre{column-count:5;width:480px;}

<pre id=o></pre>

Perl 5 , 68 bytes

//;map$\+=$'%++$m==0&&$'/$m<$_,32,29,32,31,32,31,32,32,31,32,31,32}{

Experimente online!

Python 3, 132 bytes

Este é realmente um programa bastante longo, mas achei que poderia ser interessante.

Todos os valores estão entre 0 e 7, então eu codifico cada número com 3 bits em uma cadeia binária longa. Tentei colar uma string binária bruta no meu programa python, mas não consegui fazê-la funcionar, por isso decidi pela base64 no arquivo.

Usei a seguinte string como uma tabela de pesquisa (as 7 finalizações usadas para preenchimento): 01223242434261334151533172234161321260115040331061312042410060032130113060021220420051013051110140127

O programa pega essa string e a decodifica como um número e usa a mudança de bits para extrair o resultado.

import base64
lambda n:int.from_bytes(base64.b64decode(b'pNRRxYtw01s9Jw4tFYE0QNkYsoRQgYBosEsYBFIRAUgsUkgwFQM='),'big')>>(6306-3*n)&7

66 bytes + arquivo de 37 bytes = 103 bytes

Isso lê um arquivo binário chamado ee evita o uso de base64.

lambda n:int.from_bytes(open('e','rb').read(),'big')>>(6306-3*n)&7

Aqui está um hexdump do arquivo lido (sem preenchimento):

00000000  a4 d4 51 c5 8b 70 d3 5b  3d 27 0e 2d 15 81 34 40  |..Q..p.[='.-..4@|
00000010  d9 18 b2 84 50 81 80 68  b0 4b 18 04 52 11 01 48  |....P..h.K..R..H|
00000020  2c 52 48 30 0a                                    |,RH0.|

Haskell , 61 51 bytes

f y=sum[1|i<-[96..508],mod(div i 32)13*mod i 32==y]

Experimente online!

Inspirado na resposta Python 2 do xnor e em Laikoni.

Oracle SQL, 115 bytes

select count(decode(sign(decode(l,2,29,32)-y/l),1,1))from t,
xmltable('1to 12'columns l int path'.')where mod(y,l)=0

Podemos notar que, na verdade, não importa quantos dias em abril (e meses posteriores), desde 100/4 <28. Também não é necessário verificar se o ano é bissexto ou não. Nós apenas temos que especificar que há 28 dias em fevereiro (não 29, porque essa validação será executada apenas para 2058, o que não é um salto), caso contrário, pode ser apenas 31 por qualquer mês.

Outras abordagens

Oracle SQL (12c Release 2 e posterior), 151 bytes

select count(to_date(y/l||'-'||l||'-1' default '' on conversion error,'dd-mm-y'))from t,
(select level l from dual connect by level<=12)where mod(y,l)=0

Oracle SQL (12c Release 2 e posterior), 137 bytes

select sum(validate_conversion(y/l||'-'||l||'-1'as date,'dd-mm-y'))from t,
(select level l from dual connect by level<=12)where mod(y,l)=0

Ambas as soluções poderiam ter sido 8 bytes mais curtas se substituirmos (select level l from dual connect by level<=12)por, xmltable('1to 12'columns l int path'.')mas o Oracle lança uma exceção por causa do bug (testado nas versões 12.2.0.1.0, 18.3.0.0.0).

SQL> select count(to_date(y/l||'-'||l||'-1' default '' on conversion error,'dd-mm-y'))from t,
  2  xmltable('1to 12'columns l int path'.')where mod(y,l)=0
  3  /
select count(to_date(y/l||'-'||l||'-1' default '' on conversion error,'dd-mm-y'))from t,
*
ERROR at line 1:
ORA-00932: inconsistent datatypes: expected DATE got DATE


SQL> select sum(validate_conversion(y/l||'-'||l||'-1'as date,'dd-mm-y'))from t,
  2  xmltable('1to 12'columns l int path'.')where mod(y,l)=0
  3  /
select sum(validate_conversion(y/l||'-'||l||'-1'as date,'dd-mm-y'))from t,
*
ERROR at line 1:
ORA-43909: invalid input data type

O único caso em ambas as soluções, quando o ano importa, é 2058, que é sem salto, então literalmente '-1' foi usado para especificar o ano sem salto.

Oracle SQL, 128 bytes

select count(d)from t,(select date'1-1-1'+level-1 d from dual connect by level<365)
where to_char(d(+),'mm')*to_char(d(+),'dd')=y

Oracle SQL, 126 bytes

select substr('122324243426133415153317223416132126011504033106131204241006003213011306002122042005101305111014012',y,1)from t

Atualizar

Oracle SQL, 110 bytes

select-sum(least(sign(y/l-decode(l,2,29,32)),0))from t,
xmltable('1to 12'columns l int path'.')where mod(y,l)=0

Oracle SQL, 108 bytes

select sum(decode(sign(decode(l,2,29,32)-y/l)*mod(y+1,l),1,1))from t,
xmltable('1to 12'columns l int path'.')

Spark SQL, 137 bytes

select count(cast(regexp_replace(concat_ws('-','2001',l,y/l),'.0$','')as date))
from(select explode(array(1,2,3,4,5,6,7,8,9,10,11,12))l),t

Spark 2.3+ SQL, 126 bytes

(a replacefunção fica disponível)

select count(cast(replace(concat_ws('-','2001',l,y/l),'.0')as date))
from(select explode(array(1,2,3,4,5,6,7,8,9,10,11,12))l),t

PHP , 73 bytes

Usando entrada de tubo e php -nR:

for(;++$m<13;$d=1)while($d<25+($m-2?$m>4?:7:4))$c+=$argn==$m*$d++;echo$c;

Experimente online!

PHP , 76 bytes

Usando a entrada de linha de comando arg php dm.php 18:

for(;++$m<13;$d=1)while($d<25+($m-2?$m>4?:7:4))$c+=$argv[1]==$m*$d++;echo$c;

Experimente online!

Abordagem iterativa. Como o único ano bissexto a ser observado é 2 * 29 = 58, e 2058 não é um ano bissexto, não há necessidade de considerar o ano bissexto nos dias de fevereiro. E como a envolvente não é uma preocupação - a partir de abril, qualquer dia maior que 25 excederá 100, apenas dizemos que o restante dos meses tem apenas 25 dias.

A entrada é de 2 dígitos ano via linha de comando (-10 bytes como programa, thx à sugestão de @Titus).

OU:

PHP , 101 bytes

$y=$argv[1];for($d=strtotime("$y-1");date(Y,$d)==$y;$d+=86400)eval(date("$\x+=j*n=='y';",$d));echo$x;

Experimente online!

Ainda iterativo, mas usando as funções de carimbo de data / hora do PHP. Aceita ano como número de quatro dígitos. Thx para @Titus por sugestão de uso em strtotime()vez de mktime().

PHP, 74 70 bytes

while(++$m<13)for($d=$m<5?$m-2?31:28:25;$d;)$n+=$d--*$m==$argn;echo$n;

aceita apenas dois anos.

Eu adotei considerações gwaugh's e golfed-los; minha primeira abordagem foi maior que a dele (92 bytes):

for($y=$argn%100;++$m<13;)for($d=$m-2?30+($m+$m/8)%2:29-($y%4>0);$d;)$n+=$d--*$m==$y;echo$n;

%100 permite usar anos de 4 dígitos.

Execute como pipe -nRou experimente-os online .