Это високосный год?

41

Эта задача довольно проста. Вы берете ввод, который будет годом с 1801 по 2400, и выводите, если это високосный год или нет.

Ваш ввод не будет содержать ни новой строки, ни пробелов:

1954

Вы будете выводить любым способом, который вам нравится, который четко говорит пользователю, является ли он високосным годом или нет (я приму y или n для да / нет)

Вы можете получить список високосных лет здесь: http://kalender-365.de/leap-years.php Я хотел бы отметить, что високосные годы не всегда четыре года. 1896 год високосный, а 1900 - нет. Годы, следующие за этим «пропуском»:

1900
2100
2200
2300

Тестовые случаи:

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

РЕДАКТИРОВАТЬ: Это основано на стандартном григорианском календаре: http://www.epochconverter.com/date-and-time/daynumbers-by-year.php

Кевин Круйссен
источник
9
Вы должны быть более ясными: данный год является високосным, если и только если это так (divisible by 4)∧((divisible by 100)→(divisible by 400)).
LegionMammal978
Ваш ввод не будет содержать ни новой строки, ни пробела. Черт возьми, это спасло бы меня 2 байта ...
Деннис
2
Вы должны расширить допустимый диапазон входных данных до 1601–2400 гг. Нашей эры. Это охватывает два 400-летних григорианских цикла (которые начнутся с понедельника).
Дэвид Р. Триббл
2
Ложь, если високосный год и правда, если не високосный год, считается как "четко говорит пользователю, если он или нет"?
lirtosiast
@lirtosiast Я так думаю. Многие пользователи считают, что так.
Aloisdg говорит восстановить Монику

Ответы:

22

APL, 16 14 12 символов

Возвращает 0для високосного года, 1для не високосного года.

≥/⌽×4 25 4⊤⎕

Попробуйте это решение на tryapl.org . Обратите внимание, что я изменил решение на dfn, так {≥/⌽×4 25 4⊤⍵}как tryapl.com не поддерживает (принять пользовательский ввод). Обратите внимание, что это пустое поле, а не пропущенный символ.

То же решение в J:

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

объяснение

Dyadic (encode) представляет свой правый аргумент в базе, указанной его левым аргументом. Я использую базу 4 25 4в этом решении. Это представляет год у как полином

у мод 400 = 100 а + 4 b + c,  где b <100 и c <4.

Пусть предложения α, β и γ представляют собой, если a, b и c отличны от нуля: предложение γ неверно, если y делится на 4, βγ ложно, если у является делимым на 100 и & alpha ; ∧ & beta ; ∧ & gamma вне ложь, если у делится на 400.

Таблица истинности ( *представляющая «все равно») была бы предложением Δ, если y представляет собой високосный год:

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

Следующее утверждение выражает Δ в α , β и γ :

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

Из-за структуры этого утверждения можно выразить ¬Δ как сокращение, ≥/⌽α β γгде ≥ реализует ←. Это приводит к ответу, который я сейчас объясняю.

FUZxxl
источник
16

Pyth, 11 байт

!%|F_jQ*TT4

Эта полная программа читает из STDIN и печатает True для високосных лет и False противном случае.

Спасибо @Jakube за предложение Pyth и в основном перенос моего кода CJam.

Проверьте сами тестовые примеры в Pyth Compiler / Executor .

Как это работает

     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.
Деннис
источник
15

CJam, 12 байт

rS+2m<~e|4%!

Эта полная программа читает из STDIN и печатает 1 для високосных лет и 0 в противном случае.

Проверьте сами тестовые случаи в интерпретаторе CJam .

