Uma das minhas definições favoritas dos números primos é a seguinte:

• 2 é o menor primo.

• Números maiores que 2 são primos se não forem divisíveis por um primo menor.

No entanto, essa definição parece arbitrária, por que 2? Por que não outro número? Bem, vamos tentar alguns outros números definirão n-prime tal que

• n é o menor n-prime.

• Números maiores que n são n-prime se não forem divisíveis por um n-prime menor.

Tarefa

A tarefa aqui é escrever um programa que aceite duas entradas, um número inteiro positivo n e um número inteiro positivo a . Ele então decidirá se a é n -prime. Seu programa deve gerar dois valores distintos, um para "sim, é n-prime" e outro para "não, não é n-prime".

Esta é uma questão de código-golfe, para que as respostas sejam pontuadas em bytes, com menos bytes sendo melhores.

Testes

Aqui estão as listas dos 31 primeiros números primos para n = 2 en = 12 (1 é o único número 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

Experimente online!

Eu defino uma boa função recursiva (!):

n!averifica se algum fator de a, no intervalo [n,a-1], é um n-prime. Então nega o resultado. Também garante quen>a

Python 2 , 39 37 bytes

Agradecimentos a Halvard Hummel por -2 bytes.

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

Experimente online!

Python 3 , 45 bytes

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

Experimente online!

Como funciona

Isso leva dois inteiros como entrada, i e k . Primeiro verifica se k ≥ i . Em seguida, gera o intervalo [i, k) e, para cada número inteiro N nesse intervalo, verifica se N é coprime para k . Se ambas as condições forem cumpridas, então k é um i- prime.

Casca , 6 5 bytes

εf≥⁰Ḋ

Experimente online! ou veja resultados até 80 .

Agradecimentos a Leo por -1 byte.

Explicação

ε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 bytes 37

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

Experimente online!

-7 bytes graças a Giuseppe

Retorna TRUEse

• aé igual a nou ( a==n|)
• aé maior que n e ( a>n&) para cada número k de naté a-1, anão é divisível igualmente por k ( all(a%%n:(a-1)))

Retorna FALSEcaso contrário

J, 30 bytes

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

Experimente online!

Leva o valor inicial como o argumento certo e o valor a ser verificado no argumento esquerdo.

Eu errei originalmente e não levei em conta argumentos à esquerda menos do que o prime inicial. Estou um pouco infeliz com o comprimento da minha solução agora.

Explicação

Seja xo argumento da esquerda (o valor a ser verificado) e yseja o argumento da direita (o 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

O elemento na posição x-yé o resultado de testes de primalidade para x(desde que adicionamos yao intervalo original).

A multiplicação por x >: ygarante que obtemos um valor de falsey ( 0) por xmenos de y.

JavaScript (ES6), 33 32 30 bytes

Recebe entrada na sintaxe de currying (n)(a). Retorna um booleano.

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

Demo

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 salvos graças à idéia de H.PWiz, que foi emprestada da resposta de flawr

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

Experimente online!

Ok, já faz um tempo, e a única resposta de Haskell até agora é de 45 btyes, decidi postar minha própria resposta.

Explicação

Essa função verifica se o único número entre n e a pelo qual a é divisível é um próprio.

Agora, a definição menciona apenas n- vezes menor que a , então por que estamos verificando todos esses números extras? Não teremos problemas quando a é divisível por algum composto n maior que n ?

Não o faremos porque, se houver um n- compósito maior que n, ele deverá ser divisível por um n- prima menor por definição. Assim se divide a assim importa que o menor n -prime.

Se a for menor que n [n..a] será, []portanto, não será igual, [1]causando falha na verificação.

Geléia , 8 bytes

rṖ⁴%$Ạ×<

Experimente online!

Pip , 23 19 14 bytes

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

O método mais curto é uma porta da resposta Python do Sr. Xcoder . Obtém o menor primo e o número para testar como argumentos da linha de comando. Experimente online!

C, 55 bytes

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

Experimente online!

53 bytes se vários valores de retorno verdadeiros são permitidos:

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

Experimente online!

dc , _{40 34} 37 bytes

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

Eu teria incluído um link do TIO, mas o TIO parece ter uma distribuição defeituosa de dccomo isso funciona conforme o esperado no meu sistema, mas o Qcomando funciona erroneamente no TIO. Em vez disso, aqui está um link para um bashcampo de teste com uma versão funcionando corretamente de dc:

Demo It!

APL (Dyalog) , 24 bytes

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

Experimente online!

Quão?

⍳⍵- 1paraa

o←⍺↓- npara a, salve emo

o|⍨⊂o- modulo cada item ocom cada item emo

0=- verifique onde é igual 0(divide)

+/¨ - soma o número de divisões

1= - se tivermos apenas um, o número será dividido apenas por si

o/⍨ - então mantemos essas ocorrências

⍵∊- está anessa matriz residual?

JavaScript (Node.js) , 27 bytes

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

Experimente online!

Porta da minha resposta Python, tem entrada na sintaxe currying: m(number)(first prime)

JavaScript ES5, 34 bytes

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

Adicione ++ , 20 bytes

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

Experimente online!

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]