एन डिवाइडर के साथ सबसे छोटे पूर्णांक की गणना करना

इस समस्या से निपटने के लिए मैंने पहली बार यह देखा

φ ({पी}_{1}^{इ_{1}} {पी}_{2}^{इ_{2}} \dots {पी}_{क}^{इ_{क}}) = (इ_{1} + 1) (इ_{2} + 1) \dots (इ_{क} + 1)

$\phi(p_1^{e_1} \space p_2^{e_2} \cdots \space p_k^{e_k}) = (e_1 + 1)(e_2 + 1)\cdots(e_k +1)$

कहाँ पे $\phi(m)$ (अनिवार्य रूप से अभाज्य) के विभाजकों की संख्या है $m$ । अगर $m$ सबसे छोटा पूर्णांक है ऐसा $\phi(m) = n$ , फिर

ϕ (m) = n

$\phi(m) = n$

(इ_{1} + 1) (इ_{2} + 1) \dots (इ_{क} + 1) = n

$(e_1 + 1)(e_2 + 1)\cdots(e_k +1) = n$

अब हमें चुनना होगा $e_i$ ऐसा है कि $\prod_{i} p_i^{e_i}$ न्यूनतम है। के लिए विकल्प $p$ तुच्छ हैं - वे आरोही क्रम में सिर्फ अपराध हैं।

हालांकि, चुनने के लिए मेरा पहला विचार था $e_i$ गलत था। मुझे लगा कि आप बस कारक बन सकते हैं $n$ अवरोही क्रम में कारकों को क्रमबद्ध करें और घटाएं 1. अधिकांश समय यह ठीक काम करता है, जैसे कि सबसे छोटा पूर्णांक $n = 15$ भाजक है:

15 = 5 \cdot 3

$15 = 5 \cdot 3$

15 = (4 + 1) (2 + 1)

$15 = (4 + 1)(2 + 1)$

म = 2^{4} 3^{2} = 144

$m = 2^4 3^2 = 144$

लेकिन यह गलत है $n = 16$ :

16 = 2 \cdot 2 \cdot 2 \cdot 2

$16 = 2 \cdot 2\cdot 2 \cdot 2$

16 = (1 + 1) (1 + 1) (1 + 1) (1 + 1)

$16 = (1 + 1)(1 + 1)(1 + 1)(1 + 1)$

म = 2^{1} 3^{1} 5^{1} 7^{1} = 210

$m = 2^1 3^1 5^1 7^1 = 210$

जबकि सही उत्तर है:

16 = (3 + 1) (1 + 1) (1 + 1)

$16 = (3 + 1)(1 + 1)(1 + 1)$

म = 2^{3} 3^{1} 5^{1} = 120

$m = 2^3 3^1 5^1 = 120$

इसलिए यह स्पष्ट है कि कभी-कभी हमें कारकों को मर्ज करने की आवश्यकता होती है। इस मामले में क्योंकि $7^1 > 2^2$ । लेकिन मैं बिल्कुल साफ और प्रत्यक्ष विलय की रणनीति नहीं देखता। उदाहरण के लिए, कोई सोच सकता है कि हमें हमेशा इसमें विलीन होना चाहिए $2$ शक्ति, लेकिन यह सच नहीं है:

1552 = (96 + 1) (1 + 1) (1 + 1) (1 + 1) (1 + 1)

$1552 = (96 + 1)(1 + 1)(1 + 1)(1 + 1)(1 + 1)$

म = 2^{96} 3^{1} 5^{1} 7^{1} {1 1}^{1} > 2^{96} 3^{3} 5^{1} 7^{1}

$m = 2^{96} 3^1 5^1 7^1 11^1 > 2^{96} 3^3 5^1 7^1$

मैं तुरंत एक उदाहरण के बारे में नहीं सोच सकता, लेकिन मेरी वृत्ति कहती है कि कुछ लालची दृष्टिकोण विफल हो सकते हैं यदि वे पहले गलत शक्तियों का विलय करते हैं।

क्या सही उत्तर प्राप्त करने के लिए इन शक्तियों को विलय करने के लिए एक सरल इष्टतम रणनीति है?

