परिचय

इस चुनौती में, हम एक निश्चित अनंत अप्रत्यक्ष ग्राफ के साथ काम करेंगे, जिसे मैं उच्च भाजक ग्राफ कहता हूं । इसके नोड्स 2. से शुरू दो नोड्स के बीच एक बढ़त नहीं है पूर्णांक हैं एक <b अगर एक विभाजित ख और एक ² ≥ ख । 2 से 18 तक की सीमा से बनने वाला उपसमूह इस तरह दिखता है:

16-8 12 18
  \|/ |/|
   4  6 9 10 15 14
   |  |/   |/   |
   2  3    5    7  11 13 17

यह दिखाया जा सकता है कि अनंत उच्च विभाजक ग्राफ जुड़ा हुआ है, इसलिए हम दो नोड्स के बीच सबसे छोटे मार्ग के बारे में पूछ सकते हैं।

इनपुट और आउटपुट

आपके इनपुट दो पूर्णांक हैं a और b । आप मान सकते हैं कि 2 ≤ ≤ b <1000 । आपका आउटपुट अनंत उच्च विभाजक ग्राफ में a और b के बीच सबसे छोटे पथ की लंबाई है । इसका अर्थ है मार्ग में किनारों की संख्या।

आपको निम्नलिखित तथ्य उपयोगी लग सकते हैं: हमेशा ए से बी तक एक इष्टतम पथ मौजूद होता है जो पहले बढ़ रहा है और फिर घट रहा है, और केवल नोड्स का दौरा करता है जो कड़ाई से 2 बी ² से कम हैं । विशेष रूप से, बी <1000 के बाद से आपको केवल 2 000 000 से कम नोड्स पर विचार करने की आवश्यकता है।

उदाहरण

इनपुट पर विचार करें 3और 32। नोड्स 3 और 32 के बीच एक संभावित पथ है

3 -- 6 -- 12 -- 96 -- 32

इस पथ के चार किनारे हैं, और यह पता चलता है कि छोटे रास्ते नहीं हैं, इसलिए सही आउटपुट है 4।

एक अन्य उदाहरण के रूप में, के लिए एक इष्टतम मार्ग है 2और 25है

2 -- 4 -- 8 -- 40 -- 200 -- 25

इसलिए सही उत्पादन होता है 5। इस स्थिति में, किसी भी इष्टतम पथ में नोड नहीं है 50 = lcm(2, 25)।

नियम और स्कोरिंग

आप एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं। सबसे कम बाइट गिनती जीतता है, और मानक खामियों को रोक दिया जाता है। कोई समय या स्मृति सीमा नहीं है, इसलिए पाशविक बल की अनुमति है।

परीक्षण के मामलों

2 2 -> 0
2 3 -> 4
2 4 -> 1
2 5 -> 5
3 5 -> 4
6 8 -> 2
8 16 -> 1
12 16 -> 2
16 16 -> 0
2 25 -> 5
3 32 -> 4
2 256 -> 3
60 77 -> 3
56 155 -> 3
339 540 -> 2
6 966 -> 4
7 966 -> 2
11 966 -> 4
2 997 -> 7
991 997 -> 4

code-golf number-theory path-finding

— Zgarb
स्रोत

मेरे पास एक विचार है जो एक क्रूर बल नहीं है जैसा कि मैंने माना है, यह दो संख्याओं में से सबसे छोटी संख्या को गिनता है, धीरे-धीरे शक्ति दो से गुणा करता है जब तक कि यह दिखाई नहीं देता है, फिर वर्ग संख्या द्वारा धीरे-धीरे विभाजित होता है जब तक कि दूसरी संख्या प्रकट नहीं होती है, मेरे पास कोई समय नहीं है को लागू करने के लिए अब

— घटना

ज़गारब, क्या मैथमेटिका का FindShortestPath उल्लंघन मानक खामियों के बारे में है? यदि ऐसा होता है, तो मुझे बताएं और मैं अपना सबमिशन हटा दूंगा।

— डेविड

@ डेविड मैं इसे एक खामी नहीं मानता। प्रासंगिक जवाब वास्तव में की 0. स्कोर है

— Zgarb

4

मतलाब, 218 190 175 बाइट्स

function f(a,b);q=a;l(b)=0;l(a)=1;while~l(b);x=q(1);q=q(2:end);l(end+1:x^2)=0;g=x+1:x^2;s=2:x-1;u=[g(~mod(g,x)),s(~mod(x,s)&s.^2>=x)];u=u(~l(u));q=[q,u];l(u)=l(x)+1;end;l(b)-1

सूची में कदम बढ़ाने के लिए शॉर्टकट के लिए धन्यवाद @ बीकर!

यह एक अपेक्षाकृत सीधा सादा कार्यान्वयन है:

