Compito

C'è un insieme di numeri x, tale che x^2divide 7^x-1.

Il tuo compito è trovare questi numeri. Dato un input di n, il codice stamperà l'ennesimo numero che segue questa regola.

Esempi 1-indice

In   Out
3    3
9    24
31   1140

La sequenza pertinente può essere trovata qui .

Regole

La risposta più breve sarà il vincitore *

Si applicano le regole del golf standard

Non sono ammesse scappatoie

La risposta può essere 0 o 1 indicizzata, si prega di indicare nella risposta

Haskell, 34 byte

([x|x<-[1..],mod(7^x-1)(x^2)<1]!!)

Questo utilizza l'indicizzazione basata su 0. Esempio di utilizzo: ([x|x<-[1..],mod(7^x-1)(x^2)<1]!!) 30-> 1140.

È un'implementazione diretta della definizione. Costruisce un elenco di tutti i numeri xe seleziona il nth.

Pyth , 10 byte

e.f!%t^7Z*

Un programma che accetta l'input di un numero intero e stampa un valore a un indice.

Provalo online!

Come funziona

e.f!%t^7Z*     Program. Input: Q
e.f!%t^7Z*ZZQ  Implicit variable fill
               Implicitly print
e              the last
 .f         Q  of the first Q positive integers Z
     t^7Z      for which 7^Z - 1
    %          mod
         *ZZ   Z^2
   !           is zero

JavaScript (ES7), 40 byte

f=(n,i=1)=>n?f(n-!((7**++i-1)%i**2),i):i

Questo perde precisione abbastanza rapidamente a causa del fatto che JS perde precisione 7**19. Ecco una versione ES6 di precisione quasi arbitraria:

f=(n,i=0)=>n?f(n-!(~-(s=++i*i,g=j=>j?g(j-1)*7%s:1)(i)%s),i):i

Questo termina in circa un secondo per il test case 31.

Alcuni approcci più lunghi:

f=(n,i=0)=>n?f(n-!(~-(s=>g=j=>j?g(j-1)*7%s:1)(++i*i)(i)%s),i):i
f=(n,i=0)=>n?f(n-!(s=++i*i,g=(j,n=1)=>j?g(j-1,n*7%s):~-n%s)(i),i):i
f=(n,i=0)=>n?f(n-!(s=>g=(j,n=1)=>j?g(j-1,n*7%s):~-n%s)(++i*i)(i),i):i

05AB1E , 11 byte

µ7Nm<NnÖiN¼

Provalo online!

Per qualche motivo non riesco ½a lavorare µ7Nm<NnÖ½No sarei legato a Pyth.

µ           # Loop until the counter equals n.
 7Nm<       # Calc 7^x+1.
     Nn     # Calc x^2.
       Ö    # Check divisibility.
        iN¼ # If divisible, push current x and increment counter.
            # Implicit loop end.
            # Implicitly return top of stack (x)

.

Python 2 , 48 46 byte

Grazie a @Dennis per -2 byte!

f=lambda n,i=1:n and-~f(n-(~-7**i%i**2<1),i+1)

Una funzione ricorsiva a un indice che accetta input tramite argomento e restituisce il risultato.

