Encontrar el enésimo primer tal que el primo - 1 es divisible por n

33

Problema

El objetivo es, como dice el título, encontrar el enésimo primo de modo que el primo - 1 sea divisible por n.

Explicación

Aquí hay un ejemplo para que entienda la pregunta, esta no es necesariamente la forma en que debe resolverse. Simplemente como una forma de explicar la pregunta

dado 3 como entrada, primero miraríamos todos los primos

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

Luego seleccionamos los primos de manera que el primo - 1 sea divisible por n (3 en este caso)

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

Luego seleccionamos el enésimo término en esta secuencia

Produciríamos 19 para una entrada de 3

Nota

También podemos pensar en esto como el enésimo en la secuencia {1, n + 1, 2n + 1, 3n + 1 ... kn + 1} donde k es cualquier número natural

Casos de prueba

  1 --> 2
  2 --> 5
  3 --> 19
  4 --> 29
100 --> 39301
123 --> 102337
Ando Bando
fuente
Dices enésimo [...] primer divisible por n . Son N y n el mismo número?
Dennis
Lo siento, sí, son lo mismo, debería haberlo arreglado ahora
Ando Bando
3
A077317
Gabriel Benamy
44
Es posible que desee agregar 1 -> 2 a los casos de prueba. Una de mis respuestas se equivocó en algún momento.
Dennis
Otra forma de expresar esto es "encontrar el enésimo número primo en la secuencia aritmética 1, n + 1,2n + 1, ..., kn + 1, ... (secuencia que garantiza Thich de infinitos números primos . )
hardmath

Respuestas:

9

05AB1E , 9 8 bytes

05AB1E utiliza la codificación CP-1252 .

Guardado un byte gracias a Osable

µN¹*>Dp½

Pruébalo en línea!

Explicación

µ          # 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
fuente
3
En lugar de imponer fuerza bruta, sugeriría generar múltiplos de N primero y luego verificar si son números primos. Se me ocurrió µN¹*>Dp½que guarda un byte y acelera el cálculo.
Osable
2
@Osable: ¡Ah, por supuesto! De hecho, ese es un enfoque mucho mejor. Gracias :)
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
fuente
5

Mathematica, 48 bytes

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

Función sin nombre que toma un único argumento, que nombra n. Genera una lista de los primeros n^3primos, selecciona los que son congruentes con 1 módulo n, luego toma eln elemento th del resultado. Se ejecuta en varios segundos en la entrada 123.

Actualmente no se sabe si siempre hay un solo primo, entre los primeros n^3primos, que sea congruente con 1 módulo n, mucho menos nde ellos. ¡Sin embargo, el algoritmo puede probarse correcto (al menos para grandes n) bajo el supuesto de la hipótesis generalizada de Riemann !

Greg Martin
fuente
5

Haskell, 59 47 bytes

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

Ejemplo de uso: f 4->29 .

Cómo 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

Editar: Gracias @Damien por 12 bytes eliminando la prueba de divisibilidad y solo mirando los múltiplos en primer lugar.

nimi
fuente
f n=[p|p<-[1,n+1..],all((<2).gcd p)[2..p-1]]!!n
Damien el
@Damien: wow, un byte ahorrado del 20%. ¡Muchas gracias!
nimi
3

Jalea , 9 bytes

‘ÆP>%ð#Ṫ‘

Pruébalo en línea!

Cómo 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
fuente
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;}}

Sin golf:

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 de prueba:

Pruébelo aquí (el último caso de prueba da como resultado un límite de tiempo excedido en 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));
  }
}

Salida:

2
5
19
29
39301
102337
Kevin Cruijssen
fuente
Niza para ver el Código ungolfed para la comparación, pero las pruebas tendría que estar en el código golfed para que tenga sentido ...
Trichoplax
@trichoplax Bueno, siempre publico el programa de prueba completo en la parte de Ungolfed y código de prueba de mis respuestas. Se System.out.printlnagregan principalmente para que vea qué entrada he usado para dar el resultado mostrado, y todo también se da en caso de que alguien quiera copiarlo y pegarlo en su IDE para jugar.
Kevin Cruijssen
1
Mi comentario no fue pensado con demasiada seriedad, solo podría hacer que algunas personas piensen que solo has probado el código antes de jugar al golf. Siempre podría tener tres secciones: Golf, Ungolfed y Golfed con código de prueba, si quisiera evitar esa suposición ...
trichoplax
1
@trichoplax Ah ok, en ese caso es un buen comentario justificado. :) Editaré este, y lo tendré en cuenta para futuros desafíos.
Kevin Cruijssen
3

