Dovrai generare il numero primo più piccolo con le ncifre e conterrà solo le cifre specificate nell'elenco k.

Esempi:

Ingresso:

4
1 2

Per questo, è necessario generare il primo più piccolo con le 4cifre e quel primo deve contenere solo le cifre 1e 2.

Produzione:

2111

Ingresso:

10
0 4 7 

Produzione:

4000000007

Ingresso:

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

Produzione:

115151

Puoi garantire che l'input sia sempre nel formato specificato e puoi fare qualsiasi cosa se ricevi un input non valido (ad esempio l'input è una singola cifra n, senza k.)

Se non esiste una soluzione simile a un input, al programma è consentito eseguire una delle seguenti operazioni:

• Stampare banana
• Genera un errore
• Corri per sempre
• Qualunque altra cosa

Dato che si tratta di code-golf , prova a puntare al codice più corto.

L'input può essere in qualsiasi formato specificato. Ad esempio, se vuoi che il tuo input sia simile a uno dei seguenti, va bene.

4
[1, 2]

[1,2]4

1,2
4

4 12

È possibile scrivere un programma o una funzione e deve restituire il valore corretto o stamparlo.

Gli spazi bianchi sono ammessi ovunque.

^{Questa sfida ispirata ad A036229 .}

Brachylog (2), 8 byte

j₍oᵐ∋ᵐcṗ

Provalo online!

Problemi molto lenti con molte cifre possibili o che contengono uno 0 nell'insieme di cifre possibili ( funziona in questo caso; è solo che è molto più lento che TIO scade a meno che il problema non sia molto semplice). Come al solito per Brachylog, questa è una funzione, non un programma completo.

L'immissione viene eseguita nel formato [ndigits,[list of digits]], ad es [10,[[0,4,7]]].

Spiegazione

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

Visto dal punto di vista puramente dichiarativo, questo dice "trova un numero primo, con il dato numero di cifre, dove tutte le cifre sono una delle cifre indicate". Al fine di trovare il numero più piccolo di questo tipo, utilizziamo i suggerimenti dell'ordine di valutazione al fine di garantire che l'ordine in cui testiamo i numeri sia dal più piccolo al più grande; in questo caso, ᵐrende le decisioni vicino all'inizio dell'elenco meno soggette a modifiche rispetto alle decisioni verso la fine (questo è il suo ordine naturale, che sembra essere lo stesso di quello lessicografico e quindi dell'ordine numerico sugli interi), e quindi {o∋}ᵐha due ordini di valutazione suggerimenti, "varia prima le ultime cifre" ( ᵐdall'ordine naturale) come suggerimento più importante e "controlla le cifre più piccole prima delle cifre più grandi" (dalla oprima∋, che funge da suggerimento in questo contesto) come tiebreak. {o∋}ᵐpuò essere scritto come equivalente oᵐ∋ᵐper salvare un byte.

Pacchetto Bash + bsd-games, 28 byte

• 18 byte salvati grazie a @Dennis.

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

Immissione dato alla riga di comando come n seguito da k come elenco di cifre non delimitato.

Provalo online.

Python 2 , 66 byte

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)

Provalo online!

Accetta input come f(3,{'9','3','8'}).

Python non ha built-in per i numeri primi, quindi la funzione li genera usando il Teorema di Wilson per verificare che ogni valore potenziale ka sua volta sia primo.

La disuguaglianza incatenata 10**~-n<p%k*k<s>=set(`k`)combina tre condizioni su k:

• 10**~-n<k: kcontiene almeno ncifre. Non abbiamo bisogno di controllare esattamente dal momento che se raggiungiamo più cifre, non deve esserci stata soluzione
• p%k>0: kè eccellente, tramite la condizione del Teorema di Wilson con p=(n-1)!^2. Poiché p%kè 0 o 1, questo può essere combinato con la condizione precedente come10**~-n<p%k*k
• s>=set(`k`): Tutte le cifre ksono nel set s. Questo può essere combinato perché Python 2 considera i set più grandi dei numeri.

Se la corrente knon soddisfa tutti questi, la funzione ricorre su k+1, aggiungendo 1 all'output risultante. Poiché l'output termina con il Truequale equivale 1e kinizia a 1, l'output è k. Questo tracciamento parallelo dei kbattiti genera kdirettamente il successo.

JavaScript (ES7), 100 byte

Accetta input come numero di cifre ne stringa di cifre consentite snella sintassi del curry (n)(s). Restituisce undefinedse non viene trovata alcuna soluzione.

Funziona piuttosto rapidamente per un massimo di 6 cifre, potrebbe funzionare per 7 e sicuramente troppo lento - e memoria affamata - oltre a ciò.

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

Test

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

Gelatina , 12 byte

DL×ÆP
ṗḌÇÐṀṂ

Accetta un set e un numero intero come argomenti della riga di comando. Stampa 0 se non esiste una soluzione.

Provalo online!

Come funziona

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

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

Provalo qui!

Funziona per sempre se non viene trovato alcun valore

Mathematica, 64 byte

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

Funzione pura in cui il primo argomento è l'elenco (ordinato) di cifre consentite e il secondo argomento è la lunghezza consentita. Tuples@##calcola tutti gli elenchi delle cifre consentite della lunghezza consentita, quindi troviamo FirstCasequale corrisponde in modo x:{f_,___}tale che la prima cifra fnon sia 0e il numero intero y=FromDigits@xsia primo e lo sostituisce con y.

Brachylog , 15 byte

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

Provalo online!

Questo è abbastanza lento.

Spiegazione

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

Riceve input tramite la sintassi del curry, ad es. (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>

Da eseguire in modalità rigorosa (per l' ottimizzazione delle chiamate di coda [TCO] ). Se il tuo ambiente non supporta il TCO, si verificherà un errore di overflow dello stack per numeri primi più grandi dello stack degli ambienti.

Per input non validi funzionerà per sempre.

Nota:

• Gli utenti di Chrome (> = 51) possono andare chrome://flags/#enable-javascript-harmonye abilitare questo flag per eseguire lo snippet sopra con supporto TCO.
• Safari (> = 10) supporta il TCO

MATL, 17 byte

wlwX"1GXNUStZp)l)

Questa funzione accetta due input, un numero intero che specifica il numero di cifre e una matrice di caratteri che indica i possibili valori. Nel caso di nessun numero primo, viene visualizzato un errore.

Provalo online!

Spiegazione

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

f&P_T!-Tz^Tt

Test Suite .

Sage, 62 byte

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

Accetta il modulo: f( 4 , {'1','2'} )

Perl 6 , 43 byte

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

Funziona per sempre se non esiste una soluzione.

05AB1E , 17 byte

[¾Øмg¹QiS²Kg0Qiq

Provalo 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

Provalo 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 byte

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

Esegui in questo modo:

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

Rubino, 77 76 byte

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

Formato di input: un numero e una stringa.

Esempio:

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

Perl 6 , 68 byte

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

Provalo

Restituisce Nilse non è possibile trovare tale numero primo.

Allargato:

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

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

Provalo online

L'input è come 4,{'1','2'}.

PHP, 82 byte

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

Prende un numero e una stringa di cifre dagli argomenti della riga di comando. Corri con -nr.

abbattersi

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 byte

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 byte supportando numeri superiori a 32 bit (modificato intin long)

Formato di input: un numero intero (ie 4) e una stringa (ie "12")

Spiegazione:

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
}

Codice di prova:

Provalo qui.
NOTA: il secondo caso di test è disabilitato perché si avvia per un tempo molto lungo.

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

Produzione:

2111
115151