Sie müssen die kleinste Primzahl mit nZiffern generieren. Sie enthält nur die in der Liste angegebenen Ziffern k.

Beispiele:

Eingang:

4
1 2

Dazu müssen Sie die kleinste Primzahl mit 4Ziffern erzeugen , und diese Primzahl darf nur die Ziffern 1und enthalten 2.

Ausgabe:

2111

Eingang:

10
0 4 7 

Ausgabe:

4000000007

Eingang:

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

Ausgabe:

115151

Sie können garantieren, dass die Eingabe immer in dem von Ihnen angegebenen Format erfolgt, und Sie können alles tun, wenn Sie eine ungültige Eingabe erhalten (z. B. eine einstellige Eingabe nohne k.).

Wenn für eine Eingabe keine solche Lösung vorhanden ist, kann Ihr Programm eine der folgenden Aktionen ausführen:

• Drucken banana
• Wirf einen Fehler
• Laufen Sie für immer
• Noch etwas

Da es sich um Code-Golf , versuchen , für den kürzesten Code zu zielen.

Die Eingabe kann in jedem von Ihnen angegebenen Format erfolgen. Wenn Sie beispielsweise möchten, dass Ihre Eingabe wie folgt aussieht, ist dies in Ordnung.

4
[1, 2]

[1,2]4

1,2
4

4 12

Sie können entweder ein Programm oder eine Funktion schreiben, und es muss entweder der richtige Wert zurückgegeben oder gedruckt werden.

Leerzeichen sind überall erlaubt.

^{Diese Herausforderung inspiriert von A036229 .}

Brachylog (2), 8 Bytes

j₍oᵐ∋ᵐcṗ

Probieren Sie es online!

Sehr langsam bei Problemen mit vielen möglichen Ziffern oder mit einer 0 in der Menge der möglichen Ziffern (dies funktioniert in diesem Fall; es ist nur so viel langsamer, dass TIO das Zeitlimit überschreitet, es sei denn, das Problem ist sehr einfach). Wie bei Brachylog üblich, ist dies eine Funktion, kein vollständiges Programm.

Die Eingabe erfolgt im Format [ndigits,[list of digits]], z [10,[[0,4,7]]].

Erläuterung

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

Aus rein deklarativer Sicht heißt das: "Finde eine Primzahl mit der angegebenen Anzahl von Ziffern, wobei alle Ziffern eine der angegebenen Ziffern sind". Um die kleinste solche Zahl zu finden , verwenden wir Hinweise zur Bewertungsreihenfolge, um sicherzustellen, dass die Reihenfolge, in der wir die Zahlen testen, klein bis groß ist. In diesem Fall sind ᵐEntscheidungen am Anfang der Liste weniger anfällig für Änderungen als Entscheidungen am Ende (dies ist die natürliche Reihenfolge, die zufällig der lexikografischen und damit der numerischen Reihenfolge von ganzen Zahlen entspricht) und haben daher {o∋}ᵐzwei Auswertungsreihenfolgen Hinweise: "Variieren Sie die letzten Ziffern zuerst" (aus der ᵐnatürlichen Reihenfolge) als wichtigeren Hinweis und "Überprüfen Sie die kleineren Ziffern vor den größeren Ziffern" (aus der Reihenfolge ovor der∋, was in diesem Zusammenhang als Hinweis dient) als Tiebreak. {o∋}ᵐkann als Äquivalent oᵐ∋ᵐzum Speichern eines Bytes geschrieben werden.

Bash + BSD-Spiele-Paket, 28 Bytes

• 18 Bytes dank @Dennis gespart.

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

Eingabe in der Befehlszeile als n, gefolgt von k als nicht begrenzte Ziffernliste.

Probieren Sie es online aus.

Python 2 , 66 Bytes

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)

Probieren Sie es online!

Nimmt Eingaben wie f(3,{'9','3','8'}).

In Python sind keine Primzahlen integriert, daher generiert die Funktion diese mithilfe von Wilsons Theorem , um jeden potenziellen Wert auf kPrimzahlen zu prüfen .

Die verkettete Ungleichung 10**~-n<p%k*k<s>=set(`k`)kombiniert drei Bedingungen auf k:

• 10**~-n<k: kenthält mindestens nZiffern. Wir müssen nicht genau prüfen, denn wenn wir mehr Ziffern erreichen, muss es keine Lösung gegeben haben
• p%k>0: kist prim, über die Wilsonsche Theorembedingung mit p=(n-1)!^2. Da p%k0 oder 1 ist, kann dies mit der vorherigen Bedingung als kombiniert werden10**~-n<p%k*k
• s>=set(`k`): Alle Ziffern in ksind im Satz s. Dies kann eingemischt werden, da Python 2 Mengen als größer als Zahlen betrachtet.

