El primo de n dígitos más pequeño que contiene solo estos dígitos


26

Deberá generar el primo más pequeño con ndígitos, y solo contendrá los dígitos especificados en la lista k.

Ejemplos:

Entrada:

4
1 2

Para esto, debe generar el primo más pequeño con 4dígitos, y ese primo solo debe contener los dígitos 1y 2.

Salida:

2111

Entrada:

10
0 4 7 

Salida:

4000000007

Entrada:

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

Salida:

115151

Puede garantizar que la entrada siempre estará en el formato que especifique, y puede hacer cualquier cosa si obtiene una entrada no válida (como que la entrada sea de un solo dígito n, sin k).

Si no existe tal solución para una entrada, su programa puede hacer lo siguiente:

  • Impresión banana
  • Lanzar un error
  • Corre por siempre
  • Algo más

Como se trata de , intente apuntar al código más corto.

La entrada puede estar en cualquier formato que especifique. Por ejemplo, si desea que su entrada sea como cualquiera de los siguientes, está bien.

4
[1, 2]

[1,2]4

1,2
4

4 12

Puede escribir un programa o una función, y debe devolver el valor correcto o imprimirlo.

El espacio en blanco está permitido en cualquier lugar.

Este desafío inspirado en A036229 .


2
Pregunta obligatoria: ¿Podemos usar cualquier base? (El reto es mucho más fácil en unario.)
flawr

¿Puede la solución tener ceros a la izquierda si cero es uno de los dígitos de entrada?
Luis Mendo

@flawr, por supuesto que no, creo que puede entrar en lagunas estándar (si no, debe agregarse)
Okx

1
@LuisMendo, no lo consideraría como un número 'adecuado', así que no.
Okx

¿Puede la lista ser un conjunto literal? ¿Y los personajes en lugar de los enteros? (@ La respuesta de Python de xnor está usando esos)
mbomb007

Respuestas:


4

Brachylog (2), 8 bytes

j₍oᵐ∋ᵐcṗ

Pruébalo en línea!

Muy lento en problemas que tienen muchos dígitos posibles, o que contienen un 0 en el conjunto de dígitos posibles ( funciona en este caso; es solo que es mucho más lento que TIO agota el tiempo de espera a menos que el problema sea muy simple). Como es habitual en Brachylog, esta es una función, no un programa completo.

La entrada se toma en el formato [ndigits,[list of digits]], por ejemplo [10,[[0,4,7]]].

Explicación

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 desde el punto de vista puramente declarativo, esto dice "encontrar un número primo, con el número dado de dígitos, donde todos los dígitos son uno de los dígitos dados". Para encontrar el número más pequeño , utilizamos sugerencias de orden de evaluación para asegurarnos de que el orden en el que probamos los números sea menor a mayor; en este caso, las decisiones cerca del comienzo de la lista son menos propensas a cambiar que las decisiones cerca del final (este es su orden natural, que es el mismo que el orden lexicográfico y, por lo tanto, el número en los enteros), y por lo tanto {o∋}ᵐtiene dos órdenes de evaluación consejos "varían los últimos dígitos primeros" (del orden natural 's) como el indicio más importante, y 'los dígitos de verificación más pequeños antes de dígitos más grandes'(de la oantes de la, que actúa como una pista en este contexto) como el desempate. {o∋}ᵐse puede escribir como el equivalente oᵐ∋ᵐpara guardar un byte.


12

Paquete Bash + bsd-games, 28 bytes

  • 18 bytes guardados gracias a @Dennis.
primes 1|egrep -wm1 [$2]{$1}

Entrada dada en la línea de comando como n seguido de k como una lista no delimitada de dígitos.

Pruébalo en línea.


9

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)

Pruébalo en línea!

Toma entrada como f(3,{'9','3','8'}).

Python no tiene funciones integradas para los números primos, por lo que la función los genera utilizando el Teorema de Wilson para verificar a su vez que cada valor potencial ksea ​​primo.

