निकटतम 7-विचलित-प्रधान उत्पाद

Question

_{( चैट के माध्यम से )}

OEIS प्रविष्टि A123321 उन संख्याओं के अनुक्रम को सूचीबद्ध करती है जो सात अलग-अलग primes के उत्पाद हैं। संक्षिप्तता के लिए, हम इसे 7DP नंबर कहेंगे । पहले कुछ नंबर और उनके संबंधित भाजक नीचे हैं:

510510 = 2 * 3 * 5 * 7 * 11 * 13 * 17
570570 = 2 * 3 * 5 * 7 * 11 * 13 * 19
690690 = 2 * 3 * 5 * 7 * 11 * 13 * 23
746130 = 2 * 3 * 5 * 7 * 11 * 17 * 19

यहां चुनौती दी गई इनपुट से, पूर्ण दूरी के संदर्भ में, निकटतम 7DP नंबर खोजने की होगी।

इनपुट

किसी भी सुविधाजनक प्रारूप में एक एकल सकारात्मक पूर्णांक n ।

उत्पादन

किसी भी सुविधाजनक प्रारूप में फिर से निकटतम 7DP संख्या n । यदि दो 7DP नंबर निकटतम के लिए बंधे हैं, तो आप या तो आउटपुट कर सकते हैं या दोनों।

नियम

• संख्याओं को आपकी भाषा के डिफ़ॉल्ट [int]डेटाटाइप (या समतुल्य) में फिट किया जा सकता है ।
• या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं।
• मानक खामियों को मना किया जाता है।
• यह कोड-गोल्फ है , इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड जीतता है।

उदाहरण

5 -> 510510
860782 -> 870870
1425060 -> 1438710 (or 1411410, or both)

Answer 1

पायथन, 89 86 85 बाइट्स

f=lambda n,k=0:126^sum(1>>n%i<<7*(n/i%i<1)for i in range(2,n))and f(n+k,k%2*2+~k)or n

एल्गोरिथ्म हे (डरावना) के साथ शुरू करने के लिए और पुनरावृत्ति वास्तव में मदद नहीं करता है, लेकिन यह अच्छी तरह से काम करता है जब तक n पर्याप्त रूप से एक 7DP संख्या के करीब है।

3 बाइट बंद करने के लिए @xnor को धन्यवाद!

यह repl.it पर परीक्षण करें ।

यह काम किस प्रकार करता है

पायथन में अंतर्निहित या फैक्टरिज़ेशन नहीं है, लेकिन हम उनके विभाजकों की राशि और प्रकृति द्वारा 7DP संख्याओं की पहचान कर सकते हैं।

गुणन सिद्धांत के द्वारा, पूर्णांक के विभाजकों की संख्या की गणना इसके अभाज्य कारक के संवर्धित घातांक के उत्पाद के रूप में की जा सकती है। इस प्रकार, σ ₀ (एन) ( भाजक समारोह ) है 2 ^मीटर जब भी n एक MDP संख्या है।

σ ₀ (n) = 128 इस प्रकार एक आवश्यक शर्त है, लेकिन यह पर्याप्त नहीं है; उदाहरण के लिए, σ ₀ (2 ¹²⁷ ) = 128 है, लेकिन 2 ¹²⁷ स्पष्ट रूप से एक 7DP संख्या नहीं है। हालांकि, दोनों अगर σ ₀ (एन) = 128 और कोई पूर्ण वर्ग विभाजित एन समान रूप से है, तो n एक 7DP संख्या है।

इनपुट n के लिए , एल्गोरिथ्म में पूर्णांक n , n - 1 , n + 1 , n - 2 , n + 2 , आदि का निरीक्षण करना और पहले वाले को वापस करना जो कि 7DP की संख्या है।

जब f को तर्क n के साथ बुलाया जाता है , तो निम्न होता है:

