n * k = dd0d00d où d =…?

14

Étant donné un entier positif n ≤ 500 :

  • Trouvez le plus petit entier positif k tel que tous les chiffres de la représentation décimale de n * k soient 0 ou d , avec 1 ≤ d ≤ 9 .

  • Imprimez ou retournez d en moins de 30 secondes (en savoir plus à ce sujet dans la section Clarifications et règles ).

Exemples simples

Voici les 30 premières valeurs 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 |
+----+-------+---------+---+    +----+-------+---------+---+

Exemples pas si faciles

Une particularité de ce défi est que certaines valeurs sont beaucoup plus difficiles à trouver que d'autres - au moins avec une approche purement brute. Voici quelques exemples de n qui conduisent à une valeur élevée 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 |
+-----+------------+---------------+---+    +-----+------------+---------------+---+

Clarifications et règles

  • n * k contiendra toujours au moins un chiffre d , mais il peut ne contenir aucun zéro.
  • Il s'agit de code-golf , donc le code le plus court en octets l'emporte. Cependant, votre programme ou fonction doit être capable de renvoyer le résultat pour tout 1 ≤ n ≤ 500 en moins de 30 secondes sur du matériel de milieu de gamme.
  • Gardez à l'esprit que certaines valeurs sont plus difficiles à trouver que d'autres. Un programme qui tenterait de forcer brutalement la valeur de k est peu susceptible de respecter la contrainte de limite de temps (un bon cas de test est n = 317 ). Il existe des méthodes beaucoup plus rapides pour trouver d .

Table de référence

Toutes les valeurs de d pour 1 ≤ n ≤ 500 sont répertoriées ci-dessous.

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
source
1
Librement inspiré (mais très différent de) de ce récent défi .
— Arnauld
n = 6669666 -> d = 9
— J42161217
Diagonales intéressantes dans ce tableau.
— James
@James en effet. Les motifs apparaîtront un peu plus clairement en formatant le MOD 24. Avec le MOD 25, nous obtenons à la place des diagonales. :-)
— Arnauld

Réponses:

3

Gelée , 16 15 14 octets

²B€Ḍ9×þF%Þ¹ḢQS

Durée d'exécution quadratique (moins de 25 secondes sur TIO).

Essayez-le en ligne!

Version alternative, 15 octets

2ȷB€Ḍ9×þF%Þ¹ḢQS

Durée d'exécution constante (environ 1 seconde sur TIO).

Essayez-le en ligne!

Comment ça fonctionne

²B€Ḍ9×þF%Þ¹ḢQS  Main link. Argument: n

²               Take the square of n.
                This bound is high enough for all integers up to 500. 
                In fact, The highest value we need is 1387 for input 471, so
                2000 (2ȷ) is also enough (and a lot faster).

 B€             Binary; convert 1, ..., 4159 to base 2.
   Ḍ            Undecimal; convert each digit array from base 10 to integer.
                This generates the array A of all positive integers up to n²
                whose decimal representations consist entirely of 1's and 0's.
    9×þ         9 multiply table; for each x in A, yield [x, 2x, ..., 8x, 9x].
       F        Flatten; concatenate the resulting arrays, yielding the vector
                V. Note that V contains all numbers that match the regex ^d[0d]*$
                in base 10, in ascending order.
          ¹     Identity; yield n.
        %Þ      Sort the entries for V by their remainders modulo n. This places
                multiples of n at the beginning. The sorting algorithm in stable,
                so the first element of sorted V is the smallest multiple of n.
           Ḣ    Head; extract the first element.
            Q   Unique; deduplicate its digits in base 10. This yields [d, 0].
             S  Take the sum, yielding d.
— Dennis
source
5

JavaScript (ES6), 83 octets

n=>{for(p=1;;p=k)for(d=0;d++<9;)for(k=p;k<p+p;k++)if(k.toString(2)*d%n<1)return d;}

Retourne maintenant 6pour n=252! J'ai essayé une approche récursive mais c'est aussi 83 octets et tombe en panne pour moi pour les chiffres les plus durs:

f=(n,p=1,d=1,k=p)=>k<p+p?k.toString(2)*d%n<1?d:f(n,p,d,k+1):d>8?f(n,p+p):f(n,p,d+1)
— Neil
source
4

Mathematica, 103 100 97 octets

#&@@IntegerDigits[Sort[Join@@Table[Cases[FromDigits/@{0,i}~Tuples~13/#,_Integer],{i,9}]][[10]]#]&


trouve 317 en 0,39 sec

Essayez-le en ligne, copiez / collez le code, ajoutez [317] à la fin et appuyez sur Maj + Entrée pour exécuter

-3 octets de @JungHwan Min
-3 octets de @Keyu Gan

— J42161217
source
Vous pouvez vous débarrasser de *dans *#, et Tuples[{0,i},13]est{0,i}~Tuples~13
— Junghwan Min
oui, bien sûr.
— J42161217
Oh, et un de plus: [[1]]à la fin, c'est la même chose que de mettre #&@@au début
— JungHwan Min
... et nous sommes arrivés à 100! merci pour -3 octets
— J42161217
Vous pouvez utiliser à la Join@@place deFlatten@
— Keyu Gan
2

Python 2/3, 129 128 127 octets

from itertools import*
lambda n:next(d for p in count()for d in range(1,10)for k in range(2**p,2*2**p)if d*int(bin(k)[2:])%n<1)

-1 octet: count(0)→ count()
-1 octet: ==0→ <1car il ne peut pas être négatif

— Score_Under
source
2

Gelée , 21 octets

9Rṭ€0ṗ€⁴ẎḌḍ@Ðf⁸ṢDFḟ0Ḣ

Un lien monadique renvoyant le numéro OU un programme complet l'imprimant.

Un forceur brutal à portée limitée qui prend moins de 20 secondes pour tout 1 ≤ n ≤ 500 (moins de 3 secondes pour un coût de code de 1 octet - remplacer ⁴par 13).

Essayez-le en ligne!

Comment?

9Rṭ€0ṗ€⁴ẎḌḍ@Ðf⁸ṢDFḟ0Ḣ - Link: number, n
9R                    - range of 9 = [1,2,3,4,5,6,7,8,9]
  ṭ€0                 - tack €ach to 0 -> [[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7],[0,8],[0,9]]
       ⁴              - literal 16
     ṗ€               - Cartesian product for €ach
        Ẏ             - tighten (flatten by 1 level)
         Ḍ            - covert from decimal list to number (vectorises)
              ⁸       - chain's left argument (n)
            Ðf        - filter keep items for which this yields a truthy value:
          ḍ@          -   divisible? with swapped @rguments
               Ṣ      - sort
                D     - convert to decimal list (vectorises)
                 F    - flatten into a single list
                  ḟ0  - filter out zeros
                    Ḣ - head (get the first value)
— Jonathan Allan
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.