Cho một giá trị x tìm giá trị số nhỏ nhất lớn hơn y có khả năng nhân và chia cho x trong khi giữ lại tất cả các chữ số gốc.

• Các số mới không bị mất chữ số.
• Các số mới không đạt được chữ số.

Ví dụ:

Đầu vào: x = 2, y = 250000

• Bản gốc: 285714
  • Sư đoàn: 142857
  • Phép nhân: 571428

Điều này đúng vì 285714 lớn hơn y ; sau đó khi chia cho x kết quả là 142857 và khi nhân với x kết quả là 571428 . Trong cả hai bài kiểm tra, tất cả các chữ số gốc từ 285714 đều có mặt và không có chữ số phụ nào được thêm vào.

Các quy tắc

• X nên là 2 hoặc 3 vì mọi thứ cao hơn sẽ mất quá nhiều thời gian để tính toán.
• Y được yêu cầu là một số nguyên lớn hơn 0 .
• Mã ngắn nhất sẽ thắng.

Các trường hợp thử nghiệm

Đây là những trường hợp kiểm tra phổ biến nhất của tôi vì chúng là cách nhanh nhất để kiểm tra.

• 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

Làm rõ

• Loại phân chia không thành vấn đề. Nếu bạn có thể nhận được 2.05, 0.25 và 5.20 bằng cách nào đó thì cứ thoải mái.

Chuc tât cả may măn!

Husk , 14 byte

ḟ§¤=OoDd§¤+d*/

Hãy thử trực tuyến!

Giải trình

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

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

Hãy thử trực tuyến!

Đưa đầu vào theo mẫu [x,y].

Giải trình

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

Bình luận

Điểm yếu của Brachylog trong việc sử dụng lại nhiều giá trị nhiều lần cho thấy ở đây; chương trình này là gần như tất cả các hệ thống ống nước và rất ít thuật toán.

Như vậy, có vẻ thuận tiện hơn khi chỉ đơn giản là mã hóa giá trị của y (có một nhận xét về câu hỏi này giả thuyết rằng 2 là giá trị duy nhất có thể). Tuy nhiên, trên thực tế có các giải pháp cho y = 3, có nghĩa là không may, hệ thống ống nước cũng phải xử lý giá trị của y . Cái nhỏ nhất mà tôi biết là như sau:

                         315789473684210526
315789473684210526 × 3 = 947368421052631578
315789473684210526 ÷ 3 = 105263157894736842

(Kỹ thuật tôi sử dụng để tìm số này không hoàn toàn chung chung, vì vậy có thể có một giải pháp nhỏ hơn bằng cách sử dụng một số phương pháp khác.)

Bạn không thể xác minh rằng với chương trình này , mặc dù. Brachylog pđược viết theo một cách rất chung chung, không có sự tối ưu hóa cho các trường hợp đặc biệt (chẳng hạn như trường hợp cả đầu vào và đầu ra đã được biết, có nghĩa là bạn có thể thực hiện xác minh trong O ( n log n ) thông qua việc sắp xếp, thay vào đó hơn là O ( n !) cho cách tiếp cận vũ phu mà tôi nghi ngờ nó đang sử dụng). Do đó, phải mất một thời gian rất lâu để xác minh rằng 105263157894736842 là một hoán vị của 315789473684210526 (Tôi đã để nó chạy trong vài phút mà không có tiến triển rõ ràng).

(EDIT: Tôi đã kiểm tra nguồn Brachylog vì lý do. Hóa ra nếu bạn sử dụng ptrên hai số nguyên đã biết, thuật toán được sử dụng sẽ tạo ra tất cả các hoán vị có thể có của số nguyên cho đến khi tìm thấy một số bằng với số nguyên đầu ra, như thuật toán là "đầu vào → indigits, hoán indigits → outdigits, outdigits → đầu ra". Một thuật toán hiệu quả hơn sẽ được thiết lập outdigits / mối quan hệ đầu ra đầu tiên , do đó tùy ý trong hoán vị có thể đưa vào tài khoản mà chữ số đã có sẵn.)

