O aglomerado privilegiada de um número inteiro N mais elevada do que 2 é definido como o par formado pelo maior privilegiada estritamente inferior ao N e o menor primo estritamente maior que N .

Observe que, seguindo a definição acima, se o número inteiro for um primo em si, seu cluster primo será o par dos primos que o precedem e o sucedem .

Tarefa

Dados dois números inteiros N , M ( N, M ≥ 3 ), produza um valor de verdade / falsidade com base no fato de N e M terem o mesmo cluster principal.

Isso é código-golfe , então o objetivo é reduzir sua contagem de bytes o máximo possível. Assim, o código mais curto em toda linguagem de programação vence.

Casos de teste / Exemplos

Por exemplo, o cluster principal de 9 é [7, 11]porque:

• 7 é o primo mais alto estritamente menor que 9 e
• 11 é o primo mais baixo estritamente superior a 9 .

Da mesma forma, o cluster principal de 67 é [61, 71](observe que 67 é primo).

Pares verdadeiros

8, 10
20, 22
65, 65
73, 73
86, 84
326, 318
513, 518

Pares de falsidade

4, 5
6, 8
409, 401
348, 347
419, 418
311, 313
326, 305

Geléia , 6 4 3 5 4 bytes

rÆPE

Experimente online! ou Experimente todos os casos de teste .

Como funciona

rÆPE    Main link. Arguments: N, M
r       Yield the range of integers between N and M, inclusive.
 ÆP     For each integer, yield 1 if it is prime, 0 otherwise.
   E    Yield 1 if all items are equal (none in the range were prime,
        or there's only one item).

Funciona porque dois números têm aglomerados primos diferentes se houver um primo entre eles ou qualquer um dos números é primo; a menos que ambos os números sejam iguais, nesse caso, Eretorne 1assim mesmo (todos os itens em uma matriz de item único são iguais).

Perl 6 , 52 bytes

{[eqv] @_».&{(($_...0),$_..*)».first(*.is-prime)}}

Teste-o

Expandido:

{  # bare block lambda with implicit slurpy input ｢@_｣

  [eqv]               # see if each sub list is equivalent

    @_».&{            # for each value in the input

      (

        ( $_ ... 0 ), # decreasing Seq
          $_ ..  *    # Range

      )».first(*.is-prime) # find the first prime from both the Seq and Range

    }
}

Python 3 , 103 95 91 bytes

lambda*z:len({*z})<2or[1for i in range(min(z),max(z)+1)if all(i%k for k in range(2,i))]<[0]

Experimente online!

Ruby , ₅₇ 54 bytes

->n,m{[*n..m,*m..n].all?{|x|?1*x=~/^(11+)\1+$/}||n==m}

Experimente online!

Usa o horrível teste de primalidade regex da minha resposta (que eu havia esquecido até clicar nele) para a pergunta relacionada Esse número é primo? . Como temos N, M ≥ 3, a verificação de 1 pode ser removida do padrão, fazendo com que o byte conte menos do que usando o embutido.

Nota: O teste de primalidade regex é patologicamente, hilariamente ineficiente. Acredito que seja pelo menos O (n!), Embora não tenha tempo para descobrir isso agora. Demorou doze segundos para checar 100.001 e ficou moendo por cinco ou dez minutos em 1.000.001 antes de cancelá-lo. Use / abuse por sua conta e risco.

Retina , 58 bytes

\b(.+)¶\1\b

.+
$*
O`
+`\b(1+)¶11\1
$1¶1$&
A`^(11+)\1+$
^$

Experimente online! Explicação:

\b(.+)¶\1\b

Se ambas as entradas forem iguais, exclua tudo e passe para a saída 1 no final.

.+
$*

Converta para unário.

O`

Classificar em ordem.

+`\b(1+)¶11\1
$1¶1$&

Expanda para um intervalo de todos os números.

A`^(11+)\1+$

Exclua todos os números compostos.

^$

Se não houver números restantes, digite 1, caso contrário, 0.

PARI / GP, 28 bytes

v->s=Set(v);#s<2||!primes(s)

Experimente online com todos os casos de teste!

Retorna 0ou 1(valores "booleanos" comuns do PARI / GP)).

Explicação:

vdeve ser um vetor (ou um vetor de coluna ou uma lista) com os dois números Ne Mcomo coordenadas. Por exemplo [8, 10]. Em seguida s, será o "conjunto" feito desses números, que é um vetor de uma coordenada (se N==M) ou um vetor de duas coordenadas com entradas ordenadas .

Então, se o número #sde coordenadas em sé apenas uma, obtemos 1(verdade). Caso contrário, primesretornará um vetor de todos os números primos no intervalo fechado de s[1]a s[2]. A negação !disso dará 1se o vetor estiver vazio, enquanto a negação de um vetor de uma ou mais entradas diferentes de zero (aqui uma ou mais primos) dará 0.

JavaScript (ES6), 57 56 bytes

Recebe entrada na sintaxe de currying (a)(b). Retorna 0ou 1.

a=>b=>a==b|!(g=k=>a%--k?g(k):k<2||a-b&&g(a+=a<b||-1))(a)

Casos de teste

let f =

a=>b=>a==b|!(g=k=>a%--k?g(k):k<2||a-b&&g(a+=a<b||-1))(a)