Nasm 679 bytes (Instrucción 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 no es un golfista y los 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
fuente
2

En realidad , 13 bytes

Sugerencias de golf bienvenidas! Pruébalo en línea!

;╗`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
fuente
2

Lisp común, 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

Sin golf:

(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))))

Algunas de esas loopconstrucciones probablemente se pueden acortar en dobucles, pero esto es lo que tengo por ahora.

artificial
fuente
2

MATL , 12 bytes

1i:"`_YqtqG\

Pruébalo en línea!

(Para la entrada, 123se agota el tiempo de espera en el compilador en línea, pero funciona sin conexión).

Explicación

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
fuente
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]

Utiliza la expresión regular de prueba principal para determinar si $pes primo, y se asegura de que sea congruente con 1 mod de entrada (los únicos enteros no negativos por debajo de 2 son 0 y 1, pero no puede ser 0 si es primo, por lo que debe ser 1. ahorra 1 byte más ==1).

Gabriel Benamy
fuente
Esto parece imprimir 3 para la entrada 1 (debe ser 2 ).
Dennis
Puede guardar 10 bytes haciendo (1 x++$.)!~/^(11+?)\1+$/&&($.%$_<2)&&push@a,$.while@a<$_;say$a[-1](es de lo que estaba hablando en mi comentario anterior). Sin embargo, la salida (de cualquiera de las versiones) parece mal durante al menos 2 y 3 ...
Dada
1

Mathematica 44 Bytes

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

Muy rapido. Utiliza la idea de la "Nota"

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

Salida

{0.0156001, {2, 5, 19, 29, 39301, 102337}}
Kelly Lowder
fuente
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
fuente
0

Java 8, 84 bytes

Golfed

(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;}

Sin golf

(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.
}

Explicación

Solución inspirada en varias otras respuestas. La función es una lambda que espera un solo int.

los n>1?i:2 es un truco barato porque no pude encontrar una mejor manera de considerar el caso de n = 1.

Además, esta solución supera el tiempo de espera de Ideone, pero se ha probado para todos los casos de prueba. Se agota el tiempo de espera porque para reducir un par de bytes, saqué la j<iverificación explícita en el bucle interno. Está implicado principalmente por i%j>0... excepto en el caso de i=1yj=2 (la primera iteración), en cuyo caso el ciclo se ejecuta hasta que j se desborde (supongo). Entonces funciona bien para todas las iteraciones posteriores.

Para una versión que no agota el tiempo, es un par de bytes más, ¡ mira aquí!

Xanderhall
fuente
0

Raqueta 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)]))

Sin golf:

(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)]  )))

Pruebas:

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

Salida:

2
5
19
29
39301
102337
rnso
fuente
0

Ruby 64 bytes

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

Llamado así:

f.call(100)
# 39301

Además, esta aplicación de línea de comandos funciona:

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

llamado así

ruby -rprime find_golf_prime.rb 100

pero no estoy tan seguro de cómo contar los personajes. Creo que puedo ignorar el nombre del idioma, pero tengo que incluir el -rprimeespacio y antes del nombre del script, por lo que es un poco más corto, en 63. . .

Neil Slater
fuente
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

Terriblemente ineficiente y lento, pero funciona. Lee la entrada de stdin y luego usa la isPrimefunción del numberspaquete para encontrar los primos. El resto es solo verificar si prime - 1es divisible por n.

Billywob
fuente
0

JavaScript (ES6), 65 bytes

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

Utiliza el probador de primidad regexp, ya que es a) 8 bytes más corto yb) menos recursivo que mi enfoque recursivo puro.

Neil
fuente
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)

¿Alguien sabe cómo escribir arriba usando secuencias de Axiom? ... algún ejemplo

-> 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: Tupla Entero no negativo

RosLuP
fuente