Perl 6 , 56 54 byte

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

Hãy thử trực tuyến!

Thay thế thú vị, tính toán n * x ^k cho k = -1,0,1:

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

Sạch , 92 byte

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

Hãy thử trực tuyến!

Khá đơn giản. Giải thích đến trong một thời gian.

q, 65 byte

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

Tách số trên cơ sở 10, sắp xếp từng tăng dần và kiểm tra nếu bằng nhau. Nếu không, tăng y và đi lại

JavaScript (ES6), 76 73 69 byte

^{Đã lưu 3 byte bằng cách sử dụng eval(), như được đề xuất bởi @ShieruAsakoto}

Đưa đầu vào là (x)(y).

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

Hãy thử trực tuyến!

Một phiên bản đệ quy sẽ là 62 byte , nhưng nó không phù hợp ở đây vì số lần lặp yêu cầu cao.

Làm sao?

$g$

Thí dụ:

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

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

Khi thêm hai mảng lại với nhau, mỗi mảng sẽ bị ép buộc thành một chuỗi được phân tách bằng dấu phẩy. Chữ số cuối cùng của mảng đầu tiên sẽ được nối trực tiếp với chữ số đầu tiên của mảng thứ hai không có dấu phẩy giữa chúng, điều này làm cho định dạng này không rõ ràng.

Thí dụ:

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

Nhưng:

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

Đã bình luận

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 byte

Hai byte bị loại bỏ nhờ bình luận của 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 byte

Giải pháp khá ngây thơ trên một vài loại bia; Tôi chắc chắn có một cách tốt hơn.

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

Thử nó

Python 2 , 69 byte

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

Hãy thử trực tuyến!

Thạch ,  14  13 byte

-1 cảm ơn Erik Outgolfer (`` sử dụng make_digits, do đó Dkhông bắt buộc)
+2 sửa lỗi (một lần nữa cảm ơn Erik Outgolfer vì đã chỉ ra một vấn đề)

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

Một chương trình đầy đủ in kết quả (như một liên kết dyadic, một danh sách có độ dài 1 được tạo ra).

Hãy thử trực tuyến!

Làm sao?

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

Lưu ý rằng khi phép chia không chính xác, lệnh thập phân ngầm định (tương đương với a D) được áp dụng trước khi sắp xếp sẽ mang lại một phần phân số,
ví dụ: 1800÷3D-> [6,0,0]
while 1801÷3D->[6.0,0.0,0.33333333333337123]

Toán học, 82 74 byte

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

-8 byte nhờ tsh

Hàm lấy đối số là [x,y]. Hiệu quả là một tìm kiếm vũ phu kiểm tra xem danh sách các chữ số được sắp xếp cho y, y/xvà xycó giống nhau không.

Hãy thử trực tuyến!

APL (NARS), 490 ký tự, 980 byte

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

kiểm tra

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

Tôi nghĩ vấn đề là ra số thuận tiện có thể thay đổi nên một số có 3 số r, r * x, r * x * x theo cách r bắt đầu một giá trị mà r * x ở gần y (trong đó x và y là đầu vào của vấn đề sử dụng cùng một chữ cái như bài chính). Tôi đã sử dụng quan sát rằng nếu chữ số đầu tiên của r là d hơn trong r phải xuất hiện các chữ số d * x và d * x * x, để tạo r (hoặc tốt hơn r * x) một giải pháp.

05AB1E , 16 byte

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

Hãy thử trực tuyến. (LƯU Ý: Giải pháp rất không hiệu quả, vì vậy hãy sử dụng các đầu vào gần với kết quả. Nó hoạt động cho các đầu vào lớn hơn cục bộ, nhưng trên TIO, nó sẽ hết thời gian sau 60 giây.)

Giải trình:

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