Как это работает

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.
Деннис
источник
У меня есть еще несколько 12-байтовых альтернатив. Может быть, вы можете найти что-то в них, чтобы снизить его до 11? r2/~~\e|i4%!, r2/~~\~e|4%!, r2/:~~\e|4%!, r2/S*~\e|4%!И 13 байтr2/:~W%:e|4%!
Мартин Эндер
@ MartinBüttner: есть также r2/:i:\e|4%!(12) и r2/:i(fe|~4%!(13). Я даже пробовал GolfScript (который не требует r), но or4интерпретируется как один токен. Если бы только вход имел завершающий перевод строки ...
Деннис
14

Javascript (ES6), 21 знак

Стандартным правилом yявляется високосный год, если 4 делится yи если 100 не делит yили 400 делит y. В коде

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

Нет необходимости в этих 100 и 400. Вместо этого достаточно проверить, делит ли 16 или 4 y, а 16 выбирается, если 25 делит y, 4 в противном случае. Гольф, это становится

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

Функция javascript, которая реализует это длиной 21 символ:

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


Perl, 28 26 символов

Та же идея, но в Perl.

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

Запустите, используя -lpпараметры. Например,

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

С тестом, установленным в качестве входа, это производит

1936
y
1805
n
1900
n
2272
y
2400
y
Дэвид Хаммен
источник
Я использовал ваше предложение в своем ответе, не видел вашего. Теперь я откатился назад. Примечание: вы должны указать EcmaScript 6, иначе кто-то будет жаловаться «не работает в Chrome»
edc65
@ edc65: Ну, он должен указать EcmaScript 6, потому что это EcmaScript 6. Функция обозначения стрелки ( y=>...) - это функция ES6.
Тим Час
Разве это не два ответа?
dfeuer
9

зернышко , 13 байт

Этот был более интересным, чем сначала показался. Потребовалось finagling, но я, наконец , смог заменить эти длинные ссылки 400с 4и hпеременной (= 100).

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

Выходы 1для високосного года, 0для не високосного года. Объяснение:

               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
источник
9

Pyth, 19 15 14 байтов

xFm!%Q^d2[2TyT

Слишком просто. Попробуйте онлайн: демонстрация или тестовая привязь

edit: Пропущено, что вы можете печатать значения Truthy / Falsy вместо n/y. -4 байта

редактировать 2: Использовал идею квадратного корня Мартина. -1 байт

объяснение

                 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
источник
9

Регекс, 83 62 38

Спасибо Тоби за советы по объединению обеих половин регулярного выражения.

Если мы сосредоточимся только на диапазоне 1801..2400 и предположим, что входные данные являются целыми числами:

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

Проверьте в Ruby ( ^= \Aи $= \Zпотому что Ruby) для желаемого диапазона:

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

(Бонус) за то, что должно работать не только на 1801..2400, но и на любой неотрицательный год:

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

Тест на Ruby ( ^= \Aи $= \Zпотому что Ruby) за первые 100000 лет:

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-
источник
1
Если у вас есть, (?!)вы можете объединить две половины: (?!00)([02468][048]|[13579][26])(00)?$- для 38. Это не будет работать в течение однозначных лет, хотя.
Тоби Спейт
9

JavaScript ( ES6 ) 27

Правило: (y%4==0) && (y%100!=0 || y%400==0)

Гольф: !(y%100<1&&y%400||y%4)(в основном по закону Де Моргана )

Функция, реализующая правило:

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

Тест (запустить в Firefox) просто чтобы быть уверенным:

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
источник
3
Вы можете уменьшить это на шесть символов, если вы используете !(y%(y%25?4:16))вместо !(y%100<1&&y%400||y%4). Для тех, кого беспокоит троичный оператор, вы можете использовать !(y%(4<<2*!(y%25)))и при этом сохранить еще три символа !(y%100<1&&y%400||y%4).
Дэвид Хаммен,
1
Предложение Дэвида Хаммена идентично его ответу, поэтому я думаю, что вы должны оставить длину как 27.
lirtosiast
9

TI-BASIC, 20 17 16 13

Поскольку TI-BASIC является токенизированным, он часто конкурирует с простыми математическими задачами, но не с этим, поскольку нет «делимой» команды.Может быть, это все-таки, но это все же дольше, чем CJam и Pyth.

Это использует метод Дэвида Хаммонда.

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

Старый код в 16 байтов:

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(является «дробной частью»; Возведение в степень имеет более высокий приоритет, чем деление. В TI-BASIC закрытые скобки являются необязательными.

Я использую недокументированное поведение sub( команды, обычно используемое для получения подстроки: когда ее аргумент является числом, а не строкой, он делит число на 100. Он будет работать на калькуляторе серии TI-83 или 84.

20 -> 17 путем перестановки кода, чтобы разрешить удаление близких паренсов; 17 -> 16 путем замены 400 на 16; 16 -> 13, используя идею Дэвида Хаммонда.

lirtosiast
источник
9

Stackylogic, 226 байт (не конкурирует)

Да, именно так. Я сделал программу на Stackylogic (не-TC), которая была изобретена Хелкой Хомбой, для задачи, найденной здесь . Это сделано после вызова, поэтому не конкурирует.

Stackylogic имеет только двоичный вход, поэтому необходимо использовать 10 (или более, любые другие цифры будут игнорироваться) двоичный бит (сначала вводится младший значащий бит). Любые даты за пределами указанного диапазона могут потерпеть неудачу, так как он просто проверяет, что является введенным числом: он не покрывает ненужные даты

Это не только мой первый вызов со стайлогикой, но и первый вызов со стайлогикой вообще.

Будьте готовы к этому беспорядку:

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

Это заняло у меня так много времени, потому что Stackylogic - самый запутанный язык, с которым я когда-либо сталкивался, и чрезвычайно нечитаемый: вы должны знать, как выполнялась остальная часть программы, прежде чем читать текущий редактируемый раздел. Мне даже пришлось добавить пробелы для удобства чтения при его создании.

Скудное объяснение

Это простое объяснение того, что он делает.

Stackylogic не имеет никаких математических функций, так что это усложнило. Мне пришлось жестко кодировать большую часть этого, чтобы проверить, было ли это конкретное число.

Во-первых, эта программа выполнит NOR младших разрядов, отбрасывая их в процессе. это означает, что если он делится на 4, он перейдет к основной части программы, в противном случае выведите 0.

Во-вторых, указатель переносится в лабиринт стейлогии, отсюда, если следующие два бита равны нулю, он мгновенно выдаст 1 (как тогда он делится на 16, и, следовательно, високосный год, несмотря на любые другие условия), другое мудро, что он проверит, не является ли это любое из чисел, которые делятся на 4, но не високосный год, между 1801 и 2400.

Чтобы объяснить подробно, потребуется сделать этот пост во много раз дольше, чем это уже есть

Разрушаемый Лимон
источник
8

Ассемблер IBM System Z - 56 байт.

(96 байтов источника. Ранее 712 384 202 байта источника, 168 байт исполняемого файла).

Меньшая версия все еще. Больше не сохраняет регистры вызывающего абонента, изменяет литеральное хранилище, изменяет режим адресации.

 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 

Новая версия. Это изменится с S0C1, если это високосный год, и зациклится, если это не так. Надеемся, что это соответствует требованию указания результата.

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  

Хорошо, так что не самое короткое (хотя это может быть, как только мы посмотрим на фактический исполняемый код плюс размер интерпретатора ...)

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  

Выход:

ABEND S0C1 для високосного года, S222 (когда время CPU истекло), если нет.

1936 Y 1805 N 1900 N 2272 Y 2400 Y

(при запуске несколько раз)

Стив Айвз
источник
Уменьшите размер до 376 байт, сделав минимальный размер областей хранения (13 байт), удалив промежуточную область «перепрыгивая» и включив в программу только один год (а не 5).
Стив Айвз
384 байта, предоставляя слегка отформатированный вывод:
Стив Айвз
1
+1 за интересный и познавательный выбор языка. :-)
Тоби Спейт
Я мог бы сохранить несколько байтов, отказавшись от соглашения и не потрудившись сохранять регистры вызывающих программ при запуске, поскольку программа никогда не возвращается к вызывающему. Это очень плохая форма.
Стив Айвз
7

CJam, 18 16 байтов

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

Дает 1(правда) за високосные годы и 0(ложно) в противном случае.

Запустите все тесты здесь.

объяснение

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.
Мартин Эндер
источник
6

Mathematica, 40 27 байтов, 17 символов

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

Использует 17 символов, но 27 байтов. Спасибо @alephalpha за подсказку. Обратите внимание, что вертикальные полосы на самом деле U + 2223 для делений. <U+F523>Следует заменить соответствующий символ.

LegionMammal978
источник
2
Это одна из тех загадок, где Mathematica предлагает решение, которое кажется обманчивым: LeapYearQ [#] &
zeldredge
1
Вы можете использовать для представления Divisible:, #∣4&&(!#∣100||#∣400)&21 символа, 27 байтов UTF-8.
алефальфа
@zeldredge Тем не менее, это не короче, чем решение APL.
FUZxxl
@alephalpha Кроме того, вы можете использовать U+F523( \[Implies]), чтобы сделать это #∣4&&(#∣100<U+F523>#∣400)&для 19 символов (но все еще 27 байтов).
LegionMammal978
Это стандартная лазейка; Вы используете функцию, которая выполняет именно необходимую функцию. Это верботен
FUZxxl
6

Р, 29

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

Тестовый забег

> !(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
источник
5

С, 81

Я могу сделать короче, но этот аккуратно придерживается типов 'char', без разбора аргумента (например, с atoi):

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

Он должен вызываться с именем длиной 4 символа, поскольку он предполагает стандартное предположение, что аргументы следуют сразу за именем программы, разделенные NUL. Кроме того, предполагается, что один аргумент закодирован в ASCII и не имеет начального пробела.

Объяснение:

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позиция цифры «десятки» в v[1]+2.

Если символы «десятки» и «единицы» добавляют к 96, мы заканчиваем 00, поэтому сделаем резервную копию двух символов, чтобы «десятки» и «единицы» указывали на номер столетия.

Теперь xor «единиц» с удвоенными «десятками», мод 4. Это работает, потому что 10==±2 mod 4, так что младший бит «десятков» может просто переключать бит 1 «единиц». Мы используем результат в качестве индекса в нашей таблице остатков, печатая yтолько в том случае, если модульный результат равен нулю.

Тоби Спейт
источник
4

Befunge -98, (41 байт)

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

Простота потрясающая.

MegaTom
источник
4

Сед, 55

s/00$//
y/0123456789/yNnNyNnNyN/
/N.$/y/ny/yn/
s/.\B//g
  • Первая линия делит точные века на 100.
  • Вторая строка дает «N» нечетным цифрам, «y» - 4, а «n» - не 4.
  • Третья строка меняет местами 'y' и 'n', если есть нечетная предпоследняя цифра (потому что 10 - это 2 mod 4)
  • Последняя строка удаляет все, кроме последнего символа

Обратите внимание, что не високосные годы могут быть напечатаны как nили в Nзависимости от того, являются ли они четными или нечетными. Я считаю это творческим толкованием правила, которое допускает альтернативы «да» и «нет», не указывая, что они должны быть последовательными.

Тоби Спейт
источник
4

Python2 - 37

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

Обратите внимание, что если aцелое неотрицательное число, то a<1это короткий способ записи not bool(a). Последний<1 таким образом, эффективно преобразует выражение в скобках в логическое значение и сводит на нет результат.

Применение функции gк целому числу nот 1801 до 2400 вернет, Trueесли nэто високосный год, и Falseиначе.

mathmandan
источник
3

KDB (Q), 27 байтов

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

объяснение

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

Тест

q){0=x mod(4 400)0=x mod 100}1936 1805 1900 2272 2400
10011b
Вуикент Ли
источник
3

Юлия, 30 28 байт

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

Это создает безымянную функцию, которая принимает целочисленный аргумент и возвращает логическое значение. Чтобы назвать его, дайте ему имя, напримерf=y->... .

Ungolfed:

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

Пример:

julia> for y in [1936, 1805, 1900, 2272, 2400] println(f(y)) end
true
false
false
true
true
true
Алекс А.
источник
3

PHP - 45 байт

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

Ничего особенного, просто злоупотребление жонглированием шрифтами.

Северный мост
источник
3

C #, 23 байта

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

Попробуйте онлайн!

Полный исходный код, включая контрольные примеры:

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
источник
3

T-SQL 37 22 байта

Сохранено 15 байт благодаря комментарию BradC.

Обычная жестко закодированная переменная из-за отсутствия stdin.

например

DECLARE @ NVARCHAR(4) = '2016'

Тогда решение:

PRINT ISDATE(@+'0229')
S.Karras
источник
1
Если я правильно читаю задачу, я думаю, что вы можете сэкономить кучу байтов, просто вернув 1или 0прямо:PRINT ISDATE(@+'0229')
BradC
3

Java 8, 49 45 22 20 байт

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

-2 байта благодаря @ OlivierGrégoire .

Попробуйте онлайн.

Некоторые 22-байтовые решения:

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

Попробуйте онлайн.

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

Попробуйте онлайн.

java.time.Year::isLeap

Попробуйте онлайн.

Объяснение:

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
Кевин Круйссен
источник
Еще 22 байт альтернатива: java.time.Year::isLeap.
Оливье Грегуар
2
И 20-байтовое решение:n->n%(n%25<1?16:4)<1
Оливье Грегуар
@ OlivierGrégoire Хороший 20-байтер! И не понял, что встроенный был также 22 байта. :)
Кевин Круйссен
2

Javascript ES6, 32, 29, 26

Работает любая из следующих строк:

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
источник
2

C 57 байт

Принимает ввод из стандартного ввода, с или без завершающих пробелов / новой строки. Работает только на машинах с прямым порядком байтов (да, как все в настоящее время на BE). Выходы Y или N.

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

объяснение

Ungolfed:

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

Во-первых, scanfчитается год как целое число в y. Затем, y модулируется с 4 или 400 в зависимости от того, делится ли год на 100. Если остаток равен нулю, ASCII-код для Y присваивается y, в противном случае он получает ASCII-код для N. Значение y сейчас 0x000000??, где 0x??находится назначенный символ. Находясь на машине с прямым порядком байтов, в памяти это сохраняется как ?? 00 00 00. Это строка C с нулевым символом в конце, содержащая только назначенные символы. Адрес y передается в put, и печатается символ (с завершающим символом новой строки).

Андреа Биондо
источник
1
«Вы будете выводить любым способом, который вам нравится, который четко говорит пользователю, если это високосный год или нет». Можете ли вы сохранить пару байтов, возвращая 1 или 0 вместо «Y» или «N»? (Я вообще не знаю C, просто догадываюсь.)
Алекс А.
@AlexA. Спасибо за редактирование - теперь я знаю, как выделить синтаксис :) Я обдумал это. Коды ASCII представляют собой две цифры, поэтому никакого выигрыша от этого нет (кстати, я использую прописные буквы Y и N, чтобы сохранить 2 байта, поскольку строчные буквы имеют 3 цифры). Они последовательны, так что это может быть полезно. К сожалению, из - за приоритета операторов, я получаю такое же количество байт: main(y){scanf("%d",&y);y=!(y%(y%100?4:400))+48;puts(&y);}. Я могу уменьшить размер до 48 байт, если могу вывести пустую строку для високосных лет и любой символ (ASCII 1-99) в противном случае, но я чувствую, что это немного нарушает правила. Что вы думаете?
Андреа Биондо
Должно быть, я сделал что-то не так при подсчете символов. Сейчас 57, а не 59 :)
Андреа Биондо,
1
Да, я бы сказал, что это нарушает правила, но вы можете прокомментировать вопрос и попросить у ОП подтверждение. Хороший инструмент для подсчета байтов это - я думаю, что многие люди здесь используют его.
Алекс А.
Нет, я оставлю все как есть :)
Андреа Биондо
2

PowerShell, 31 байт

Я взволнован, чтобы сказать, что я играл в гольф ниже, чем встроенный!

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

Выводы true для високосных лет и false в противном случае.

Builtin:

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

Хотя, если бы я хотел расширить выражение «четко говорит пользователю, если это високосный год или нет» и сделать что-то нестандартное, я мог бы сэкономить 3 байта и использовать:

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

Это приводит 0к високосным годам и 1 или выше для не високосных лет, что мне не нравится, так как я предпочел бы возвращать более стандартное истинное значение для високосных лет.

ThePoShWolf
источник
2

LOLCODE, 228 202 159 байт

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

В Python ungolfed, потому что LOLCODE сбивает с толку:

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
источник
Будет ли короче определить функцию?
Утренняя монахиня
возможно, но я отредактирую это позже.
OldBunny2800
Вы обновили основной код, чтобы он стал функцией, а не кодом без кода?
Разрушаемый Лимон
Я думал, что LOLCODE имеет автоматическое приведение типов, а это означает, что любое ненулевое значение эквивалентно WIN..
Leaky Nun
Да, но как я могу это использовать? Я не думаю, что я занимаюсь кастингом.
OldBunny2800