รับค่าxค้นหาค่าตัวเลขที่เล็กที่สุดที่มากกว่าyที่สามารถคูณและหารด้วยxในขณะที่ยังคงรักษาตัวเลขเดิมทั้งหมดไว้

• ตัวเลขใหม่จะไม่สูญเสียตัวเลข
• หมายเลขใหม่ไม่ได้รับตัวเลข

ตัวอย่างเช่น:

อินพุต: x = 2, y = 250000

• เดิม: 285714
  • กอง: 142857
  • การคูณ: 571428

นี่คือความจริงเพราะ285714มีค่ามากกว่าปี ; แล้วเมื่อหารด้วยxผลลัพธ์ใน142,857และเมื่อคูณด้วย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 คุณก็จะรู้สึกเป็นอิสระ

ขอให้โชคดีทุกท่าน!

Husk , 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กับจำนวนเต็มสองจำนวนที่รู้จักกันอัลกอริทึมที่ใช้สร้างการเรียงสับเปลี่ยนที่เป็นไปได้ทั้งหมดของจำนวนเต็มในคำถามจนกว่าจะพบหนึ่งที่เท่ากับจำนวนเต็มออก คือ "input → indigits, permig indigits → outdigits, outdigits → output" อัลกอริทึมที่มีประสิทธิภาพมากขึ้นคือการตั้งค่า outdigits / ความสัมพันธ์เอาท์พุทก่อนเพื่อให้ backtracking ภายในการเปลี่ยนแปลงสามารถนำมาพิจารณาว่า

Perl 6 , 56 54ไบต์

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

ลองออนไลน์!

ทางเลือกที่น่าสนใจโดยคำนวณ n * x ^kสำหรับ k = -1,0,1:

->\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 ไบต์

^{บันทึก 3 ไบต์โดยใช้eval()ตามที่แนะนำโดย @ShieruAsakoto}

(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 ต้องขอบคุณ Erik the Outgolfer (`` ใช้ make_digits ดังนั้นจึงDไม่จำเป็น)
+2 แก้ไขข้อผิดพลาด (ขอบคุณ Erik the Outgolfer อีกครั้งสำหรับการชี้ให้เห็นถึงปัญหาหนึ่งต่อหนึ่ง)

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

โปรแกรมเต็มรูปแบบการพิมพ์ผล (เป็นลิงค์ dyadic รายการความยาว 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]
ขณะที่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 

ฉันคิดว่าปัญหาเป็นจำนวนสะดวกสบาย ra ที่สามารถเปลี่ยนแปลงได้ดังนั้นหนึ่งมี 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