Este desafío es bastante simple. Tomará una entrada que será un año de 1801 a 2400, y la salida si es un año bisiesto o no.
Su entrada no tendrá líneas nuevas ni espacios finales:
1954
La salida de la forma que desee le indica claramente al usuario si es o no un año bisiesto (aceptaré yn para sí / no)
Puede obtener una lista de los años bisiestos aquí: http://kalender-365.de/leap-years.php Quisiera señalar que los años bisiestos no siempre son cuatro años. 1896 es un año bisiesto, pero 1900 no lo es. Los años que siguen a este "salto" son:
1900
2100
2200
2300
Casos de prueba:
1936 -> y
1805 -> n
1900 -> n
2272 -> y
2400 -> y
EDITAR: Esto se basa en un calendario gregoriano estándar: http://www.epochconverter.com/date-and-time/daynumbers-by-year.php
code-golf
date
decision-problem
Kevin Cruijssen
fuente
fuente
(divisible by 4)∧((divisible by 100)→(divisible by 400))
.Respuestas:
APL,
161412 caracteresDevoluciones
0
para un año bisiesto,1
para un año no bisiesto.Prueba esta solución en tryapl.org . Tenga en cuenta que he cambiado la solución a la dfn
{≥/⌽×4 25 4⊤⍵}
ya que tryapl.com no es compatible⎕
(tome la entrada del usuario). Tenga en cuenta que⎕
es un cuadro vacío, no un carácter faltante.La misma solución en J:
Explicación
Dyadic
⊤
(codificar) representa su argumento derecho en la base especificada por su argumento izquierdo. Yo uso base4 25 4
en esta solución. Esto representa el año y como polinomio.Deje proposiciones alpha, β, y gamma representan si a, b, y c son no-cero: la Propuesta γ es falsa si y es divisible por 4, β ∧ γ es falso si y es divisible por 100 y alpha ∧ β ∧ γ es decir falso si y es divisible por 400.
Una tabla de verdad (que
*
representa "no importa") donde la proposición Δ representa si y es un año bisiesto obtiene:La siguiente declaración expresa Δ en α , β y γ :
Debido a la estructura de esta declaración, uno puede expresar ¬Δ como la reducción
≥/⌽α β γ
donde ≥ implementa ←. Esto lleva a la respuesta que estoy explicando en este momento.fuente
Pyth, 11 bytes
Este programa completo lee de STDIN e imprime True para los años bisiestos y False de lo contrario.
Gracias a @Jakube por sugerir Pyth y básicamente portar mi código CJam.
Verifique los casos de prueba usted mismo en Pyth Compiler / Executor .
Cómo funciona
fuente
CJam, 12 bytes
Este programa completo lee de STDIN e imprime 1 para los años bisiestos y 0 en caso contrario.
Verifique los casos de prueba usted mismo en el intérprete de CJam .
Cómo funciona
fuente
r2/~~\e|i4%!
,r2/~~\~e|4%!
,r2/:~~\e|4%!
,r2/S*~\e|4%!
Y el 13 bytesr2/:~W%:e|4%!
r2/:i:\e|4%!
(12) yr2/:i(fe|~4%!
(13). Incluso probé GolfScript (que no requierer
), peroor4
se interpreta como un token único. Si solo la entrada tuviera una nueva línea al final ...Javascript (ES6), 21 caracteres
La regla estándar es que
y
es un año bisiesto si 4 dividey
y si 100 no dividey
o 400 dividey
. En codigo,No hay necesidad de que 100 y 400. En cambio, es suficiente verificar si 16 o 4 divide y, con 16 elegidos si 25 divide y, 4 de lo contrario. Golfizado, esto se convierte
Una función de JavaScript que implementa esto tiene 21 caracteres de longitud:
Perl,
2826 caracteresLa misma idea, pero en perl.
Ejecuta usando las
-lp
opciones. Por ejemplo,Con la prueba establecida como entrada, esto produce
fuente
y=>...
) es una característica de ES6.Pip , 13 bytes
Este fue más interesante de lo que parecía al principio. Me tomó un poco de tiempo, pero finalmente pude reemplazar esas largas referencias a y
400
con4
lah
variable (= 100).Salidas
1
para el año bisiesto,0
para el año no bisiesto. Explicación:fuente
Pyth,
191514 bytesDemasiado fácil. Pruébelo en línea: demostración o prueba de arnés
editar: Perdido, que puede imprimir valores de Verdad / Falsificación, en lugar de
n/y
. -4 byteeditar 2: Usó la idea de raíz cuadrada de Martin. -1 byte
Explicación
fuente
Regex,
836238Gracias a Toby por los consejos sobre la combinación de ambas mitades de la expresión regular.
Si nos centramos solo en el rango 1801..2400 y asumimos que la entrada son enteros:
Pruebe en Ruby (
^
=\A
y$
=\Z
porque Ruby) para el rango deseado:(Bonificación) para algo que debería funcionar no solo para 1801..2400, sino para cualquier año no negativo:
Prueba en Ruby (
^
=\A
y$
=\Z
porque Ruby) durante los primeros 100000 años:fuente
(?!)
, puede combinar las dos mitades:(?!00)([02468][048]|[13579][26])(00)?$
- por 38. Sin embargo, eso no funcionará durante años de un dígito.JavaScript ( ES6 ) 27
La regla:
(y%4==0) && (y%100!=0 || y%400==0)
Golfizado:
!(y%100<1&&y%400||y%4)
(principalmente usando la ley de De Morgans )Una función que implementa la regla:
Una prueba (ejecutar en Firefox) solo para estar seguro:
fuente
!(y%(y%25?4:16))
lugar de!(y%100<1&&y%400||y%4)
. Para aquellos molestados por el operador ternario, puede usar!(y%(4<<2*!(y%25)))
y guardar tres caracteres!(y%100<1&&y%400||y%4)
.TI-BASIC,
20 17 1613Debido a que está tokenizado, TI-BASIC a menudo es competitivo en desafíos matemáticos simples, pero no en este ya que no existe un comando "divisible".Tal vez es después de todo, pero esto aún es más largo que CJam y Pyth.Esto usa el método de David Hammond.
Código antiguo a 16 bytes:
Sin golf:
fPart(
es "parte fraccional"; La exponenciación tiene mayor precedencia que la división. En TI-BASIC, los parentescos cercanos son opcionales.Utilizo el comportamiento no documentado del
sub(
comando, que generalmente se usa para obtener una subcadena: cuando su argumento es un número en lugar de una cadena, divide el número por 100. Funcionará en una calculadora de la serie TI-83 u 84.20 -> 17 reorganizando el código para permitir la eliminación de parentescos cercanos; 17 -> 16 reemplazando 400 con 16; 16 -> 13 usando la idea de David Hammond.
fuente
Stackylogic, 226 bytes (no competidor)
Si, eso es correcto. Hice un programa en Stackylogic (no TC), que fue inventado por Helka Homba, para el desafío que se encuentra aquí . Esto se hace después del desafío, por lo que no compite.
Stackylogic solo tiene entrada binaria, por lo que se deben usar 10 bits (o más, se ignorarán más dígitos) bit binario (primero se ingresa el bit menos significativo). Cualquier fecha fuera del rango especificado puede fallar, ya que simplemente comprueba cuál es el número ingresado: no cubre fechas innecesarias
No solo es este mi primer desafío con stackylogic, sino el primer desafío con stackylogic.
Prepárate para este desastre:
Me llevó mucho tiempo hacerlo, porque Stackylogic es el lenguaje más confuso que he encontrado y extremadamente ilegible: debes saber cómo se ha ejecutado el resto del programa antes de poder leer la sección actual que se está editando. Incluso tuve que agregar espacios para facilitar la lectura mientras lo creaba.
Explicación pobre
Esta es una explicación simple de lo que hace.
Stackylogic no tiene ninguna función matemática, por lo que esto lo hizo más difícil. Tuve que codificar la mayor parte, para verificar si era un número específico.
Primero, este programa hará un NOR de los bits menos significativos, descartándolos en el proceso. Esto significa que si es divisible por 4, se procederá a la parte principal del programa, de lo contrario salida 0.
En segundo lugar, el puntero se traslada al laberinto de stackylogic, desde aquí, si los siguientes dos bits son cero, generará instantáneamente 1 (ya que es divisible por 16 y, por lo tanto, un año bisiesto a pesar de cualquier otra condición), otro sabiamente verificará si ninguno de los números es divisible por 4 pero no es un año bisiesto, entre 1801 y 2400.
Para explicar en detalle, implicaría hacer esta publicación muchas veces más larga de lo que ya es
fuente
Ensamblador IBM System Z - 56 bytes.
(96 bytes de fuente. Anteriormente
712384202 bytes de fuente, 168 bytes ejecutables).Versión más pequeña todavía. Ya no guarda los registros de las personas que llaman, los cambios en el almacenamiento literal, el modo de direccionamiento modificado.
Nueva versión. Esto ABENDRÁ con un S0C1 si es un año bisiesto, y se repetirá si no lo es. Esperemos que cumpla el requisito de indicar el resultado.
OK, entonces no es el más corto (aunque podría ser una vez que veamos el código ejecutado real más el tamaño del intérprete ...)
Salida:
ABENDER S0C1 por un año bisiesto, S222 (cuando se agota el tiempo de CPU) si no.
1936 Y 1805 N 1900 N 2272 Y 2400 Y(cuando se ejecuta varias veces)fuente
CJam,
1816 bytesDa
1
(verdad) para los años bisiestos y0
(falso) lo contrario.Ejecute todos los casos de prueba aquí.
Explicación
fuente
Mathematica,
4027 bytes, 17 caracteresUtiliza 17 caracteres, pero 27 bytes. Gracias a @alephalpha por el dato. Tenga en cuenta que las barras verticales son en realidad U + 2223 para las divisiones. El
<U+F523>
debe ser reemplazado con el carácter correspondiente.fuente
∣
para representarDivisible
:#∣4&&(!#∣100||#∣400)&
21 caracteres, 27 bytes UTF-8.U+F523
(\[Implies]
) para hacerlo#∣4&&(#∣100<U+F523>#∣400)&
por 19 caracteres (pero aún 27 bytes).R, 29
Prueba de funcionamiento
fuente
C, 81
Puedo hacerlo más corto, pero este se adhiere perfectamente a los tipos 'char', sin analizar el argumento (por ejemplo, con
atoi
):Debe invocarse con un nombre de 4 caracteres de largo, ya que supone que los argumentos siguen inmediatamente al nombre del programa, separados por NUL. Además, se supone que el argumento único está codificado en ASCII y no tiene espacio inicial.
Explicación:
*v+9
es la posición del dígito 'decenas' env[1]+2
.Si los caracteres 'decenas' y 'unidades' se suman a 96, terminamos
00
, así que haga una copia de seguridad de dos caracteres, de modo que 'decenas' y 'unidades' apunten al número del siglo.Ahora xor 'unidades' con el doble de 'decenas', mod 4. Esto funciona porque
10==±2 mod 4
, por lo que el bit inferior de las 'decenas' puede alternar el bit 1 de las 'unidades'. Usamos el resultado como un índice en nuestra tabla de residuos, imprimiendoy
solo si el resultado modular es cero.fuente
Befunge -98, (41 bytes)
La simplicidad es asombrosa.
fuente
sed, 55
Tenga en cuenta que los años no bisiestos pueden imprimirse según sean pares o impares
n
oN
dependiendo de ellos. Considero que esta es una interpretación creativa de la regla que permite alternativas a 'sí' y 'no' sin especificar que tienen que ser consistentes.fuente
Python2 - 37
g=lambda x:(x%4or x%400and x%100<1)<1
Tenga en cuenta que si
a
es un entero no negativo, entoncesa<1
es una forma corta de escribirnot bool(a)
. El último<1
convierte efectivamente la expresión entre paréntesis en un booleano y niega el resultado.La aplicación de la función
g
a un número enteron
entre 1801 y 2400 devolveráTrue
sin
es un año bisiesto, y de loFalse
contrario.fuente
KDB (Q), 27 bytes
Explicación
Prueba
fuente
Julia,
3028 bytesEsto crea una función sin nombre que acepta un argumento entero y devuelve un valor booleano. Para llamarlo, dale un nombre, por ejemplo
f=y->...
.Sin golf:
Ejemplo:
fuente
PHP - 45 bytes
Nada realmente especial, solo abusar del malabarismo de tipos.
fuente
C #, 23 bytes
Pruébalo en línea!
Fuente completa, incluidos los casos de prueba:
fuente
C,
373430 bytesCaja de varitas
fuente
T-SQL
3722 bytesGuardado 15 bytes gracias al comentario de BradC.
La variable codificada habitual por falta de a
stdin
.p.ej
Entonces la solución es:
fuente
1
o0
directamente:PRINT ISDATE(@+'0229')
Java 8,
49452220 bytes-2 bytes gracias a @ OlivierGrégoire .
Pruébalo en línea.
Algunas soluciones de 22 bytes:
Pruébalo en línea.
Pruébalo en línea.
Pruébalo en línea.
Explicación:
fuente
java.time.Year::isLeap
.n->n%(n%25<1?16:4)<1
Haskell, 19 bytes
Pruébalo en línea!
fuente
Javascript ES6, 32, 29, 26
Cualquiera de las siguientes líneas funciona:
fuente
C, 57 bytes
Toma la entrada de stdin, con o sin espacios finales / nueva línea. Solo funciona en pequeñas máquinas endian (sí, como si todos estuvieran en BE en estos días). Salidas Y o N.
Explicación
Sin golf:
Primero,
scanf
lee el año como un entero en y. Luego, y se modula con 4 o 400 dependiendo de si el año es divisible por 100. Si el resto es cero, el código ASCII para Y se asigna a y, de lo contrario, obtiene el código ASCII para N. El valor de y es ahora0x000000??
, donde0x??
está el personaje asignado. Al estar en una máquina little-endian, en la memoria esto se almacena como?? 00 00 00
. Esta es una cadena C terminada en NULL, que contiene solo los caracteres asignados. La dirección de y se pasa a put y se imprime el carácter (con una nueva línea final).fuente
main(y){scanf("%d",&y);y=!(y%(y%100?4:400))+48;puts(&y);}
. Puedo bajar a 48 bytes si puedo generar una línea vacía para los años bisiestos y cualquier carácter (ASCII 1-99) de lo contrario, pero siento que está un poco doblando las reglas. ¿Qué piensas?PowerShell, 31 bytes
¡Estoy emocionado de decir que jugué golf más corto que el incorporado!
Salidas verdaderas para años bisiestos y falsas de lo contrario.
Incorporado:
Sin embargo, si quisiera estirar la declaración "claramente le dice al usuario si es o no un año bisiesto" y hacer algo no estándar, podría guardar 3 bytes y usar:
Esto da como resultado
0
los años bisiestos y 1 o superior para los años no bisiestos, lo que no me gusta, ya que preferiría devolver un valor de verdad más estándar para los años bisiestos.fuente
LOLCODE,
228202159 bytesSin golf:
En Python sin golf, porque LOLCODE es confuso:
fuente
WIN
...