您将需要生成带有n数字的最小素数，并且它仅包含list中指定的数字k。

例子：

输入：

4
1 2

为此，您必须生成带有4数字的最小素数，并且该素数必须仅包含数字1和2。

输出：

2111

输入：

10
0 4 7 

输出：

4000000007

输入：

6
5 5 5 5 5 5 5 5 5 5 1 5 5 5 5 5 5 5 5 5 5

输出：

115151

您可以保证输入将始终采用您指定的格式，并且如果输入无效（例如，输入为一位n，而没有k），则可以执行任何操作。

如果不存在此类输入解决方案，则允许您的程序执行以下任一操作：

• 打印 banana
• 抛出错误
• 永远跑
• 还要别的吗

由于这是代码高尔夫，请尝试以最短的代码为目标。

输入可以是您指定的任何格式。例如，如果您希望您的输入与以下任何一种一样，那就很好。

4
[1, 2]

[1,2]4

1,2
4

4 12

您可以编写程序或函数，并且必须返回正确的值或将其打印出来。

在任何地方都可以使用空格。

^{这一挑战受A036229的启发。}

Brachylog（2），8个字节

j₍oᵐ∋ᵐcṗ

在线尝试！

对于可能位数很多或在可能位数中包含0的问题，它的运行速度非常慢（在这种情况下确实有效 ;只是除非问题非常简单，否则TIO超时会非常慢）。与Brachylog一样，这是一个功能，而不是完整的程序。

输入为格式[ndigits,[list of digits]]，如[10,[[0,4,7]]]。

说明

j₍oᵐ∋ᵐcṗ
j₍        Make a number of copies of the second element equal to the first element
  oᵐ      Sort each (ᵐ) of those copies (evaluation order hint)
    ∋ᵐ    Take one element from each of those copies
      c   Concatenate those elements to form an integer (asserts no leading 0)
       ṗ  producing a prime number

从纯粹声明性的角度来看，这表示“找到具有给定数字位数的质数，其中所有数字都是给定数字之一”。为了找到最小的数字，我们使用评估顺序提示，以确保测试数字的顺序是最小到最大。在这种情况下，ᵐ使列表开头附近的决策比结尾附近的决策更不易更改（这是其自然顺序，它与词典顺序相同，因此与整数上的数字顺序相同），因此{o∋}ᵐ具有两个评估顺序提示，“先更改后几位数字”（从ᵐ的自然顺序开始）作为更重要的提示，并“先检查较小的数字，然后再检查较大的数字”（从o之前的数字开始∋，在此情况下作为提示）。{o∋}ᵐ可以写为等同oᵐ∋ᵐ于保存一个字节。

Bash + bsd-games包，28个字节

• @Dennis节省了18个字节。

primes 1|egrep -wm1 [$2]{$1}

在命令行中输入的输入为n，后跟k作为无限制的数字列表。

在线尝试。

Python 2，66字节

f=lambda n,s,k=1,p=1:10**~-n<p%k*k<s>=set(`k`)or-~f(n,s,k+1,p*k*k)

在线尝试！

接受类似的输入f(3,{'9','3','8'})。

Python没有内置的质数，因此该函数使用威尔逊定理生成它们k以依次检查每个潜在值是否为质数。

连锁不平等10**~-n<p%k*k<s>=set(`k`)结合了以下三个条件k：

• 10**~-n<k：k至少包含n数字。我们不需要精确检查，因为如果达到更多数字，肯定没有解决方案
• p%k>0：k是素数，通过的威尔逊定理条件p=(n-1)!^2。由于p%k是0或1，因此可以与之前的条件组合为10**~-n<p%k*k
• s>=set(`k`)：中的所有数字k都在集合中s。因为Python 2认为集合大于数字，所以可以进行拼接。

如果电流k不满足所有这些条件，则该函数将递归到k+1，将1加到结果输出。由于输出True从等于终止1，并k从开始于1，因此输出为k。k拍子的这种并行跟踪k直接在成功时输出。

JavaScript（ES7），100字节

以currying语法将输入作为数字位数n和允许的数字字符串。如果找不到解决方案，则返回。s(n)(s)undefined

最多可以快到6位数字，可能要快到7位数字，而且速度肯定太慢-并且占用大量内存-除此之外。

n=>s=>(a=[...Array(10**n).keys()]).find(i=>eval(`/[${s}]{${n}}/`).test(i)&&a.every(j=>j<2|j==i|i%j))

测试

let f =

