गुणा और भाग करें

Question

मान x को देखते हुए y से बड़ा सबसे छोटा संख्यात्मक मान पाते हैं जो सभी मूल अंकों को बनाए रखते हुए गुणा और x से विभाजित होने में सक्षम है ।

• नए नंबर अंकों को नहीं खोते हैं।
• नए नंबर अंकों को हासिल नहीं करते हैं।

उदाहरण के लिए:

इनपुट: x = 2, y = २५००००

• मूल: 285714
  • प्रभाग: 142857
  • गुणन: 571428

यह सच है क्योंकि 285714 y से बड़ा है ; तब जब x को १४२7५ and में विभाजित किया जाता है और जब x को ५14१४२ in में गुणा किया जाता है । दोनों परीक्षणों में 285714 से सभी मूल अंक मौजूद हैं और कोई अतिरिक्त अंक नहीं जोड़े गए हैं।

---

नियम

• एक्स 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 प्राप्त कर सकते हैं तो स्वतंत्र महसूस करें।

---

आप सबको शुभकामनाएं!

Comments

" X को 2 और 5 के बीच का मान होना चाहिए ।" - यदि X> = 4, X द्वारा गुणा की गई संख्या X से विभाजित संख्या से कम से कम 16 गुना बड़ी होगी, तो निश्चित रूप से इसमें अधिक अंक होंगे

— ngn

x 2 या 3 के अलावा कुछ भी नहीं हो सकता क्योंकि उत्पाद x ^ 2 गुना भागफल है और दोनों में समान संख्या में अंक होने चाहिए। x = 1 एक तुच्छ मामला होगा। IMO, किसी भी y के लिए x = 3 का कोई समाधान नहीं है, हालांकि मैं गलत हो सकता हूं।

— जतिन संघवी

क्या विभाजन फ्लोट या पूर्णांक विभाजन है?

— आउटगॉल्फ

टेस्ट के मामले बहुत अच्छे होंगे

— स्टीफन

मुझे संदेह है कि मैं एकमात्र व्यक्ति नहीं हूं जो मतदान से फिर से खोलने से परहेज कर रहा है क्योंकि स्पष्टीकरण वास्तव में चुनौती को अधिक अस्पष्ट बनाता है, क्योंकि सही उत्तर अस्थायी बिंदु आउटपुट पर निर्भर करता है या नहीं पर निर्भरता बदल सकता है। मुझे लगता है @EriktheOutgolfer के सवाल चल बिन्दु उत्पादन की अनुमति के बारे में पूछ नहीं थी, लेकिन है कि क्या के बारे में इसका इस्तेमाल करने की अनुमति दी है छोटा पूर्णांक विभाजन। (और मुझे खेद है कि अगर मेरी टिप्पणी भ्रम में गयी।)

— अर्जन जोहान्सन

Answer 1

भूसी , 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

Comments

मैंने y के लिए मूल्य को एक प्रारंभिक बिंदु प्राप्त करने के लिए समायोजित किया और परिणाम x = 3, y = 25000000 के लिए गलत था ।

— एम्मा - सदाबहार

@PerpetualJ: यदि आप परिणाम जानते हैं तो आप बस y को समायोजित कर सकते हैं , और यह संस्करण थोड़ा तेज होना चाहिए (केवल टाइप-चेकिंग हालांकि)।

— ბიმო 21

मैंने इसे कुछ विचार के बाद समायोजित किया है और अपनी पहली टिप्पणी संपादित की है।

— एम्मा - सदाबहार

@PerpetualJ: मैंने इसे ठीक कर लिया है: एक धारणा बनाई गई -जिसके बारे में गलत था।

— ბიმო

@PerpetualJ: मैंने कार्यक्रम लिखा;) मैंने एक स्पष्टीकरण जोड़ा, अब हर किसी को समझना चाहिए कि क्या चल रहा है।

— 21

Answer 2

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

टीका