console.log('Truthy')
console.log(f(8)(10))
console.log(f(20)(22))
console.log(f(65)(65))
console.log(f(73)(73))
console.log(f(86)(84))
console.log(f(326)(318))
console.log(f(513)(518))

console.log('Falsy')
console.log(f(4)(5))
console.log(f(6)(8))
console.log(f(409)(401))
console.log(f(348)(347))
console.log(f(419)(418))
console.log(f(311)(313))

Como?

a => b =>                 // given a and b
  a == b |                // if a equals b, force success right away
  !(g = k =>              // g = recursive function taking k
    a % --k ?             //   decrement k; if k doesn't divide a:
      g(k)                //     recursive calls until it does
    :                     //   else:
      k < 2 ||            //     if k = 1: a is prime -> return true (failure)
      a - b &&            //     if a equals b: neither the original input integers nor
                          //     any integer between them are prime -> return 0 (success)
      g(a += a < b || -1) //     else: recursive call with a moving towards b
  )(a)                    // initial call to g()

R , 63 46 bytes

-17 por Giuseppe

function(a,b)!sd(range(numbers::isPrime(a:b)))

Experimente online!

Aplicação bastante simples da solução Jelly da ETHProductions . O principal argumento interessante é que com vetores booleanos R any(x)==all(x)é equivalente a min(x)==max(x).

C (gcc), 153 146 bytes

i,B;n(j){for(B=i=2;i<j;)B*=j%i++>0;return!B;}
#define g(l,m,o)for(l=o;n(--l););for(m=o;n(++m););
a;b;c;d;h(e,f){g(a,b,e)g(c,d,f)return!(a-c|b-d);}

-7 de Jonathan Frech

Define uma função hque recebe dois se intretorna 1para verdade e 0para falsey

Experimente online!

n é uma função que retorna 1 se seu argumento não for primo.

g é uma macro que define seus primeiro e segundo argumentos para o próximo primo menor que e maior que (respectivamente), é terceiro argumento

hfaz gpara ambas as entradas e verifica se as saídas são as mesmas.

Gelatina , 6 bytes

ÆpżÆnE

Experimente online!

-2 graças a Dennis .

APL (Dyalog Unicode) , 18 + 16 = 34 24 bytes

⎕CY'dfns'
∧/=/4 ¯4∘.pco⎕

Experimente online!

Agradecimentos a Adám por 10 bytes.

A linha ⎕CY'dfns'( C OP Y é necessário) para importar os NDR ( d inâmica f unctio ns ) recolha, incluído no padrão Dyalog APL instala.

Como funciona:

∧/=/4 ¯4∘.pco⎕ ⍝ Main function. This is a tradfn body.
             ⎕ ⍝ The 'quad' takes the input (in this case, 2 integers separated by a comma.
          pco  ⍝ The 'p-colon' function, based on p: in J. Used to work with primes.
    4 ¯4∘.     ⍝ Applies 4pco (first prime greater than) and ¯4pco (first prime smaller than) to each argument.
  =/           ⍝ Compares the two items on each row
∧/             ⍝ Applies the logical AND between the results.
               ⍝ This yields 1 iff the prime clusters are equal.

Python 2 , 87 86 bytes

lambda*v:v[0]==v[1]or{1}-{all(v%i for i in range(2,v))for v in range(min(v),max(v)+1)}

Experimente online!

C (gcc) , 103 bytes 100 bytes

i,j,p,s;f(m,n){s=1;for(i=m>n?i=n,n=m,m=i:m;i<=n;i++,p?s=m==n:0)for(p=j=2;j<i;)p=i%j++?p:0;return s;}

Experimente online!

Haskell , 81 bytes

Uma solução simples:

p z=[x|x<-z,all((0/=).mod x)[2..x-1]]!!0
c x=(p[x-1,x-2..],p[x+1..])
x!y=c x==c y

Experimente online!

Mathematica, 39 27 26 bytes

Equal@@#~NextPrime~{-1,1}&

Expandido:

                         &  # pure function, takes 2-member list as input
       #~NextPrime~{-1,1}   # infix version of NextPrime[#,{-1,1}], which
                            # finds the upper and lower bounds of each
                              argument's prime clusters
Equal@@                     # are those bounds pairs equal?

Uso:

Equal@@#~NextPrime~{-1,1}& [{8, 10}]
(*  True  *)

Equal@@#~NextPrime~{-1,1}& [{6, 8}]
(*  False  *)

Equal@@#~NextPrime~{-1,1}& /@ {{8, 10}, {20, 22}, {65, 65}, 
    {73, 73}, {86, 84}, {326, 318}, {513, 518}}
(*  {True, True, True, True, True, True, True}  *)

Equal@@#~NextPrime~{-1,1}& /@ {{4, 5}, {6, 8}, {409, 401}, 
    {348, 347}, {419, 418}, {311, 313}}
(*  {False, False, False, False, False, False}  *)

Contribuições: -12 bytes por Jenny_mathy , -1 byte por Martin Ender

J , 15 bytes

-:&(_4&p:,4&p:)

Como funciona:

   &(           ) - applies the verb in the brackets to both arguments
            4&p:  - The smallest prime larger than y
      _4&p:       - The largest prime smaller than y
           ,      - append
 -:               - matches the pairs of the primes

Experimente online!