• कोड

  126^sum(1>>n%i<<7*(n/i%i<1)for i in range(2,n))

  परीक्षण करता है, तो n है नहीं एक 7DP संख्या इस प्रकार है।

  सभी पूर्णांकों के लिए मैं ऐसा हूं कि 1 <i <n , का 1>>n%i<<7*(n/i%i<1)मूल्यांकन किया जाता है।

  • यदि n i से विभाज्य है लेकिन i ^{2 से} नहीं है , 1>>n%iतो 1 और (n/i%i<1)पैदावार 0 देता है , जिसके परिणामस्वरूप
    1 · 2 ^{7 · 0} = 1 होता है ।

  • यदि n i ² से विभाज्य है , 1>>n%iऔर (n/i%i<1)दोनों 1 उपज देते हैं , जिसके परिणामस्वरूप 1 · 2 ^{7 · 1} = 128 होता है ।

  • यदि n i से विभाज्य नहीं है , 1>>n%iतो 0 प्राप्त होता है , जिसके परिणामस्वरूप 0 · 2 ^{7 · x} = 0 होता है ।

  
  जिसके परिणामस्वरूप पूर्णांकों का योग होगा 2 ^मीटर - 2 यदि n एक MDP संख्या (अपनी है 2 ^मीटर divisors, को छोड़कर 1 और एन ) और से बड़ी संख्या 127 है, तो n एक पूर्ण वर्ग कारक है। इस प्रकार, योग 126 होगा यदि और केवल यदि n एक 7DP संख्या है।

• 7DP संख्याओं के लिए, योग 126 है , इसलिए इसे 126 पैदावार 0 के साथ XORing कर दिया , जो मिथ्या है। इस प्रकार, या लैम्ब्डा का हिस्सा मार डाला और है च रिटर्न के वर्तमान मूल्य एन ।

• यदि n एक 7DP संख्या नहीं है, तो XOR एक गैर-शून्य, सत्य मान लौटाएगा। इस प्रकार, और लैम्ब्डा के हिस्से को निष्पादित किया जाता है।

  f(n+k,k%2*2+~k)

  रिकर्सिवली कॉल च का अद्यतन मूल्यों के साथ n (अगले संभावित 7DP संख्या) और कश्मीर (नए उम्मीदवार और उसके बाद एक के बीच अंतर)।

  अगर कश्मीर एक और भी, गैर नकारात्मक पूर्णांक है, k%2*2पैदावार 0 और ~kपैदावार - (k + 1) । दोनों परिणामों का योग है - (k + 1) , जो एक विषम, ऋणात्मक पूर्णांक है, जो k की तुलना में निरपेक्ष मान से 1 अधिक है ।

  यदि k एक विषम, ऋणात्मक पूर्णांक है, k%2*2तो 2 और ~kपैदावार - (k + 1) है । दोनों परिणामों का योग 2 है - (k + 1) = - (k - 1) , जो कि सम, गैर-ऋणात्मक पूर्णांक है, जो k की तुलना में निरपेक्ष मान से 1 इकाई अधिक है ।

  इसका मतलब यह है कि k मान 0, -1, 2, -3, 4, the लेता है ।

  जब करने के लिए संचयी जोड़ा एन ₀ (का प्रारंभिक मूल्य n ), जिसके परिणामस्वरूप पूर्णांक हैं

  • एन _० + ०
  • ( एन ₀ + 0) - 1 = एन ₀ - 1
  • ( n ₀ - 1) + 2 = n ₀ + 1
  • ( एन ₀ + 1) - 3 = एन ₀ - 2
  • ( n ₀ - 2) + 4 = n ₀ + 2
  • आदि।

  
  सुनिश्चित करें कि पहले 7DP संख्या हम सामना करने के लिए करीब के रूप में है n ₀ संभव के रूप में।

Comments

भाजक गिनती के साथ महान विचार! मुझे लगता है कि आप बारी-बारी से kसीधे चलकर f(n+k,k%2*2+~k), जैसे कि शुरुआत कर सकते हैं k=0।

— xnor

महान सुधार। धन्यवाद!

— डेनिस

Answer 2

ब्रेकीलॉग , 44 40 16 बाइट्स