परिशिष्ट। एक लालची एल्गोरिथ्म जो हर संभव मर्ज की जाँच करता है और मर्ज-बाय-मर्ज के आधार पर सबसे अच्छा प्रदर्शन करता है, विफल रहता है $n = 3072$ । एक-एक मर्ज की श्रृंखला है:

2^{2} 3^{1} 5^{1} 7^{1} {1 1}^{1} 13^{1} 17^{1} 19^{1} 23^{1} 29^{1} 31^{1}

$2^2 3^1 5^1 7^1 11^1 13^1 17^1 19^1 23^1 29^1 31^1$

2^{3} 3^{2} 5^{1} 7^{1} {1 1}^{1} 13^{1} 17^{1} 19^{1} 23^{1} 29^{1}

$2^3 3^2 5^1 7^1 11^1 13^1 17^1 19^1 23^1 29^1$

2^{5} 3^{3} 5^{1} 7^{1} {1 1}^{1} 13^{1} 17^{1} 19^{1} 23^{1}

$2^5 3^3 5^1 7^1 11^1 13^1 17^1 19^1 23^1$

हालांकि इष्टतम समाधान है:

2^{7} 3^{3} 5^{2} 7^{1} {1 1}^{1} 13^{1} 17^{1} 19^{1}

$2^7 3^3 5^2 7^1 11^1 13^1 17^1 19^1$

number-theory primes

— orlp
स्रोत

@orlp: मेरा सुझाव था: फिक्स

n

$n$ (जैसे कि,

24

$24$ ), और ठीक करें

m

$m$ (जैसे कि,

2

$2$ )। तब आप कम करने की कोशिश कर रहे हैं

k_{1} \log (2) + k_{2} \log (3)

$k_1\log(2)+k_2\log(3)$ , का विषय है

k_{1} k_{2} = 24

$k_1k_2=24$ । तो एक निश्चित संख्या के साथ काम करके

m

$m$ (primes), आप जटिलताओं की अनदेखी कर सकते हैं कि क्या वैश्विक न्यूनतम में एक निश्चित प्राइम दिखना चाहिए या नहीं। आप प्रत्येक के लिए न्यूनतम पाते हैं

m

$m$ , तो उन लोगों के मंत्री ले लो।

— स्टीव डी

जवाबों:

यहाँ एक समाधान है, ऊपर मेरी टिप्पणियों के आधार पर। मैं कोई दावा नहीं करता कि यह इष्टतम है।

विचार करना है $T(n,m)$ , जिसे हम "सबसे छोटे धनात्मक पूर्णांक" के रूप में परिभाषित करते हैं $n$ भाजक और $m$ अलग-अलग प्रमुख कारक "हम आसान अवलोकन करते हैं:

\begin{aligned} टी (n, 1) & = 2^{n - 1} \\ टी (2^{म}, म) & = {पी}_{1} {पी}_{2} \dots {पी}_{म} \end{aligned}

$\begin{align} T(n, 1) &= 2^{n-1}\\ T(2^m, m) &= p_1p_2\cdots p_m \end{align}$

और हमारे पास पुनरावृत्ति भी है:

टी (n, म) = \underset{घ | n}{मिनट} [टी (\frac{n}{घ}, म - 1) \cdot {पी}_{म}^{घ - 1}]

$\begin{equation} T(n,m) = \min_{d|n} [T\left(\frac{n}{d}, m-1\right)\cdot p_m^{d-1}] \end{equation}$

अंत में, वह मात्रा जिसकी आप तलाश कर रहे हैं

\underset{1 \leq मैं \leq ⌈ लॉग (n) ⌉}{मिनट} टी (n, मैं)

$\begin{equation} \min_{1\le i\le\lceil\log(n)\rceil} T(n, i) \end{equation}$

उस अंत तक, यहां कुछ पायथन कोड है, जो आपके द्वारा दिए गए सभी नंबरों से सहमत है। ध्यान दें कि यह संख्याओं को छोटा रखने के लिए लघुगणक के साथ काम करता है: इसलिए जो वास्तविक पूर्णांक आप चाहते हैं round(2**smallest(n))।

import functools
import itertools
import math

# All primes less than 100.
PRIMES = [
  2, 3, 5, 7, 11,
  13, 17, 19, 23, 29,
  31, 37, 41, 43, 47,
  53, 59, 61, 67, 71,
  73, 79, 83, 89, 97,
]

