दिए गए कारकों के उत्पाद के रूप में कम से कम पूर्णांक

17

हाल ही में बहुत सारी अभाज्य / प्रधान कारक-संबंधी चुनौतियाँ आई हैं, इसलिए मैंने सोचा कि दूसरे रास्ते पर जाना दिलचस्प हो सकता है।

दिया हुआ:

  • एक सकारात्मक पूर्णांक n , और
  • सकारात्मक पूर्णांकों की गैर-रिक्त सूची f

एक पूरा कार्यक्रम या पूर्णांक छोटी से छोटी खोजने के लिए एक समारोह लिखने iऐसा है कि i >= nऔर iमें तत्वों की गैर नकारात्मक, पूर्णांक शक्तियों का एक उत्पाद है f।

उदाहरण:

  • मान लीजिए n = 11, f = [2, 3, 5]।

    पहले कुछ उत्पाद हैं:

    1   = 2^0 * 3^0 * 5^0
2   = 2^1 * 3^0 * 5^0
3   = 2^0 * 3^1 * 5^0
5   = 2^0 * 3^0 * 5^1
4   = 2^2 * 3^0 * 5^0
6   = 2^1 * 3^1 * 5^0
10  = 2^1 * 3^0 * 5^1
9   = 2^0 * 3^2 * 5^0
15  = 2^0 * 3^1 * 5^1
25  = 2^0 * 3^0 * 5^2
8   = 2^3 * 3^0 * 5^0
12  = 2^2 * 3^1 * 5^0 => smallest greater than (or equal to) 11, so we output it.
20  = 2^2 * 3^0 * 5^1
18  = 2^1 * 3^2 * 5^0
30  = 2^1 * 3^1 * 5^1
50  = 2^1 * 3^0 * 5^2
27  = 2^0 * 3^3 * 5^0
45  = 2^0 * 3^2 * 5^1
75  = 2^0 * 3^1 * 5^2
125 = 2^0 * 3^0 * 5^3

  • मान लीजिए n=14, f=[9, 10, 7]।

    फिर से, पहले कुछ उत्पाद: 

    1 = 7^0 * 9^0 * 10^0
7 = 7^1 * 9^0 * 10^0
9 = 7^0 * 9^1 * 10^0
10 = 7^0 * 9^0 * 10^1
49 = 7^2 * 9^0 * 10^0  => smallest greater than (or equal to) 14, so we output it.
63 = 7^1 * 9^1 * 10^0
70 = 7^1 * 9^0 * 10^1
81 = 7^0 * 9^2 * 10^0
90 = 7^0 * 9^1 * 10^1
100 = 7^0 * 9^0 * 10^2

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

n, f -> output
10, [2, 3, 5]              -> 10
17, [3, 7]                 -> 21
61, [3,5,2,7]              -> 63
23, [2]                    -> 32
23, [3]                    -> 27
23, [2, 3]                 -> 24
31, [3]                    -> 81
93, [2,2,3]                -> 96
91, [2,4,6]                -> 96
1,  [2,3,5,7,11,13,17,19]  -> 1
151, [20,9,11]             -> 180
11616, [23,32]             -> 12167
11616, [23,32,2,3]         -> 11664 = 2^4 * 3^6
5050, [3,6,10,15,21,28,36,45,55,66,78,91,105,120,136,153,171,190,210] -> 5103 = 3^6 * 7
12532159, [57, 34, 12, 21] -> 14183424 = 12^5 * 57

नियम

  • आप मान सकते हैं कि fइसमें कम से कम एक तत्व होगा, और यह कि सभी तत्व f1 से अधिक होंगे।
  • आप वैकल्पिक रूप से मान सकते हैं कि fघटते / बढ़ते क्रम में क्रमबद्ध है यदि आप चाहें (लेकिन कृपया निर्दिष्ट करें)।
  • fयदि आप चाहें तो आप वैकल्पिक रूप से उन तत्वों की संख्या ले सकते हैं।
  • एक स्ट्रिंग के रूप में आउटपुट की अनुमति है।
  • यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में बाइट्स में सबसे कम उत्तर जीतता है!
  • डिफ़ॉल्ट I / O नियम लागू होते हैं, और मानक कमियां निषिद्ध हैं।
  • स्पष्टीकरण को प्रोत्साहित किया जाता है।
code-golf  arithmetic  integer 
— ग्यूसेप
स्रोत

जवाबों:

10

भूसी , 8 बाइट्स

ḟṠ€ȯmΠṖṘ

बेहद धीमी। इसे ऑनलाइन आज़माएं!

व्याख्या

