Encontrando o n-ésimo Prime, de modo que o primo-1 seja divisível por n

33

Problema

O objetivo é, como o título diz, encontrar o enésimo nono primo, de modo que o primeiro - 1 seja divisível por n.

Explicação

Aqui está um exemplo para que você entenda a pergunta, não é necessariamente assim que deve ser resolvida. É apenas uma maneira de explicar a questão

dado 3 como entrada, veríamos primeiro todos os números primos

 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 ...

Em seguida, selecionamos os primos de modo que o primo - 1 seja divisível por n (3 neste caso)

 7 13 19 31 37 43 61 67 73 79 97 103 107 109 127 ...

Em seguida, selecionamos o enésimo termo nesta sequência

Produziríamos 19 para uma entrada de 3

Nota

Também podemos pensar nisso como o enésimo enésimo na sequência {1, n + 1, 2n + 1, 3n + 1 ... kn + 1} em que k é qualquer número natural

Casos de teste

  1 --> 2
  2 --> 5
  3 --> 19
  4 --> 29
100 --> 39301
123 --> 102337
Ando Bando
fonte
Você diz o enésimo primo [...] divisível por n . São N e n o mesmo número?
Dennis
Desculpe, sim, eles são os mesmos, eu deveria ter corrigido agora
Ando Bando
3
A077317
Gabriel Benamy
4
Você pode adicionar 1 -> 2 aos casos de teste. Uma das minhas respostas errou em algum momento.
Dennis
Outra maneira de expressar isso é "encontre o enésimo nono primo na sequência aritmética 1, n + 1,2n + 1, ..., kn + 1, ... (cuja sequência é garantida por ter infinitos numeros primos por Thm de Dirichlet. )
hardmath 17/11/16

Respostas:

9

05AB1E , 9 8 bytes

05AB1E usa a codificação CP-1252 .

Guardou um byte graças a Osable

µN¹*>Dp½

Experimente online!

Explicação

µ          # for N in [1 ...] loop until counter == input
 N¹*>      # N*input+1 (generate multiples of input and increment)
     D     # duplicate
      p½   # if prime, increase counter
           # implicitly output last prime
Emigna
fonte
3
Em vez de força bruta, sugiro gerar múltiplos de N primeiro e depois verificar se são primos. Eu vim com µN¹*>Dp½isso economiza um byte e acelera o cálculo.
Osable
2
@ Osable: Ah, é claro! Essa é realmente uma abordagem muito melhor. Obrigado :)
Emigna
7

Python 2, 58 bytes

n=N=input();m=k=1
while N:m*=k*k;k+=1;N-=m%k>~-k%n
print k
Dennis
fonte
5

Mathematica, 48 bytes

