（随机启发/mathpro//q/339890）
（相关：1，2）

给定一个包含不同素数的输入列表（例如[2, 5, 7]）和一个整数n，输出所有严格小于所有n仅包含那些素数作为除数的正整数。对于输入[2, 5, 7]，n=15这意味着输出为[2, 4, 5, 7, 8, 10, 14]。

进一步的例子

[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]

规则和说明

• 输入列表保证为非空，但只能是单个元素
• 您可以假定输入列表已经以最方便的方式进行了预排序
• n 将始终大于输入列表中的最大元素
• 由于，例如，2**0 = 1您可以选择将其包括1在输出列表中
• 输入和输出可以通过任何方便的方法给出
• 您可以将结果打印到STDOUT或将其作为函数结果返回
• 完整的程序或功能都可以接受
• 如果适用，您可以假设输入/输出整数适合您语言的本机int范围
• 禁止出现标准漏洞
• 这是代码高尔夫球，因此所有常用的高尔夫规则都适用，并且最短的代码（以字节为单位）获胜

Stax，6 个字节

Ç─☼?▬µ

在staxlang.xyz上运行和调试它！

解压缩（7个字节）和说明：

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

05AB1E，6 个字节

<LʒfåP

将整数作为第一个输入，列表作为第二个。1在输出中包括可选项。

在线尝试或验证所有测试用例。

说明：

<       # 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)

@Grimy提供的两个6 字节替代方案：

GNfåP–

在线尝试。

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

这很慢（[2,5,7], 15测试用例已经超时），但是不像其他两种方法那样：

sиPÑʒ›

与上面的其他两个程序不同，它将列表作为第一个输入，将整数作为第二个输入。不过，它的确1在输出中包括了可选的。

在线尝试。

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字节

取输入作为(n)(primes)其中的素数是一组。通过修改设置输出。

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

在线尝试！

已评论

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个字节

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]

在线尝试！

-3个字节，感谢@xnor

该函数采用素数序列和整数n作为输入。输出是一个包含1的列表。

取消高尔夫：

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)

在线尝试！

Haskell，51个字节

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]

在线尝试！

Haskell，39个字节

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

在线尝试！

检查是否k是整除只有在素l通过查看的产品l带到了一个高功率整除k。

Python 2，65个字节

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

在线尝试！

检查是否k是整除只有在素l通过查看的产品l带到了一个高功率整除k。

如果l可以作为字符串列表使用，则eval("*".join(l)) 可以节省3个字节，reduce(int.__mul__,l)并且可以在缺少的Python 3中使用reduce。

Python 3，64字节

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

在线尝试！

一个函数以相反的顺序打印，并以错误终止。

如果将其n本身包含在列表中，则下面的递归解决方案将更短。我也尝试递归地计算的乘积l，但这要更长一些。

62个字节（不工作）

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

在线尝试！

盖亚 10字节

…@e⟪ḍ‡⁻!⟫⁇

在线尝试！

我以前从未使用‡过monad，它对堆栈操作很有帮助。

…		| 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个字节

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

在线尝试！

果冻，7个字节

ṖÆffƑ¥Ƈ

在线尝试！

一个以排他上限为左参数，以素数列表为右的二元​​链接。返回一个包含1以及仅由提供的质数组成的数字的列表。

备选方案7是 ṖÆfḟ¥Ðḟ

Python 2，98个字节

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

在线尝试！

Japt -f，11 8 字节

k
è@e!øV

尝试一下

Japt -f，7 个字节

©k e!øV

尝试一下

红宝石 -rprime，61字节

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

在线尝试！

视网膜0.8.2，64字节

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

在线尝试！列表包括较小的测试用例（10000由于所有长字符串而超时）。按顺序接受输入n f1 f2 f3...（因子不必为素数，但它们必须为互素数）。输出包括1。说明：

\d+
$*

转换为一元。

\G1
$.`,$`;

生成一个从0到的列表（n-1十进制和一进制）。

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

反复将一元除以任何可用因子。

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

输出将一进制数减少为的十进制数1。

Pyth，10个字节

f!-PThQtUe

在线尝试！

输入为 [[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个字节

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

在线尝试！

xnor的Haskell解决方案的端口。还输出1。

木炭，22 20字节

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

在线尝试！链接是详细版本的代码。对于较大的测试用例来说太慢了。说明：

 Φ                      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

以前更快的22字节答案：

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

在线尝试！链接是详细版本的代码。输出包括1。说明：

⊞υ¹

推1送到预定义的空列表。

Ｆυ

循环遍历列表，包括循环中推送到列表中的所有项目。

Ｆ×ιθ

将当前项目乘以每个素数，然后遍历产品。

Ｆ›‹κη№υκ

检查产品是否是新值。

⊞υκ

如果是这样，则将其推送到列表。

Ｉυ

打印列表。

C（clang），115个字节

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

在线尝试！

一种基于Eratosthenes的解决方案。

（在输出中包括1）

感谢@ceilingcat的建议：printf（x [i] +“ \ 0％d”，i ++）而不是x [i] && printf（“％d”，i），i ++我想它会移动文字的指针，但没有找不到任何文档，如果有人可以给我一些见解，那将是受欢迎的。