Gần đây đã có rất nhiều thách thức liên quan đến yếu tố chính / nguyên tố, vì vậy tôi nghĩ có thể sẽ rất thú vị khi đi theo con đường khác.

Được:

• một số nguyên dương nvà
• một danh sách không trống của các số nguyên dương f

viết một chương trình đầy đủ hoặc một hàm để tìm số nguyên nhỏ nhất isao cho i >= nvà ilà một sản phẩm của các số nguyên không lũy ​​thừa, các số nguyên của các phần tử trong f.

Ví dụ:

• Giả sử n = 11, f = [2, 3, 5].

  Một vài sản phẩm đầu tiên là:

  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
  

• Giả sử n=14, f=[9, 10, 7].

  Một lần nữa, một vài sản phẩm đầu tiê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
  

Các trường hợp thử nghiệm:

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

Quy tắc

• Bạn có thể cho rằng fsẽ chứa ít nhất một phần tử và tất cả các phần tử của fsẽ lớn hơn 1.
• Bạn có thể tùy ý cho rằng fđược sắp xếp theo thứ tự giảm / tăng nếu bạn muốn (nhưng vui lòng ghi rõ).
• Bạn có thể tùy ý lấy số lượng phần tử fnếu bạn muốn.
• Đầu ra dưới dạng một chuỗi được cho phép.
• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất tính bằng byte trong mỗi ngôn ngữ sẽ thắng!
• Quy tắc I / O mặc định được áp dụng và các lỗ hổng tiêu chuẩn bị cấm.
• Giải thích được khuyến khích.

Husk , 8 byte

ḟṠ€ȯmΠṖṘ

Vô cùng chậm chạp. Hãy thử trực tuyến!

Giải trình

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

Ngôn ngữ Wolfram (Mathicala) , 68 65 62 61 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Lấy đầu vào là [n,k,f1,f2,f3,...,fk](ví dụ [11,3,2,3,5]:): giá trị đầu tiên là mục tiêu n, thứ hai là số lượng các yếu tố và tất cả các hệ số theo sau.

Các thách thức lý thuyết số khác gần đây đều được xếp thành các phần dựng sẵn ưa thích (ít nhất là chúng đã sử dụng FactorInteger), vì vậy tôi nghĩ rằng tôi đã thử một cái gì đó chỉ sử dụng các công cụ cơ bản. Về cơ bản, giải pháp này nói rằng để viết nnhư một sản phẩm của các yếu tố, chúng ta sử dụng yếu tố đầu tiên f1(và tái diễn n/f1, sau đó nhân với f1) hoặc không (và lặp lại trong danh sách các yếu tố ngắn hơn), sau đó lấy phút.

Đệ quy chạm đáy khi mục tiêu nhỏ hơn 1 hoặc khi số lượng các yếu tố là 0, chúng tôi kiểm tra cùng #^#2<=1một lúc, sau đó tạo 1 trong trường hợp đầu tiên và Infinitytrong trường hợp sau với 1~Max~-Log@#2.

Hàm này đưa ra một loạt các cảnh báo (nhưng vẫn hoạt động) trừ khi bạn chạy nó Quiet, bởi vì cuối cùng nó sẽ tái diễn trong các trường hợp #3không tồn tại, làm cho nhánh thứ hai không được sử dụng Ifbuồn.

-3 byte: lấy số lượng các yếu tố làm đầu vào.

-3 byte nhờ @ngenisis: bằng cách sử dụng ∞.

-1 byte và không có ∞sự mơ hồ: #^#2kiểm tra.

Python 2 , 91 88 84 byte

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)

Hãy thử trực tuyến!

Hàm fkiểm tra đệ quy nếu nlà sản phẩm có quyền hạn của các phần tử trong l, gchỉ là một trình bao bọc để điều khiển phép lặp

Python, 55 byte

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

Hãy thử trực tuyến!

Không biết sao chép kịch bản chân trang của Rod để thử nghiệm

Thạch , 13 byte

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

Một liên kết dyadic lấy danh sách, fở bên trái và số n, ở bên phải mang lại một số.

Hãy thử trực tuyến! Golfily không hiệu quả - sẽ hết thời gian cho các đầu vào với mức cao hơnnvà / hoặc lâu hơnf.

