Étant donné une valeur x, trouvez la plus petite valeur numérique supérieure à y qui peut être multipliée et divisée par x tout en conservant tous les chiffres d'origine.

• Les nouveaux numéros ne perdent pas de chiffres.
• Les nouveaux numéros ne gagnent pas de chiffres.

Par exemple:

Entrée: x = 2, y = 250000

• Original: 285714
  • Division: 142857
  • Multiplication: 571428

Cela est vrai car 285714 est supérieur à y ; puis lorsqu'il est divisé par x donne 142857 et lorsqu'il est multiplié par x donne 571428 . Dans les deux tests, tous les chiffres originaux de 285714 sont présents et aucun chiffre supplémentaire n'a été ajouté.

Les règles

• X doit être égal à 2 ou 3, car tout élément supérieur prend trop de temps à calculer.
• Y doit être un nombre entier supérieur à zéro .
• Le code le plus court gagne.

Cas de test

Ce sont mes cas de test les plus courants car ils sont les plus rapides à tester.

• x = 2, y = 250000 = 285714
• x = 2, y = 290000 = 2589714
• x = 2, y = 3000000 = 20978514
• x = 3, y = 31000000 = 31046895
• x = 3, y = 290000000 = 301046895

Clarifications

• Le type de division n'a pas d'importance. Si vous pouvez obtenir 2.05, 0.25 et 5.20, n'hésitez pas.

Bonne chance à vous tous!

Husk , 14 octets

ḟ§¤=OoDd§¤+d*/

Essayez-le en ligne!

Explication

ḟ§¤=O(Dd)§¤+d*/  -- example inputs: x=2  y=1
ḟ                -- find first value greater than y where the following is true (example on 285714)
 §               -- | fork
         §       -- | | fork
              /  -- | | | divide by x: 142857
                 -- | | and
             *   -- | | | multiply by y: 571428
                 -- | | then do the following with 142857 and 571428
                 -- | | | concatenate but first take
           +     -- | | | | digits: [1,4,2,8,5,7] [5,7,1,4,2,8]
          ¤ d    -- | | | : [1,4,2,8,5,7,5,7,1,4,2,8]
                 -- | and
       d         -- | | digits: [2,8,5,7,1,4]
      D          -- | | double: [2,8,5,7,1,4,2,8,5,7,1,4]
                 -- | then do the following with [2,8,5,7,1,4,2,8,5,7,1,4] and [1,4,2,8,5,7,5,7,1,4,2,8]
   =             -- | | are they equal
  ¤ O            -- | | | when sorted: [1,1,2,2,4,4,5,5,7,7,8,8] [1,1,2,2,4,4,5,5,7,7,8,8]
                 -- | : truthy
                 -- : 285714

Brachylog v2, 15 octets

t<.g,?kA/p.∧A×p

Essayez-le en ligne!

Prend la saisie dans le formulaire [x,y].

Explication

t<.g,?kA/p.∧A×p
t                  Tail (extract y from the input)
 <                 Brute-force search for a number > y, such that:
  .                  it's the output to the user (called ".");
   g                 forming it into a list,
    ,?               appending both inputs (to form [.,x,y]),
      k              and removing the last (to form [.,x])
       A             gives a value called A, such that:
        /              first ÷ second element of {A}
         p             is a permutation of
          .            .
           ∧         and
            A×         first × second element of {A}
              p        is a permutation of {.}

Commentaire

La faiblesse de Brachylog à réutiliser plusieurs valeurs plusieurs fois apparaît ici; ce programme est presque entièrement de plomberie et très peu d'algorithme.

