Dado un valor x, encuentre el valor numérico más pequeño mayor que y que sea capaz de multiplicarse y dividirse por x manteniendo todos los dígitos originales.

• Los nuevos números no pierden dígitos.
• Los nuevos números no ganan dígitos.

Por ejemplo:

Entrada: x = 2, y = 250000

• Original: 285714
  • División: 142857
  • Multiplicación: 571428

Esto es cierto porque 285714 es mayor que y ; luego, cuando se divide por x da como resultado 142857 y cuando se multiplica por x da como resultado 571428 . En ambas pruebas, todos los dígitos originales de 285714 están presentes y no se han agregado dígitos adicionales.

Las normas

• X debe ser 2 o 3, ya que cualquier cosa más alta tarda demasiado en calcularse.
• Se requiere que Y sea ​​un número entero mayor que cero .
• El código más corto gana.

Casos de prueba

Estos son mis casos de prueba más comunes, ya que son los más rápidos para detectar.

• 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

Aclaraciones

• El tipo de división no importa. Si puede obtener 2.05, 0.25 y 5.20 de alguna manera, siéntase libre.

¡Buena suerte a todos ustedes!

Casco , 14 bytes

ḟ§¤=OoDd§¤+d*/

Pruébalo en línea!

Explicación

ḟ§¤=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 bytes

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

Pruébalo en línea!

Toma entrada en el formulario [x,y].

Explicación

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 {.}

Comentario

La debilidad de Brachylog al reutilizar múltiples valores varias veces se muestra aquí; Este programa es casi todo plomería y muy poco algoritmo.

Como tal, puede parecer más conveniente simplemente codificar el valor de y (hay un comentario sobre esta pregunta que supone que 2 es el único valor posible). Sin embargo, de hecho, existen soluciones para y = 3, lo que significa que, desafortunadamente, la tubería también debe manejar el valor de y . El más pequeño que conozco es el siguiente:

                         315789473684210526
315789473684210526 × 3 = 947368421052631578
315789473684210526 ÷ 3 = 105263157894736842

(La técnica que utilicé para encontrar este número no es totalmente general, por lo que es posible que haya una solución más pequeña que utilice algún otro enfoque).

Sin embargo, es poco probable que verifique eso con este programa. Brachylog pestá escrito de una manera muy general que no tiene optimizaciones para casos especiales (como el caso en el que ya se conocen tanto la entrada como la salida, lo que significa que puede hacer la verificación en O ( n log n ) mediante la clasificación, en lugar de que el O ( n !) para el enfoque de fuerza bruta que sospecho que está usando). Como consecuencia, lleva mucho tiempo verificar que 105263157894736842 es una permutación de 315789473684210526 (lo he dejado funcionando durante varios minutos sin ningún progreso obvio).

(EDITAR: Revisé la fuente de Brachylog por la razón. Resulta que si usa pdos enteros conocidos, el algoritmo utilizado genera todas las permutaciones posibles del entero en cuestión hasta que encuentre uno que sea igual al entero de salida, como el algoritmo es "input → indigits, permute indigits → outdigits, outdigits → output". Un algoritmo más eficiente sería configurar primero la relación outdigits / output , de modo que el retroceso dentro de la permutación pudiera tener en cuenta qué dígitos estaban disponibles).

Perl 6 , 56 54 bytes

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

Pruébalo en línea!

Alternativa interesante, calcular n * x ^k para k = -1,0,1:

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

Limpio , 92 bytes

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

Pruébalo en línea!

Bastante simple. Explicación que viene en un momento.

q, 65 bytes

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

Dividir el número en la base 10, ordenar cada ascendente y verificar si es igual. Si no, incremente y vaya de nuevo

JavaScript (ES6), 76 73 69 bytes

^{Se guardaron 3 bytes utilizando eval(), como lo sugiere @ShieruAsakoto}

Toma entrada como (x)(y).

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

Pruébalo en línea!

Una versión recursiva tendría 62 bytes , pero no es adecuada aquí debido a la gran cantidad de iteraciones requeridas.

¿Cómo?

$g$

Ejemplo:

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

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

Al agregar dos matrices juntas, cada una de ellas se coacciona implícitamente a una cadena separada por comas. El último dígito de la primera matriz se concatenará directamente con el primer dígito de la segunda matriz sin una coma entre ellos, lo que hace que este formato no sea ambiguo.

Ejemplo:

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

Pero:

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

Comentado

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 bytes

Dos bytes eliminados gracias al comentario 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 bytes

Solución bastante ingenua con unas pocas cervezas; Estoy seguro de que hay una mejor manera.

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

Intentalo

Python 2 , 69 bytes

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

Pruébalo en línea!

Jalea ,  14  13 bytes

-1 gracias a Erik the Outgolfer (`` usa make_digits, por Dlo que no fue necesario)
+2 arreglando un error (gracias nuevamente a Erik the Outgolfer por señalar el problema de off-by)

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

Un programa completo que imprime el resultado (como enlace diádico se genera una lista de longitud 1).

Pruébalo en línea!

¿Cómo?

×;÷;⁸Ṣ€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)

Tenga en cuenta que cuando la división no es exacta, la instrucción decimal implícita (equivalente a a D) aplicada antes de la clasificación produce una parte fraccionaria,
por ejemplo: 1800÷3D-> [6,0,0]
while 1801÷3D->[6.0,0.0,0.33333333333337123]

Mathematica, 82 74 bytes

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

-8 bytes gracias a tsh

Función que toma argumentos como [x,y]. Efectivamente una fuerza bruta de búsqueda que comprueba si la lista ordenada de dígitos y, y/xy xyson los mismos.

Pruébalo en línea!

APL (NARS), 490 caracteres, 980 bytes

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

prueba

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

Pensé que el problema era un número conveniente que puede variar para que uno tenga los 3 números r, r * x, r * x * x en la forma en que r comienza a un valor de que r * x está cerca de y (donde x e y son entradas del problema usando las mismas letras que la publicación principal). Utilicé la observación de que si el primer dígito de r es d que en r tiene que aparecer también los dígitos d * x y d * x * x, para hacer r (o mejor r * x) una solución.

05AB1E , 16 bytes

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

Pruébalo en línea. (NOTA: solución muy ineficiente, por lo tanto, use entradas cercanas al resultado. Funciona para entradas más grandes también localmente, pero en TIO se agota el tiempo de espera después de 60 segundos).

Explicación:

[                   # 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