J'aime à penser à un nombre 10-adique comme un nombre qui va infiniment vers la gauche, ou à un module entier une très très grande puissance de 10.

Les choses portent infiniment vers la gauche et disparaissent. Pour voir ce que je veux dire, notons que ...6667 * 3 = 1dans le pays 10-adique, puisque le "2" qui porte vers la gauche va à l'infini.

L'addition et la multiplication ont un sens pour les nombres 10-adiques, car les derniers nchiffres de la somme / produit ne dépendent que des derniers nchiffres des sommets / multiplicandes.

Étant donné n, vous devez imprimer les derniers nchiffres de la racine cubique 10-adique de 3, c'est-à-dire xsatisfaisant x*x*x = 3.

Cela se termine:

...878683312291648481630318492665160423850087895134587

Votre code doit se terminer n=1000avant la soumission.

Disons que si le nombre que vous devez imprimer commence par zéro, vous n'avez pas besoin d'imprimer les zéros de tête, car ce n'est pas vraiment le point d'imprimer des zéros supplémentaires.

C'est du code-golf . La réponse la plus courte en octets gagne.

Python 2 , 33 octets

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

Essayez-le en ligne!

La powfonction calcule efficacement l'exposant modulaire 3**(10**k*2/3+1)%10**k.

On nous demande de trouver une solution r**3 = 3 (mod 10**k). Nous voulons trouver un exposant epour lequel la carte x -> x**eest inverse du cubing x -> x**3mod de travail 10**k, tout comme les exposants de déchiffrement et de chiffrement dans RSA annulent pour produire la valeur d'origine. Cela signifie que (x**3)**e = x (mod 10**k)pour tous x. (Nous supposerons tout au long de cela gcd(x,10) = 1.) Ensuite, nous pouvons récupérer ren inversant le cubage pour obtenir r = 3**e (mod 10**k).

L'expansion (r**3)**e = r (mod 10**k), nous obtenons

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

Nous recherchons un exposant 3*e-1qui garantit la multiplication du nombre d'exemplaires 1.

Le module de multiplication 10**kforme un groupe de nombres inversibles, c'est-à-dire ceux avec gcd(x,10) = 1. Par le théorème de Lagrange, x**c = 1où cest le nombre d'éléments dans le groupe. Pour le groupe modulo N, ce décompte est la valeur φ(N)du total d' Euler , le nombre de valeurs de 1à Nqui sont relativement premiers à N. Donc, nous l'avons r**φ(10**k) = 1 (mod 10**k). Par conséquent, il suffit 3*e-1d'être un multiple de φ(10**k).

Nous calculons

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

Donc, nous voulons 3*e-1être un multiple de4 * 10**(k-1)

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

De nombreux choix sont possibles r, mais r=5donne l'expression courte

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

avec eun nombre entier. Un peu jouer au golf en utilisant raccourcit-division du sol eà 10**k*2/3+1, et l' expression r = 3**e (mod 10**k)donne le résultat souhaité r.

Python 2 (PyPy) , 55 50 octets

-5 octets grâce à @HP Wiz !

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

Essayez-le en ligne!

Calcule (non-bruteforcing) chiffre par chiffre, donc c'est plus rapide que la force brute.

Version sans exec

Explication

(Merci @Leaky Nun et @ user202729 d' avoir compris cela)

Tout d'abord, observez qu'il n**3s'agit d'un modulo d'involution 10 (c'est-à-dire si la fonction est appelée f, alors f(f(n)) == n). Cela peut être confirmé à l'aide d'une recherche exhaustive.

Nous pouvons utiliser l'induction mathématique pour trouver le chiffre suivant.
Soit le e chiffre du nombre (à partir de la droite).dnn

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

Supposons maintenant que nous connaissons le nombre jusqu'au ktroisième chiffre,x

              x 3 ≡ 3 (mod 10 k )
  (d k + 1 · 10 k + x) 3 ≡ 3 (mod 10 k + 1 )
3 · d k + 1 x 2 · 10 k + x 3 ≡ 3 (mod 10 k + 1 ) (expansion binomiale.)
(Notez que les deux autres termes peuvent être ignorés car ils sont 0 mod 10 k + 1 )
3 · d k + 1 x 2 · 10 k + x 3 ≡ 3 (mod 10 k + 1 )

Nous savons que:

       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 )

Substituant ceci dans:

3 · d k + 1 x 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 est l'inverse de 7 mod 10)

Wolfram Language (Mathematica) , 21 octets

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

Essayez-le en ligne!

05AB1E , 17 13 octets

7IGD3mN°÷7*θì

Port de la réponse Python 2 (PyPy) de @ ASCII uniquement .
-4 octets ET correction de bogue pour les sorties avec des zéros non significatifs grâce à @Emigna , en remplaçant T%N°*+par θì.

Essayez-le en ligne.

Explication:

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 141 136 135 octets

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 de la réponse Python 2 (PyPy) de @ ASCII uniquement .
-2 octets grâce à @Neil .
-20 octets grâce à @ ASCII uniquement .

NOTE: Il y a déjà une réponse Java beaucoup plus courte par @ OlivierGrégoire utilisant une approche algorithmique utilisant modPow.

Essayez-le en ligne.

Explication:

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 octets

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

Essayez-le en ligne!

Crédits

• Port de xnor Python 2 réponse .
• -6 octets grâce à Kevin Cruijssen

dc , 15

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

Utilise l'exponentiation modulaire, comme la réponse de @ xnor .

Essayez-le en ligne!

TIO calcule l'entrée = 1000 en 21 s.

Pyth , 12

.^3h/y^TQ3^T

Essayez-le en ligne!

Encore une fois, en utilisant l'exponentiation modulaire, comme la réponse de @ xnor .

Haskell , 37 octets

1 octet enregistré grâce à ASCII uniquement!

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

Essayez-le en ligne!

J'utilise une approche similaire à ASCII uniquement, mais j'évite d'utiliser la division

Pyth , 23 octets

Bien sûr, cela utilise l'approche ASCII uniquement.

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

Essayez-le ici!

Fusain , 26 22 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

≔⁷η

Initialisez le résultat à 7. (ne doit pas nécessairement être 7, mais 0 ne fonctionne pas.)

ＦＮ

Faites une boucle sur le nombre de chiffres requis.

        η       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.

Utilise désormais l'approche de @ HPWiz pour économiser 4 octets.

Ｉη

Imprimez le résultat.

Voici une version à force brute de 28 octets qui prend des racines cubiques de valeurs arbitraires:

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. La première entrée est le nombre de chiffres, la seconde est la valeur à la racine.

J , 33 octets

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

TIO

port de la réponse de @ ASCII uniquement, mais en utilisant le module fixe 10 ^ n tout au long

Gelée , 23 18 17 octets

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

Essayez-le en ligne!

Je sais que ce ƒsera utile.