Aufgabe

Es gibt eine Reihe von Zahlen x, die sich x^2teilen 7^x-1.

Ihre Aufgabe ist es, diese Zahlen zu finden. Bei einer Eingabe von n gibt der Code die n-te Zahl aus, die dieser Regel folgt.

Beispiele 1-Index

In   Out
3    3
9    24
31   1140

Die entsprechende Reihenfolge finden Sie hier .

Regeln

Kürzeste Antwort gewinnt *

Es gelten die Standard-Golfregeln

Lücken sind nicht erlaubt

Ihre Antwort kann entweder mit 0 oder 1 indiziert sein. Bitte geben Sie dies in Ihrer Antwort an

Haskell, 34 Bytes

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

Dies verwendet eine 0-basierte Indizierung. Anwendungsbeispiel: ([x|x<-[1..],mod(7^x-1)(x^2)<1]!!) 30-> 1140.

Es ist eine direkte Implementierung der Definition. Es erstellt eine Liste aller Zahlen xund wählt die nth.

Pyth , 10 Bytes

e.f!%t^7Z*

Ein Programm, das die Eingabe einer Ganzzahl akzeptiert und einen Wert mit einem Index ausgibt.

Probieren Sie es online!

Wie es funktioniert

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

Dies verliert relativ schnell an Präzision, da JS an Präzision verliert 7**19. Hier ist eine ES6-Version mit nahezu beliebiger Genauigkeit:

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

Dies ist für Testfall 31 innerhalb von etwa einer Sekunde abgeschlossen.

Ein paar längere Ansätze:

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 Bytes

µ7Nm<NnÖiN¼

Probieren Sie es online!

Aus irgendeinem Grund kann ich nicht ½arbeiten µ7Nm<NnÖ½Noder ich wäre mit Pyth verbunden.

µ           # 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 Bytes

Danke an @Dennis für -2 Bytes!

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

Eine einindexierte rekursive Funktion, die Eingaben über Argumente entgegennimmt und das Ergebnis zurückgibt.

Probieren Sie es online! (Das Rekursionslimit wurde erhöht, damit der letzte Testfall ausgeführt werden kann.)

Wie es funktioniert

nist der gewünschte Index und idie Zählvariable.

Der Ausdruck ~-7**i%i**2<1gibt True(äquivalent zu 1), wenn i^2dividiert wird 7^i - 1, und False(äquivalent zu 0), wenn nicht. Jedes Mal, wenn die Funktion aufgerufen wird, wird das Ergebnis des Ausdrucks abgezogen nund njedes Mal , wenn ein Treffer gefunden wird , dekrementiert . iwird ebenfalls erhöht.

Das Kurzschlussverhalten von andbedeutet, dass wann nist 0, 0zurückgegeben wird; Dies ist der Basisfall. Sobald dies erreicht ist, stoppt die Rekursion und der aktuelle Wert von iwird vom ursprünglichen Funktionsaufruf zurückgegeben. Anstatt explizit zu verwenden i, wird dies unter Verwendung der -~vor dem Aufruf stehenden Taste durchgeführt. Inkrementierzeiten 0 iergeben isich nach Bedarf.

Python 2 , 57 53 51 Bytes

^{-4 Bytes dank ETHproductions
-2 Bytes dank TuukkaX}

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

Probieren Sie es online!
Die Sequenz ist 1-indiziert

Python 2, 57 Bytes

Bei großen Werten dauert dies sehr, sehr lange. Außerdem wird viel Speicher verwendet, da die gesamte Liste weiter als erforderlich erstellt wird. Das Ergebnis ist nullindexiert.

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

Probieren Sie es online aus

Mathematica, 43 Bytes

Ich habe derzeit drei verschiedene Lösungen bei dieser Byteanzahl:

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 Bytes

Ziemlich einfach. 1-indiziert, obwohl dies leicht geändert werden könnte.

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

oder

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

Python 3 , 45 Bytes

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

Geben Sie für Eingabe 1 True zurück , was standardmäßig zulässig ist .

Probieren Sie es online!

R, 35 Bytes

Dies funktioniert nur für n<=8.

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

Hier ist jedoch eine längere Version, die n<=25für 50 Bytes funktioniert :

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

PHP, 47 49 Bytes

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

Funktioniert nur für n <9 ( 7**9ist größer als PHP_INT_MAXbei 64bit)

62 Bytes mit Ganzzahlen beliebiger Länge: (nicht getestet; PHP auf meinem Rechner hat kein bcmath)

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

Laufen Sie mit php -nr '<code>' <n>.

Pseudocode

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

Pyke, 10 Bytes

~1IX7i^tR%

Probieren Sie es hier aus!

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

Clojure , 83 Bytes

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

Probieren Sie es online!

Dies erstellt eine unendliche Liste von Java BigIntegers ab 1 und filtert sie nach der Definition. Es verwendet eine nullbasierte Indizierung, um den n- ^ten Wert aus der gefilterten Liste auszuwählen .

Perl 5, 35 Bytes

Nun, das fehlte, also hier ist es:

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

PowerShell, zu viele Bytes

Nur um zu sehen, ob es möglich war und ist.

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

Perl 6 , 35 34 Bytes

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

0-indiziert.

Dank Brad Gilbert ein Byte gespart.

QBIC , 39 Bytes

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

Ich konnte es in QBasic 4.5 nicht zum Laufen bringen, aber es scheint in QB64 gut zu laufen. Aus irgendeinem unerklärlichen Grund weigert sich QBasic, 13.841.287.200 sauber durch 144 zu teilen, sondern gibt stattdessen einen Rest von -128 an. Es gibt dann 16 als 7. Term dieser Sequenz statt 12 zurück ...

:{      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]

Wunder , 28 Bytes

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

Nullindexiert. Verwendung:

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

Filtert aus der Liste der natürlichen Zahlen mit einem Prädikat, das bestimmt, ob x^2es durch teilbar ist 7^x-1, und erhält dann das n-te Element in dieser Liste.

Tcl , 73 Bytes

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

Probieren Sie es online!