En tant que tel, il peut sembler plus pratique de simplement coder en dur la valeur de y (il y a un commentaire sur cette question en faisant l'hypothèse que 2 est la seule valeur possible). Cependant, il existe en fait des solutions pour y = 3, ce qui signifie que malheureusement, la plomberie doit également gérer la valeur de y . Le plus petit que je sache est le suivant:

                         315789473684210526
315789473684210526 × 3 = 947368421052631578
315789473684210526 ÷ 3 = 105263157894736842

(La technique que j'ai utilisée pour trouver ce nombre n'est pas entièrement générale, il est donc possible qu'il existe une solution plus petite utilisant une autre approche.)

Il est peu probable que vous vérifiiez cela avec ce programme. Brachylog pest écrit d'une manière très générale qui n'a pas d'optimisations pour des cas spéciaux (comme le cas où l'entrée et la sortie sont déjà connues, ce qui signifie que vous pouvez faire la vérification dans O ( n log n ) via le tri, plutôt que le O ( n !) pour l'approche de force brute que je soupçonne qu'il utilise). Par conséquent, il faut très longtemps pour vérifier que 105263157894736842 est une permutation de 315789473684210526 (je l'ai laissé fonctionner pendant plusieurs minutes maintenant sans progrès évident).

(EDIT: J'ai vérifié la source Brachylog pour la raison. Il s'avère que si vous utilisez psur deux entiers connus, l'algorithme utilisé génère toutes les permutations possibles de l'entier en question jusqu'à ce qu'il en trouve une qui est égale à l'entier de sortie, comme l'algorithme est "entrée → indigits, permutent indigits → sur-chiffres, sur-chiffres → sortie". Un algorithme plus efficace serait de configurer la relation entre les chiffres et les sorties en premier , de sorte que le retour arrière dans la permutation puisse prendre en compte les chiffres disponibles.)

Perl 6 , 56 54 octets

->\x,\y{(y+1...{[eqv] map *.comb.Bag,$_,$_*x,$_/x})+y}

Essayez-le en ligne!

Alternative intéressante, calculer n * x ^k pour k = -1,0,1:

->\x,\y{first {[eqv] map ($_*x***).comb.Bag,^3-1},y^..*}

Nettoyer , 92 octets

import StdEnv
$n m=hd[i\\i<-[m..],[_]<-[removeDup[sort[c\\c<-:toString j]\\j<-[i,i/n,i*n]]]]

Essayez-le en ligne!

Assez simple. Explication à venir dans un moment.

q, 65 octets

{f:{asc 10 vs x};while[not((f y)~f y*x)&(f y*x)~f"i"$y%x;y+:1];y}

Divisez le nombre sur la base 10, triez chaque ordre croissant et vérifiez s'il est égal. Sinon, incrémentez y et recommencez

JavaScript (ES6), 76 73 69 octets

^{Enregistré 3 octets en utilisant eval(), comme suggéré par @ShieruAsakoto}

Prend l'entrée comme (x)(y).

x=>y=>eval("for(;(g=x=>r=[...x+''].sort())(y*x)+g(y/x)!=g(y)+r;)++y")

Essayez-le en ligne!

Une version récursive serait de 62 octets , mais elle n'est pas bien adaptée ici en raison du nombre élevé d'itérations requises.

Comment?

$g$

Exemple:

g(285714) = [ '1', '2', '4', '5', '7', '8' ]

$y\times x$$y/x$$y$$g(y\times x)$$g(y/x)$$g(y)$

Lorsque vous ajoutez deux tableaux ensemble, chacun d'eux est implicitement contraint à une chaîne séparée par des virgules. Le dernier chiffre du premier tableau va être directement concaténé avec le premier chiffre du deuxième tableau sans virgule entre eux, ce qui rend ce format sans ambiguïté.

Exemple:

g(123) + g(456) = [ '1', '2', '3' ] + [ '4', '5', '6' ] = '1,2,34,5,6'

Mais:

g(1234) + g(56) = [ '1', '2', '3', '4' ] + [ '5', '6' ] = '1,2,3,45,6'

Commenté

x => y =>                   // given x and y
  eval(                     // evaluate as JS code:
    "for(;" +               //   loop:
      "(g = x =>" +         //     g = helper function taking x
        "r =" +             //       the result will be eventually saved in r
          "[...x + '']" +   //       coerce x to a string and split it
          ".sort() + ''" +  //       sort the digits and coerce them back to a string
      ")(y * x) +" +        //     compute g(y * x)
      "g(y / x) !=" +       //     concatenate it with g(y / x)
      "g(y) + r;" +         //     loop while it's not equal to g(y) concatenated with
    ")" +                   //     itself
    "++y"                   //   increment y after each iteration
  )                         // end of eval(); return y

Haskell, 76 74 octets

Deux octets rasés grâce au commentaire de Lynn

import Data.List
s=sort.show
x#y=[n|n<-[y+1..],all(==s n)[s$n*x,s$n/x]]!!0

Japt, 24 octets

Solution assez naïve sur quelques bières; Je suis sûr qu'il y a une meilleure façon.

@[X*UX/U]®ì nÃeeXì n}a°V

Essayez-le

Python 2 , 69 octets

S=sorted
x,y=input()
while(S(`y`)==S(`y*x`)==S(`y/x`))<1:y+=1
print y

Essayez-le en ligne!

Gelée ,  14  13 octets

-1 merci à Erik l'Outgolfer (`` utilise make_digits, donc ce Dn'était pas nécessaire)
+2 a corrigé un bogue (merci encore à Erik the Outgolfer pour avoir signalé le problème de coupure)

×;÷;⁸Ṣ€E
‘ç1#

Un programme complet imprimant le résultat (en tant que lien dyadique une liste de longueur 1 est produite).

Essayez-le en ligne!

Comment?

