Dado um número natural , retorne o ésimo primo cubano . $n$ $n$

Primes cubanos

Um primo cubano é um número primo da forma

p = \frac{x^{3} - y^{3}}{x - y}

$p = \frac{x^3-y^3}{x-y}$

onde e ou $y>0$ $x = 1+y$ $x = 2+y$

Detalhes

Você pode usar a indexação baseada em 0 ou 1, o que melhor lhe convier.
Você pode retornar o ésimo primo, dado o índice ou o primeiro primos em ordem crescente, ou alternativamente, pode retornar uma lista / gerador infinito que produz os primos em ordem crescente. $n$ $n$ $n$

Casos de teste

Os primeiros termos são os seguintes:

(#1-13)   7, 13, 19, 37, 61, 109, 127, 193, 271, 331, 397, 433, 547,
(#14-24) 631, 769, 919, 1201, 1453, 1657, 1801, 1951, 2029, 2269, 2437,
(#25-34) 2791, 3169, 3469, 3571, 3889, 4219, 4447, 4801, 5167, 5419,
(#35-43) 6211, 7057, 7351, 8269, 9241, 10093, 10267, 11719, 12097,
(#44-52) 12289, 13267, 13669, 13873, 16651, 18253, 19441, 19927, 20173

Mais termos podem ser encontrados no OEIS: Eles são divididos em duas seqüências, dependendo de ou : A002407 e A002648 $x = 1+y$ $x = 2+y$

— flawr
fonte

2

Podemos retornar os primeiros n primos não classificados?

— J42161217

@ J42161217 Não, os números primos devem estar em ordem crescente.

— flawr

23

JavaScript (V8) , 54 bytes

Um programa completo que imprime números primos cubanos para sempre.

for(x=0;;){for(k=N=~(3/4*++x*x);N%++k;);~k||print(-N)}

Experimente online!

^{Nota: A menos que você tenha papel infinito na impressora, não tente executá-lo no console do navegador , onde print()pode ter um significado diferente.}

JavaScript (ES6), 63 61 60 59 bytes

Retorna o $n$ ésimo primo cubano, indexado em 1.

f=(n,x)=>(p=k=>N%++k?p(k):n-=!~k)(N=~(3/4*x*x))?f(n,-~x):-N

Experimente online!

Quão?

Isso se baseia no fato de que os primos cubanos são primos da forma:

p_{n} = ⌊ \frac{3 n^{2}}{4} ⌋ + 1, n \geq 3

$p_n=\left\lfloor\frac{3n^2}{4}\right\rfloor+1,\;n\ge3$

A fórmula acima pode ser escrita como:

p_{n} = {\begin{cases} \frac{3 n^{2} + 1}{4} E se n é estranho \\ \frac{3 n^{2} + 4}{4} E se n é par \end{cases}

$p_n=\begin{cases} \dfrac{3n^2+1}{4}\;\text{ if }n\text{ is odd}\\ \dfrac{3n^2+4}{4}\;\text{ if }n\text{ is even} \end{cases}$

ou para qualquer $y>0$ :

p_{2 y + 1} = \frac{3 (2 y + 1)^{2} + 1}{4} = 3 y^{2} + 3 y + 1

$p_{2y+1}=\dfrac{3(2y+1)^2+1}{4}=3y^2+3y+1$

p_{2 y + 2} = \frac{3 (2 y + 2)^{2} + 4}{4} = 3 y^{2} + 6 y + 4

$p_{2y+2}=\dfrac{3(2y+2)^2+4}{4}=3y^2+6y+4$

que é $\dfrac{x^3-y^3}{x-y}$ para $x=y+1$ e $x=y+2$ respectivamente.

— Arnauld
fonte

7

05AB1E , 16 12 9 bytes

Gera uma lista infinita.
Economizou 4 bytes com a fórmula do porto de Arnaulds, de Kevin Cruijssen .
Economizou mais 3 bytes graças ao Grimy

∞n3*4÷>ʒp

Experimente online!

Explicação

∞          # on the list of infinite positive integers
 n3*4÷>    # calculate (3*N^2)//4+1 for each
       ʒp  # and filter to only keep primes

— Emigna
fonte

Você fez um erro de digitação na sua explicação: " coloque uma cópia N^2+3na pilha " deve ser 3*N^2. Além disso, por que o em )vez de ¯? Porque é mais fácil digitar? E, por alguma razão, tenho a sensação de que NnN‚3*¬sO‚pode ser 1 byte menor, mas não estou vendo. Uma alternativa leve de byte igual é Nn3*DN3*+‚. Mas provavelmente estou vendo coisas que não estão lá ..;) Resposta agradável, então +1 de mim.

— Kevin Cruijssen

1

Na verdade, tentei portar minha resposta para 05AB1E, mas falhei miseravelmente. : D

— Arnauld

1

Na verdade, gerando uma lista infinita é mais conveniente: 9 bytes com ∞n3 * 4 ÷> ʒp

— Grimmy

1

OK, não estou acostumado a especificações que se contradizem. :-)

— WGroleau

6

@WGroleau Suponho que você nunca tenha desenvolvido software profissionalmente. Fico mais preocupado quando recebo especificações que não se contradizem.

— MikeTheLiar

7

R , 75 73 bytes

n=scan()
while(F<n)F=F+any(!(((T<-T+1)*1:4-1)/3)^.5%%1)*all(T%%(3:T-1))
T

Experimente online!

-2 bytes, percebendo que posso remover colchetes se eu usar em *vez de &(precedência diferente).

Produz o nprimeiro número cubano (1-indexado).

Ele usa o fato (dado em OEIS) de que os primos cubanos têm a forma $p=1+3n^2$ ou $4p=1+3n^2$ para alguns $n$ , ou seja, $n=\sqrt{\frac{a\cdot p-1}{3}}$ é um número inteiro para $a=1$ ou $a=4$ .

O truque é que não nobre pode ser da forma de $2p=1+3n^2$ ou $3p=1+3n^2$ (*), de modo que pode poupar 2 bytes, verificando a fórmula para $a\in\{1, 2, 3, 4\}$ ( 1:4) em vez de $a\in\{1, 4\}$ ( c(1,4)).

Versão ligeiramente não destruída do código:

# F and T are implicitly initialized at 0 and 1
# F is number of Cuban primes found so far
# T is number currently being tested for being a Cuban prime
n = scan()                       # input
while(F<n){
  T = T+1                        # increment T 
  F = F +                        # increment F if
    (!all(((T*1:4-1)/3)^.5 %% 1) # there is an integer of the form sqrt(((T*a)-1)/3)
     & all(T%%(3:T-1)))          # and T is prime (not divisible by any number between 2 and T-1)
  }
T                                # output T

(*) Nenhum primo pode ter a forma $3p=1+3n^2$ , caso contrário $1=3(p-n^2)$ seria divisível por $3$ .

Nenhum primo diferente de $p=2$ (que não é um primo cubano) pode da forma $2p=1+3n^2$ : $n$ precisaria ser ímpar, ou seja, $n=2k+1$ . Expandindo dá $2p=4+12k(k+1)$ , portanto, $p=2+6k(k+1)$ e $p$ seria mesmo.

— Robin Ryder
fonte

que tal evitar um loop usando um limite superior no enésimo número primo cubano?

— Xian

@ Xi'an eu pensei sobre isso, mas não consegui chegar a esse limite. Você tem um?

— Robin Ryder

5

Wolfram Language (Mathematica) , 66 65 56 bytes

(f=1+⌊3#/4#⌋&;For[n=i=0,i<#,PrimeQ@f@++n&&i++];f@n)&

Experimente online!

J42161217 -1 usando em ⌊ ⌋vez deFloor[ ]
attinat
- -1 usando em ⌊3#/4#⌋vez de⌊3#^2/4⌋
- -8 para em For[n=i=0,i<#,PrimeQ@f@++n&&i++]vez den=2;i=#;While[i>0,i-=Boole@PrimeQ@f@++n]

— speedstyle
fonte

1

65 bytes . Bem-vindo ao ppcg. Boa primeira resposta! +1

— J42161217

Obrigado! (Há muito tempo.) Como não consegui analisar sua resposta existente, escrevi a minha e ela ficou um pouco mais curta. Eu também poderia fazer um Python.

— speedstyle

2

56 bytes

— attinat

@attinat Eu pensei que a fórmula de Arnauld só funcionava para n> 2, então não comecei com 0 - embora, como no seu exemplo, funcione para todos os n (porque inicia 1 1 4 7 13 ... então os números primos são 7 13. ..)

— speedstyle

3

Java 8, 94 88 86 84 bytes

v->{for(int i=3,n,x;;System.out.print(x<1?++n+" ":""))for(x=n=i*i++*3/4;~n%x--<0;);}

-6 bytes usando o verificador principal de Java do @SaraJ , portanto, faça um voto positivo!
-2 bytes graças a @ OlivierGrégoire . Como o primeiro número que verificamos é 7, podemos descartar o rastreio %ndo verificador principal da Sara, que é o fim do loop n=1.
-2 bytes graças a @ OlivierGrégoire, portando a resposta de @Arnauld .

Saídas delimitadas por espaço indefinidamente.

Experimente online.

Explicação (da versão antiga de 86 bytes): TODO: Atualizar explicação

$p_n=\left\lfloor\frac{3n^2}{4}\right\rfloor+1,\;n\ge3$

v->{                     // Method with empty unused parameter and no return-type
  for(int i=3,           //  Loop-integer, starting at 3
          n,x            //  Temp integers
      ;                  //  Loop indefinitely:
      ;                  //    After every iteration:
       System.out.print( //     Print:
        n==x?            //      If `n` equals `x`, which means `n` is a prime:
         n+" "           //       Print `n` with a space delimiter
        :                //      Else:
         ""))            //       Print nothing
    for(n=i*i++*3/4+1,   //   Set `n` to `(3*i^2)//4+1
                         //   (and increase `i` by 1 afterwards with `i++`)
        x=1;             //   Set `x` to 1
        n%++x            //   Loop as long as `n` modulo `x+1`
                         //   (after we've first increased `x` by 1 with `++x`)
             >0;);}      //   is not 0 yet
                         //   (if `n` is equal to `x`, it means it's a prime)

— Kevin Cruijssen
fonte

Eu realmente não acho viável, mas outra maneira de encontrar os primos cubanos usa esta fórmula: v->{for(int n=7,i=3,p,x,d,r=0;;i+=++r%2*3,n+=i,System.out.print(x>1?x+" ":""))for(x=n,d=1;++d<n;x=x%d<1?0:n);}talvez alguém possa usar isso para jogar golfe? Não pude.

— Olivier Grégoire

1

@ OlivierGrégoire Você pode jogar um pouco mais o seu removendo o não utilizado ,pe mudando i+=++r%2*3,n+=ipara n+=i+=++r%2*3, mas ainda assim eu terminarei em 106 bytes. Usando Java 11 de String#repeatcom primeiro-regex é de 105 bytes: v->{for(int n=7,i=3,r=0;;n+=i+=++r%2*3)if(!"x".repeat(n).matches(".?|(..+?)\\1+"))System.out.println(n);}.

— Kevin Cruijssen

Sim, eu acho que não era muito jogável, apesar dos meus erros (agora óbvios). Obrigado por dar uma volta;)

— Olivier Grégoire

@ OlivierGrégoire Talvez também seja bom saber para você, mas aparentemente há um loop de verificação de prime mais curto em Java. Veja minha edição e a resposta do SaraJ na verificação de prime.

— Kevin Cruijssen

Posso estar errado, mas o último %nnão é obrigatório, é?

— Olivier Grégoire

2

Wolfram Language (Mathematica) , 83 bytes

(t=1;While[Length[l=Select[Join@@Array[{(v=3#^2+1)+3#,v}&,t++],PrimeQ]]<#];Sort@l)&

Experimente online!

— J42161217
fonte

2

Gelatina , 12 bytes

²×3:4‘
ÇẒ$#Ç

Experimente online!

Com base no método de @ Arnauld . Aceita stdin e retorna muitos primos cubanos.

— Nick Kennedy
fonte

1

Wolfram Language (Mathematica) , 83 bytes

Esta solução produzirá o n-ésimo primo cubano com os benefícios adicionais de ser rápido e lembrar de todos os resultados anteriores no símbolo f.

(d:=1+3y(c=1+y)+3b c;e:=If[PrimeQ@d,n++;f@n=d];For[n=y=b=0,n<#,e;b=1-b;e,y++];f@#)&

Experimente online!

— Kelly Lowder
fonte

1

Espaço em branco , 180 bytes

[S S S T    S N
_Push_2][S N
S _Duplicate][N
S S N
_Create_Label_OUTER_LOOP][S N
N
_Discard_top_stack][S S S T N
_Push_1][T  S S S _Add][S N
S _Duplicate][S N
S _Duplicate][T S S N
_Multiply][S S S T  T   N
_Push_3][T  S S N
_Multiply][S S S T  S S N
_Push_4][T  S T S _Integer_divide][S S S T  N
_Push_1][T  S S S _Add][S S S T N
_Push_1][S N
S _Duplicate_1][N
S S S N
_Create_Label_INNER_LOOP][S N
N
_Discard_top_stack][S S S T N
_Push_1][T  S S S _Add][S N
S _Duplicate][S N
S _Duplicate][S T   S S T   T   N
_Copy_0-based_3rd][T    S S T   _Subtract][N
T   S T N
_Jump_to_Label_PRINT_if_0][S T  S S T   S N
_Copy_0-based_2nd][S N
T   _Swap_top_two][T    S T T   _Modulo][S N
S _Duplicate][N
T   S S S N
_Jump_to_Label_FALSE_if_0][N
S N
S N
_Jump_to_Label_INNER_LOOP][N
S S T   N
_Create_Label_PRINT][T  N
S T _Print_as_integer][S S S T  S T S N
_Push_10_(newline)][T   N
S S _Print_as_character][S N
S _Duplicate][N
S S S S N
_Create_Label_FALSE][S N
N
_Discard_top_stack][S N
N
_Discard_top_stack][N
S N
N
_Jump_to_Label_OUTER_LOOP]

Letras S(espaço), T(tabulação) e N(nova linha) adicionadas apenas como destaque.
[..._some_action]adicionado apenas como explicação.

Saídas delimitadas por nova linha indefinidamente.

Experimente online (apenas com espaços brutos, tabulações e novas linhas).

Explicação em pseudo-código:

$p_n=\left\lfloor\frac{3n^2}{4}\right\rfloor+1,\;n\ge3$

Integer i = 2
Start OUTER_LOOP:
  i = i + 1
  Integer n = i*i*3//4+1
  Integer x = 1
  Start INNER_LOOP:
    x = x + 1
    If(x == n):
      Call function PRINT
    If(n % x == 0):
      Go to next iteration of OUTER_LOOP
    Go to next iteration of INNER_LOOP

function PRINT:
  Print integer n
  Print character '\n'
  Go to next iteration of OUTER_LOOP

— Kevin Cruijssen
fonte

1

Python 3 , 110 108 102 bytes

Método semelhante ao da minha resposta do Mathematica (ie isPrime(1+⌊¾n²⌋) else n++), usando este verificador primário golfista e retornando um gerador infinito anônimo

from itertools import*
(x for x in map(lambda n:1+3*n**2//4,count(2)) if all(x%j for j in range(2,x)))

Experimente online!

mypetlion -2 porque geradores indiscutivelmente anônimos são mais permitidos do que os nomeados
-6 iniciando countem 2 _+1, para que o and x>1check-in emprestado seja desnecessário _-7

— speedstyle
fonte

A resposta que entra em uma variável geralmente não é considerada uma forma válida de "saída". Você poderia refazer sua resposta para que o resultado seja enviado para stdout ou retornado por uma função?

— mypetlion

1

como funções anônimas são permitidas e o desafio permite explicitamente um gerador infinito, eu removi g=. Eu só o incluí em primeiro lugar porque permitiu um rápido visual no TIO com print(next(g) for i in range(52)).

— speedstyle

1

Japonês , 14 13 bytes

Adaptado da fórmula de Arnauld . 1 indexado.

@µXj}f@Ò(X²*¾

Tente

1 byte salvo graças ao EmbodimentOfIgnorance.

— Shaggy
fonte

13 bytes? Não testado completamente embora.

— Modalidade de ignorância

Obrigado, @EmbodimentofIgnorance. Eu tentei isso, mas não funcionou; Acontece que eu esqueci o (.

— Shaggy

1

Raquete , 124 bytes

(require math)(define(f n[i 3])(let([t(+(exact-floor(* 3/4 i i))1)][k(+ 1 i)])(if(prime? t)(if(= 0 n)t(f(- n 1)k))(f n k))))

Experimente online!

Retorna o n-ésimo primo cubano, indexado em 0.

Usa a fórmula da resposta JavaScript de @ Arnauld

— Galen Ivanov
fonte

1

Python 3 , 83 bytes

imprime os primos cubanos para sempre.

P=k=1
while 1:P*=k*k;x=k;k+=1;P%k>0==((x/3)**.5%1)*((x/3+.25)**.5%1-.5)and print(k)

Experimente online!

Baseado neste gerador principal. Para cada primo, verifica se existe um número inteiro y que preencha a equação para $x = 1+y$ $x=2+y$

p = \frac{(1 + y)^{3} - y^{3}}{(1 + y) - y} = 1 + 3 y + 3 y^{2} \Leftrightarrow y = - \frac{1}{2} \pm \sqrt{\frac{1}{4} + \frac{p - 1}{3}}

$p=\frac{(1+y)^3-y^3}{(1+y)-y} = 1 + 3y +3y^2 \Leftrightarrow y = -\frac{1}{2}\pm\sqrt{\frac{1}{4}+\frac{p-1}{3}}$

p = \frac{(2 + y)^{3} - y^{3}}{(1 + y) - y} = 4 + 6 y + 3 y^{2} \Leftrightarrow y = - 1 \pm \sqrt{\frac{p - 1}{3}}

$p=\frac{(2+y)^3-y^3}{(1+y)-y} = 4 + 6y +3y^2 \Leftrightarrow y = -1 \pm\sqrt{\frac{p-1}{3}}$

y

$y$

\pm

$\pm$

- 1

$-1$

— ovs
fonte

1

Perl 6 , 33 31 bytes

-2 bytes graças ao Grimy

{grep &is-prime,1+|¾*$++²xx*}

Experimente online!

Bloco de código anônimo que retorna uma lista infinita e lenta de números primos cubanos. Isso usa a fórmula de Arnauld para gerar possíveis números primos cubanos e depois &is-primefiltrá-los.

Explicação:

{                           }  # Anonymous code block
 grep &is-prime,               # Filter the primes from
                         xx*   # The infinite list
                   ¾*          # Of three quarters
                     $++²      # Of an increasing number squared
                1+|            # Add one by ORing with 1

— Brincadeira
fonte

1

1+0+|pode ser justo1+|

— Grimmy

0

Pari / GP , 51 bytes

Usando a fórmula de Arnauld .

n->a=0;for(i=1,n,until(isprime(p=3*a^2\4+1),a++));p

Experimente online!

— alefalpha
fonte

0

APL (NARS), 98 caracteres, 196 bytes

r←h w;y;c;v
r←c←y←0⋄→4
→3×⍳∼0πv←1+3×y×1+y+←1⋄r←v⋄→0×⍳w≤c+←1
→2×⍳∼0πv+←3×y+1⋄c+←1⋄r←v
→2×⍳w>c

recuado:

r←h w;y;c;v
r←c←y←0⋄→4
    →3×⍳∼0πv←1+3×y×1+y+←1⋄r←v⋄→0×⍳w≤c+←1
    →2×⍳∼0πv+←3×y+1⋄c+←1⋄r←v
    →2×⍳w>c

teste:

  h ¨1..20
7 13 19 37 61 109 127 193 271 331 397 433 547 631 769 919 1201 1453 1657 1801 
  h 1000
25789873
  h 10000
4765143511

é baseado em: se y em N, um possível Cuban Prime é

S1=1+3y(y+1)

o próximo possível Cuban Prime será

S2=3(y+1)+S1

— RosLuP
fonte