Una de mis definiciones favoritas de los números primos es la siguiente:

• 2 es el primo más pequeño.

• Los números mayores que 2 son primos si no son divisibles por un primo más pequeño.

Sin embargo, esta definición parece arbitraria, ¿por qué 2? ¿Por qué no algún otro número? Bueno, intentemos con otros números que definirán n-primo de modo que

• n es el n-primo más pequeño.

• Los números mayores que n son n-primos si no son divisibles por un n-primo más pequeño.

Tarea

La tarea aquí es escribir un programa que tome dos entradas, un entero positivo n y un entero positivo a . Luego decidirá si a es n -prime. Su programa debería generar dos valores distintos, uno para "sí, es n-prime" y otro para "no, no es n-prime".

Esta es una pregunta de código de golf, por lo que las respuestas se puntuarán en bytes, siendo menos bytes mejores.

Pruebas

Aquí hay una lista de los primeros 31 primos para n = 2 a n = 12 (1 es el único número primo 1)

n=2: [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127]
n=3: [3,4,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127]
n=4: [4,5,6,7,9,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113]
n=5: [5,6,7,8,9,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113]
n=6: [6,7,8,9,10,11,13,15,17,19,23,25,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107]
n=7: [7,8,9,10,11,12,13,15,17,19,23,25,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107]
n=8: [8,9,10,11,12,13,14,15,17,19,21,23,25,29,31,35,37,41,43,47,49,53,59,61,67,71,73,79,83,89,97]
n=9: [9,10,11,12,13,14,15,16,17,19,21,23,25,29,31,35,37,41,43,47,49,53,59,61,67,71,73,79,83,89,97]
n=10: [10,11,12,13,14,15,16,17,18,19,21,23,25,27,29,31,35,37,41,43,47,49,53,59,61,67,71,73,79,83,89]
n=11: [11,12,13,14,15,16,17,18,19,20,21,23,25,27,29,31,35,37,41,43,47,49,53,59,61,67,71,73,79,83,89]
n=12: [12,13,14,15,16,17,18,19,20,21,22,23,25,27,29,31,33,35,37,41,43,47,49,53,55,59,61,67,71,73,77]

Haskell , 45 bytes

n!a=not$any(n!)[x|x<-[n..a-1],mod a x<1]||n>a

Pruébalo en línea!

Defino una buena función recursiva (!):

n!acomprueba si algún factor de a, en el rango [n,a-1], es un n-prime. Entonces niega el resultado. También se asegura de quen>a

Python 2 , 39 37 bytes

Gracias a Halvard Hummel por -2 bytes.

f=lambda n,i:n==i or i>i%n>0<f(n+1,i)

Pruébalo en línea!

Python 3 , 45 bytes

lambda i,k:(i>k)<all(k%r for r in range(i,k))

Pruébalo en línea!

Cómo funciona

Esto toma dos enteros como entrada, i y k . Primero verifica si k ≥ i . Luego genera el rango [i, k) y para cada número entero N en este rango, verifica si N es coprimo para k . Si se cumplen ambas condiciones, entonces k es un i -prime.

Casco , 6 5 bytes

εf≥⁰Ḋ

Pruébalo en línea! o ver resultados hasta 80 .

Gracias a Leo por -1 byte.

Explicación

εf≥⁰Ḋ  Inputs are n and k.
    Ḋ  Divisors of k.
 f     Keep those that are
  ≥⁰   at least n.
ε      Is the result a one-element list?

R , 44 37 bytes

function(a,n)a==n|a>n&all(a%%n:(a-1))

Pruébalo en línea!

-7 bytes gracias a Giuseppe

Devuelve TRUEsi

• aes igual noa==n| )
• aes mayor que n y ( a>n&) para cada número k desde nhasta a-1, ano es divisible por k (all(a%%n:(a-1)) )

Devoluciones de lo FALSEcontrario

J, 30 bytes

