Ich stelle mir eine 10-adische Zahl gerne als eine Zahl vor, die unendlich nach links geht, oder ein ganzzahliges Modulo, eine sehr sehr große Potenz von 10.

Dinge tragen unendlich nach links und verschwinden. Um zu sehen, was ich meine, beachten Sie, dass ...6667 * 3 = 1im 10-adischen Land, da die "2", die nach links trägt, ins Unendliche geht.

Addition und Multiplikation sind für 10-adische Zahlen sinnvoll, da die letzten nStellen der Summe / des Produkts nur von den letzten nStellen der Summanden / Multiplikanden abhängen .

Dazu nmüssen Sie die letzten nZiffern der 10-adischen xKubikwurzel von 3 ausgeben , also befriedigend x*x*x = 3.

Es endet:

...878683312291648481630318492665160423850087895134587

Ihr Code muss vor der Übermittlung für enden n=1000.

Nehmen wir an, wenn die zu druckende Zahl mit Null beginnt, brauchen Sie die führenden Nullen nicht zu drucken, da dies nicht der eigentliche Punkt ist, um zusätzliche Nullen zu drucken.

Das ist Code-Golf . Kürzeste Antwort in Bytes gewinnt.

Python 2 , 33 Bytes

lambda k:pow(3,10**k*2/3+1,10**k)

Probieren Sie es online!

Die powFunktion berechnet effizient den modularen Exponenten 3**(10**k*2/3+1)%10**k.

Wir werden gebeten, eine Lösung zu finden r**3 = 3 (mod 10**k). Wir wollen einen Exponenten finden, efür den die Map x -> x**eumgekehrt zu Cubing x -> x**3Working Mod ist 10**k, genau wie die Entschlüsselungs- und Verschlüsselungsexponenten in RSA aufheben, um den ursprünglichen Wert zu erzeugen. Das bedeutet das (x**3)**e = x (mod 10**k)für alle x. (Wir nehmen das an gcd(x,10) = 1.) Dann können wir uns erholen, rindem wir den Würfel umkehren, um zu erhalten r = 3**e (mod 10**k).

Wenn (r**3)**e = r (mod 10**k)wir uns ausdehnen , bekommen wir

r**(3*e-1) = 1 (mod 10**k)

Wir suchen einen Exponenten 3*e-1, der garantiert, dass wir so viele Kopien multiplizieren können 1.

Das Multiplikationsmodulo 10**kbildet eine Gruppe für invertierbare Zahlen, also solche mit gcd(x,10) = 1. Nach dem Satz von Lagrange, x**c = 1wo cist die Anzahl der Elemente in der Gruppe. Für die Gruppe Modulo Nist diese Anzahl der Euler-Totientenwert φ(N), die Anzahl der Werte von 1bis Nist relativ hoch N. Also haben wir r**φ(10**k) = 1 (mod 10**k). Daher ist es ausreichend 3*e-1, ein Vielfaches von zu sein φ(10**k).

Wir rechnen