q=a;                  %queue
l(b)=0;       %list of path lengths
l(a)=1;
while~l(b);         %if there is no predecessor to b
    x=q(1);         %get first queue element
    q=q(2:end);
    %add edges 
    l(end+1:x^2)=0;% lengthen predecessor list if too short
    g=x+1:x^2;      % g=greater neighbours
    s=2:x-1;        % s=smaller neighbours %keep only valid/unvisited neighbours 
    u=[g(~mod(g,x)),s(~mod(x,s)&s.^2>=x)]; %-1byte
    u=u(~l(u));
    q=[q,u];      %add only hte valid nodes edges to queue
    l(u)=l(x)+1;       %mark x as predecessor  
end;
l(b)-1 %output length to the end of the path

_{^{आज कोई विश्वास नहीं}}

— flawr
स्रोत

2

इसके बजाय l=zeros(1,a*b);आप का उपयोग कर सकते हैं l(a*b)=0;, जो एक ही करता है

— लुइस मेंडो

अफसोस .... अभी भी आपके पीछे 10 बाइट्स हैं।

— अबराम

1

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

(m,n)=>(g=i=>{for(q=[i],r=[],r[i]=j=0;i=q[j++];)for(k=i+i;k<=i*i&(k<m*m*2|k<n*n*2);k+=i)r[k]-r[i]<2?0:r[q.push(k),k]=r[i]+1},g(m),s=r,g(n),Math.min(...r.map((i,j)=>i+s[j]).filter(i=>i)))

एक सहायक समारोह का उपयोग करता है gसब से आरोही पथ की गणना करने के mलिए और nप्रदान की सीमा तक बारी में, फिर एक साथ रास्तों और रिटर्न सबसे कम मूल्य का योग।

— नील
स्रोत

1

गणितज्ञ 98 बाइट्स

मैं मान रहा हूं कि अंतर्निहित फ़ंक्शन FindShortestPathमानक कमियों के बारे में बाधा का उल्लंघन नहीं करता है। यदि ऐसा होता है, तो मुझे बताएं और मैं इस सबमिशन को हटा दूंगा।

जानवर बल, इसलिए के बड़े मूल्यों के साथ धीमा b। मैं अभी भी इसे गति देने के तरीकों के बारे में सोच रहा हूं।

