Son zamanlarda başlıca / asal çarpanlarına ayırma ile ilgili birçok zorluk yaşandı, bu yüzden diğer tarafa gitmenin ilginç olabileceğini düşündüm.

Verilen:

• pozitif bir tam sayı nve
• boş olmayan pozitif tam sayı listesi f

en küçük tamsayıyı bulmak için tam bir program veya işlev yazın ve iöyle ki i >= nve iöğelerin negatif olmayan, tamsayı güçlerinin bir ürünüdür f.

Örnekler:

• Farz edin n = 11, f = [2, 3, 5].

  İlk birkaç ürün:

  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
  

• Farz edin n=14, f=[9, 10, 7].

  Yine, ilk birkaç ürün:

  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
  

Test senaryoları:

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

kurallar

• Bunun fen az bir öğe içereceğini ve tüm öğelerinin f1'den büyük olacağını varsayabilirsiniz .
• İsterseniz, fisterseniz azalan / artan sırada sıralandığını varsayabilirsiniz (ancak lütfen belirtin).
• İsterseniz öğesinin sayısını isteğe bağlı olarak alabilirsiniz f.
• Dizge olarak çıktıya izin verilir.
• Bu kod golf , her dilde bayt en kısa cevap kazanır!
• Varsayılan G / Ç kuralları geçerlidir ve standart boşluklar yasaktır.
• Açıklamalar teşvik edilir.

Kabuk , 8 bayt

ḟṠ€ȯmΠṖṘ

Son derece yavaş. Çevrimiçi deneyin!

açıklama

ḟṠ€ȯ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.

Wolfram Dili (Mathematica) , 68 65 62 61 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

Girdiyi [n,k,f1,f2,f3,...,fk](örneğin [11,3,2,3,5]) alır: ilk değer hedeftir n, ikincisi faktör sayısıdır ve tüm früktörler takip eder.

Diğer sayı teorisi zorlukları son zamanlarda süslü yerleşiklere katlanmıştı (en azından kullandılar FactorInteger), bu yüzden sadece temel araçları kullanan bir şeyi deneyeceğim diye düşündüm. Bu çözüm temel nolarak, faktörlerin bir ürünü olarak yazmak için ya ilk faktörü kullandığımızı f1(ve n/f1daha sonra çarpanı , sonra çarparak f1) ya da yapmadığımızı (ve daha kısa bir faktör listesine geri çekildiğimizi), sonra min.

Özyineleme, hedef 1'den az olduğunda veya bir #^#2<=1defada kontrol ettiğimiz faktör sayısı 0 olduğunda dibe vurur ve daha sonra ilk durumda ve Infinityikincisinde ile 1 üretiriz 1~Max~-Log@#2.

İşlev, siz çalıştırmadığınız sürece bir sürü uyarı verir (ancak yine de çalışır) Quiet, çünkü sonunda bulunmayan durumlara geri döner #3ve kullanılmayan ikinci dalı Ifüzer.

-3 bayt: faktör sayısını girdi olarak almak.

@Ngenisis sayesinde -3 bayt: kullanarak ∞.

-1 bayt ve ∞belirsizlik yok : #^#2kontrol.

Python 2 , 91 88 84 bayt

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)

Çevrimiçi deneyin!

Fonksiyonu fise kontrol yinelemeli nelemanların güçlerin bir ürünüdür l, gbir yineleme kontrol etmek için, sadece bir sarıcı

Python, 55 bayt

f=lambda n,l,x=1:min(f(n,l,x*e)for e in l)if x<n else x

Çevrimiçi deneyin!

Test için Utanmazca kopyalanan Rod'un altbilgi betiği

Jöle , 13 bayt

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

fSoldaki listeyi nve sağdaki sayıyı veren sayıyı alan ikili bağlantı .

Çevrimiçi deneyin! Golf verimsiz - daha yükseknve / veya daha uzungirişler için zaman aşımı olurf .

