给定值x，找到大于y的最小数值，该数值可以乘以x并除以x，同时保留所有原始数字。

• 新数字不会丢失数字。
• 新数字不获取数字。

例如：

输入：x = 2，y = 250000

• 原件：285714
  • 师：142857
  • 乘法：571428

这是正确的，因为285714大于y。然后，当被x除时，结果为142857；当与x相乘时，结果为571428。在这两个测试中，都存在285714的所有原始数字，并且没有添加任何额外的数字。

规则

• X应该是2或3，因为更高的值需要太长时间才能计算。
• Y必须是大于零的整数。
• 最短的代码获胜。

测试用例

这些是我最常用的测试用例，因为它们是测试最快的用例。

• 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

澄清说明

• 划分的类型无关紧要。如果您能以某种方式获得2.05、0.25和5.20，请放心。

祝大家好运！

外壳，14个字节

ḟ§¤=OoDd§¤+d*/

在线尝试！

说明

ḟ§¤=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个字节

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

在线尝试！

以形式输入[x,y]。

说明

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

评论

Brachylog在多次重用多个值方面的弱点体现在这里；这个程序几乎都是管道，很少有算法。

因此，简单地对y的值进行硬编码似乎更方便（此问题的注释假设2是唯一可能的值）。但是，实际上存在y = 3的解决方案，这意味着不幸的是，管道也必须处理y的值。我知道的最小的是：

                         315789473684210526
315789473684210526 × 3 = 947368421052631578
315789473684210526 ÷ 3 = 105263157894736842

（我用来查找该数字的技术并不完全通用，因此可能有使用其他方法的较小解决方案。）

不过，您不太可能通过该程序进行验证。Brachylog的p写法非常普通，没有针对特殊情况（例如，输入和输出都已知的情况）进行优化，这意味着您可以通过排序在O（n log n）中进行验证，而不是比我怀疑它正在使用的蛮力方法的O（n！））。结果，需要很长时间才能验证105263157894736842是否是315789473684210526的排列（我已经让它运行了几分钟，现在没有明显进展）。

（编辑：出于这个原因，我检查了Brachylog源。事实证明，如果您p对两个已知整数使用，则所使用的算法会生成所讨论整数的所有可能排列，直到找到与输出整数相等的整数为止，作为算法是“输入→indigits，置换indigits→outdigits，outdigits→输出”。一种更有效的算法将是成立outdigits /输出关系首先，使得置换内回溯可考虑到其中的数字可用。）

Perl 6、56 54字节

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

在线尝试！

有趣的选择是，为k = -1,0,1 计算n * x ^k：

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

干净，92字节

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

在线尝试！

很简单 解释会在一段时间内出现。

q，65个字节

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

以10为基数分割数字，对每个升序进行排序，然后检查是否相等。如果不是，请递增y并再次执行

JavaScript（ES6），76 73 69字节

^{eval()根据@ShieruAsakoto的建议，使用节省了3个字节}

将输入作为(x)(y)。

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

在线尝试！

递归版本将为62个字节，但由于所需的迭代次数很高，因此不适用于此版本。

怎么样？

$g$

例：

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

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

将两个数组加在一起时，每个数组都隐式强制为逗号分隔的字符串。第一个数组的最后一位将与第二个数组的第一位直接连接在一起，并且它们之间没有逗号，这使得这种格式是明确的。

例：

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

但：

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

已评论

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字节

感谢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个字节

几杯啤酒的天真解决方案；我敢肯定有更好的方法。

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

尝试一下

Python 2，69个字节

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

在线尝试！

果冻， 14  13 字节

-1多亏了Outgolfer的Erik（``使用make_digits，所以D不是必需的）
+2修复了一个错误（再次感谢Outgolfer的Erik指出了一个不重要的问题）

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

完整的程序将打印结果（作为二元链接，将产生长度为1的列表）。

在线尝试！

怎么样？

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

请注意，当除法不精确时D，在排序之前应用的隐式十进制指令（等效于）会产生小数部分，
例如：1800÷3D-> [6,0,0]
while- 1801÷3D>[6.0,0.0,0.33333333333337123]

Mathematica，82 74字节

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

-8个字节感谢tsh

将参数作为的函数[x,y]。有效的蛮力搜索，如果数字的排序列表检查y，y/x并且xy是相同的。

在线尝试！

APL（NARS），490个字符，980个字节

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

测试

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

我认为问题是方便的数字，它可以变化，所以一个人有3个数字r，r * x，r * x * x，r的值开始是r * x接近y（其中x和y是输入问题使用与主要职位相同的字母）。我观察到，如果r的第一个数字是d，则r中的数字也必须出现d * x和d * x * x，以使r（或更优的r * x）成为一个解决方案。

05AB1E，16 个字节

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

在线尝试。（注意：解决方案效率很低，因此请使用接近结果的输入。它在本地也适用于较大的输入，但是在TIO上，它会在60秒后超时。）

说明：

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