LOG_PRIMES = [math.log2(p) for p in PRIMES]

def smallest(n):
  max_factors = math.ceil(math.log2(n))
  min_so_far = float('Infinity')
  factors = factorize(n)
  memo = {}
  for i in range(1, max_factors+1):
    t = T(n,i, factors, memo)
    if 0.0 < t < min_so_far:
      min_so_far = t
  return min_so_far

def T(n, m, factors=None, memo=None):
  if memo is None:
    memo = {}
  if n < 2 or m < 1:
    return 0
  elif m == 1:
    # Everything on the smallest prime.
    return (n-1) * LOG_PRIMES[0]
  elif n < 2**m:
    return 0
  elif n == 2**m:
    # Product of first m primes, in log.
    return sum(LOG_PRIMES[:m])
  elif (n,m) in memo:
    return memo[(n,m)]

  if factors is None:
    factors = factorize(n)
  if len(factors) < m:
    return 0

  smallest = float('Infinity')  
  for factor_list in powerset(factors):
    divisor = product(factor_list)
    first = T(divisor, m-1, factor_list, memo)
    # No such product.
    if first < 1.0:
      continue
    second = (n/divisor - 1) * LOG_PRIMES[m-1]
    total = first + second
    if total < smallest:
      smallest = total

  memo[(n,m)] = smallest
  return smallest

def product(nums):
  return functools.reduce(lambda x,y: x*y, nums, 1)

def factorize(n):
  prime_factors = []
  for p in PRIMES:
    while n%p == 0:
      n //= p
      prime_factors.append(p)
    if n == 1:
      break
  return prime_factors

def powerset(lst):
  # No empty set.
  return itertools.chain.from_iterable(itertools.combinations(lst, r) 
                                       for r in range(1, len(lst)+1))

— स्टीव डी
स्रोत

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

n

$n$ घटक)। क्या यह उस समय की जटिलता की अनुकूलता है जिसके बारे में आप अनिश्चित हैं? मैं एक पूर्णांक के विभाजकों की संख्या के लिए एक तंग बाध्य नहीं जानता

n

$n$ , लेकिन यहां तक कि बहुत निराशावादी बाध्य के साथ

O (n)

$O(n)$ आपका एल्गोरिथ्म केवल है

O (n^{2} \log n)

$O(n^2\log n)$ , जिसके लिए पर्याप्त उपवास होना चाहिए

n

$n$ हजारों में! : (Btw मैं एक ही एल्गोरिथ्म (शून्य से कुछ अनुकूलन लिख रहा था), लेकिन आप वहां पहले, अच्छी तरह से किया!)

— j_random_hacker

@j_random_hacker: हाँ, निश्चित नहीं कि उन टिप्पणियों का क्या हुआ: उनमें से कई थे, और वे अब चले गए हैं! मैं वास्तव में समय की जटिलता के बारे में बात कर रहा था; मैं वास्तव में लगता है कि यह शायद करीब है

O (n \log n)

$O(n\log n)$ , लेकिन भाजक की संख्या एक मुश्किल काम है। बेशक, उपरोक्त कोड निश्चित रूप से बेहतर अनुकूलित किया जा सकता है: powersetउदाहरण के लिए, डुप्लिकेट के लिए खाता नहीं है।

— स्टीव डी

मेरा मानना है कि यह गतिशील प्रोग्रामिंग का उपयोग करके कुशलतापूर्वक लागू करना आसान है: gist.github.com/orlp/0fbb7784782712bc7c411aa58a188143 मैं वास्तव में इस तरह से लघुगणक चाल के साथ सहज नहीं हूं - अस्थायी बिंदु सीमित परिशुद्धता कुछ बिंदु पेंच चीजों पर होगा। यह कहा जा रहा है, मुझे विश्वास नहीं है कि यह वास्तव में सभी गुणात्मक विभाजन पैदा करने से तेज है। वास्तव में, मेरा मानना है कि वास्तव में यह भेस में क्या कर रहा है!

— orlp

@ Orlp की टिप्पणी और आपके कोड को और अधिक बारीकी से पढ़ने के बाद, मुझे लगता है कि अब समय जटिलता (और व्यावहारिक प्रदर्शन) के लिए यह महत्वपूर्ण for factor_list in powerset(factors)है कि कुछ को nएक बार के प्रत्येक अलग विभाजक को बदल दिया जाए । इस तरह, के लिए, कहते हैं,