_{पार किया 44 अभी भी नियमित है 44 ;;}

:I=+.>0,.$pPdPl7

उदाहरण:

?- run_from_atom(':I=+.>0,.$pPdPl7',1425060,Z).
Z = 1438710 .

क्या यह हो सकता है कि यह भाषा हमेशा न चूके? मैंने जेली और MATL को हराया!

के साथ परीक्षण का मामला 5सबसे लंबा है और मेरी मशीन पर लगभग 10 सेकंड लगते हैं।

यह 12 बाइट्स होगा यदि $pबग नहीं किया गया था (हमें >0,.भाग की आवश्यकता नहीं होगी )

व्याख्या

Brachylog सभी पूर्णांक अंकगणित के लिए डिफ़ॉल्ट रूप से बाधा तर्क प्रोग्रामिंग का उपयोग करता है। इसके अलावा, लेबलिंग अंतर्निहित =अनंत डोमेन पर काम करता है।

यह क्रमिक (-inf, inf)रूप से इस तरह के रूप में कोई बाधा (यानी में ) के साथ एक चर को एकीकृत करता है 0, 1, -1, 2, -2, 3, …:।

इसलिए, हम पहले नंबर Iको (-inf, inf)(जिसमें ऑटोमैटिक बैकट्रैकिंग का उपयोग करके) एकीकृत किया गया है , के लिए निकटतम 7DP नंबर प्राप्त कर सकते हैं , जिसके लिए Input + I7DP नंबर है।