>:*(-{1=[:+/0=[:|/~]+i.@[)^:>:

Pruébalo en línea!

Toma el valor inicial como el argumento correcto y el valor para verificar en el argumento izquierdo.

Me equivoqué originalmente y no tomé en cuenta los argumentos de la izquierda menos que el primo inicial. Estoy algo descontento con la duración de mi solución ahora.

Explicación

Deje que xsea ​​el argumento izquierdo (el valor a verificar) y ysea ​​el argumento correcto (el primo inicial).

>:*(-{1=[:+/0=[:|/~]+i.@[)^:>:
                          ^:>:  Execute left argument if x >= y
                     i.@[         Create range [0..x]
                   ]+             Add y to it (range now: [y..x+y])
                |/~               Form table of residues
            0=                    Equate each element to 0
          +/                      Sum columns
      1=                          Equate to 1
    -{                            Take the element at position x-y
>:*                             Multiply by result of x >= y

Notas

El elemento en la posición x-yes el resultado de la prueba de primalidad para x(ya que agregamos yal rango original).

Multiplicar por x >: ygarantiza que obtengamos un valor de falsey ( 0) por xmenos de y.

JavaScript (ES6), 33 32 30 bytes

Toma entrada en la sintaxis de curry (n)(a). Devuelve un booleano.

n=>p=(a,k=a)=>k%--a?p(a,k):a<n

Manifestación

let f =

n=>p=(a,k=a)=>k%--a?p(a,k):a<n

for(n = 2; n <= 12; n++) {
  for(a = n, P = []; P.length < 31; a++) {
    f(n)(a) && P.push(a);
  }
  O.innerText += 'n=' + n + ': ' + P.join(',') + '\n';
}

<pre id=O></pre>

Haskell , 30 bytes

2 bytes guardados gracias a la idea de H.PWiz que fue tomada de la respuesta de flawr

n!a=[1]==[1|0<-mod a<$>[n..a]]

Pruébalo en línea!

Ok, ya que ha pasado un tiempo, y la única respuesta de Haskell hasta ahora es de 45 btyes, decidí publicar mi propia respuesta.

Explicación

Esta función comprueba que el único número entre n y a que a es divisible es a sí mismo.

Ahora la definición solo menciona n -primes más pequeños que a , entonces, ¿por qué estamos verificando todos estos números adicionales? ¿No tendremos problemas cuando a es divisible por algún compuesto n mayor que n ?

No lo haremos porque si hay un compuesto n mayor que n , debe ser divisible por un n -prime más pequeño por definición. Por lo tanto, si divide a, también debe hacerlo el n -prime más pequeño.

Si a es menor que n [n..a] , []entonces no puede ser igual, lo que [1]hace que la verificación falle.

Jalea , 8 bytes

rṖ⁴%$Ạ×<

Pruébalo en línea!

Pip , 23 19 14 bytes

b>=a&$&b%(a,b)

El método más corto es un puerto de la respuesta de Python del Sr. Xcoder . Toma el primo más pequeño y el número para probar como argumentos de línea de comandos. Pruébalo en línea!

C, 55 bytes

f(n,a,i){for(i=a;i-->n;)a%i||f(n,i)&&(i=0);return-1<i;}

Pruébalo en línea!

53 bytes si se permiten múltiples valores de retorno verdaderos:

f(n,a,i){for(i=a;i-->n;)a%i||f(n,i)&&(i=0);return~i;}

Pruébalo en línea!

dc , _{40 34} 37 bytes

[0p3Q]sf?se[dler%0=f1+dle>u]sudle>u1p

Hubiera incluido un enlace TIO, pero TIO parece estar llevando una distribución defectuosa de dcver cómo funciona esto según lo previsto en mi sistema, pero elQ comando funciona erróneamente en TIO. En cambio, aquí hay un enlace a un bashcampo de pruebas con una versión que funciona correctamente de dc:

Demo It!

APL (Dyalog) , 24 bytes

{⍵∊o/⍨1=+/¨0=o|⍨⊂o←⍺↓⍳⍵}

Pruébalo en línea!

¿Cómo?

⍳⍵ - 1aa

o←⍺↓- naa , guardar eno

o|⍨⊂o - módulo de cada elemento en o con cada elemento eno

0= - verifica donde es igual 0 (se divide)

+/¨ - suma el número de divisiones

1= - si solo tenemos uno, entonces el número solo se divide por sí mismo

o/⍨ - entonces mantenemos estas ocurrencias

⍵∊- está aen esa matriz residual?

JavaScript (Node.js) , 27 bytes

i=>f=n=>i==n||i>i%n&&f(n+1)

Pruébalo en línea!

El puerto de mi respuesta de Python, toma la entrada en la sintaxis curry: m(number)(first prime)

JavaScript ES5, 34 bytes

for(a=i=(p=prompt)();a%--i;);i<p()

Añadir ++ , 20 bytes

L,2Dx@rBcB%B]b*!!A>*

Pruébalo en línea!

L,   - Create a lambda function
     - Example arguments:  [5 9]
  2D - Copy below; STACK = [5 9 5]
  x  - Repeat;     STACK = [5 9 [9 9 9 9 9]]
  @  - Reverse;    STACK = [[9 9 9 9 9] 5 19] 
  r  - Range;      STACK = [[9 9 9 9 9] [5 6 7 8 9]]
  Bc - Zip;        STACK = [[9 5] [9 6] [9 7] [9 8] [9 9]]
  B% - Modulo;     STACK = [4 3 2 1]
  B] - Wrap;       STACK = [[4 3 2 1]]
  b* - Product;    STACK = [24]
  !! - Boolean;    STACK = [1]
  A  - Arguments;  STACK = [1 5 9]
  >  - Greater;    STACK = [1 1]
  *  - Product;    STACK = [1]