कई बार कई मूल्यों का पुन: उपयोग करते हुए ब्रेजलॉग की कमजोरी यहां दिखाई देती है; यह कार्यक्रम लगभग सभी प्लंबिंग और बहुत कम एल्गोरिदम है।

इस तरह, यह केवल y के मूल्य को हार्डकोड करने के लिए अधिक सुविधाजनक लग सकता है (इस सवाल पर एक टिप्पणी है कि 2 परिकल्पना केवल संभव मूल्य है)। हालांकि, y = 3 के लिए वास्तव में समाधान हैं , जिसका अर्थ है कि दुर्भाग्य से, नलसाजी को y के मूल्य को भी संभालना है । सबसे छोटा जो मुझे पता है वह निम्नलिखित है:

                         315789473684210526
315789473684210526 × 3 = 947368421052631578
315789473684210526 ÷ 3 = 105263157894736842

(मैं इस नंबर को खोजने के लिए जिस तकनीक का उपयोग करता था वह पूरी तरह से सामान्य नहीं है, इसलिए यह संभव है कि कुछ अन्य दृष्टिकोण का उपयोग करके एक छोटा समाधान हो।)

हालांकि, इस कार्यक्रम के साथ आपको यह सत्यापित करने की संभावना नहीं है । Brachylog's pको बहुत ही सामान्य तरीके से लिखा गया है जिसमें विशेष मामलों के लिए अनुकूलन नहीं है (जैसे कि मामला जहां इनपुट और आउटपुट दोनों पहले से ही ज्ञात हैं, जिसका अर्थ है कि आप सत्यापन को O ( n log n ) में सॉर्टिंग के माध्यम से कर सकते हैं , बल्कि जानवर बल दृष्टिकोण के लिए ओ ( एन !) की तुलना में मुझे संदेह है कि यह उपयोग कर रहा है)। नतीजतन, यह सत्यापित करने में बहुत लंबा समय लगता है कि 10526315789473684242 315789473684210526 का क्रमचय है (मैं इसे कई मिनटों से चला रहा हूं अब कोई स्पष्ट प्रगति नहीं है)।

(संपादित करें: मैंने कारण के लिए ब्रैचीलॉग स्रोत की जाँच की। यह पता चला है कि यदि आप pदो ज्ञात पूर्णांक पर उपयोग करते हैं, तो उपयोग किया गया एल्गोरिथ्म प्रश्न में पूर्णांक के सभी संभावित क्रमांक उत्पन्न करता है जब तक कि यह एक पूर्णांक आउटपुट आउटपुट के बराबर न हो जाए, एल्गोरिथ्म के रूप में "इनपुट → इंडिजिट्स, परमिट इंडिग्ज → बहिर्गमन, बहिर्गमन → आउटपुट"। एक और अधिक कुशल एल्गोरिथ्म सबसे पहले एग्जिट / आउटपुट संबंध स्थापित करना होगा , ताकि क्रमचय के भीतर बैकट्रैकिंग को ध्यान में रखा जा सके जो अंक उपलब्ध थे।)

Comments

एक कांटा का उपयोग आपके कोड को 1 बाइट से घटा सकता है। इसे ऑनलाइन आज़माएं!

— क्रॉपेब

इसके अलावा डॉक्स के अनुसार, यह जाँच लगता है दो ज्ञात सूची नहीं है अगर एक क्रमचय ओ (n²) है swi-prolog.org/pldoc/man?predicate=permutation/2

— Kroppeb

@ क्रॉपेब: समस्या यह है कि ब्रिगलॉग दो ज्ञात सूचियों के साथ pनहीं चलता permutation/2, यहां तक ​​कि जब दो ज्ञात पूर्णांकों को तर्क के रूप में दिया जाता है; यह पहले पूर्णांक ( एक ज्ञात सूची के permutation/2साथ उपयोग ) के सभी क्रमचय उत्पन्न करता है और फिर दूसरे पूर्णांक के खिलाफ उनकी तुलना करता है।