Làm sao?

Chúng tôi biết rằng sức mạnh của các yếu tố cá nhân (hoàn toàn tích cực) sẽ không bao giờ cần vượt quá n-1
... vì vậy hãy kiểm tra tất cả các cách có thể!

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

Võng mạc , 76 byte

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

Hãy thử trực tuyến! Liên kết loại trừ các trường hợp thử nghiệm chậm nhất, nhưng nó vẫn hơi chậm, vì vậy hãy cố gắng không đập máy chủ của @ Dennis.

Pyth - 10 byte

Chạy ra khỏi bộ nhớ rất nhanh.

f}T*My*QTE

Dùng thử trực tuyến tại đây .

Câu trả lời hợp lý cho 16 byte: fsm.A}RQ*Md./PTE

Toán học, 85 byte

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

Đầu vào

[{danh sách f}, n, số phần tử của f]
[{57, 34, 12, 21}, 12532159, 4]

Japt , 10 byte

_k e!øV}aU

Kiểm tra nó trực tuyến!

Không hoạt động trong trường hợp thử nghiệm cuối cùng do giới hạn lặp được thiết kế để giữ cho trình thông dịch không chạy mãi mãi (mặc dù không giúp được gì nhiều ở đây, vì nó đóng băng trình duyệt của tôi trong một giờ ...)

Giải trình

_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

Thạch , 9 byte

xŒPP€ḟḶ}Ṃ

Thời gian chạy và sử dụng bộ nhớ O (2 ^{n • length (f)} ) làm cho điều này trở thành một giải pháp lý thuyết.

Hãy thử trực tuyến!

Haskell , 46 byte

Đây là một cổng của câu trả lời Python tuyệt vời của KSab . Cảm ơn Laikoni vì sự giúp đỡ của họ trong việc gỡ lỗi và đánh golf câu trả lời này trong phòng chat PPCG Haskell, Of Monads and Men . Gợi ý chơi golf chào mừng! Hãy thử trực tuyến!

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

Toán học, 73 byte

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

Về cơ bản là một cổng của câu trả lời Python của Rod . Xác định hai toán tử nhị phân và . trả về nếu là một sản phẩm của các yếu tố và khác. cho số nguyên nhỏ nhất±·n±fTruenfFalsen·fi . Nếu ai đó có thể tìm ra cách để loại bỏ kiểm tra chia hết, tôi có thể tiết kiệm 10 byte bằng cách sử dụng mã hóa ISO 8859-1.

Giải trình

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 byte

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

Hãy thử trực tuyến!

Đã 3 tuần, vì vậy tôi nghĩ cuối cùng tôi cũng đã đăng giải pháp của riêng mình. Đây là một cách tiếp cận vũ phu.

Tuy nhiên, có một nội dung:

R , 5 byte

nextn

Hãy thử trực tuyến!

Từ các tài liệu R:

nextntrả về số nguyên nhỏ nhất, lớn hơn hoặc bằng n, có thể được lấy như một sản phẩm quyền hạn của các giá trị có trong factors. nextnđược dự định sẽ được sử dụng để tìm độ dài phù hợp cho zero-pad đối số fftđể biến đổi được tính toán nhanh chóng. Giá trị mặc định để factorsđảm bảo điều này.

Tuy nhiên, một số thử nghiệm đã tiết lộ một lỗi trong quá trình triển khai, như liên kết TIO ở trên cho thấy.

nextn(91,c(2,6))nên trả về 96, nhưng trả về 128 thay vào đó. Điều này rõ ràng chỉ xảy ra khi factorskhông phải là tất cả tương đối nguyên tố với nhau. Thật vậy, mã C bên dưới nó tiết lộ rằng nextntham lam cố gắng phân chia factorlần lượt cho đến khi 1đạt được:

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;
}

Điều này có thể được giải quyết bằng cách lấy đầu vào theo thứ tự giảm dần.

JavaScript (ES6), 53 50 byte

Đã lưu 3 byte nhờ @DanielIndie

Đưa đầu vào theo cú pháp currying (n)(a).

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

Các trường hợp thử nghiệm

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

Làm sao?

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