Provalo online! (Limite di ricorsione aumentato per consentire l'esecuzione del test case finale)

Come funziona

nè l'indice desiderato ed iè la variabile di conteggio.

L'espressione ~-7**i%i**2<1restituisce True(equivalente a 1) se i^2divide 7^i - 1e False(equivalente a 0) in caso contrario. Ogni volta che viene chiamata la funzione, il risultato dell'espressione viene sottratto n, diminuendo nogni volta che viene trovato un colpo; iviene anche incrementato.

Il comportamento in corto circuito di andsignifica che quando nè 0, 0viene restituito; questo è il caso base. Una volta raggiunto questo, la ricorsione si interrompe e il valore corrente di iviene restituito dalla chiamata di funzione originale. Piuttosto che usare esplicitamente i, questo viene fatto usando il fatto che per ogni chiamata di funzione, è stato eseguito un incremento usando il -~davanti alla chiamata; i 0 itempi di incremento danno i, come richiesto.

Python 2 , 57 53 51 byte

^{-4 byte grazie a ETHproductions
-2 byte grazie a TuukkaX}

i=0
g=input()
while g:i+=1;g-=~-7**i%i**2<1
print i

Provalo online!
la sequenza è 1 indicizzata

Python 2, 57 byte

Ciò richiede molto, molto tempo per valori di grandi dimensioni. Utilizza anche molta memoria, perché crea l'intero elenco molto più lontano del necessario. Il risultato è indicizzato zero.

lambda n:[x for x in range(1,2**n+1)if(7**x-1)%x**2<1][n]

Provalo online

Mathematica, 43 byte

Al momento ho tre diverse soluzioni con questo numero di byte:

Nest[#+1//.x_/;!(x^2∣(7^x-1)):>x+1&,0,#]&
Nest[#+1//.x_/;Mod[7^x-1,x^2]>0:>x+1&,0,#]&
Nest[#+1//.x_:>x+Sign@Mod[7^x-1,x^2]&,0,#]&

PARI / GP , 42 byte

Abbastanza diretto. 1 indicizzato, anche se questo potrebbe essere facilmente modificato.

n->=k=1;while(n--,while((7^k++-1)%k^2,));k

o

n->=k=1;for(i=2,n,while((7^k++-1)%k^2,));k

Python 3 , 45 byte

f=lambda n,k=2:n<2or-~f(n-(7**k%k**2==1),k+1)

Restituisce True per l'ingresso 1 , che è consentito per impostazione predefinita .

Provalo online!

R, 35 byte

Questo funziona solo per n<=8.

z=1:20;which(!(7^z-1)%%z^2)[scan()]

Tuttavia, ecco una versione più lunga per cui funziona n<=25, per 50 byte :

z=1:1e6;which(gmp::as.bigz(7^z-1)%%z^2==0)[scan()]

PHP, 47 49 byte

while($n<$argv[1])$n+=(7**++$x-1)%$x**2<1;echo$x;

Funziona solo per n <9 ( 7**9è maggiore di PHP_INT_MAXcon 64 bit)

62 byte usando numeri interi di lunghezza arbitraria: (non testato; PHP sulla mia macchina non ha bcmath)

for($x=$n=1;$n<$argv[1];)$n+=bcpowmod(7,++$x,$x**2)==1;echo$x;

Corri con php -nr '<code>' <n>.

pseudo codice

implicit: $x = 0, $n = 0
while $n < first command line argument
    increment $x
    if equation is satisfied
        increment $n
print $x

Pyke, 10 byte

~1IX7i^tR%

Provalo qui!

~1         -  infinite(1)
  IX7i^tR% - filter(^, not V)
    7i^    -    7**i
       t   -   ^-1
        R% -  ^ % v
   X       -   i**2
           - implicit: print nth value

Clojure , 83 byte

(fn[n](nth(filter #(= 0(rem(-(reduce *(repeat % 7N))1)(* % %)))(iterate inc 1N))n))

Provalo online!

Questo crea un elenco infinito di BigIntegers Java a partire da 1 e li filtra in base alla definizione. Esso utilizza indicizzazione in base zero per selezionare il n ^esimo valore dall'elenco filtrato.

Perl 5, 35 byte

Bene, questo mancava, quindi eccolo qui:

map{$_ if!((7**$_-1)%($_**2))}1..<>

Powershell, troppi byte

Solo per vedere se era possibile e lo è.

[System.Linq.Enumerable]::Range(1,10000)|?{[System.Numerics.BigInteger]::Remainder([System.Numerics.BigInteger]::Pow(7,$_)-1,$_*$_) -eq 0}

Perl 6 , 35 34 byte

{grep({(7**$_-1)%%$_²},^∞)[$_]}

0-indicizzati.

Rasato di un byte grazie a Brad Gilbert.

QBIC , 39 byte

:{~(7^q-1)%(q^2)=0|b=b+1]~b=a|_Xq\q=q+1

Non riuscivo a farlo funzionare in QBasic 4.5, ma sembra funzionare bene in QB64. Per qualche motivo inspiegabile, QBasic rifiuta di dividere nettamente 13.841.287.200 per 144, ma fornisce invece un resto di -128. Quindi restituisce 16 come settimo termine di questa sequenza anziché 12 ...

:{      get N from the command line, start an infinite DO-loop
~       IF
(7^q-1) Part 1 of the formula (Note that 'q' is set to 1 as QBIC starts)
%       Modulus
(q^2)   The second part
=0      has no remainder
|b=b+1  Then, register a 'hit'
]       END IF
~b=a    If we have scored N hits
|_Xq    Quit, printing the last used number (q)
\q=q+1  Else, increase q by 1. 
        [DO-loop and last IF are implicitly closed by QBIC]

Meraviglia , 28 byte

@:^#0(!>@! % - ^7#0 1^#0 2)N

Zero indicizzati. Uso:

(@:^#0(!>@! % - ^7#0 1^#0 2)N)2

Filtra dall'elenco dei numeri naturali con un predicato che determina se x^2è divisibile per 7^x-1, quindi ottiene l'ennesimo elemento in quell'elenco.

Tcl , 73 byte

while {[incr i]} {if 0==(7**$i-1)%$i**2 {incr j;if $j==$n break}}
puts $i

Provalo online!