Vous devrez générer le plus petit nombre premier avec des nchiffres, et il ne contiendra que les chiffres spécifiés dans la liste k.

Exemples:

Contribution:

4
1 2

Pour cela, vous devez générer le plus petit nombre premier avec des 4chiffres, et ce nombre premier doit contenir uniquement les chiffres 1et 2.

Sortie:

2111

Contribution:

10
0 4 7 

Sortie:

4000000007

Contribution:

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

Sortie:

115151

Vous pouvez garantir que l'entrée sera toujours dans le format que vous spécifiez, et vous pouvez faire n'importe quoi si vous obtenez une entrée non valide (telle que l'entrée étant un seul chiffre n, sans k.)

Si une telle solution à une entrée n'existe pas, votre programme est autorisé à effectuer l'une des opérations suivantes:

• Impression banana
• Lancer une erreur
• Courez pour toujours
• Rien d'autre

Puisqu'il s'agit de code-golf , essayez de viser le code le plus court.

L'entrée peut être dans n'importe quel format que vous spécifiez. Par exemple, si vous souhaitez que votre entrée soit semblable à l'une des suivantes, c'est très bien.

4
[1, 2]

[1,2]4

1,2
4

4 12

Vous pouvez soit écrire un programme ou une fonction, et il doit soit retourner la valeur correcte, soit l'imprimer.

Les espaces sont autorisés partout.

^{Ce défi inspiré par A036229 .}

Brachylog (2), 8 octets

j₍oᵐ∋ᵐcṗ

Essayez-le en ligne!

Très lent sur les problèmes qui ont beaucoup de chiffres possibles, ou qui contiennent un 0 dans l'ensemble des chiffres possibles (cela fonctionne dans ce cas; c'est juste que c'est tellement plus lent que TIO expire à moins que le problème ne soit très simple). Comme d'habitude pour Brachylog, c'est une fonction, pas un programme complet.

L'entrée est prise dans le format [ndigits,[list of digits]], par exemple [10,[[0,4,7]]].

Explication

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

Vu du point de vue purement déclaratif, cela dit "trouver un nombre premier, avec le nombre de chiffres donné, où tous les chiffres sont l'un des chiffres donnés". Afin de trouver le plus petit nombre, nous utilisons des conseils d'ordre d'évaluation afin de garantir que l'ordre dans lequel nous testons les nombres est du plus petit au plus grand; dans ce cas, ᵐrend les décisions près du début de la liste moins sujettes à changement que les décisions près de la fin (c'est son ordre naturel, qui se trouve être le même que lexicographique et donc l'ordre numérique sur les entiers), et a donc {o∋}ᵐdeux ordres d'évaluation ", faites d'abord varier les derniers chiffres" (dans l' ᵐordre naturel de l ') comme indice le plus important, et "vérifiez les petits chiffres avant les plus gros" (d' oavant le∋, qui agit comme un indice dans ce contexte) comme bris d'égalité. {o∋}ᵐpeut être écrit comme équivalent oᵐ∋ᵐpour enregistrer un octet.

Paquet Bash + BSD-Games, 28 octets

• 18 octets enregistrés grâce à @Dennis.

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

Entrée donnée sur la ligne de commande sous la forme n suivie de k sous la forme d'une liste non délimitée de chiffres.

Essayez-le en ligne.

Python 2 , 66 octets

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)

Essayez-le en ligne!

Prend l'entrée comme f(3,{'9','3','8'}).

Python n'a pas intégré de nombres premiers, donc la fonction les génère en utilisant le théorème de Wilson pour vérifier chaque valeur potentielle kà son tour comme étant premier.

L'inégalité chaînée 10**~-n<p%k*k<s>=set(`k`)combine trois conditions sur k:

• 10**~-n<k: kcontient au moins des nchiffres. Nous n'avons pas besoin de vérifier exactement car si nous atteignons plus de chiffres, il ne doit pas y avoir de solution
• p%k>0: kest premier, via la condition du théorème de Wilson avec p=(n-1)!^2. Puisque p%kest 0 ou 1, cela peut être combiné avec la condition précédente comme10**~-n<p%k*k
• s>=set(`k`): Tous les chiffres ksont dans l'ensemble s. Cela peut être épissé car Python 2 considère les ensembles comme plus grands que les nombres.

Si le courant kne satisfait pas à tous ces critères, la fonction revient sur k+1, en ajoutant 1 à la sortie résultante. Puisque la sortie se termine avec Truece qui est égal à 1et kcommence à 1, la sortie est k. Ce suivi parallèle des ktemps sort kdirectement du succès.

JavaScript (ES7), 100 octets

Prend l'entrée comme nombre de chiffres net chaîne de chiffres autorisés sdans la syntaxe de curry (n)(s). Renvoie undefinedsi aucune solution n'est trouvée.

Fonctionne assez rapidement jusqu'à 6 chiffres, peut fonctionner pour 7 et certainement trop lent - et gourmand en mémoire - au-delà.

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

Tester

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

Gelée , 12 octets

DL×ÆP
ṗḌÇÐṀṂ

Prend un ensemble et un entier comme arguments de ligne de commande. Imprime 0 si aucune solution n'existe.

Essayez-le en ligne!

Comment ça marche

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

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

Essayez-le ici!

S'exécute pour toujours si aucune valeur n'a été trouvée

Mathematica, 64 octets

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

Fonction pure où le premier argument est la liste (triée) des chiffres autorisés et le deuxième argument est la longueur autorisée. Tuples@##calcule toutes les listes des chiffres autorisés de la longueur autorisée, puis nous trouvons celui FirstCasequi correspond de x:{f_,___}telle sorte que le premier chiffre fne l'est pas 0et que l'entier y=FromDigits@xest premier et le remplace par y.

Brachylog , 15 octets

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

Essayez-le en ligne!

C'est assez lent.

Explication

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 octets

Prend des entrées via la syntaxe de curry, par exemple, (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>

À exécuter en mode strict (pour l' optimisation des appels de queue [TCO] ). Si votre environnement ne prend pas en charge le TCO, il en résultera une erreur de dépassement de pile pour les nombres premiers supérieurs à la pile des environnements.

Pour les entrées non valides, il s'exécutera pour toujours.

Remarque:

• Les utilisateurs de Chrome (> = 51) peuvent accéder à chrome://flags/#enable-javascript-harmonyet activer cet indicateur pour exécuter l'extrait ci-dessus avec le support TCO.
• Safari (> = 10) prend en charge le TCO

MATL, 17 octets

wlwX"1GXNUStZp)l)

Cette fonction accepte deux entrées, un entier spécifiant le nombre de chiffres et un tableau de caractères indiquant les valeurs possibles. Dans le cas d'aucun nombre premier, une erreur est affichée.

Essayez-le en ligne!

Explication

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

f&P_T!-Tz^Tt

Suite de tests .

Sauge, 62 octets

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

Prend la saisie du formulaire: f( 4 , {'1','2'} )

Perl 6 , 43 octets

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

Fonctionne indéfiniment si aucune solution n'existe.

05AB1E , 17 octets

[¾Øмg¹QiS²Kg0Qiq

Essayez-le en ligne!

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

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

Essayez-le en ligne!

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

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

Courez comme ceci:

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

Rubis, 77 76 octets

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

Format d'entrée: un nombre et une chaîne.

Exemple:

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

Perl 6 , 68 octets

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

Essayez-le

Résultats Nil si aucun tel nombre premier ne peut être trouvé.

Étendu:

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

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

Essayez-le en ligne

L'entrée est comme 4,{'1','2'}.

PHP, 82 octets

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

Prend un nombre et une chaîne de chiffres à partir des arguments de la ligne de commande. Courez avec -nr.

panne

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 octets

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 octets en prenant en charge les nombres supérieurs à 32 bits (changé inten long)

Format d'entrée: un entier (ie 4) et une chaîne (ie "12")

Explication:

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
}

Code de test:

Essayez-le ici.
REMARQUE: le deuxième scénario de test est désactivé car il est en boucle pendant très longtemps.

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

Sortie:

2111
115151