Nasıl?

Bireysel (kesinlikle pozitif) faktörlerin güçlerinin asla geçmemesi gerekeceğini biliyoruz n-1
... bu yüzden tüm olası yolları inceleyelim!

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

Retina , 76 bayt

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

Çevrimiçi deneyin! Link, en yavaş test senaryolarını hariç tutar, ancak yine de biraz yavaştır, bu nedenle @ Dennis'in sunucusunu çekiçlememeye çalışın.

Pyth - 10 bayt

Bellek çok çabuk bitiyor.

f}T*My*QTE

Burada çevrimiçi deneyin .

16 bayt için makul cevap: fsm.A}RQ*Md./PTE

Mathematica, 85 bayt

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

Giriş

[{liste f}, n, f öğesinin öğe sayısı]
[{57, 34, 12, 21}, 12532159, 4]

Japt , 10 bayt

_k e!øV}aU

Çevrimiçi test edin!

Tercümanın sonsuza kadar çalışmasını önlemek için tasarlanmış bir yineleme sınırı nedeniyle son test durumunda çalışmaz (tarayıcımı bir saat boyunca donduğu için burada çok yardımcı olmadı ...)

açıklama

_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

Jöle , 9 bayt

xŒPP€ḟḶ}Ṃ

O (2 ^{n • uzunluk (f)} ) çalışma zamanı ve bellek kullanımı bunu teorik bir çözüm haline getirir.

Çevrimiçi deneyin!

Haskell , 46 bayt

Bu, KSab'ın mükemmel Python cevabının bir limanıdır . Laikoni'ye PPCG Haskell sohbet odasında, Monads ve Men'deki hata ayıklama ve golf oynamadaki yardımları için teşekkürler . Golf önerileri hoş geldiniz! Çevrimiçi deneyin!

(#1)
(l#x)n|x<n=minimum[(l#(x*e))n|e<-l]|1>0=x

Mathematica, 73 bayt

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

Esasen Rod'un Python cevabının bir limanı . İki ikili operatör ±ve ·. n±fdöner Truehalinde nelemanlarının bir üründür fveFalse başka türlü . n·fen küçük tamsayıyı verir i. Birisi bölünebilirlik testini ortadan kaldırmanın bir yolunu bulabilirse, ISO 8859-1 kodlamasını kullanarak 10 bayt tasarruf edebilirim.

açıklama

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. *)

R , 52 bayt

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

Çevrimiçi deneyin!

3 hafta oldu, bu yüzden sonunda kendi çözümümü yayınlayacağımı düşündüm. Bu kaba kuvvet yaklaşımıdır.

Bununla birlikte, bir yerleşik var:

R , 5 bayt

nextn

Çevrimiçi deneyin!

R belgelerinden:

nextnniçerdiği değerlerin güçlerinin bir ürünü olarak elde edilebilen en büyük veya ona eşit en küçük tamsayıyı döndürür factors. nextn, fftdönüşümün hızlı bir şekilde hesaplanması için argümanını sıfırlamak üzere uygun bir uzunluk bulmak için kullanılır . İçin varsayılan değerfactors bunu sağlar.

Bununla birlikte, bazı testler, yukarıdaki TIO bağlantısının gösterdiği gibi uygulamada bir hata ortaya koydu.

nextn(91,c(2,6))96 döndürmelidir, bunun yerine 128 döndürür. Bu açıktır ki, sadece factorsbirbirleriyle göreceli olarak asal olmadığında ortaya çıkar . Gerçekten de, bunun altında yatan C kodu , nextnher birine factorsırayla bölünmeye çalıştıklarını ortaya çıkarır 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;
}

Bu, girdiler azalan sırada alınarak çözülebilir.

JavaScript (ES6), 53 50 bayt

@DanielIndie sayesinde 3 bayt kaydedildi

Körili sözdiziminde girdi alır (n)(a).

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

Test senaryoları

let f =

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

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

Nasıl?

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