— अनीस 523

Answer 3

पर्ल 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^..*}

Answer 4

क्लीन , 92 बाइट्स

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

इसे ऑनलाइन आज़माएं!

बहुत साधारण। थोड़ी देर में स्पष्टीकरण आ रहा है।

Answer 5

क्यू, 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 और फिर से जाएं

Answer 6

जावास्क्रिप्ट (ईएस 6), 76 73 69 बाइट्स

^{eval()@ बिशुअर्सकोतो द्वारा सुझाए अनुसार उपयोग करके 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

Comments

66: x=>F=y=>(g=x=>r=[...x+''].sort()+'')(y*x)!=g(y)|r!=g(y/x)?F(y+1):yस्टैक ओवरफ्लो का कारण हो सकता है यदि y समाधान थियो से दूर है।

— शायरु असकोतो

या 75 का उपयोग कर eval:x=>y=>eval("for(;(g=x=>r=[...x+''].sort()+'')(y*x)!=g(y)|r!=g(y/x);y++);y")

— Shieru Asakoto

@ShieruAsakoto इस eval()विचार के लिए धन्यवाद । मेरा पहला प्रयास वास्तव में पुनरावर्ती था, लेकिन आवश्यक पुनरावृत्तियों की उच्च संख्या के कारण मैंने हार मान ली।

— अरनौल्ड

Answer 7

हास्केल, 76 74 बाइट्स

दो बाइट्स ने लिन की टिप्पणी के लिए धन्यवाद दिया

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

Comments

एक ही बाइट के लिए आपकी गिनती fहो सकती है, f x y=[n|n<-[y+1..],all(==s n)[s$n*x,s$n/x]]!!0लेकिन फिर एक ऑपरेटर के रूप में आपके उत्तर को परिभाषित करने से दो बाइट्स बचते हैं: x!y=…और फिर आपका उत्तर है (!):)

— Lynn

सूची समझ का उपयोग करने के बारे में नहीं सोचा था! सुझाव के लिए धन्यवाद: D

— umnikos

Answer 8

जाप, 24 बाइट्स

कुछ बियर पर सुंदर भोला समाधान; मुझे यकीन है कि एक बेहतर तरीका है।

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

कोशिश करो

Comments

दुर्भाग्यवश यह गलत परिणाम देता है जब x = 3 और y = 25000 ।

— एम्मा -

@PerpetualJ मान 315789473684210526लेना x=3, जावास्क्रिप्ट या Japt के लिए पहला उपाय है , इसे सही तरीके से गणना नहीं कर सकते क्योंकि यह दोहरी सटीकता में फिट नहीं है।

— बब्बलर

@PerpetualJ, पहले से तय है। उस परीक्षण का मामला कभी पूरा नहीं होगा, हालांकि, ऊपर उल्लिखित बबलर के कारण।

— झबरा

@ शागी यह अब एक सही परिणाम पैदा करता है और बब्लर ने जो समाधान बताया वह 25000 से ऊपर का पहला सही परिणाम नहीं है । यदि आप उस पर उत्सुक हैं तो मेरे परीक्षण मामलों को देखें। +1

— एमा - PerpetualJ

Answer 9

पायथन 2 , 69 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Comments

f=lambda x,y,S=sorted:y*(S(`y`)==S(`y*x`)==S(`y/x`))or f(x,y+1)काम करना चाहिए, लेकिन यह पुनरावृत्ति सीमा को काफी तेज़ी से हिट करता है, और मुझे नहीं पता कि पीपीसीजी के नियमों के बारे में क्या कहना है।

— लिन

Answer 10

जेली ,  14  13 बाइट्स

-1 एर्गिक द आउटग्रफ़र के लिए धन्यवाद (`` मेक_डिजिट्स का उपयोग करता है, इसलिए Dइसकी आवश्यकता नहीं थी)
+2 एक बग को ठीक करना (ऑफ-आउट एक मुद्दे को इंगित करने के लिए आउटग्रोफ़र को फिर से एरिक करने के लिए धन्यवाद)

