Effiziente Berechnung der kleinsten Ganzzahl mit n Teilern

Um dieses Problem anzugehen, habe ich das zuerst beobachtet

$$\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)$$

Wobei die Anzahl der (nicht unbedingt primären) Teiler von . Wenn die kleinste ganze Zahl ist, so dass , dann$\phi(m)$$m$$m$$\phi(m) = n$

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

Jetzt müssen wir so wählen , dass minimal ist. Die Auswahlmöglichkeiten für p sind trivial - sie sind nur die Primzahlen in aufsteigender Reihenfolge.$e_i$$\prod_{i} p_i^{e_i}$$p$

Mein erster Gedanke für die Wahl von $e_i$ war jedoch falsch. Ich dachte, Sie könnten einfach $n$ faktorisieren, die Faktoren in absteigender Reihenfolge sortieren und 1 subtrahieren. Meistens funktioniert dies einwandfrei, z. B. ist die kleinste ganze Zahl mit $n = 15$ Teilern:

$$15 = 5 \cdot 3$$ $$15 = (4 + 1)(2 + 1)$$ $$m = 2^4 3^2 = 144$$

Dies ist jedoch falsch für $n = 16$ :

16 = ( 1 + 1 ) ( 1 + 1 ) ( 1 + 1 ) ( 1 + 1 ) m = 2 1 3 1 5 1 7 1 =

$$16 = 2 \cdot 2\cdot 2 \cdot 2$$ $$16 = (1 + 1)(1 + 1)(1 + 1)(1 + 1)$$ $$m = 2^1 3^1 5^1 7^1 = 210$$

Die richtige Antwort lautet:

m = 2 3 3 1 5 1 =

$$16 = (3 + 1)(1 + 1)(1 + 1)$$ $$m = 2^3 3^1 5^1 = 120$$

Es ist also klar, dass wir manchmal Faktoren zusammenführen müssen. In diesem Fall weil . Aber ich sehe nicht gerade eine saubere und direkte Zusammenführungsstrategie. Zum Beispiel könnte man denken, wir müssen immer in die Potenzen verschmelzen , aber das ist nicht wahr:$7^1 > 2^2$$2$

m = 2 96 3 1 5 1 7 1 11 1 > 2 96 3 3 5 1 7

$$1552 = (96 + 1)(1 + 1)(1 + 1)(1 + 1)(1 + 1)$$ $$m = 2^{96} 3^1 5^1 7^1 11^1 > 2^{96} 3^3 5^1 7^1$$

Ich kann mir nicht sofort ein Beispiel vorstellen, aber mein Instinkt sagt, dass einige gierige Ansätze scheitern können, wenn sie zuerst die falschen Kräfte zusammenführen.

Gibt es eine einfache optimale Strategie, um diese Kräfte zusammenzuführen, um die richtige Antwort zu erhalten?

---

Nachtrag. Ein gieriger Algorithmus, der jede mögliche Zusammenführung überprüft und die beste auf Zusammenführungsbasis ausführt, schlägt bei fehl . Die Reihe der Einzelzusammenführungen lautet:$n = 3072$

$$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 11^1 13^1 17^1 19^1 23^1 29^1$$

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

Die optimale Lösung ist jedoch:

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

Hier ist eine Lösung, basierend auf meinen obigen Kommentaren. Ich mache keine Ansprüche, das ist optimal.

Die Idee ist, , das wir als "kleinste positive ganze Zahl mit genau Teilern und verschiedenen Primfaktoren" definieren. Wir machen die einfachen Beobachtungen:$T(n,m)$$n$$m$

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

Und wir haben auch die Wiederholung:

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

Schließlich ist die Menge

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

Zu diesem Zweck finden Sie hier einen Python-Code, der mit allen oben angegebenen Zahlen übereinstimmt. Beachten Sie, dass es mit den Logarithmen funktioniert, um die Zahlen kleiner zu halten: Die tatsächlich gesuchte Ganzzahl ist also 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))

Mögliche Kandidaten für "kleinste ganze Zahl mit n Teilern" sind die ganzen Zahlen der Form wobei a ≥ b ≥ c ... und (a + 1) (b + 1) (c + 1) ... = n.$2^a·3^b·5^c...$

Sie müssen also alle Möglichkeiten finden, um n als Produkt von ganzen Zahlen ≥ 2 in nicht aufsteigender Reihenfolge auszudrücken und die entsprechenden Kandidaten zu berechnen und zu überprüfen. Wenn zum Beispiel n = 16, 16 = 8 · 2 = 4 · 4 = 4 · 2 · 2 = 2 · 2 · 2 · 2 ist, sind die Möglichkeiten , , , , und das kleinste ist .$2^7·3$$2^3·3^3$$2^3·3·5$$2·3·5·7$$2^3·3·5 = 120$

Wenn n das Produkt zweier Primzahlen p · q, p ≥ q ist, sind die einzigen Kandidaten und , und letzterer ist immer kleiner .$2^{pq-1}$$2^{p-1}·3^{q-1}$

Sie können eine Bedingung herausfinden, wenn es einen Faktor , indem Sie beispielsweise prüfen, ob für einige prime x das ist kein faktor. Im Beispiel n = 16 gibt es einen Faktor weil .$2^{ab-1}$$2^{ab-1} > 2^{a-1}·x^{b-1}$$2^3$$2^3 < 2·7$