(Lấy cảm hứng ngẫu nhiên từ /mathpro//q/339890 )
(Liên quan: 1 , 2 )

Đưa ra một danh sách đầu vào gồm các số nguyên tố riêng biệt (ví dụ [2, 5, 7]:) và một số nguyên n, xuất ra tất cả các số nguyên dương nhỏ hơn nchỉ chứa các số nguyên tố đó như là ước số. Đối với đầu vào [2, 5, 7]và n=15điều này có nghĩa là một đầu ra của [2, 4, 5, 7, 8, 10, 14].

Ví dụ khác

[list] n | output

[2, 5, 7] 15 | [2, 4, 5, 7, 8, 10, 14]
[2, 5, 7] 14 | [2, 4, 5, 7, 8, 10]
[2] 3 | [2]
[2] 9 | [2, 4, 8]
[103, 101, 97] 10000 | [97, 101, 103, 9409, 9797, 9991]
[97, 101, 103] 104 | [97, 101, 103]

Quy tắc và làm rõ

• Danh sách đầu vào được đảm bảo không trống, nhưng có thể chỉ là một yếu tố duy nhất
• Bạn có thể giả sử danh sách đầu vào được sắp xếp trước theo bất kỳ cách nào thuận tiện nhất
• n sẽ luôn lớn hơn phần tử lớn nhất trong danh sách đầu vào
• Vì, ví dụ, 2**0 = 1bạn có thể tùy ý đưa 1vào danh sách đầu ra của mình
• Đầu vào và đầu ra có thể được cung cấp bởi bất kỳ phương pháp thuận tiện
• Bạn có thể in kết quả sang STDOUT hoặc trả lại dưới dạng kết quả hàm
• Một chương trình đầy đủ hoặc một chức năng được chấp nhận
• Nếu có thể, bạn có thể giả sử số nguyên đầu vào / đầu ra phù hợp với intphạm vi gốc của ngôn ngữ của bạn
• Sơ hở tiêu chuẩn bị cấm
• Đây là môn đánh gôn, vì vậy tất cả các quy tắc chơi gôn thông thường đều được áp dụng và mã ngắn nhất (tính bằng byte) sẽ thắng

Stax , 6 byte

Ç─☼?▬µ

Chạy và gỡ lỗi nó tại staxlang.xyz!

Giải nén (7 byte) và giải thích:

vf:Fn-!
vf         Filter range [1..n-1]:
  :F         Distinct prime factors
    n-       Remove all in provided list
      !      Is empty?

05AB1E , 6 byte

<LʒfåP

Lấy số nguyên làm đầu vào đầu tiên, liệt kê là thứ hai. Bao gồm các tùy chọn 1trong đầu ra.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

<       # Decrease the (implicit) input by 1
 L      # Create a list in the range [1,input-1]
  ʒ     # Filter it by:
   f    #  Get all prime factors of the current number (without duplicates)
    å   #  Check for each if its in the (implicit) input-list
     P  #  And check if this is truthy for all
        # (after the filter, the result is output implicitly)

Hai lựa chọn thay thế 6 byte được cung cấp bởi @Grimy :

GNfåP–

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

G       # Loop `N` in the range [1, (implicit) input):
 Nf     #  Get all prime factors of `N` (without duplicates)
   å    #  Check for each if its in the (implicit) input-list
    P   #  And check if this is truthy for all
     –  #  If it is, output the current `N` with trailing newline

Cách này rất chậm ( [2,5,7], 15trường hợp thử nghiệm đã hết thời gian), nhưng ít giống như hai cách tiếp cận khác:

sиPÑʒ›

Không giống như hai chương trình khác ở trên, nó lấy danh sách làm đầu vào đầu tiên và số nguyên làm thứ hai. Nó cũng bao gồm các tùy chọn 1trong đầu ra là tốt.

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

s       # Swap so the stack is now [list-input, integer-input]
 и      # Repeat the list (flattened) the integer amount of times
        #  i.e. [2,5] and 10 → [2,5,2,5,2,5,2,5,2,5,2,5,2,5,2,5,2,5,2,5]
  P     # Take the product of this list
        #  → 10000000000
   Ñ    # Get all divisors of this integer
        # (the bottleneck for larger integers in this approach)
        #  → [1,2,4,5,8,10,16,20,25,32,40,50,64,80,100,125,128,160,200,250,256,320,400,500,512,625,640,800,1000,1024,1250,1280,1600,2000,2500,2560,3125,3200,4000,5000,5120,6250,6400,8000,10000,12500,12800,15625,16000,20000,25000,25600,31250,32000,40000,50000,62500,64000,78125,80000,100000,125000,128000,156250,160000,200000,250000,312500,320000,390625,400000,500000,625000,640000,781250,800000,1000000,1250000,1562500,1600000,1953125,2000000,2500000,3125000,3200000,3906250,4000000,5000000,6250000,7812500,8000000,9765625,10000000,12500000,15625000,16000000,19531250,20000000,25000000,31250000,39062500,40000000,50000000,62500000,78125000,80000000,100000000,125000000,156250000,200000000,250000000,312500000,400000000,500000000,625000000,1000000000,1250000000,2000000000,2500000000,5000000000,10000000000]
    ʒ   # Filter these divisors:
     ›  #  And only keep those where the (implicit) input-integer is larger than the divisor
        #  → [1,2,4,5,8]
        # (after the filter, the result is output implicitly)

JavaScript (ES6),  64 ... 52  50 byte

Lấy đầu vào là (n)(primes)nơi số nguyên tố là một tập hợp. Đầu ra bằng cách sửa đổi tập hợp.

n=>g=(s,q=1)=>{for(p of s)(p*=q)<n&&g(s.add(p),p)}

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

Đã bình luận

n =>              // n = maximum value
g = (             // g is a recursive function taking:
  s,              //   s = set of primes
  q = 1           //   q = current product, initialized to 1
) => {            //
  for(p of s)     // for each value p in s:
    (p *= q)      //   multiply p by q
    < n &&        //   if the result is less than n:
      g(          //     do a recursive call:
        s.add(p), //       with p added to the set
        p         //       with q = p
      )           //     end of recursive call
}                 //

Python 3 , 68 65 byte

f=lambda s,n,c=1:n//c*s and f(s,n,s[0]*c)+f(s[1:],n,c)or[c][:c<n]

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

-3 byte nhờ @xnor

Hàm lấy một số nguyên tố và một số nguyên n làm đầu vào. Đầu ra là một danh sách bao gồm 1.

Ung dung:

def f(s, n, c=1):
    if not c < n:
       return []
    elif not s:
       return [c]
    else:
       return f(s,n,s[0]*c) + f(s[1:],n,c)

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

Haskell , 51 byte

xpmapM((<$>[0..n]).(^))p$1,x,x^2,\ldots,x^n$$n$product

np$(\#p)^n$

p#n=[k|k<-product<$>mapM((<$>[0..n]).(^))p,k<n,k>1]

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

Haskell , 39 byte

l%n=[k|k<-[2..n-1],mod(product l^k)k<1]

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

Kiểm tra nếu kchỉ chia hết cho các số nguyên tố lbằng cách xem liệu sản phẩm lđược đưa đến công suất cao có chia hết không k.

Python 2 , 65 byte

lambda l,n:[k for k in range(2,n)if reduce(int.__mul__,l)**n%k<1]

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

Kiểm tra nếu kchỉ chia hết cho các số nguyên tố lbằng cách xem liệu sản phẩm lđược đưa đến công suất cao có chia hết không k.

Nếu lcó thể được thực hiện như là một danh sách các chuỗi eval("*".join(l)) tiết kiệm 3 byte trên reduce(int.__mul__,l)và có thể được sử dụng trong Python 3 mà thiếu reduce.

Python 3 , 64 byte

def f(l,n,P=1):
 for x in l:P*=x
 n-=1;P**n%n or print(n);f(l,n)

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

Một chức năng in theo thứ tự ngược lại và chấm dứt với lỗi.

Giải pháp đệ quy dưới đây sẽ ngắn hơn nếu nbản thân nó được đưa vào danh sách. Tôi cũng đã thử tính toán đệ quy sản phẩm l, nhưng nó dài hơn.

62 byte (không hoạt động)

f=lambda l,n:n*[f]and[n][reduce(int.__mul__,l)**n%n:]+f(l,n-1)

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

Gaia , 10 byte

…@e⟪ḍ‡⁻!⟫⁇

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

Tôi chưa bao giờ sử dụng ‡với một đơn nguyên trước đây, nó khá hữu ích cho thao tác ngăn xếp.

…		| push [0..n-1]
@e		| push list of primes
  ⟪    ⟫⁇	| filter [0..n-1] for where the following predicate is true:
   ḍ‡		| the list of prime factors
     ⁻		| minus the list of primes
      !		| is empty

J , 24 byte

(]#~0=1#.(-."1~q:))2}.i.

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

Thạch , 7 byte

ṖÆffƑ¥Ƈ

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

Một liên kết dyadic lấy giới hạn trên độc quyền làm đối số bên trái của nó và danh sách các số nguyên tố làm bên phải của nó. Trả về một danh sách bao gồm 1 cũng như các số chỉ bao gồm các số nguyên tố được cung cấp.

Một thay thế 7 sẽ là ṖÆfḟ¥Ðḟ

Python 2 , 98 byte

lambda a,n:[i for i in R(2,n)if{p for p in R(2,i+1)if(i%p<1)*all(j%p for j in R(2,p))}<=a]
R=range

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

Japt -f , 11 8 byte

k
è@e!øV

Thử nó

Japt -f , 7 byte

©k e!øV

Thử nó

Ruby -rprime , 61 byte

->n,l{(2..n).select{|i|i.prime_division.all?{|b,|[b]-l==[]}}}

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

Võng mạc 0.8.2 , 64 byte

\d+
$*
\G1
$.`,$`;
+`,(1+)(\1)*(?=;.* \1\b)
,1$#2$*
!`\d+(?=,1;)

Hãy thử trực tuyến! Danh sách bao gồm các trường hợp thử nghiệm nhỏ hơn ( 10000hết thời gian vì tất cả các chuỗi dài). Đưa đầu vào theo thứ tự n f1 f2 f3...(các yếu tố không cần phải là số nguyên tố nhưng chúng cần phải có tính đồng thời). Đầu ra bao gồm 1. Giải trình:

\d+
$*

Chuyển đổi sang unary.

\G1
$.`,$`;

Tạo một danh sách từ 0 đến n-1, theo cả số thập phân và đơn nguyên.

+`,(1+)(\1)*(?=;.* \1\b)
,1$#2$*

Liên tục chia unary bởi bất kỳ yếu tố có sẵn.

!`\d+(?=,1;)

Xuất ra các số thập phân trong đó số unary đã được giảm xuống 1.

Bình thường , 10 byte

f!-PThQtUe

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

Đưa đầu vào là [[primes...], n]

        Ue  # range(0, Q[-1])  (Q is the input, implicit)
       t    #                [1:] -> range(1, Q[-1]), tUe == PSe
f           # filter that on the condition: lambda T:
   PT       # prime_divisors(T)
  -  hQ     #                   - Q[0]
 !          # logical negation (![] == True)

Perl 6 , 27 byte

{grep [*](@^a)**$^b%%*,^$b}

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

Cổng của giải pháp Haskell của xnor. Ngoài ra đầu ra 1.

Than , 22 20 byte

ＩΦ…²η⬤…·²ι∨﹪ιλ⊙θ¬﹪λν

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Quá chậm cho trường hợp thử nghiệm lớn hơn. Giải trình:

 Φ                      Filter on
  …                     Range from
   ²                    Literal `2` to
    η                   Input limit
     ⬤                  Where all values
      …·                Inclusive range from
        ²               Literal `2` to
         ι              Filter value
          ∨             Either
             λ          Inner value
           ﹪            Is not a divisor of
            ι           Filter value
              ⊙         Or any of
               θ        Input primes
                   ν    Current prime
                ¬﹪      Is a divisor of
                  λ     Inner value
Ｉ                       Cast to string for implicit print

Câu trả lời 22 byte nhanh hơn trước:

⊞υ¹ＦυＦ×ιθＦ›‹κη№υκ⊞υκＩυ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Đầu ra bao gồm 1. Giải trình:

⊞υ¹

Đẩy 1vào danh sách trống được xác định trước.

Ｆυ

Lặp lại danh sách, bao gồm bất kỳ mục nào được đẩy vào nó trong vòng lặp.

Ｆ×ιθ

Nhân các mục hiện tại với mỗi số nguyên tố và lặp trên các sản phẩm.

Ｆ›‹κη№υκ

Kiểm tra xem sản phẩm là một giá trị mới.

⊞υκ

Nếu vậy thì đẩy nó vào danh sách.

Ｉυ

In danh sách.

C (tiếng kêu) , 115 byte

#define f(n,l,z){int j,i,k,x[n]={};for(i=x[1]=1;i<n;printf(x[i]+"\0%d ",i++))for(j=z;j--;k<n?x[k]=x[i]:0)k=i*l[j];}

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

Một giải pháp dựa trên sàng của Eratosthenes.

(Bao gồm 1 trong đầu ra)

Nhờ đề xuất @ceilingcat: printf (x [i] + "\ 0% d", i ++) thay vì x [i] && printf ("% d", i), i ++ Tôi cho rằng nó thay đổi con trỏ của chữ nhưng không Không tìm thấy bất kỳ tài liệu nào, nếu bất cứ ai có thể cung cấp cho tôi một số thông tin chi tiết, nó sẽ được hoan nghênh.