Dado un entero positivo n ≤ 500 :
Encuentre el número entero positivo más pequeño k tal que todos los dígitos en la representación decimal de n * k sean 0 o d , con 1 ≤ d ≤ 9 .
Imprima o devuelva d en menos de 30 segundos (lea más sobre eso en la sección de Aclaraciones y reglas ).
Ejemplos sencillos
Aquí están los primeros 30 valores de d .
+----+-------+---------+---+ +----+-------+---------+---+
| n | k | n * k | d | | n | k | n * k | d |
+----+-------+---------+---+ +----+-------+---------+---+
| 1 | 1 | 1 | 1 | | 16 | 5 | 80 | 8 |
| 2 | 1 | 2 | 2 | | 17 | 653 | 11101 | 1 |
| 3 | 1 | 3 | 3 | | 18 | 5 | 90 | 9 |
| 4 | 1 | 4 | 4 | | 19 | 579 | 11001 | 1 |
| 5 | 1 | 5 | 5 | | 20 | 1 | 20 | 2 |
| 6 | 1 | 6 | 6 | | 21 | 37 | 777 | 7 |
| 7 | 1 | 7 | 7 | | 22 | 1 | 22 | 2 |
| 8 | 1 | 8 | 8 | | 23 | 4787 | 110101 | 1 |
| 9 | 1 | 9 | 9 | | 24 | 25 | 600 | 6 |
| 10 | 1 | 10 | 1 | | 25 | 2 | 50 | 5 |
| 11 | 1 | 11 | 1 | | 26 | 77 | 2002 | 2 |
| 12 | 5 | 60 | 6 | | 27 | 37 | 999 | 9 |
| 13 | 77 | 1001 | 1 | | 28 | 25 | 700 | 7 |
| 14 | 5 | 70 | 7 | | 29 | 37969 | 1101101 | 1 |
| 15 | 2 | 30 | 3 | | 30 | 1 | 30 | 3 |
+----+-------+---------+---+ +----+-------+---------+---+
Ejemplos no tan fáciles
Una particularidad de este desafío es que algunos valores son mucho más difíciles de encontrar que otros, al menos con un enfoque puramente de fuerza bruta. A continuación se presentan algunos ejemplos de n que conducen a un alto valor de k .
+-----+------------+---------------+---+ +-----+------------+---------------+---+
| n | k | n * k | d | | n | k | n * k | d |
+-----+------------+---------------+---+ +-----+------------+---------------+---+
| 81 | 12345679 | 999999999 | 9 | | 324 | 13717421 | 4444444404 | 4 |
| 157 | 64338223 | 10101101011 | 1 | | 353 | 28615017 | 10101101001 | 1 |
| 162 | 13717421 | 2222222202 | 2 | | 391 | 281613811 | 110111000101 | 1 |
| 229 | 43668559 | 10000100011 | 1 | | 405 | 13717421 | 5555555505 | 5 |
| 243 | 13717421 | 3333333303 | 3 | | 439 | 22781549 | 10001100011 | 1 |
| 283 | 35371417 | 10010111011 | 1 | | 458 | 43668559 | 20000200022 | 2 |
| 299 | 33478599 | 10010101101 | 1 | | 471 | 64338223 | 30303303033 | 3 |
| 307 | 32576873 | 10001100011 | 1 | | 486 | 13717421 | 6666666606 | 6 |
| 314 | 64338223 | 20202202022 | 2 | | 491 | 203871711 | 100101010101 | 1 |
| 317 | 3154574483 | 1000000111111 | 1 | | 499 | 22244489 | 11100000011 | 1 |
+-----+------------+---------------+---+ +-----+------------+---------------+---+
Aclaraciones y reglas.
- n * k siempre contendrá al menos un dígito d , pero puede no contener ningún cero.
- Este es el código de golf , por lo que gana el código más corto en bytes. Sin embargo, su programa o función debe poder devolver el resultado para cualquier 1 ≤ n ≤ 500 en menos de 30 segundos en hardware de rango medio.
- Tenga en cuenta que algunos valores son más difíciles de encontrar que otros. Es improbable que un programa que intente aplicar fuerza bruta al valor de k cumpla con la restricción del límite de tiempo (un buen caso de prueba es n = 317 ). Hay métodos significativamente más rápidos para encontrar d .
Tabla de referencia
Todos los valores de d para 1 ≤ n ≤ 500 se enumeran a continuación.
n | d
--------+--------------------------------------------------
001-025 | 1 2 3 4 5 6 7 8 9 1 1 6 1 7 3 8 1 9 1 2 7 2 1 6 5
026-050 | 2 9 7 1 3 1 8 3 2 7 9 1 2 3 4 1 6 1 4 9 2 1 6 7 5
051-075 | 3 4 1 9 5 7 1 2 1 6 1 2 9 8 5 6 1 4 3 7 1 9 1 2 3
076-100 | 4 7 6 1 8 9 2 1 4 5 2 3 8 1 9 1 4 3 2 5 6 1 7 9 1
101-125 | 1 6 1 8 7 2 1 9 1 1 1 7 1 2 5 4 9 2 7 6 1 2 3 4 5
126-150 | 6 1 8 3 1 1 6 7 2 9 8 1 6 1 7 1 2 1 9 5 2 7 4 1 3
151-175 | 1 8 9 7 5 4 1 2 1 8 7 2 1 4 3 2 1 8 1 1 3 4 1 6 7
176-200 | 8 3 2 1 9 1 2 1 8 5 6 1 4 9 1 1 6 1 2 3 7 1 9 1 2
201-225 | 3 2 7 4 5 2 9 8 1 7 1 4 1 2 5 9 7 2 3 2 1 2 1 7 9
226-250 | 2 1 4 1 1 3 8 1 6 5 4 3 7 1 6 1 2 3 4 7 6 1 8 3 5
251-275 | 1 6 1 2 3 8 1 6 7 2 9 2 1 6 5 7 3 4 1 9 1 8 3 2 5
276-300 | 6 1 2 9 7 1 2 1 4 5 2 7 9 1 1 3 4 1 7 5 8 9 2 1 3
301-325 | 7 2 3 8 5 6 1 4 3 1 1 8 1 2 9 4 1 2 1 8 1 7 1 4 5
326-350 | 2 1 8 7 3 1 4 3 2 5 8 1 2 3 2 1 6 1 8 3 2 1 4 1 7
351-375 | 9 8 1 6 5 4 7 2 1 9 1 2 3 4 5 2 1 8 9 1 7 6 1 2 3
376-400 | 8 1 9 1 2 3 2 1 6 7 2 9 4 1 3 1 7 1 2 5 9 1 2 7 4
401-425 | 1 6 1 4 5 2 1 8 1 1 3 4 7 9 5 8 1 2 1 6 1 2 3 8 5
426-450 | 2 7 4 3 1 1 9 1 7 3 4 1 6 1 4 3 2 1 4 5 2 3 7 1 9
451-475 | 1 4 3 2 5 8 1 2 9 2 1 6 1 8 3 2 1 6 7 1 3 8 1 6 5
476-500 | 7 3 2 1 6 1 2 3 4 5 6 1 8 3 7 1 6 1 2 9 8 7 6 1 5
code-golf
arithmetic
Arnauld
fuente
fuente
Respuestas:
Jalea ,
161514 bytesTiempo de ejecución cuadrático (menos de 25 segundos en TIO).
Pruébalo en línea!
Versión alternativa, 15 bytes.
Tiempo de ejecución constante (aprox. 1 segundo en TIO).
Pruébalo en línea!
Cómo funciona
fuente
JavaScript (ES6), 83 bytes
Ahora vuelve
6
porn=252
! Intenté un enfoque recursivo, pero también tiene 83 bytes y se bloquea por los números más difíciles:fuente
Mathematica,
10310097 bytesencuentra 317 en 0.39 segundos
Pruébelo en línea, copie / pegue el código, agregue [317] al final y presione Mayús + Intro para ejecutar
-3 bytes de @JungHwan Min
-3 bytes de @Keyu Gan
fuente
*
en*#
, yTuples[{0,i},13]
es{0,i}~Tuples~13
[[1]]
al final es lo mismo que poner#&@@
al principioJoin@@
lugar deFlatten@
Python 2/3,
129128127 bytes-1 byte:
count(0)
→count()
-1 byte:
==0
→<1
ya que no puede ser negativofuente
Jalea , 21 bytes
Un enlace monádico que devuelve el número O un programa completo que lo imprime.
Una fuerza bruta de rango limitado que toma menos de 20 segundos para cualquier 1 ≤ n ≤ 500 (menos de 3 segundos para un costo de código de 1 byte - reemplace
⁴
con13
).Pruébalo en línea!
¿Cómo?
fuente
PHP , 87 bytes
Pruébalo en línea!
PHP , 89 bytes
Pruébalo en línea!
fuente