Select[Array[Prime,(n=#)^3],Mod[#-1,n]==0&][[n]]&

Função sem nome usando um único argumento, que ele nomeia n. Gera uma lista dos primeiros n^3números primos, seleciona aqueles que são congruentes a 1 módulo e n, em seguida, pega o nth elemento do resultado. É executado em alguns segundos na entrada 123.

Atualmente, não se sabe se há sempre um único primo, entre os primeiros n^3primos, que é congruente a 1 módulo n, muito menos ndeles. No entanto, o algoritmo pode ser provado correto (pelo menos para grandes n) sob a suposição da hipótese generalizada de Riemann !

Greg Martin
fonte
5

Haskell, 59 47 bytes

f n=[p|p<-[1,n+1..],all((<2).gcd p)[2..p-1]]!!n

Exemplo de uso: f 4 -> 29.

Como funciona:

[p|p<-[1,n+1..]                     ]    -- make a list of all multiples of n+1
                                         -- (including 1, as indexing is 0-based)
           ,all((<2).gcd p)[2..p-1]      -- and keep the primes
                              !!n       -- take the nth element

Edit: Obrigado @ Damien por 12 bytes, removendo o teste de divisibilidade e olhando apenas para múltiplos em primeiro lugar.

nimi
fonte
f n=[p|p<-[1,n+1..],all((<2).gcd p)[2..p-1]]!!n
21416 Damien
@ Damien: uau, um byte economiza 20%. Muito obrigado!
nimi
3

Geléia , 9 bytes

‘ÆP>%ð#Ṫ‘

Experimente online!

Como funciona

‘ÆP>%ð#Ṫ‘  Main link. Argument: n

     ð#    Call the dyadic chain to the left with right argument n and left
           argument k = n, n+1, n+2, ... until n of them return 1.
‘          Increment; yield k+1.
 ÆP        Test k+1 for primality, yielding 1 or 0.
    %      Compute k%n.
   >       Compare the results to both sides, yielding 1 if and only if k+1 is
           prime and k is divisible by n.
       Ṫ   Tail; extract the last k.
        ‘  Increment; yield k+1.
Dennis
fonte
3

Java 7, 106 bytes

int c(int n){for(int z=1,i=2,j,x;;i++){x=i;for(j=2;j<x;x=x%j++<1?0:x);if(x>1&(i-1)%n<1&&z++==n)return i;}}

Ungolfed:

int c(int n){
  for(int z = 1, i = 2, j, x; ; i++){
    x = i;
    for(j = 2; j < x; x = x % j++ < 1
                           ? 0
                           : x);
    if(x > 1 & (i-1) % n < 1 && z++ == n){
      return i;
    }
  }
}

Código do teste:

Experimente aqui (o último caso de teste resulta em um limite de tempo excedido no ideone)

class M{
  static int c(int n){for(int z=1,i=2,j,x;;i++){x=i;for(j=2;j<x;x=x%j++<1?0:x);if(x>1&(i-1)%n<1&&z++==n)return i;}}

  public static void main(String[] a){
    System.out.println(c(1));
    System.out.println(c(2));
    System.out.println(c(3));
    System.out.println(c(4));
    System.out.println(c(100));
    System.out.println(c(123));
  }
}

Saída:

2
5
19
29
39301
102337
Kevin Cruijssen
fonte
Bom ver o código ungolfed para comparação, mas os testes teriam de ser no código golfed para ser significativo ...
Trichoplax
@trichoplax Bem, eu sempre posto o programa de teste completo na parte Ungolfed & test code das minhas respostas. Eles System.out.printlnsão adicionados principalmente para que você possa ver qual entrada eu usei para fornecer a saída mostrada, e tudo também é fornecido caso alguém queira copiá-lo e colá-lo em seu IDE para brincar.
21716 Kevin Kurtzssen
1
Meu comentário não foi muito sério - apenas algumas pessoas acham que você só testou o código antes de jogar golfe. Você pode sempre ter três seções: golfed, Ungolfed e golfed com código de teste, se você queria dirigir fora essa suposição ...
Trichoplax
1
@trichoplax Ah ok, nesse caso, é realmente um comentário justificado e bom. :) Vou editar este e ter em mente os desafios futuros.
21716 Kevin Kurtzssen
3

Nasm 679 bytes (Instrução Intel 386 cpu 120 bytes)

isPrime1:  
push ebp
mov ebp,dword[esp+ 8]
mov ecx,2
mov eax,ebp
cmp ebp,1
ja .1
.n: xor eax,eax
jmp short .z
.1: xor edx,edx
cmp ecx,eax
jae .3
div ecx
or edx,edx
jz .n
mov ecx,3
mov eax,ebp
.2: xor edx,edx
cmp ecx,eax
jae .3
mov eax,ebp
div ecx
or edx,edx
jz .n
inc ecx
inc ecx
jmp short .2
.3: xor eax,eax
inc eax
.z: pop   ebp
ret 4
Np:  
push esi
push edi
mov esi,dword[esp+ 12]
xor edi,edi
or esi,esi
ja .0
.e: xor eax,eax
jmp short .z
.0: inc esi
jz .e
push esi
call isPrime1
add edi,eax
dec esi
cmp edi,dword[esp+ 12]
jae .1
add esi,dword[esp+ 12]
jc .e
jmp short .0
.1: mov eax,esi
inc eax
.z: pop edi
pop esi
ret 4

este é um não destruído e os resultados

;0k,4ra,8Pp
isPrime1: 
          push    ebp
          mov     ebp,  dword[esp+  8]
          mov     ecx,  2
          mov     eax,  ebp
          cmp     ebp,  1
          ja      .1
.n:       xor     eax,  eax
          jmp     short  .z
.1:       xor     edx,  edx
          cmp     ecx,  eax
          jae     .3
          div     ecx
          or      edx,  edx
          jz      .n
          mov     ecx,  3
          mov     eax,  ebp
.2:       xor     edx,  edx
          cmp     ecx,  eax
          jae     .3
          mov     eax,  ebp
          div     ecx
          or      edx,  edx
          jz      .n
          inc     ecx
          inc     ecx
          jmp     short  .2
.3:       xor     eax,  eax
          inc     eax
.z:       
          pop     ebp
          ret     4

; {1, n+1, 2n+1, 3n+1 }
; argomento w, return il w-esimo primo nella successione di sopra
;0j,4i,8ra,12P
Np:       
          push    esi
          push    edi
          mov     esi,  dword[esp+  12]
          xor     edi,  edi
          or      esi,  esi
          ja      .0
.e:       xor     eax,  eax
          jmp     short  .z
.0:       inc     esi
          jz      .e
          push    esi
          call    isPrime1
          add     edi,  eax
          dec     esi
          cmp     edi,  dword[esp+  12]
          jae     .1
          add     esi,  dword[esp+  12]
          jc      .e
          jmp     short  .0
.1:       mov     eax,  esi
          inc     eax
.z:       
          pop     edi
          pop     esi
          ret     4

00000975  55                push ebp
00000976  8B6C2408          mov ebp,[esp+0x8]
0000097A  B902000000        mov ecx,0x2
0000097F  89E8              mov eax,ebp
00000981  81FD01000000      cmp ebp,0x1
00000987  7704              ja 0x98d
00000989  31C0              xor eax,eax
0000098B  EB28              jmp short 0x9b5
0000098D  31D2              xor edx,edx
0000098F  39C1              cmp ecx,eax
00000991  731F              jnc 0x9b2
00000993  F7F1              div ecx
00000995  09D2              or edx,edx
00000997  74F0              jz 0x989
00000999  B903000000        mov ecx,0x3
0000099E  89E8              mov eax,ebp
000009A0  31D2              xor edx,edx
000009A2  39C1              cmp ecx,eax
000009A4  730C              jnc 0x9b2
000009A6  89E8              mov eax,ebp
000009A8  F7F1              div ecx
000009AA  09D2              or edx,edx
000009AC  74DB              jz 0x989
000009AE  41                inc ecx
000009AF  41                inc ecx
000009B0  EBEE              jmp short 0x9a0
000009B2  31C0              xor eax,eax
000009B4  40                inc eax
000009B5  5D                pop ebp
000009B6  C20400            ret 0x4
68

000009B9  56                push esi
000009BA  57                push edi
000009BB  8B74240C          mov esi,[esp+0xc]
000009BF  31FF              xor edi,edi
000009C1  09F6              or esi,esi
000009C3  7704              ja 0x9c9
000009C5  31C0              xor eax,eax
000009C7  EB1D              jmp short 0x9e6
000009C9  46                inc esi
000009CA  74F9              jz 0x9c5
000009CC  56                push esi
000009CD  E8A3FFFFFF        call 0x975
000009D2  01C7              add edi,eax
000009D4  4E                dec esi
000009D5  3B7C240C          cmp edi,[esp+0xc]
000009D9  7308              jnc 0x9e3
000009DB  0374240C          add esi,[esp+0xc]
000009DF  72E4              jc 0x9c5
000009E1  EBE6              jmp short 0x9c9
000009E3  89F0              mov eax,esi
000009E5  40                inc eax
000009E6  5F                pop edi
000009E7  5E                pop esi
000009E8  C20400            ret 0x4
000009EB  90                nop
120


[0, 0] [1, 2] [2, 5] [3, 19] [4, 29] [5, 71] [6, 43] [7, 211] [8, 193] [9, 271] [1
0, 191] [11, 661] [12, 277] [13, 937] [14, 463] [15, 691] [16, 769] [17, 1531] [18
, 613] [19, 2357] [20, 1021] [21, 1723] [22, 1409] [23, 3313] [24, 1609] [25, 3701
] [26, 2029] [27, 3187] [28, 2437] [29, 6961] [30, 1741] [31, 7193] [32, 3617] [33
, 4951] [34, 3877] [35, 7001] [36, 3169] [37, 10657] [38, 6271] [39, 7879] [40, 55
21] [41, 13613] [42, 3823] [43, 15137] [44, 7349] [45, 9091] [46, 7499] [47, 18049
] [48, 6529] [49, 18229] [50, 7151] [51, 13159] [52, 10141] [53, 26501] [54, 7669]
 [55, 19801] [56, 11593] [57, 18127] [58, 13109] [59, 32569] [60, 8221] [61, 34649
] [62, 17981] [63, 21799] [64, 16001] [65, 28081] [66, 10429] [67, 39799] [68, 193
81] [69, 29947] [70, 14771] [71, 47713] [72, 16417] [73, 51539] [74, 25013] [75, 2
9101] [76, 26449] [77, 50051] [78, 16927] [79, 54037] [80, 23761] [81, 41149] [82,
 31489] [83, 68891] [84, 19237] [85, 51341] [86, 33713] [87, 45589] [88, 34057] [8
9, 84551] [90, 19531] [91, 64793] [92, 42689] [93, 54499] [94, 41737] [95, 76001]
[96, 27457] [97, 97583] [98, 40867] [99, 66529] [100, 39301] [101, 110899] [102, 2
9989] [103, 116803] [104, 49297] [105, 51871] [106, 56711] [107, 126047] [108, 385
57] [109, 133853] [110, 42901] [111, 76369] [112, 53089] [113, 142607] [114, 40129
] [115, 109481] [116, 63337] [117, 83071] [118, 67733] [119, 112337] [120, 41281]
[121, 152219] [122, 70639] [123, 102337]
RosLuP
fonte
2

Na verdade , 13 bytes

Sugestões de golfe são bem-vindas! Experimente online!

;╗`PD╜@%Y`╓NP

Ungolfing

         Implicit input n.
;╗       Save a copy of n to register 0.
`...`╓   Push first n values where f(x) is truthy, starting with f(0).
  PD       Get the x-th prime - 1.
  ╜@%      Push (x_p - 1) % n.
  Y        If x_p-1 is divisible by n, return 1. Else, return 0.
NP       Get the n-th prime where n_p-1 is divisible by n.
         Implicit return.
Sherlock9
fonte
2

Lisp comum, 162 bytes

(defun s(n)(do((b 2(loop for a from(1+ b)when(loop for f from 2 to(1- a)never(=(mod a f)0))return a))(a 0)(d))((= a n)d)(when(=(mod(1- b)n)0)(incf a)(setf d b))))

Uso:

* (s 100)

39301

Ungolfed:

(defun prime-search (n)
  (do ((prime 2 (loop for next from (1+ prime) when
                 (loop for factor from 2 to (1- next) never
                      (= (mod next factor) 0)) return next))
       (count 0) (works))
      ((= count n) works)
    (when (= (mod (1- prime) n) 0)
      (incf count)
      (setf works prime))))

Algumas dessas loopconstruções provavelmente podem ser encurtadas em doloops, mas é isso que tenho por enquanto.

artificialnull
fonte
2

MATL , 12 bytes

1i:"`_YqtqG\

Experimente online!

(Para entrada 123, o tempo limite é excedido no compilador online, mas funciona offline.)

Explicação

1          % Push 1
i:         % Input n and push [1 2 ... n]
"          % For each (that is, do the following n times)
  `        %   Do...while
    _Yq    %     Next prime
    tq     %     Duplicate, subtract 1
    G      %     Push n again
    \      %     Modulo
           %   End (implicit). Exit loop if top of stack is 0; else next iteration
           % End (implicit)
           % Display (implicit)
Luis Mendo
fonte
1

Perl, 77 76 + 1 = 77 bytes

for($p=2;@a<$_;$p++){push@a,$p if(1 x$p)!~/^(11+?)\1+$/&&($p%$_<2)}say$a[-1]

Usa o regex de teste primário para determinar se $pé primo e garante que seja congruente 1 modificação da entrada (os únicos números inteiros não negativos abaixo de 2 são 0 e 1, mas não pode ser 0 se for primo, por isso é necessário be 1. economiza 1 byte acima ==1).

Gabriel Benamy
fonte
Isso parece imprimir 3 para a entrada 1 (deve ser 2 ).
Dennis
Você pode economizar 10 bytes fazendo (1 x++$.)!~/^(11+?)\1+$/&&($.%$_<2)&&push@a,$.while@a<$_;say$a[-1](é disso que eu estava falando no meu comentário anterior). No entanto, a saída (de qualquer versão) parece errada por pelo menos 2 e 3 ...
Dada
1

Mathematica 44 Bytes

   Pick[x=Table[i #+1,{i,# #}],PrimeQ/@x][[#]]&

Muito rápido. Usa a ideia do "Note"

% /@ {1, 2, 3, 4, 100, 123} // Timing

Saída

{0.0156001, {2, 5, 19, 29, 39301, 102337}}
Kelly Lowder
fonte
1

Perl 6 ,  46 39  37 bytes

->\n{(2..*).grep({.is-prime&&($_-1)%%n})[n-1]}
->\n{(1,n+1...*).grep(*.is-prime)[n-1]}
{(1,$_+1...*).grep(*.is-prime)[$_-1]}
Brad Gilbert b2gills
fonte
0

Java 8, 84 bytes

Golfe

(n)->{for(int s=n,i=1;;i+=n)for(int j=2;i%j>0&j<i;)if(++j==i&&--s<1)return n>1?i:2;}

Ungolfed

(n) -> { 
for (int s = n,      // Counting down to find our nth prime.
    i = 1;           // Counting up for each multiple of n, plus 1.
    ;                // No end condition specified for outer for loop.
    i += n)          // Add n to i every iteration.
for (int j = 2;      // Inner for loop for naive primality check.
     i % j > 0)      // Keep looping while i is not divisible by j 
                     // (and implicitly while j is less than i).
     if(++j==i       // Increment j. If j has reached i, we've found a prime
     &&              // Short-circutting logical AND, so that we only decrement s if a prime is found
     --s < 1)        // If we've found our nth prime...
     return n>1?i:2; // Return it. Or 2 if n=1, because otherwise it returns 3.
}

Explicação

Solução inspirada em várias outras respostas. A função é uma lambda que espera um único int.

O n>1?i:2é um hack barato, porque não consegui descobrir uma maneira melhor de considerar o caso de n = 1.

Além disso, essa solução expira em Ideone, mas foi testada para todos os casos de teste. Tempo limite porque, para economizar alguns bytes, fiz a j<iverificação explícita no loop interno. É principalmente implícito por i%j>0... exceto no caso de i=1e j=2(a primeira iteração), caso em que o loop é executado até j exceder (estou assumindo). Depois, funciona bem para todas as iterações posteriormente.

Para uma versão que não excede o tempo limite, são mais alguns bytes, veja aqui!

Xanderhall
fonte
0

Raquete 109 bytes

(let p((j 2)(k 0))(cond[(= 0(modulo(- j 1)n))(if(= k(- n 1))j(p(next-prime j)(+ 1 k)))][(p(next-prime j)k)]))

Ungolfed:

(define (f n)
  (let loop ((j 2)
             (k 0))
    (cond
      [(= 0 (modulo (sub1 j) n))
       (if (= k (sub1 n)) 
           j
           (loop (next-prime j) (add1 k)))]
      [else (loop (next-prime j) k)]  )))

Teste:

(f 1)
(f 2)
(f 3)
(f 4)
(f 100)
(f 123)

Saída:

2
5
19
29
39301
102337
rnso
fonte
0

Ruby 64 bytes

require'prime';f=->(n){t=n;Prime.find{|x|(x-1)%n==0&&(t-=1)==0}}

Chamado assim:

f.call(100)
# 39301

Além disso, este aplicativo de linha de comando funciona:

n=t=ARGV[0].to_i;p Prime.find{|x|(x-1)%n==0&&(t-=1)==0}

chamado assim

ruby -rprime find_golf_prime.rb 100

mas não tenho tanta certeza de como contar os caracteres. Acho que posso ignorar o nome do idioma, mas preciso incluir o -rprimeespaço antes do nome do script, para que seja um pouco mais curto, aos 63 anos. . .

Neil Slater
fonte
0

R, 72 bytes

n=scan();q=j=0;while(q<n){j=j+1;q=q+1*(numbers::isPrime(j)&!(j-1)%%n)};j

Terrivelmente ineficiente e lento, mas funciona. Ele lê a entrada de stdin e, em seguida, usa a isPrimefunção do numberspacote para encontrar os números primos. O resto está apenas verificando se prime - 1é divisível por n.

Billywob
fonte
0

JavaScript (ES6), 65 bytes

f=(n,i=n,j=1)=>i?f(n,i-!/^(..+?)\1+$/.test('.'.repeat(j+=n)),j):j

Utiliza o testador de primalidade regexp, pois é a) 8 bytes mais curto eb) menos recursivo do que minha abordagem recursiva pura.

Neil
fonte
0

Axioma 64 bytes

f(n)==(n<0 or n>150=>0;[i*n+1 for i in 0..2000|prime?(i*n+1)].n)

alguém sabe como escrever acima usando fluxos Axiom? ... algum exemplo

-> f(i)  for i in 1..150
   Compiling function f with type PositiveInteger -> NonNegativeInteger


   [2, 5, 19, 29, 71, 43, 211, 193, 271, 191, 661, 277, 937, 463, 691, 769,
    1531, 613, 2357, 1021, 1723, 1409, 3313, 1609, 3701, 2029, 3187, 2437,
    6961, 1741, 7193, 3617, 4951, 3877, 7001, 3169, 10657, 6271, 7879, 5521,
    13613, 3823, 15137, 7349, 9091, 7499, 18049, 6529, 18229, 7151, 13159,
    10141, 26501, 7669, 19801, 11593, 18127, 13109, 32569, 8221, 34649, 17981,
    21799, 16001, 28081, 10429, 39799, 19381, 29947, 14771, 47713, 16417,
    51539, 25013, 29101, 26449, 50051, 16927, 54037, 23761, 41149, 31489,
    68891, 19237, 51341, 33713, 45589, 34057, 84551, 19531, 64793, 42689,
    54499, 41737, 76001, 27457, 97583, 40867, 66529, 39301, 110899, 29989,
    116803, 49297, 51871, 56711, 126047, 38557, 133853, 42901, 76369, 53089,
    142607, 40129, 109481, 63337, 83071, 67733, 112337, 41281, 152219, 70639,
    102337, 75641, 126001, 42589, 176531, 85121, 107071, 62791, 187069, 55837,
    152419, 94873, 104761, 92753, 203857, 62929, 226571, 72661, 144103, 99401,
    193051, 69697, 168781, 112859, 133183, 111149, 250619, 60601]

Tipo: Tuple NonNegativeInteger

RosLuP
fonte