ḟṠ€ȯmΠṖṘ  Implicit inputs, say L=[3,4] and n=5.
ḟ         Find the lowest integer k≥n that satisfies:
       Ṙ   Replicate L by k: [3,3,3,3,3,4,4,4,4,4]
      Ṗ    Powerset: [[],[3],[4],..,[3,3,3,3,3,4,4,4,4,4]]
    mΠ     Product of each: [1,3,4,..,248832]
 Ṡ€ȯ       k is in this list.
— Zgarb
स्रोत
7

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 68 65 62 61 बाइट्स

If[#^#2<=1,1~Max~-Log@#2,Min[#0[#,#2-1,##4],#0[#/#3,##2]#3]]&

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

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

इनपुट के रूप में [n,k,f1,f2,f3,...,fk](उदाहरण के लिए [11,3,2,3,5]) लेता है : पहला मान लक्ष्य है n, दूसरा कारकों की संख्या है, और सभी फ्रिज का अनुसरण करते हैं।

अन्य नंबर-थ्योरी चुनौतियां हाल ही में सभी फैंसी-इन (बहुत कम से कम, वे इस्तेमाल किए गए FactorInteger) के लिए मुड़ीं, इसलिए मैंने सोचा कि मैं कुछ ऐसा प्रयास करूं जो केवल मूल उपकरण का उपयोग करता हो। यह समाधान मूल रूप से कहता है कि nकारकों के एक उत्पाद के रूप में लिखने के लिए, हम या तो पहले कारक का उपयोग करते हैं f1(और n/f1फिर से पुन: प्रयास करते हैं , फिर से गुणा करेंf1 ) या (और कारकों की एक छोटी सूची पर ), फिर मिनट लें।

जब लक्ष्य 1 से कम हो या जब कारकों की संख्या 0 हो, तो रिकर्सन बॉटम्स, जिसे हम #^#2<=1एक बार में जांचते हैं, और फिर पहले मामले Infinityमें और बाद में 1 उत्पन्न करते हैं 1~Max~-Log@#2।

जब तक आप इसे नहीं चलाते हैं Quiet, तब तक यह फ़ंक्शन चेतावनी का एक पूरा गुच्छा देता है (लेकिन फिर भी काम करता है) , क्योंकि यह अंततः उन मामलों की पुनरावृत्ति #3करता है जहां मौजूद नहीं है, जिससे Ifदुखी की दूसरी शाखा बनती है।

-3 बाइट्स: इनपुट के रूप में कारकों की संख्या लेना।

-3 बाइट्स थैंक्स टू @ngenisis: यूज़ ∞।

-1 बाइट, और कोई ∞अस्पष्टता: #^#2चेक।

— मिशा लावरोव
स्रोत
2
बहुत अच्छा! Tr [1 ^ {##}] पर बाइट्स ∞बचाता है 3बाइट से -Log@0 (doesn't work on TIO, but works fine on desktop Mathematica). Also, कम है Length@{##}।
— 20-28 में ngenisis
मुझे पूरी तरह से यकीन नहीं है कि मैं अनुकूलन का उपयोग करने के बारे में कैसा महसूस करता हूं टीआईओ को पसंद नहीं है, लेकिन यकीन है, मैं इसे जोड़ूंगा। और #2से भी छोटा है Tr[1^{##}]। :)
— मीशा लावरोव
1
मुझे लगता है कि आपको Quietअपने मुख्य कोड में उकसाना चाहिए । यह उत्तर कई गलत संदेशों को आउटपुट करता है। कम से कम ओपी से पूछें कि क्या वह ठीक है
— 2242 में J42161217
2
ऐसा लगता है कि STDERR की अनदेखी दूसरी भाषा में होगी, जिसे व्यवहार में स्वीकार किया जाता है ।
— मिशा लावरोव
2
∞समस्या एक बग प्रतीत होता है। मैं ठीक करने की कोशिश करूँगा।
— डेनिस
6

पायथन 2 , 91 88 84 बाइट्स

f=lambda n,l:n<2or any(n%x<1and f(n/x,l)for x in l)
g=lambda n,l:n*f(n,l)or g(n+1,l)

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

फ़ंक्शन fपुनरावर्ती जाँच करता है यदि nतत्वों की शक्तियों का एक उत्पाद है l, gपुनरावृत्ति को नियंत्रित करने के लिए सिर्फ एक आवरण है

— छड़ी
स्रोत
4

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

L⁹ṗ’⁸*P€ḟ⁹Ḷ¤Ṃ

सूची fको बाईं ओर और संख्या nपर दाईं ओर ले जाने वाला एक डायडिक लिंक , जो एक नंबर देता है।

इसे ऑनलाइन आज़माएं! गोल्फ से अक्षम - उच्चnऔर / या लंबे समय तकइनपुट के लिए समय निकाल देगाf।

कैसे?

हम जानते हैं कि व्यक्तिगत (सख्ती से सकारात्मक) कारकों की शक्तियों को पार करने की आवश्यकता नहीं होगी n-1
... तो चलो बस सभी संभावित तरीकों का निरीक्षण करें!

L⁹ṗ’⁸*P€ḟ⁹Ḷ¤Ṃ - Link: list, f; number, n
 ⁹            - chain's right argument, n
L             - length of f
  ṗ           - Cartesian power  ...e.g.: len(f)=2; n=3 -> [[1,1],[1,2],[1,3],[2,1],[2,2],[2,3],[3,1],[3,2],[3,3]]
   ’          - decrement (vectorises)
    ⁸         - chain's left argument, f
     *        - exponentiate (vectorises) - that is [f1^a, f2^b, ...] for each [a, b, ...] in the list formed from the Cartesian power
      P€      - product for €ach - that is f1^a * f2^b * ... for each [a, b, ...] in the list formed from the Cartesian power
           ¤  - nilad followed by link(s) as a nilad:
         ⁹    -   chain's right argument, n
          Ḷ   -   lowered range -> [0,1,2,3,...,n-1]
        ḟ     - filter discard - that is remove values less than n
            Ṃ - minimum
— जोनाथन एलन
स्रोत
2

रेटिना , 76 बाइट्स

\d+
$*
1+;
$&$&
{+`;(1+)(\1)*(?=;.*\b\1\b)
;1$#2$*1
}`(1+);11+;
1$1;1$1;
\G1

इसे ऑनलाइन आज़माएं! लिंक सबसे धीमे परीक्षण मामलों को बाहर करता है, लेकिन यह अभी भी थोड़ा धीमा है, इसलिए @ डेनिस के सर्वर को हथौड़ा न करने का प्रयास करें।

— नील
स्रोत
2

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

Min@Select[Flatten[1##&@@(s^#)&/@Tuples[0~Range~⌈Log[Min[s=#],d=#2]⌉,#3]],#>=d&]&

इनपुट

[{सूची f}, n, f के तत्वों की संख्या]
[{५ 34, ३४, १२, २१}, १२५३२१५ ९, ४]

— J42161217
स्रोत
{d,s}Min@Select[Flatten[1##&@@(s^#)&/@0~Range~9~Tuples~Tr[1^s]],#>=d&]
— ngenisis
@ngenisis वह प्रतीक क्या है जो प्रदर्शित नहीं होता है? क्या आप इसके बजाय TIO लिंक बना सकते हैं?
— J42161217
कभी नहीं सोचा था कि मैं उस दिन देखूंगा जहां "मैथेमेटिका" और "टीआईओ" एक ही पोस्ट में इस्तेमाल किए गए थे: पी
— केयर्ड सिक्काहेरिंगहिंग
@ जेनी_मथी, यह U+F4A1लंबा नाम है \[Function]।
— एनजाइनिसिस
का उपयोग करना 0~Range~9बहुत रूढ़िवादी लगता है। क्या g[{2,3,5},1001]वास्तव में छोड़ देना चाहिए 1024और वापस आ जाना चाहिए 1080? यह एक विशेष रूप से बड़ा इनपुट नहीं है।
— मीशा लावरोव
2

Japt , 10 बाइट्स

_k e!øV}aU

इसे ऑनलाइन टेस्ट करें!

इंटरप्रेटर को हमेशा के लिए चलाने से रोकने के लिए डिज़ाइन की गई एक पुनरावृत्ति सीमा के कारण अंतिम परीक्षण के मामले पर काम नहीं करता है (हालांकि यहाँ बहुत मदद नहीं मिली, क्योंकि यह एक घंटे के लिए मेरे ब्राउज़र को फ्रीज करता है ...)

व्याख्या

_k e!øV}aU    Implicit: U = input integer, V = array of factors
_      }aU    Starting at U, find the next integer Z where
 k              the factors of Z
   e            are such that every factor
    !øV         is contained in V (e!øV -> eX{VøX}, where VøX means "V contains X").
              Implicit: output result of last expression
— ETHproductions
स्रोत
2

हास्केल , 46 बाइट्स

यह केसाब के उत्कृष्ट पायथन उत्तर का एक बंदरगाह है । PPCG हास्केल चैटरूम, मोनाड्स एंड मेन में इस उत्तर को डिबगिंग और गोल्फ में मदद के लिए लाइकोनी का धन्यवाद। । गोल्फ सुझाव का स्वागत करते हैं! इसे ऑनलाइन आज़माएं!

(#1)
(l#x)n|x<n=minimum[(l#(x*e))n|e<-l]|1>0=x
— Sherlock9
स्रोत
1

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

1±_=1>0;n_±f_:=Or@@(#∣n&&n/#±f&/@f);n_·f_:=NestWhile[#+1&,n,!#±f&]

अनिवार्य रूप से रॉड के पायथन उत्तर का एक बंदरगाह है । दो बाइनरी ऑपरेटरों को परिभाषित करता है ±और ·। n±fरिटर्न Trueअगर और nतत्वों का एक उत्पाद हैfFalse अन्यथा।n·fसबसे छोटा पूर्णांक देता हैi । यदि कोई विभाज्यता परीक्षण को खत्म करने के तरीके का पता लगा सकता है, तो मैं आईएसओ 8859-1 एन्कोडिंग का उपयोग करके 10 बाइट बचा सकता हूं।

व्याख्या

1±_=1>0;                         (* If the first argument is 1, ± gives True. *)
n_±f_:=Or@@(#∣n&&n/#±f&/@f);     (* Recursively defines ±. *)
                                 (* For each element of f, check to see if it divides n. *)
                                 (* For each element # that does, check if n/# is a product of elements of f. *)
n_·f_:=NestWhile[#+1&,n,!#±f&]   (* Starting with n, keep incrementing until we find an i that satisfies i±f. *)
— ngenisis
स्रोत
1

आर , 52 बाइट्स

function(n,f)min((y=(x=outer(f,0:n,"^"))%o%x)[y>=n])

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

3 सप्ताह हो गए हैं, इसलिए मैंने सोचा कि मैं आखिरकार अपना समाधान पोस्ट करूंगा। यह एक क्रूर बल दृष्टिकोण है।

हालांकि, एक बिलिन है:

आर , 5 बाइट्स

nextn

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

R डॉक्स से:

nextnसबसे छोटे पूर्णांक को लौटाता है, उससे अधिक या उसके बराबर n, जो निहित मूल्यों की शक्तियों के उत्पाद के रूप में प्राप्त किया जा सकता है factors। nextnइसका उद्देश्य शून्य-पैड को उपयुक्त लंबाई खोजने के लिए उपयोग किया जाना चाहिए fftताकि तर्क की गणना जल्दी से की जा सके। इसके लिए डिफ़ॉल्ट मान factorsयह सुनिश्चित करता है।

कुछ परीक्षण के कार्यान्वयन में एक बग का पता चला, हालांकि, ऊपर दिए गए TIO लिंक के रूप में।

nextn(91,c(2,6))96 वापस करना चाहिए, लेकिन इसके बजाय 128 लौटाता है। यह स्पष्ट रूप से केवल तब होता है जब factorsसभी एक दूसरे के साथ अपेक्षाकृत प्रमुख नहीं होते हैं। वास्तव में, अंतर्निहित अंतर्निहित कोड से पता चलता है कि nextnलालची factorबारी-बारी से प्रत्येक तक 1पहुंचने की कोशिश करता है:

static Rboolean ok_n(int n, int *f, int nf)
{
    int i;
    for (i = 0; i < nf; i++) {
    while(n % f[i] == 0) {
        if ((n = n / f[i]) == 1)
        return TRUE;
    }
    }
    return n == 1;
}



static int nextn0(int n, int *f, int nf)
{
    while(!ok_n(n, f, nf))
    n++;
    return n;
}

घटते क्रम में इनपुट लेकर इसे हल किया जा सकता है।

— ग्यूसेप
स्रोत
1

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

सहेजे गए 3 बाइट्स @DanielIndie के लिए धन्यवाद

करी सिंटैक्स में इनपुट लेता है (n)(a)।

n=>m=a=>(g=k=>k<n?a.map(x=>g(k*x)):k>m?0:m=k)(1)|m

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

कोड स्निपेट दिखाएं

कैसे?

n => a => (                 // given n and a
  g = k =>                  // g = recursive function taking k
    k < n ?                 // if k is less than n:
      a.map(x => g(k * x))  //   recursive calls to g with x * k for each x in a
    :                       // else:
      k > m ?               //   if k is greater than m and m is not set to NaN:
        0                   //     ignore this result
      :                     //   else:
        m = k               //     update m to k
  )(                        // initial call to g with:
    1,                      //   k = 1
    m = +a                  //   m = either NaN or the single integer contained in a
  ) | m                     // return m
— Arnauld
स्रोत
n => m = a => (g = k => k <n! a.map (x => g (k * x)): k> m? 0: m = k) (1) | mm = function हमेशा पहले रन पर असत्य पैदा करता है, इसलिए यह मूल रूप से + ए डालने के समान है, यह अब 51 बाइट्स है
— डैनियलइंडी
@ डैनियलइंडी वास्तव में 50 बाइट्स है। आपका बहुत बहुत धन्यवाद!
— अरनौलद
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.