×;÷;⁸Ṣ€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]
जबकि 1801÷3D->[6.0,0.0,0.33333333333337123]

Comments

मुझे यकीन नहीं है कि यह उत्तर मान्य है; चुनौती के लिए परिणाम " y से बड़ा" होना आवश्यक है , जिसे मैं " Y से सख्ती से अधिक" के रूप में व्याख्या करता हूं । इसके अलावा, आप की जरूरत नहीं है D।

— आउटगॉल्फ

आह अच्छी जगह पर >=मैं पूरी तरह से याद किया! कोई विचार नहीं Ṣथा make_digits उस पर सेट - धन्यवाद। हालांकि बाद में इसे ठीक करना होगा और अपडेट करना होगा ...

— जोनाथन एलन

Answer 11

मैथमेटिका, 82 74 बाइट्स

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

-8 बाइट्स टीशर्ट के लिए धन्यवाद

फ़ंक्शन जो तर्क के रूप में लेता है [x,y]। प्रभावी रूप से एक जानवर बल खोज है कि जांच के लिए अंकों की क्रमबद्ध सूची अगर y, y/xऔर xyएक ही हैं।

इसे ऑनलाइन आज़माएं!

Comments

मैं गणितज्ञ से परिचित नहीं हूँ। लेकिन यह साबित किया जा सकता है कि यदि आप विभाजन के भिन्नात्मक भाग को छोड़ देते हैं, तो उत्तर अभी भी सही होगा: सभी ans, ans / x, ans * x 9. से विभाज्य होना चाहिए और इससे आपका समाधान कम हो सकता है।

— tsh

@tsh यह काम करता है x=3, लेकिन मुझे यकीन नहीं है कि यह सच है x=2।

— अर्जन जोहान्सन

@ ØrjanJohansen Let v = a[1]*10^p[1] + a[2]*10^p[2] + ... + a[n]*10^p[n], u = a[1] * 10^q[1] + ... + a[n] * 10^q[n]। और u-v = a[1]*(10^p[1]-10^q[1]) + ... + a[n]*(10^p[n]-10^q[n])चूँकि 10^x-10^y=0 (mod 9)हमेशा रखती है। u-v=0 (mod 9)हमेशा रखती है। यदि कोई गलत उत्तर है w, तब से w*x-w=0 (mod 9), और w-floor(w/x)=0 (mod 9): हमारे पास है floor(w/x)=0 (mod 9)। अगर floor(w/x)*x <> w, w-floor(w/x)*x>=9लेकिन यह इस तथ्य के साथ संघर्ष करता है कि w-floor(w/x)*x<xजब x 2 या 3 हो सकता है

— tsh

@tsh धन्यवाद! बहुत लंबा रास्ता ले रही है इस बिंदु प्राप्त करने के लिए अन्य लोगों के लाभ के लिए, w=0 (mod 9)वहाँ से इस प्रकार है w*x-w=0 (mod 9)क्योंकि x-13. से विभाज्य नहीं है

— Orjan Johansen

यदि मैं IntegerQपरीक्षण को बाहर करता हूं , तो यह कुछ त्रुटियों का उत्पादन करता है जब यह IntegerDigitsअंशों पर करने की कोशिश करता है , लेकिन गणितज्ञ अभी भी उनके पीछे जाता है और सही उत्तर का उत्पादन करता है। मुझे यकीन नहीं है कि गणना के दौरान शामिल की जा रही त्रुटियों को अनुमति दी जाएगी, भले ही अंतिम उत्तर सही हो।

— नंबरमैन

Answer 12

एपीएल (एनएआरएस), 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 की तुलना में r का पहला अंक d है तो * d (x और d * x * x) को भी r (या बेहतर r * x) एक हल के लिए अंक प्रदर्शित करना है।

Answer 13

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