La desigualdad encadenada 10**~-n<p%k*k<s>=set(`k`)combina tres condiciones en k:

  • 10**~-n<k: kcontiene al menos ndígitos. No necesitamos verificar exactamente ya que si alcanzamos más dígitos, no debe haber solución
  • p%k>0: kes primo, a través de la condición del teorema de Wilson con p=(n-1)!^2. Como p%kes 0 o 1, esto se puede combinar con la condición anterior como10**~-n<p%k*k
  • s>=set(`k`): Todos los dígitos kestán en el conjunto s. Esto se puede empalmar porque Python 2 considera los conjuntos como más grandes que los números.

Si la corriente kno satisface todo esto, la función se repite k+1y agrega 1 a la salida resultante. Como la salida termina con lo Trueque es igual 1, y kcomienza en 1, la salida es k. Este seguimiento paralelo de klatidos que salen kdirectamente en caso de éxito.


¡Guau, increíble uso del teorema de Wilson!
Chandler Watson

5

JavaScript (ES7), 100 bytes

Toma la entrada como número de dígitos ny cadena de dígitos permitidos sen la sintaxis de curry (n)(s). Devuelve undefinedsi no se encuentra una solución.

Funciona bastante rápido para hasta 6 dígitos, podría funcionar para 7 y definitivamente demasiado lento, y con mucha memoria, más allá de eso.

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

Prueba


Exactamente lo que hubiera hecho, excepto quizás con una prueba de primalidad diferente.
Veré

@ETHproductions Comencé con una prueba de primitiva recursiva pero la habría limitado a 4 dígitos (¿o quizás un poco más en algunos navegadores?)
Arnauld

Mi primer pensamiento para una solución recursiva es cuatro bytes más corto, pero arroja un error para números grandes. Tenían=>s=>[...Array(10**n).keys()].find(i=>eval(`/[${s}]{${n}}/`).test(i)&(p=j=>i%--j?p(j):j==1)(i))
ETHproductions

@ETHproductions Yo también tuve la tentación de usar & en lugar de &&. Pero en cuanto al rendimiento, este es un byte muy costoso.
Arnauld