×;÷;⁸Ṣ€E - Link 1, checkValidity: n, x               e.g. n=285714,  x=2
×        -     multiply -> n×x                       571428
  ÷      -     divide -> n÷x                         142857
 ;       -     concatenate -> [n×x,n÷x]              [571428,142857]
    ⁸    -     chain's left argument = n             285714
   ;     -     concatenate -> [n×x,n÷x,n]            [571428,142857,285714]
     Ṣ€  -     sort €ach (implicitly make decimals)  [[1,2,4,5,7,8],[1,2,4,5,7,8],[1,2,4,5,7,8]]
        E    -     all equal?                        1

‘ç1# - Main link: y, x
‘    - increment -> y+1
   # - count up from n=y+1 finding the first...
  1  - ...1 match of:
 ç   -   the last link (1) as a dyad i.e. f(n, x)

Notez que lorsque la division n'est pas exacte, l'instruction décimale implicite (équivalente à a D) appliquée avant le tri donne une partie fractionnaire,
par exemple: 1800÷3D-> [6,0,0]
tandis que 1801÷3D->[6.0,0.0,0.33333333333337123]

Mathematica, 82 74 octets

x=Sort@*IntegerDigits;Do[If[x[i#]==x@Floor[i/#]==x@i,Break@i],{i,#2,∞}]&

-8 octets grâce à tsh

Fonction qui prend les arguments comme [x,y]. Effectivement, une recherche par force brute qui vérifie si la liste triée de chiffres pour y, y/xet xysont les mêmes.

Essayez-le en ligne!

APL (NARS), 490 caractères, 980 octets

T←{v←⍴⍴⍵⋄v>2:7⋄v=2:6⋄(v=1)∧''≡0↑⍵:4⋄''≡0↑⍵:3⋄v=1:5⋄⍵≢+⍵:8⋄⍵=⌈⍵:2⋄1}
D←{x←{⍵≥1e40:,¯1⋄(40⍴10)⊤⍵}⍵⋄{r←(⍵≠0)⍳1⋄k←⍴⍵⋄r>k:,0⋄(r-1)↓⍵}x}
r←c f w;k;i;z;v;x;y;t;u;o ⍝   w  cxr
   r←¯1⋄→0×⍳(2≠T c)∨2≠T w⋄→0×⍳(c≤1)∨w<0⋄→0×⍳c>3
   r←⌊w÷c⋄→Q×⍳w≤c×r⋄r←r+c
Q: u←D r⋄x←1⊃u⋄y←c×x⋄t←c×y⋄o←↑⍴u⋄→0×⍳o>10⋄→A×⍳∼t>9
M:                     r←10*o⋄⍞←r⋄→Q
A: u←D r⋄→M×⍳x≠1⊃u⋄→B×⍳∼(t∊u)∧y∊u⋄z←r×c⋄v←D z⋄→C×⍳(⍳0)≡v∼⍦u
B: r←r+1⋄→A
C: k←z×c⋄⍞←'x'⋄→B×⍳(⍳0)≢v∼⍦D k
   ⎕←' '⋄r←z

tester

  2 f¨250000 290000 3000000
xxxx 
1000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 
10000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 
285714 2589714 20978514 
 3 f¨ 31000000 290000000 
xxxxxxxxx 
100000000xxxxxxxxxxxxxxxxxxxxxxxxxx 
31046895 301046895 

Je pensais que le problème était un nombre pratique qui peut varier, donc on a les 3 nombres r, r * x, r * x * x dans la façon dont r commence à une valeur qui r * x est proche de y (où x et y sont des entrées du problème en utilisant les mêmes lettres que la poste principale). J'ai utilisé l'observation que si le premier chiffre de r est d, alors que dans r doit apparaître aussi les chiffres d * x et d * x * x, pour faire r (ou mieux r * x) une solution.

05AB1E , 16 octets

[>©Ð²÷s²*)€{Ë®s#

Essayez-le en ligne. (REMARQUE: Solution très inefficace, utilisez donc des entrées proches du résultat. Cela fonctionne également pour les entrées plus grandes localement, mais sur TIO, le délai expirera après 60 secondes.)

Explication:

[                   # Start an infinite loop
 >                  #  Increase by 1 (in the first iteration the implicit input is used)
  ©                 #  Store it in the register (without popping)
   Ð                #  Triplicate it
    ²÷              #  Divide it by the second input
      s             #  Swap so the value is at the top of the stack again
       ²*           #  Multiply it by the second input
         )          #  Wrap all the entire stack (all three values) to a list
          €{        #  Sort the digits for each of those lists
             ®s     #  Push the value from the register onto the stack again
            Ë       #  If all three lists are equal:
               #    #   Stop the infinite loop