Wenn der Strom knicht alle diese Anforderungen erfüllt, kehrt die Funktion zu zurück k+1und addiert 1 zu der resultierenden Ausgabe. Da die Ausgabe mit " Truegleich" endet 1und bei " kbeginnt" beginnt 1, ist die Ausgabe "gleich" k. Diese parallele Verfolgung von kBeats wird kdirekt nach dem Erfolg ausgegeben .

JavaScript (ES7), 100 Byte

Übernimmt die Eingabe als Anzahl der Stellen nund Zeichenfolge der zulässigen Stellen sin der aktuellen Syntax (n)(s). Gibt zurück, undefinedwenn keine Lösung gefunden wurde.

Funktioniert ziemlich schnell für bis zu 6 Stellen, arbeitet möglicherweise für 7 und ist definitiv zu langsam - und speicherhungrig - darüber hinaus.

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

Prüfung

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

Gelee , 12 Bytes

DL×ÆP
ṗḌÇÐṀṂ

Nimmt eine Menge und eine Ganzzahl als Befehlszeilenargumente. Gibt 0 aus, wenn keine Lösung vorhanden ist.

Probieren Sie es online!

Wie es funktioniert

ṗḌÇÐṀṂ  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 Bytes

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

Probieren Sie es hier aus!

Läuft für immer, wenn keine Werte gefunden werden

Mathematica, 64 Bytes

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

Reine Funktion, bei der das erste Argument die (sortierte) Liste der zulässigen Ziffern und das zweite Argument die zulässige Länge ist. Tuples@##berechnet alle Listen der erlaubten Ziffern der erlaubten Länge, dann finden wir FirstCasedie Übereinstimmungen x:{f_,___}so, dass die erste Ziffer fnicht 0und die ganze Zahl y=FromDigits@xeine Primzahl ist und ersetzen sie durch y.

Brachylog , 15 Bytes

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

Probieren Sie es online!

Das ist ziemlich langsam.

Erläuterung

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 Byte

Übernimmt Eingaben über die Currying-Syntax, zB (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>

Wird im strikten Modus ausgeführt (zur Tail-Call-Optimierung [TCO] ). Wenn Ihre Umgebung keine TCO unterstützt, führt dies bei Primzahlen, die größer als der Umgebungsstapel sind, zu einem Stapelüberlauf.

Für ungültige Eingaben wird es für immer ausgeführt.

Hinweis:

• Chrome-Benutzer (> = 51) können chrome://flags/#enable-javascript-harmonydieses Flag aufrufen und aktivieren, um das obige Snippet mit TCO-Unterstützung auszuführen.
• Safari (> = 10) unterstützt TCO

MATL, 17 Bytes

wlwX"1GXNUStZp)l)

Diese Funktion akzeptiert zwei Eingaben, eine Ganzzahl, die die Anzahl der Stellen angibt, und ein Zeichenarray, das die möglichen Werte angibt. Wenn keine Primzahlen vorhanden sind, wird ein Fehler angezeigt.

Probieren Sie es online!

Erläuterung

        % 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 Bytes

f&P_T!-Tz^Tt

Test Suite .

Salbei, 62 Bytes

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

Übernimmt die Eingabe des Formulars: f( 4 , {'1','2'} )

Perl 6 , 43 Bytes

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

Läuft für immer, wenn keine Lösung vorhanden ist.

05AB1E , 17 Bytes

[¾Øмg¹QiS²Kg0Qiq

Probieren Sie es online!

[¾Ø ¼             # 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 Byte (-1 @Riley)

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

Probieren Sie es online!

[                   # 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 Bytes

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

Laufen Sie wie folgt:

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

Ruby, 77 76 Bytes

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

Eingabeformat: eine Zahl und eine Zeichenfolge.

Beispiel:

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

Perl 6 , 68 Bytes

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

Versuch es

Gibt zurück, Nilwenn keine solche Primzahl gefunden werden kann.

Erweitert:

->
  \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 Bytes

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

Probieren Sie es online aus

Eingabe ist wie 4,{'1','2'}.

PHP, 82 Bytes

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

Nimmt eine Zahl und eine Ziffernfolge aus Befehlszeilenargumenten. Laufen Sie mit -nr.

Nervenzusammenbruch

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 Bytes

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

+2 Bytes durch Unterstützung von Zahlen über 32-Bit (geändert intinlong )

Eingabeformat: Eine Ganzzahl (dh 4) und eine Zeichenfolge (dh)"12" )

Erläuterung:

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
}

Testcode:

Probieren Sie es hier aus.
HINWEIS: Der zweite Testfall ist deaktiviert, da er sehr lange wiederholt wird.

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

Ausgabe:

2111
115151