:I=                Label variables in [Input, I]. I has no constraints and Input is known
   +.              Unify Output with Input + I
     >0,           Output > 0 (wouldn't be needed if $p failed for numbers less than 1)
        .$pP       Unify P with the list of prime factors of Output
            dP     Check that P with duplicates removed is still P
              l7   Check that the length of P is 7

Comments

मैंने जेली और MATL को हराया! लेकिन केवल 0 बाइट्स द्वारा :-P

— लुइस मेंडो

@LuisMendo अगर मैं एक बग को ठीक करता हूं तो यह 13 बाइट्स होगा $p। सिद्धांत रूप में मुझे इसकी आवश्यकता नहीं है >0,, लेकिन मेरा कार्यान्वयन छोटी गाड़ी है: P

— घातक

@DavidC हाँ, क्योंकि यह इनपुट पर शुरू होता है और फिर सभी संख्याओं को इस तरह आज़माता है: Input+1, Input-1, Input+2, Input-2, Input+3, ...इसलिए उस पद्धति से मिला पहला 7DP सबसे नज़दीकी होगा।

— घातक

@mat फिक्सिंग के बाद कीड़े को पोस्ट करने के बाद उत्तर को गैर-प्रतिस्पर्धात्मक बना देता है, इसलिए मैं इसे 16 पर छोड़ दूंगा, भले ही अब यह 12 बाइट्स ( >0,.आवश्यक नहीं) हो सकता है

— Fatalize

codegolf.stackexchange.com/a/111998/59995 क्रॉस्ड-आउट 444 अभी भी 444 है। जब हम क्रॉस-आउट 4444 देखेंगे तो मैं प्रभावित हो

— जाऊंगा।

Answer 3

जेली, 17 बाइट्स

Pµạ³,
×⁹ÆRœc7Ç€ṂṪ

सिद्धांत रूप में काम करता है, लेकिन पूरा होने में कई साल लगते हैं।

---

यहाँ एक संस्करण है जो वास्तव में दिए गए इनपुट के लिए काम करता है, लेकिन सैद्धांतिक रूप से बड़े इनपुट के लिए विफल रहता है:

Pµạ³,
50ÆRœc7Ç€ṂṪ

इसे यहाँ आज़माएँ। यह सभी प्राइम्स को 50 तक उत्पन्न करता है, फिर सभी 7-कॉम्बिनेशन ऑफ प्राइम्स को उस सूची में, और फिर उनके सभी उत्पादों को खोजता है। अंत में, यह दी गई दलील में उस सूची से निकटतम तत्व को ढूंढता है।

बेशक, एक बार हमारे 7DP में 50 से अधिक primes होते हैं, यह विफल हो जाएगा। सैद्धांतिक संस्करण एक इनपुट n के लिए सभी प्राइम को 256n तक उत्पन्न करता है, लेकिन अन्यथा उसी तरह काम करता है।

प्रमाण

के p(x)बाद अगले प्रधानमंत्री को निरूपित करते हैं x। X के लिए निकटतम 7DP उत्पाद के लिए ऊपरी (बेहद ढीला) ऊपरी सीमा है:

p(x) * p(p(x)) * p(p(p(x))) * ... * p(p(p(p(p(p(p(x)))))))

इसलिए हमें केवल [2… p (p (p (p (p (p (x)))))]) में primes की जाँच करने की आवश्यकता है । बर्ट्रेंड के पोस्टुलेट का कहना है कि पी (x) so 2x है , इसलिए यह 128x तक के सभी प्राइम की जांच करने के लिए पर्याप्त है ।

Comments

×⁹ÆRœc7P€µạ³ỤḢịया ×⁹ÆRœc7P€µạ³NMị( सभी समाधानों के सरणी को प्रिंट करते हुए ) बाइट्स के एक जोड़े को बचाता है। इसके अलावा, दक्षता में सुधार ×⁹करने के +⁴लिए बदला जा सकता है ।

— डेनिस

Answer 4

MATL , 21 17 16 14 13 बाइट्स

एक सुझाव के लिए डेनिस का धन्यवाद जिसने 4 बाइट्स निकाले, और एक और जिसने 1 और बाइट को बचाया!

t17*Zq7XN!pYk

यह सिद्धांत रूप में काम करता है, लेकिन ऊपर 6(ऑनलाइन संकलक) इनपुट के लिए स्मृति से बाहर चलाता है ।

एक अधिक कुशल संस्करण 21 बाइट्स का उपयोग करता है , और लगभग एक सेकंड में सभी परीक्षण मामलों की गणना करता है:

t3e4/k16+_YqZq7XN!pYk

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

• मेमोरी-अक्षम संस्करण
• मेमोरी-कुशल संस्करण
• मेमोरी-कुशल संस्करण, सभी परीक्षण मामले

व्याख्या

मेमोरी-कुशल संस्करण

उदाहरण के रूप में इनपुट N = लें 860782। यह एम = तक के अपराधों पर विचार करने के लिए पर्याप्त है 29, जो कि 2*3*5*7*11*13एन से अधिक से गुणा करने वाला पहला प्रमुख है । इस उदाहरण में, 2*3*5*7*11*13*29 = 870870। अगले प्रधानमंत्री है 31। उस प्राइम या अधिक को शामिल करने वाला कोई भी उत्पाद कम से कम होगा 2*3*5*7*11*13*31 = 930930, और इसलिए यह समाधान नहीं होने की गारंटी है , क्योंकि यह एन870870 से अधिक है ।

M की गणना पहले से अधिक अभाज्य के रूप में की जाती है max(N/(2*3*5*7*11*13), 16)। maxसमारोह सुनिश्चित करना है कि कम से कम के लिए प्रयोग किया जाता है 17उठाया है। कुछ बाइट्स, कोड की जगह बचाने के लिए 2*3*5*7*11*13 = 30030से 30000, और समारोह maxके अलावा द्वारा। ये परिवर्तन मान्य हैं क्योंकि वे एक बड़ा मूल्य देते हैं।

t      % Take input implicitly. Duplicate
3e4/k  % Divide input by 30000 and round down (rounding here is only needed
       % due to a bug in the "next prime" function)
16+    % Add 16
_Yq    % Next prime
Zq     % Prime numbers up to that value
7XN    % Combinations of those primes taken 7 at a time. Gives a 2D array
       % with each combination on a different row
!p     % Product of each row
Yk     % Output product that is closest to the input. Implicitly display

मेमोरी-अक्षम संस्करण

बाइट्स की संख्या को कम करने के लिए विभाजन को हटाया जा सकता है; वास्तव में, यह गुणा करने के लिए पर्याप्त है 17(धन्यवाद, @ डेनिस)। यह सुनिश्चित करता है कि अगले प्राइम में ( बर्ट्रेंड के द्वारा ) को शामिल किया गया है और परिणाम कम से कम है 17। इस सिद्धांत में काम करता है, लेकिन के बारे में की तुलना में बड़ा आदानों के लिए स्मृति से बाहर चलाता है 6।

कोड में, अनुभाग

3e4/k  % Divide input by 30000 and round down (rounding here is only needed
       % due to a bug in the "next prime" function)
16+    % Add 16
_Yq    % Next prime

द्वारा प्रतिस्थापित किया जाता है

17*    % Multiply by 17

Answer 5

पाइके, 32 बाइट्स

#PDl 7q.ID}lRlqi*(#)DF-X,)R],She

यहाँ यह कोशिश करो!

ध्यान दें कि यह ऑनलाइन काम नहीं करता है - यह कई बार खत्म हो जाता है। यह संस्करण केवल 2 अलग-अलग अपराधों के लिए जाँच करता है और तेजी से काम करना चाहिए। जब लक्ष्य से समान दूरी के 2 नंबर होते हैं, तो यह निचले को चुनता है।

यह सभी नंबरों से गुजरता है जब तक कि यह एक ऐसा नहीं है जो इनपुट से बड़ा है और एक 7DP है। प्रत्येक संख्या के लिए, यह एक 7DP नहीं है, तो इसे से छुटकारा मिल जाता है। इसके बाद इनपुट की 7DP तक की सूची है जिसमें से एक बड़ा है। यह तब इनपुट के सबसे करीब होता है।

Answer 6

जूलिया, 59 बाइट्स

!n=sort(map(prod,combinations(17n|>primes,7))-n,by=abs)[]+n

यह बहुत अक्षम है, लेकिन यह व्यवहार में पहले परीक्षण के मामले और सिद्धांत में दूसरों के लिए काम करता है।

5 और बाइट्स की लागत पर - कुल 64 बाइट्स के लिए - दक्षता में नाटकीय रूप से सुधार किया जा सकता है।

!n=sort(map(prod,combinations(n>>14+17|>primes,7))-n,by=abs)[]+n

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

पृष्ठभूमि

जैसा कि @ लुइसमेन्डो के उत्तर में उल्लेख किया गया है , हमारे पास 7 पीडी नंबर के लिए विचार करने के लिए निर्धारित अपराधों का सेट काफी छोटा है। यह सेट के लिए पर्याप्त है कि इसमें एक 7DP संख्या होती है जो इनपुट n से बड़ी होती है , जो कि केवल तभी सत्य होगी यदि इसमें एक प्रमुख p such 17 हो जैसे कि 30300p = 2 · 3 · 5 · 7 · 11 · 13 · p ≥ एन ।

में कम से कम एक अभाज्य संख्या युक्त अंतराल पर साबित करता है कि अंतराल [x, 1.5x) कम से कम एक अभाज्य संख्या जब भी शामिल एक्स ≥ 8 । के बाद से 30030/16384 ≈ 1.83 , कि अर्थ है कि एक प्रमुख होना चाहिए पी में (, एन / 30030 n / 16384) जब भी n> 8 · 30300 = 242,400 ।

अंत में, जब n <510510 , p = 17 स्पष्ट रूप से पर्याप्त है, इसलिए हमें केवल n / 1638+ + 17 तक के अपराधों पर विचार करने की आवश्यकता है ।

दक्षता की कीमत पर, हम 17n के बजाय primes पर विचार कर सकते हैं । यह काम करता है जब एन = 1 और से काफी बड़ा है n / 16384 + 17 के बड़े मूल्यों के लिए एन ।

यह काम किस प्रकार करता है

17n|>primesऔर n>>14+17|>primes(बिटशिफ्ट 2 ¹⁴ = 16384 से विभाजित होने के बराबर है ) पिछले पैराग्राफ में वर्णित प्राइम रेंज की गणना करता है। फिर, combinations(...,7)उस श्रेणी में सात अलग-अलग अभाज्य संख्याओं के सभी सरणियों की गणना करता है, और prodउन पर मैपिंग उनके उत्पादों की गणना करता है, अर्थात, 7DP संख्याएं जिनमें से हम उत्तर चुनेंगे।

इसके बाद, प्रत्येक 7DP संख्या को n-n घटाएं , फिर उन अंतरों को उनके निरपेक्ष मानों के अनुसार क्रमबद्ध करें। अंत में, हम इसके साथ पहले अंतर का चयन करते हैं और n के साथ जोड़कर संबंधित 7DP संख्या की गणना करते हैं ।sort(...,by=abs)[]+n

Answer 7

अजगर, 30 बाइट्स

L&{IPbq7lPby#.W!syMH,hhZa0teZ,

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

परीक्षण सूट।

(5 को चलने में बहुत समय लगता है)

व्याख्या

L&{IPbq7lPby#.W!syMH,hhZa0teZ,

L&{IPbq7lPb     Defines a function y, whose argument is b:
 &                  Return if both the following are true:
  {IPb                  the prime factorization contains no duplicate; and:
      q7lPb             the number of prime factors is 7

           y#.W!syMH,hhZa0teZ,   The main programme. Input as Q.
                             ,QQ Implicit arguments, yield [Q,Q].
             .W                  While
               !syMH                   both numbers do not satisfy y:
                    ,hhZ             increment the first number
                          teZ        and decrement the second number
                        a0           while making it non-negative.

Answer 8

गणितज्ञ 136 80 75 बाइट्स

यह एक सीधा दृष्टिकोण है, जिससे बाहर की ओर काम किया जाता है n।

nएक 7-भिन्न-प्रधान उत्पाद है यदि प्रधान कारकों की संख्या 7 है ( PrimeNu@#==7) और इनमें से कोई भी कारक एक से अधिक बार ( SquareFreeQ@#&) दिखाई नहीं देता है ।

g@n_:=(k=1;While[!(PrimeNu@#==7&&SquareFreeQ@#&)⌊z=n-⌊k/2](-1)^k⌋,k++];z)

मेरे पहले सबमिशन (136 बाइट्स) में पहले 7-अलग-प्राइम-प्राइम उत्पाद मिले n, और अगर यह मौजूद है, तो नीचे पहला 7-प्राइम-प्राइम उत्पाद n। यह तो बस निर्धारित किया गया था जो करीब था n। यदि उत्पाद समतुल्य थे, तो यह दोनों वापस आ गया।

वर्तमान संस्करण n-1, n + 1, n-2, n + 2 की जांच करता है ... जब तक कि यह पहले 7-अलग-प्रमुख उत्पाद तक नहीं पहुंचता। इस अधिक कुशल संस्करण ने डेनिस के दृष्टिकोण को अपनाया।

⌊k/2](-1)^k⌋सीरीज़ को 0, 1, -1, 2, -2 ... को वापस करने के लिए महत्वपूर्ण एडवांस का उपयोग किया गया था । शून्य का उपयोग यह जांचने के लिए किया जाता है कि क्या nयह 7-अलग-अलग प्राइम उत्पाद है। इस कारण से, Floor(अर्थात ⌊...⌋) का उपयोग इसके बजाय किया जाता है Ceiling।

---

g[5]
g[860782]
g[1425060]

510,510

870,870

1438710

Answer 9

05AB1E , 10 बाइट्स

°Åp7.ÆPs.x

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

पहले 10 ** इनपुट प्राइम्स के 7 के सभी संयोजनों की कोशिश करता है। 1 से अधिक इनपुट के लिए मेमोरी से बाहर चलाता है।

काफी अधिक कुशल 14 बाइट्स संस्करण:

5°/7+Åp7.ÆPs.x

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

पहले (इनपुट / 100000 + 7) प्राइम का उपयोग करता है।