n=>s=>(a=[...Array(10**n).keys()]).find(i=>eval(`/[${s}]{${n}}/`).test(i)&&a.every(j=>j<2|j==i|i%j))
                                        
console.log(f(5)("247")) // 22247

果冻，12字节

DL×ÆP
ṗḌÇÐṀṂ

将集合和整数作为命令行参数。如果不存在解决方案，则输出0。

在线尝试！

怎么运行的

ṗḌÇÐṀṂ  Main link. Left argument: A (digit set/array). Right argument: n (integer)

ṗ       Cartesian power; yield all arrays of length n that consist only of elements
        of the array A.
 Ḍ      Undecimal; convert all generated digit arrays to integers.
  ÇÐṀ   Keep only elements for which the helper link returns a maximal result.
     Ṃ  Take the minimum.


DL×ÆP   Helper link. Argument: k (integer)

D       Decimal; convert k into the array of its base 10 digits.
 L      Take the length.
   ÆP   Test if k is a prime number. Yields 1 or 0.
  ×     Multiply the length and the Boolean.

Pyke，18个16字节

j;~p#`ljqi`Q-!)h

在这里尝试！

如果找不到值，则永久运行

Mathematica，64个字节

FirstCase[Tuples@##,x:{f_,___}/;f>0&&PrimeQ[y=FromDigits@x]:>y]&

纯函数，其中第一个参数是允许的数字的（排序的）列表，第二个参数是允许的长度。Tuples@##计算允许长度的所有允许数字列表，然后找到与之FirstCase匹配x:{f_,___}的第一个数字f不是0且整数y=FromDigits@x为质数并将其替换为y。

Brachylog，15个字节

tL∧?h~lṗ.dẹp⊆L∧

在线尝试！

这相当慢。

说明

tL                Input = [H, L]
  ∧
   ?h~l .         The Output is a variable of length H
       ṗ.         The Output is a prime number
          ẹ       The Output's digits...
        .d        ...when removing duplicate digits...
           p      ...is a permutation...
            ⊆L    ...of an ordered subset of L
              ∧

JavaScript（ES6），86个字节

通过currying语法获取输入，例如， (4)('12')

n=>(d,F=(i,P=j=>i%--j?P(j):1==j)=>P(i)&&`${i}`.match(`^[${d}]{${n}}$`)?i:F(i+1))=>F(2)

'use strict';

const G=n=>(d,F=(i,P=j=>i%--j?P(j):1==j)=>P(i)&&`${i}`.match(`^[${d}]{${n}}$`)?i:F(i+1))=>F(2)

const submit = () => {
  console.clear();
  console.log(G(+n.value)(d.value));
}

button.onclick = submit;
submit();

<input id="n" type="number" min="1" value="4" />
<input id="d" type="text" value="12" />
<button id="button">Submit</button>

在严格模式下运行（用于尾部调用优化[TCO]）。如果您的环境不支持TCO，则对于大于环境堆栈的质数，将导致堆栈溢出错误。

对于无效输入，它将永远运行。

注意：

• Chrome（> = 51）用户可以转到chrome://flags/#enable-javascript-harmony并启用此标志，以在TCO支持下运行上述代码段。
• Safari（> = 10）支持TCO

MATL，17个字节

wlwX"1GXNUStZp)l)

该函数接受两个输入，一个整数指定位数，一个字符数组表示可能的值。在没有素数的情况下，将显示错误。

在线尝试！

说明

        % Implicitly grab two inputs. First as an integer (N), second as a string (OPTS)
w       % Reverse the order of the inputs
l       % Push the literal 1 to the stack
w       % Pull N back to the top of the stack
X"      % Repeat OPTS N times 
1G      % Explicitly grab N again
XN      % Get all N-character combinations of the repeated version of OPTS
U       % Convert each row from a string to a number
S       % Sort them in ascending order
tZp)    % Grab only those that are primes
l)      % Retrieve the first prime
        % Implicitly print the result

Pyth- 13 12字节

f&P_T!-Tz^Tt

测试套件。

贤者，62字节

lambda l,d:[p for p in primes(10^(l-1),10^l)if set(`p`)<=d][0]

接受以下形式的输入： f( 4 , {'1','2'} )

Perl 6、43字节

->\n,@k {first *.is-prime&/^@k**{n}$/,^∞}

如果不存在解决方案，则永远运行。

05AB1E，17个字节