h@{a_,b_}:=Length@FindShortestPath[Graph[Apply[Join,Thread[#<->Range[2,#] #]&/@Range[b^2]]],a,b]-1

इससे नोड्स के बीच उपयुक्त किनारों के साथ एक ग्राफ सेट होता aहै b^2। FindShortestPathग्राफ में सबसे छोटा रास्ता पाता है। Lengthनोड्स गिना जाता है; Length -1किनारों की संख्या है।

Thread[# <-> Range[2, #] #] &पूर्ण ग्राफ के किनारों का निर्माण करता है। उदाहरण के लिए, Thread[# <-> Range[2, #] #]&[5]किनारों का उत्पादन करेगा {5 <-> 2*5, 5 <-> 3*5, 5 <-> 4*5, 5 <-> 5*5}, अर्थात {5 <-> 10, 5 <-> 15, 5 <-> 20, 5 <-> 25}।

— DavidC
स्रोत

1

Matlab (195) (185) (181) (179)(173)

नोट: मुझे उपयोगकर्ता Agawa001 व्यक्तिगत रूप से मैं इस बात की पुष्टि करता हूं कि मैंने उपयोगकर्ता @flawr पर उनकी सहायता का उपयोग करके जीता

 function t(a,b,p),for r=0:1,d=(b*~r+r*a)/gcd(a,b);while(d>1)p=p+1;e=find(~rem(d,1:d));f=max(e(a^(1-r/2)>=e));a=a*min([find(1:a*a>=b) a])^~(f-1);d=d/f;a=a*f^(1-2*r);end,end,p

यह फ़ंक्शन अलग-अलग ड्रोम दूसरों का है, यह शुद्ध गणितीय गणनाओं और कारकों का एक समूह का पालन करता है लेकिन पथ या ग्राफ़ के साथ इसका कोई लेना-देना नहीं है।
फ़ंक्शन कॉल का उदाहरण:
```
 t(2,3,0)

 p =

 4
```
सभी परीक्षण मामले संतुष्ट हैं
स्पष्टीकरण:

स्पष्टीकरण के साथ शुरुआत करने से पहले कुछ नींबूओं को "हरे रंग की नहीं" साबित करने दें:

लेम्मा (1): किन्हीं दो नंबरों के बीच एक इष्टतम पथ(a,b) एक तरह से मौजूद होता है, नोड्स पहले बढ़ रहे होते हैं फिर घटते हैं।

क्यों ? यह केवल इसलिए सिद्ध होता है क्योंकि किसी भी संख्या aको विभाजित करने वाली अधिकतम पूर्णांक राशि क्रमशः संख्या के रूप में बड़ी होती aहै, इसलिए एक चतुर दृष्टिकोण के रूप में हमें aइसे पर्याप्त रूप से बड़ा बनाने के लिए जितना संभव हो उतना गुणा करना होगा , फिर बड़े मूल्यों से विभाजित करना होगा। अगर कभी हम रास्ता गोल करते हैं, तो संख्याa सिकुड़ती है, इसलिए हमें धीरे-धीरे इसे पुन: गुणा करने के लिए और अधिक पुनरावृत्तियों की आवश्यकता होती है।

लेम्मा (2): एक संख्या aसे b, यदि gcd(a,b)=1 aगुणा किया जाता है b, यदि bउससे बड़ा है तो aइसे किसी ज्ञात संख्या से गुणा किया जाएगा c, यदि नाम gcd>1 aके सबसे बड़े विभाजक द्वारा धीरे-धीरे गुणा किया जाना चाहिए , जो उस स्थिति को भी सत्यापित करता है, जब यह सब अर्थात् न्यूनतम से बड़े हैं , प्राप्त करता हैb/gcdda >= ddaaa*c फिर ।

किसी भी शुरुआती नोड को साबित करने के लिए यह धारणा सरल aहै, इसे तब तक गुणा किया जाना चाहिए जब तक कि यह सबसे छोटे से कई तक नहीं पहुंचता है aऔर bइसलिए या तो हम b*gcdअधिकतम की शुरुआत के अनुपात से गुणा करते हैं जो मुख्य स्थिति की पुष्टि करता है, जो हमेशा विभाजन शुरू होने से पहले smp के लिए सबसे कम पथ की गारंटी देता है। या जब dकोई संख्या उपलब्ध नहीं है , तो इस पहले चरण के लिए एक वैध स्थिति बनाने के लिए एक संख्या cको गुणा किया aजाता है a>=d।

लेम्मा (3): एक ग्राफ-ultimum कई से की aकरने के लिए b, इस संख्या के gcd और bहै bही

खैर यह केवल पिछले जोड़तोड़ का परिणाम है, और अंतिम शेष चरणों को भी धीरे-धीरे सबसे बड़े विभाजक द्वारा विभाजित किया जाता है जो कि इसके वर्गमूल से अधिक नहीं होता है।

दुविधा: क्या है कि इसके cद्वारा गुणा की जाने वाली इष्टतम संख्या aचरण 1 के लिए प्रारंभिक स्थिति के साथ सीधे होती है तो सबसे उपयुक्त है?

अच्छा सवाल है, किसी भी साधारण स्थिति के लिए एक साधारण पैरी है, इसलिए (a,b)=(4,26)इस तरह दो कारकों का एक उदाहरण माना जाता है :

  2 | 2
  2 | 13

इसके अलावा gcd=2छोटी से छोटी पूर्णांक जो से गुणा किया जाना चाहिए 2पहुंच के लिए 13है 7, लेकिन यह स्पष्ट रूप से, की संभावना से इनकार कर रहा है तो एक चुकता है cuz यह 2 से भी बड़ा है।

  2 | 2 
  5 | 13

दूसरे उदाहरण में Appearenlty (a,b)=(10,26)ऊपर cसबसे कम पूर्णांक से के रूप में मापा जाता है 1करने के लिए 5जो अधिक हो जाती है 13/5इसलिए यह संतुष्ट ग्राफ-स्केलिंग है, जो की हालत 3है, तो अगले कदम के यहाँ से गुणा किया जाता है3

  2 | 2 
  5 | 13
  3 |

क्यों ? इसका कारण यह है कि एक बार जब हमें 2*13/gcd=13तालिका के दूसरी तरफ से गुणा करना होता है, तो इससे पहले जो रंक राशि जोड़ी जाती है वह आशातीत रूप से सबसे छोटी होती है, और ग्राफ़ के साथ आगे बढ़ना कम से कम हो जाता है, यदि कभी-कभी हम 10विभाजन के अवसरों की तरह बड़े मूल्य से गुणा करते हैं कम से कम समय कम हो जाता है, और यह हमारे लक्ष्य तक पहुंचने के लिए 1 और विभाजन कदम से बढ़ गया होता 2*13। जो करने के लिए enumerated हैं: 13*2*5*10/2*5तो 13*2*5/5। जबकि, जाहिर है कि यहां संख्या को विभाजित किया जाना है5*3<13*2

और एक और बात ........ हेल मेल्स ...

ये मेरे तुलनात्मक परिणाम हैं @flawr वाले, बस ध्यान दें कि मैंने समय निष्पादन के लिए ऊपरी सीमा बनाई है त्रुटिपूर्ण एल्गोरिथ्म को जीतने में, इसमें बहुत अधिक समय लगता है!

आप ऑनलाइन कंपाइलेबल कोड के हेडर में a और b वेरिएबल के रूप में स्टार्टिंग और एंडिंग स्कैनिंग रेंज सम्मिलित कर सकते हैं।

— Abr001am
स्रोत

वाह, यह आश्चर्य की बात है। मुझे उम्मीद नहीं थी कि एक सीधे रास्ते में इष्टतम रास्तों का निर्माण किया जा सकता है। स्पष्टीकरण के लिए आगे देख रहे हैं ...

— ज़र्गब

@Zgarb मैंने मुख्य पोस्ट टिप्पणियों के भीतर एक तुच्छ विवरण किया है, जब मैं गोल्फ खत्म करूँगा, btw, क्या एक अनोखी अच्छी चुनौती होगी!