φ(10**k) = φ(5**k) φ(2**k)= 4 * 5**(k-1) * 2**(k-1) = 4 * 10**(k-1)`

Wir wollen 3*e-1also ein Vielfaches von sein4 * 10**(k-1)

3*e - 1 = r * 4 * 10**(k-1)
e = (4r * 10**(k-1) + 1)/3

Viele Auswahlmöglichkeiten stehen zur Verfügung r, geben aber r=5den kurzen Ausdruck

e = (2 * 10**k + 1)/3

mit eeiner ganzen Zahl. Ein wenig Golf mit boden Division kürzt eauf 10**k*2/3+1, und mit dem Ausdruck r = 3**e (mod 10**k)gibt das gewünschte Ergebnis r.

Python 2 (PyPy) , 55-50 Bytes

-5 Bytes dank @HP Wiz !

n=p=1;exec"p*=10;n+=3*(3-n**3)%p;"*input();print n

Probieren Sie es online!

Berechnet Ziffer für Ziffer (ohne Brute-Forcing), ist also schneller als Brute-Force.

Version ohne exec

Erläuterung

(Danke @Leaky Nun und @ user202729 , dass Sie das herausgefunden haben)

Beobachten Sie zunächst, dass dies n**3ein Involution Modulo 10 ist (dh, wenn die Funktion aufgerufen wird f, dann f(f(n)) == n). Dies kann durch eine umfassende Suche bestätigt werden.

Wir können mathematische Induktion verwenden, um die nächste Ziffer zu finden.
Sei die dritte Ziffer der Zahl (von rechts).dnn

d 1 3 ≡ 3 (mod 10)
 d 1 ≡ 3 3 (mod 10)
    ≡ 27 (mod 10)
    ≡ 7 (mod 10)

Angenommen, wir kennen die Zahl bis zur kvierten Ziffer.x

              x 3 ≡ 3 (mod 10 k )
  (d k + 1 · 10 k + x) 3 × 3 (mod 10 k + 1 )
3 · d k + 1 · 2 · 10 k + x 3 · 3 (mod 10 k + 1 ) (Binomialexpansion.)
(Beachten Sie, dass die anderen beiden Begriffe ignoriert werden können, da sie 0 mod 10 k + 1 sind. )
3 · d k + 1 · 2 · 10 k + x 3 · 3 (mod 10 k + 1 )

Wir wissen das:

       x ≡ 7 (mod 10)
      x 2 ≡ 49 (mod 10)
         ≡ 9 (mod 10)
  x 2 · 10 k · 9 · 10 k   (mod 10 k + 1 )
3 · x 2 · 10 k · 27 · 10 k (mod 10 k + 1 )
         ≤ 7 · 10 k   (mod 10 k + 1 )

Einsetzen in:

3 · d k + 1 · 2 · 10 k + x 3 · 3 (mod 10 k + 1 )
  7 · d k + 1 · 10 k + x 3 · 3 (mod 10 k + 1 )
             d k + 1 ≤ (3 - x 3 ) ≤ (7 · 10 k ) (mod 10)
                 ≡ (3 - x 3 ) ÷ (7 · 10 k ) (mod 10)
           ≤ d k + 1 ≤ 3 · (3 - x 3 ) ≤ 10 k    (mod 10) (3 ist die Umkehrung von 7 mod 10)

Wolfram Language (Mathematica) , 21 Byte

PowerMod[3,1/3,10^#]&

Probieren Sie es online!

05AB1E , 17 13 Bytes

7IGD3mN°÷7*θì

Port der Python 2 (PyPy) -Antwort von @ ASCII-only .
-4 Byte UND Bugfix für Ausgaben mit führenden Nullen dank @Emigna , durch Ersetzen T%N°*+durch θì.

Probieren Sie es online aus.

Erläuterung:

7               # Start result-string `r` at '7'
IG              # Loop `N` in the range [1, input)
  D3m           #  `r` to the power 3
       ÷        #  Integer-divided with
     N°         #  10 to the power `N`
        7*      #  Multiplied by 7
          θì    #  Then take the last digit of this, and prepend it to the result `r`
                # Implicitly output result `r` after the loop

Java 8, 158 156 141 136 135 Bytes

n->{var t=n.valueOf(3);var r=n.ONE;for(int i=0;i++<n.intValue();)r=r.add(t.subtract(r.pow(3)).multiply(t).mod(n.TEN.pow(i)));return r;}

Port der Python 2 (PyPy) -Antwort von @ ASCII-only .
-2 Bytes dank @Neil .
-20 Bytes dank nur @ ASCII .

HINWEIS: Es gibt bereits eine viel kürzere Java-Antwort von @ OlivierGrégoire unter Verwendung eines algorithmischen Ansatzes modPow.

Probieren Sie es online aus.

Erläuterung:

n->{                            // Method with BigInteger as both parameter and return-type
  var t=n.valueOf(3);           //  Temp BigInteger with value 3
  var r=n.ONE;                  //  Result-BigInteger, starting at 1
  for(int i=0;i++<n.intValue();)//  Loop `i` in the range [1, n]
    r=r.add(                    //   Add to the result-BigDecimal:
       t.subtract(r.pow(3))     //    `t` subtracted with `r` to the power 3
       .multiply(t)             //    Multiplied by 3
       .mod(n.TEN.pow(i)));     //    Modulo by 10 to the power `i`
  return r;}                    //  Return the result-BigInteger

Java (JDK 10) , 106 Byte

n->n.valueOf(3).modPow(n.valueOf(2).multiply(n=n.TEN.pow(n.intValue())).divide(n.valueOf(3)).add(n.ONE),n)

Probieren Sie es online!

Credits

• Port of Xnors Python 2 Antwort .
• -6 Bytes dank Kevin Cruijssen

dc , 15

3?Ar^d2*3/1+r|p

Verwendet modulare Exponentiation, wie die Antwort von @ xnor .

Probieren Sie es online!

TIO berechnet die Eingabe = 1000 in 21s.

Pyth , 12

.^3h/y^TQ3^T

Probieren Sie es online!

Wieder mit modularer Exponentiation, wie @ xnors Antwort .

Haskell , 37 Bytes

Dank nur ASCII 1 Byte gespart!

(10!1!!)
n!x=x:(n*10)!mod(9-3*x^3+x)n

Probieren Sie es online!

Ich benutze einen ähnlichen Ansatz wie nur ASCII, aber ich vermeide die Division

Pyth , 23 Bytes

Dabei wird natürlich nur der ASCII-Ansatz verwendet.

K7em=+K*%*7/^K3J^TdTJtU

Probieren Sie es hier aus!

Holzkohle , 26 22 Bytes

≔⁷ηＦＮ≧⁺﹪׳⁻³Ｘη³Ｘχ⊕ιηＩη

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

≔⁷η

Initialisiere das Ergebnis auf 7. (Muss nicht 7 sein, aber 0 funktioniert nicht.)

ＦＮ

Durchlaufen Sie die Anzahl der erforderlichen Stellen.

        η       Current result.
       Ｘ ³     Take the cube. 
     ⁻³         Subtract from 3.
   ׳           Multiply by 3.
            ⊕ι  Increment the loop index.
          Ｘχ    Get that power of 10.
  ﹪             Modulo
≧⁺            η Add to the result.

Verwendet jetzt den Ansatz von @ HPWiz, um 4 Bytes zu sparen.

Ｉη

Drucken Sie das Ergebnis.

Hier ist eine 28-Byte-Brute-Force-Version, die Kubikwurzeln beliebiger Werte verwendet:

ＦＮ⊞υ⊟Φχ¬﹪⁻ＸＩ⁺κ⭆⮌υμ³ＩηＸχ⊕ι↓Ｉυ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Die erste Eingabe ist die Anzahl der Stellen, die zweite ist der Wert für root.

J , 33 Bytes

f=:3 :'((10x^y)|]+3*3-^&3)^:y 1x'

TIO

Port der Antwort von @ ASCII-only, aber durchgehend mit festem Modulo 10 ^ n

Jelly , 23 18 17 Bytes

*3:×7DṪ×+⁸
R⁵*çƒ7

Probieren Sie es online!

Ich weiß, ƒwird nützlich sein.