La versión actual de Chrome admite TCO si habilita el indicador "enable-javascript-harmony" (solo vaya a chrome: // flags y encuentre esa opción)
ETHproductions

4

Jalea , 12 bytes

DL×ÆP
ṗḌÇÐṀṂ

Toma un conjunto y un entero como argumentos de línea de comandos. Imprime 0 si no existe una solución.

Pruébalo en línea!

Cómo funciona

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

3

Pyke, 18 16 bytes

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

Pruébalo aquí!

Se ejecuta para siempre si no se encuentran valores


@Okx ahora debería ser lo suficientemente rápido como para ejecutar la mayoría, si no todos, los casos de prueba ahora
Azul

@ Ok, ¿sabes que puedes descargar Pyke y ejecutarlo sin conexión si quieres probarlo completamente sin límite de tiempo?
Azul

Oh, lo siento. Pensé que era el código. Resulta que el tiempo de espera es de aproximadamente cuatro segundos, lo que no es mucho.
Okx

3

Mathematica, 64 bytes

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

Función pura donde el primer argumento es la lista (ordenada) de dígitos permitidos y el segundo argumento es la longitud permitida. Tuples@##calcula todas las listas de los dígitos permitidos de la longitud permitida, luego encontramos los FirstCaseque coinciden de manera x:{f_,___}tal que el primer dígito fno lo es 0y el entero y=FromDigits@xes primo y lo reemplaza por y.


2
Es genial cómo usa la /;prueba para seleccionar una tupla pero también la :>convierte al formato de salida deseado. (¡Veo en la documentación que está permitido, pero solo después de leer esta respuesta!) Debe especificar que su función requiere que se ordenen los dígitos permitidos: da la respuesta incorrecta en 3331lugar de 3313si se llama con [{3,1},4].
Greg Martin

@ngenisis ¿qué tal Select[FromDigits/@Tuples[Sort@#,#2],PrimeQ][[1]]&@@#&?
Martin

@martin Eso no tiene en cuenta las tuplas que comienzan 0y @@#&parece redundante.
ngenisis

@ngenisis lo siento - no lo tomé en cuenta
martin

3

Brachylog , 15 bytes

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

Pruébalo en línea!

Esto es bastante lento.

Explicación

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
              ∧

2

JavaScript (ES6), 86 bytes

Toma información a través de la sintaxis de curry, por ejemplo, (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>

Para ejecutarse en modo estricto (para la optimización de llamada de cola [TCO] ). Si su entorno no admite TCO, se producirá un error de desbordamiento de la pila para primos más grandes que la pila de entornos.

Para entradas no válidas se ejecutará para siempre.

Nota:

  • Los usuarios de Chrome (> = 51) pueden acceder chrome://flags/#enable-javascript-harmonyy habilitar este indicador para ejecutar el fragmento anterior con soporte de TCO.
  • Safari (> = 10) admite TCO

Creo que puede guardar dos bytes conF=i=>(P=j=>i%--j?P(j):1==j)(i)&&...
ETHproductions

@ETHproductions no puede porque tiene que ejecutarse en modo estricto (para evitar el desbordamiento de la pila) y eso crea una variable global P.
George Reith

Oh, no me di cuenta de que el TCO solo se aplicaba en modo estricto.
ETHproductions

@ETHproductions Sí, tampoco lo hice hasta que leí la especificación que publiqué XD. Mi primera variación de la respuesta usó ese acceso directo hasta que me di cuenta de que no era válida.
George Reith

2

MATL, 17 bytes

wlwX"1GXNUStZp)l)

Esta función acepta dos entradas, un número entero que especifica el número de dígitos y una matriz de caracteres que indica los posibles valores. En el caso de no primos, se muestra un error.

Pruébalo en línea!

Explicación

        % 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


2

Sabio, 62 bytes

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

Toma entrada del formulario: f( 4 , {'1','2'} )


1

Perl 6 , 43 bytes

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

Se ejecuta para siempre si no existe una solución.


¿Cuál es el formato de entrada?
Okx

1
@Okx: es una lambda que toma dos argumentos: un número n y una lista k.
sonríe

1

05AB1E , 17 bytes

[¾Øмg¹QiS²Kg0Qiq

Pruébalo en línea!

[¾Ø ¼             # 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

1

05AB1E , 22 19 18 bytes (-1 @Riley)

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

Pruébalo en línea!

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

1
No creo que necesites el ,al final.
Riley

@Riley buena llamada!
Magic Octopus Urn

0

Perl5, 77 bytes

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

Corre así:

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

0

Ruby, 77 76 bytes

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

Formato de entrada: un número y una cadena.

Ejemplo:

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

0

Perl 6 , 68 bytes

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

Intentalo

Devoluciones Nil si no se puede encontrar tal primo.

Expandido:

->
  \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
    )
}

0

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

Pruébalo en línea

La entrada es como 4,{'1','2'}.


1,{'1'}no es una entrada válida (porque 1 no es primo), por lo que puede hacer lo que quiera allí.

Correcto. Gracias.
mbomb007

0

PHP, 82 bytes

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

Toma un número y una cadena de dígitos de los argumentos de la línea de comandos. Corre con -nr.

Descompostura

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

0

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 al admitir números superiores a 32 bits (cambiado inta long)

Formato de entrada: un entero (es decir 4) y una cadena (es decir"12" )

Explicación:

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
}

Código de prueba:

Pruébalo aquí
NOTA: El segundo caso de prueba está deshabilitado porque se repite durante mucho tiempo.

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

Salida:

2111
115151
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.