Desafío:
Su programa tomará dos enteros n
y k
como entrada, y generará el entero más pequeño mayor que (pero no igual a) n
que contiene al menos k
ocurrencias del dígito 5
.
Puedes asumir 1 ≤ k ≤ 15
y 1 ≤ n < 10**15
.
Este es un desafío de tiempo restringido . Su programa debe ejecutarse en TIO para todos los casos de prueba y completarse en 10 segundos en total.
Reglas generales:
Este es el código de golf , por lo que gana la respuesta más corta en bytes.
No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolf. Intenta encontrar una respuesta lo más breve posible para cualquier lenguaje de programación.Las reglas estándar se aplican a su respuesta con las reglas de E / S predeterminadas , por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada. Los parámetros de la función pueden tomarse en cualquier orden, pero especifique en su respuesta.
- Las lagunas predeterminadas están prohibidas.
- Debe agregar un enlace con una prueba para su código (es decir, TIO ).
- El encabezado de respuesta debe enumerar la puntuación en bytes, pero también el tiempo total necesario para todos los casos de prueba en TIO
- Si su idioma no está en TIO, el código debería terminar mucho menos de 10 segundos en su máquina para que esté seguro de que es lo suficientemente rápido en cualquier computadora razonable.
- Agregar una explicación para su respuesta es muy recomendable.
Casos de prueba:
(n, k) -> output
(53, 2) -> 55
(55, 1) -> 56
(65, 1) -> 75
(99, 1) -> 105
(555, 3) -> 1555
(557, 1) -> 558
(5559, 3) -> 5565
(6339757858743, 5) -> 6339757859555
(99999999999999, 15) -> 555555555555555
Ejemplo de programa:
Este programa es correcto.
fuente
(n, k) = (45, 1)
es50
? Algunas de las respuestas se equivocan.Respuestas:
R + stringr,
858476 bytes, .062s en TIOPruébalo en línea!
-1 byte gracias a Robert S.
-8 bytes gracias a Giuseppe.
Una solución recursiva simple sería incrementar en 1 hasta que se encuentre la respuesta, pero esto no cumpliría con la restricción de tiempo. Para cumplir con la restricción de tiempo, esta función hace uso del hecho de que si faltan 5s p, podemos aumentar en 2 * 10 ^ (p-2).
Tenga en cuenta que cuando p = 1, el incremento se convierte en 0.2. Esto está bien, ya que después de 5 pasos volvemos a un número entero, y ninguno de los números decimales encontrados en el tiempo medio tiene un 5. extra. En cambio, si aumentamos en 5 * 10 ^ (p-2) o en 1 * 10 ^ (p-2), entonces encontraríamos f (24, 1) = 24.5 en lugar de 25 por ejemplo.
fuente
if
variante de función.a
estaba haciendo, así que lo eliminé y parece estar bien.Jelly , 37 bytes 0.113 s en TIO
Pruébalo en línea!
Esto funciona por
k
y hacer un número con tantos cincofuente
[557,1]
(resultados en558
lugar de560
); El caso de prueba en la descripción parece incorrecto, ya que[557,2]
debería resultar en su558
lugar.05AB1E ,
3332 bytesEl sorprendente enfoque de PortNickKennedy en su respuesta de Jelly , ¡así que asegúrate de votarlo!
Pruébelo en línea o verifique todos los casos de prueba .
Explicación:
fuente
Stax , 17 bytes (6.861 segundos totales en TIO)
Ejecutar y depurarlo
Este programa toma
k
yn
en la entrada estándar separados por un espacio. Stax no tiene una forma conveniente de ejecutar múltiples casos de prueba en TIO, por lo que ejecuté cada entrada por separado y sumé el tiempo. El 99% del tiempo está en el inicio del proceso de interpretación. Usando el intérprete de JavaScript en staxlang.xyz, todos los casos de prueba se ejecutan en 50 milisegundos.Último caso de prueba en ¡Pruébelo en línea!
Procedimiento :
5
s, finalice e imprimat
= número de5
s finales en el número10 ** t
fuente
Python 2 ,
7068 bytes (.025 segundos en TIO)Pruébalo en línea!
Esto podría ser un poco exagerado; es correcto en todos los casos y termina en un tiempo insignificante para los casos de prueba, pero no termina en un tiempo razonable para otros casos. Sin embargo, técnicamente cumple los requisitos.
En resumen, si el número más pequeño con
k
cinco es mayor quen
, usamos ese número ya que obviamente es la solución correcta. Si no es así, recurrimos al enfoque recursivo estándar.fuente
Perl 5
-pl
, 44 bytesPruébalo en línea!
Encuentra cuál es el número sin sus 5s finales. Incrementa esa porción en 1. Continúa hasta que haya suficientes 5s en el número. Toma alrededor de .012s en TIO para ejecutar todos los casos de prueba.
fuente
Python 3 ,
144988675 bytesPruébalo en línea!
El algoritmo consiste en redondear cada dígito (comenzando por el menos significativo) al valor más cercano de 5 hasta que la representación decimal del nuevo número tenga el recuento deseado.
El enfoque original utilizaba una comprensión de lista abortable (D = iter (rango (k)) y lista (D) en el trabajo aquí), pero @ ASCII-only me ha convencido de que nunca ganará el código golf. No me gusta la recursividad, pero si el algoritmo está escrito para minimizar la profundidad de recursión, entonces un futuro compilador / intérprete será lo suficientemente inteligente como para volver a implementarlo como un ciclo while.
fuente
(-(-~n//l+5))%10
es la razónPython 3 , 59 bytes
Solución recursiva. La profundidad de recursión es un problema (debe cambiarse para números más altos), pero es correcta.
Pruébalo en línea!
fuente
Python 3, 72 bytes
Pruébalo en línea!
fuente
Java 8, 69 bytes, más de 60 segundos en TIO con el último caso de prueba, ~ 1.5 segundos sin.
¿Alguien tiene alguna idea sobre cómo pasar el último caso de prueba?
fuente
PHP ,
10997 bytes, (<0.03s en TIO)Pruébalo en línea!
Basado en el algoritmo de @ recursive .
fuente
Retina , 63 bytes
Pruébalo en línea! Toma
n
yk
en líneas separadas, pero el enlace incluye un encabezado que convierte el conjunto de pruebas al formato apropiado. Explicación:Convierte
k
a unario.Incremento
n
. El*
repite su argumento derecho (aquí el primer_
carácter) el número de veces dado por su argumento izquierdo (que, como aquí, por defecto es la coincidencia). Esto da como resultado una cadena de esa longitud. El$(
(el)
está implícito) luego concatena eso con el segundo_
y.
hace que se tome la longitud resultante. (En realidad, Retina 1 es más inteligente que eso y solo realiza el cálculo en las longitudes subyacentes en primer lugar).Pruebe si
5
se pueden encontrar suficientes sn
para coincidir con los_
s de la representación unaria dek
. Esta prueba ha sido desarrollada y sería tres veces más rápida si se^
agrega después de la inicial/
y aún más rápida si[^5]
se usara en lugar de.
.Hasta que pase la prueba ...
... incrementa
n
pero excluye los5
s finales .Eliminar
k
.fuente
Almeja , 30 bytes, ~ 0.2s en TIO
Transpiles a este JS (conjunto de pruebas completo agregado para el tiempo, por supuesto), donde
inputs
hay una matriz de las entradas (n
primero,k
segundo)Gracias @ArBo por el enfoque
Explicación
fuente
C (gcc) ,
159158152150149 bytes, ~ 0,04 sEmite la respuesta a STDOUT, con ceros a la izquierda.
-3 bytes gracias a ceilingcat
Pruébalo en línea!
fuente