n = 2^{k} 3^{k}

$n=2^k3^k$ , जब आप पहले वाले समाधानों पर विचार करते हैं

2 k

$2k$ उनके अलग-अलग प्रमुख कारकों के रूप में primes, आप केवल करेंगे

O (k^{2})

$O(k^2)$ इसके बजाय गैर-पुनरावर्ती कार्य

O ((\binom{2 k}{k}))

$O({{2k}\choose{k}})$ , जो में घातीय है

k

$k$ ।

— j_random_hacker

@orlp: मैंने "गुणात्मक विभाजन" शब्द को गलत समझा, क्षमा करें। पायथन कोड के लिए धन्यवाद। यह देखने के लिए कि स्टीव डी का एल्गोरिथ्म उस कोड को समानांतर क्यों नहीं करता है, विचार करें multiplicative_partitions(24), जो (अन्य के बीच) विभाजन का उत्पादन करता है [4, 3, 2]और [6, 2, 2], जो (सबसे छोटे प्रमुख कारक को उच्चतम प्रतिपादक देने के लिए आदेश को उलटने के बाद) समाधान के अनुरूप है

2^{3} 3^{2} 5^{1}

$2^3 3^2 5^1$ तथा

2^{5} 3^{1} 5^{1}

$2^5 3^1 5^1$ , क्रमशः। स्टीव डी का एल्गोरिथ्म कभी भी बाद के समाधान पर विचार नहीं करेगा, क्योंकि यह पहले से ही निर्धारित कर चुका है कि सबसॉल्यूशन

2^{3} 3^{2} = 72 < 2^{5} 3^{1} = 96

$2^3 3^2 = 72 < 2^5 3^1 = 96$ ।

— j_random_hacker 13

-1

"एन डिविजर्स के साथ सबसे छोटे पूर्णांक" के संभावित उम्मीदवार फॉर्म के पूर्णांक हैं $2^a·3^b·5^c...$ जहां एक 1 बी ... सी ... और (ए + १) (बी + १) (सी + १) ... = एन।

इसलिए आपको पूर्णांक के उत्पाद के रूप में n को व्यक्त करने के सभी तरीके खोजने की आवश्यकता है, गैर-आरोही क्रम में all 2, और संबंधित उम्मीदवारों की गणना और जांच करें। उदाहरण के लिए, जब n = 16, 16 = 8 · 2 = 4 · 4 = 4 · 2 · 2 = 2 · 2 · 2 · 2, तो संभावनाएं हैं $2^7·3$ , $2^3·3^3$ , $2^3·3·5$ , $2·3·5·7$ , और सबसे छोटा है $2^3·3·5 = 120$ ।

यदि n दो primes p · q, p the q का गुणनफल है, केवल अभ्यर्थी हैं $2^{pq-1}$ तथा $2^{p-1}·3^{q-1}$ , और बाद वाला हमेशा छोटा होता है।

जब कोई कारक हो सकता है तो आप कुछ स्थिति का पता लगा सकते हैं $2^{ab-1}$ उदाहरण के लिए, जाँच करके कि क्या $2^{ab-1} > 2^{a-1}·x^{b-1}$ कुछ प्रमुख एक्स के लिए जो एक कारक नहीं है। उदाहरण n = 16 में, एक कारक है $2^3$ चूंकि $2^3 < 2·7$ ।

— gnasher729
स्रोत

मुझे माफ़ कर दो, लेकिन यह मेरे सवाल का जवाब नहीं देता है, यह सिर्फ संक्षेप में बताता है कि मैंने अपने प्रश्न में क्या पाया है। एक शीर्षक,: शीर्षक सिर्फ इतना है कि है नहीं सवाल ही। मुझे ऐसा लगता है कि आपने उत्तर देने से पहले केवल शीर्षक पढ़ा है। असली प्रश्न मेरे प्रश्न पाठ के निचले भाग में है।

— orlp

इसका उत्तर अंतिम पैराग्राफ में दिया गया है।

— gnasher729

@ gnasher729 यह एक प्रश्न "कुशलता से गणना", या यहां तक कि "विलय के लिए इष्टतम रणनीति" के लिए एक उत्तर होने से बहुत दूर है

— यो