[¾Øмg¹QiS²Kg0Qiq

在线尝试！

[¾Ø ¼             # Infinite loop over all primes
   Ð              # Push two extra copies on the stack
     g¹Qi         # If the length of this prime == the first input...
         S²K      # Push this prime without any of the digits in the second input
            g0Qi  # If the length of what remains is 0...
                q # quit
                  # implicitly print this prime

05AB1E，22 19 18字节（-1 @Riley）

[NØ©S¹Kg0Q®g²Q&i®q

在线尝试！

[                   # infinite loop.
 NØ©                # push nth prime.
    S¹Kg0Q          # see if, without banned digits, it's 0 length.
          ®g²Q&     # see if, it is originally also the length specified.
               i®q  # if true, print result and exit.

Perl5，77个字节

($n,$d)=@ARGV;/^[$d]{$n}$/&&("x"x$_)!~/^(..+?)\1+$/&&print&&die for 2..10**$n

像这样运行：

perl -le '($n,$d)=@ARGV;/^[$d]{$n}$/&&("x"x$_)!~/^(..+?)\1+$/&&print&&die for 2..10**$n' 4 12

Ruby，77 76字节

->n,l{(10**~-n..10**n).find{|n|(2...n).none?{|x|n%x<1}&&!n.to_s[/[^#{l}]/]}}

输入格式：数字和字符串。

例：

->n,l{...see above...} [6,"555555555515555555555"]
=> 115151

Perl 6、68个字节

->\n,\k{first {.is-prime&&/.**{n}/},+«[X~] 0,|(k.unique.sort xx n)}

试试吧

Nil如果找不到这样的素数，则返回。

展开：

->
  \n, # number of digits
  \k  # list of digits
{

  first

    {
        .is-prime
      &&
        / . ** {n} / # exactly ｢n｣ digits ( in case ｢k｣ has a 0 )
    },

    +«\          # turn the following into a list of numbers

    [X[~]]       # cross the following with &infix:<~>

    0,           # append a 0 in case ｢n｣ was 1
    |(           # slip this list in (flatten)

        k        # the input list of possible digits
        .unique  # only one of each to reduce the search space (optional)
        .sort    # sort it so that the cross meta op returns them sorted

      xx         # list repeat

        n        # ｢n｣ times
    )
}

Python 2 + primefac，91 85字节

import primefac as P
n,k=input()
p=10**~-n
while set(`p`)!=k:p=P.nextprime(p)
print p

在线尝试

输入就像4,{'1','2'}。

PHP，82字节

for($n=10**--$argv[1];$i-1||a&trim($n,$argv[2]);)for($i=++$n;--$i&&$n%$i;);echo$n;

从命令行参数中获取一个数字和一串数字。用运行-nr。

分解

for($n=10**--$argv[1];  // $n = smallest number with (argument1) digits
    $i-1||                  // loop while $n is not prime or
    a&trim($n,$argv[2]);    // $n without all digits from (argument2) is not empty
)
    for($i=++$n;--$i&&$n%$i;);  // $i=largest divisor of $n smaller than $n (1 for primes)
echo$n;                 // print

Java 7中，139个 141字节

long c(int a,String b){for(long n=2,i,x;;n++){for(x=n,i=2;i<x;x=x%i++<1?0:x);if(x>1&(n+"").length()==a&(n+"").matches("["+b+"]+"))return n;}}

通过支持32位以上的数字来+2字节（更改int为long）

输入格式：整数（即4）和字符串（即"12"）

说明：

long c(int a, String b){                  // Method with the two input parameters specified above
  for(long n = 2, i, x; ; n++){           // Loop from 2 going upwards
    for(x = n, i = 2; i < x; x = x % i++ < 1 ? 0 : x);  // Prime check for `n` 
    if (x > 1                             // if `n` is a prime (if `x` > 1 after the loop above it means `n` is a prime)
         & (n+"").length() == a           // AND if `n` has a length equal to the input integer
         & (n+"").matches("["+b+"]+")){   // AND if `n` only contains the specified digits of the input String (using a regex)
      return n;                           // Then we have our answer
    }
  }                                       // If no answer is available for the given input, it continues looping
}

测试代码：

在这里尝试。
注意：第二个测试用例被禁用，因为它循环了很长时间。

class M{
  static long c(int a,String b){for(long n=2,i,x;;n++){for(x=n,i=2;i<x;x=x%i++<1?0:x);if(x>1&(n+"").length()==a&(n+"").matches("["+b+"]+"))return n;}}

  public static void main(String[] a){
    System.out.println(c(4, "12"));
    //System.out.println(c(10, "047"));
    System.out.println(c(6, "555555555515555555555"));
  }
}

输出：

2111
115151