Eu gosto de pensar em um número 10-adic como um número que vai infinitamente para a esquerda, ou em um módulo inteiro uma potência muito grande de 10.

As coisas carregam infinitamente para a esquerda e desaparecem. Para entender o que quero dizer, observe que ...6667 * 3 = 1na terra 10-adic, já que o "2" que leva à esquerda vai para o infinito.

Adição e multiplicação fazem sentido para números 10-adic, uma vez que os últimos ndígitos da soma / produto dependem apenas dos últimos dígitos da soma n/ multiplicandos.

Dado n, você precisa imprimir os últimos ndígitos da raiz cúbica 10-adic de 3, ou seja, xsatisfatório x*x*x = 3.

Termina:

...878683312291648481630318492665160423850087895134587

Seu código deve terminar n=1000antes do envio.

Digamos que, se o número que você precisa imprimir começa com zero, não é necessário imprimir os zeros iniciais, pois não é realmente o ponto de imprimir zeros extras.

Isso é código-golfe . A resposta mais curta em bytes vence.

Python 2 , 33 bytes

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

Experimente online!

A powfunção calcula eficientemente o expoente modular 3**(10**k*2/3+1)%10**k.

Somos solicitados a encontrar uma solução para r**3 = 3 (mod 10**k). Queremos encontrar um expoente epara o qual o mapa x -> x**eé inverso ao cubo do x -> x**3mod de trabalho 10**k, assim como os expoentes de descriptografia e criptografia no RSA são cancelados para produzir o valor original. Isso significa isso (x**3)**e = x (mod 10**k)para todos x. (Vamos assumir isso gcd(x,10) = 1.) Então, podemos recuperar rinvertendo o cubo para obter r = 3**e (mod 10**k).

Expandindo (r**3)**e = r (mod 10**k), obtemos

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

Estamos à procura de um expoente 3*e-1que garanta a multiplicação que muitas cópias nos dão 1.

O módulo de multiplicação 10**kforma um grupo para números invertíveis, ou seja, números com gcd(x,10) = 1. Pelo Teorema de Lagrange, x**c = 1onde cestá a contagem de elementos no grupo. Para o módulo de grupo N, essa contagem é o valor do totiente de Euler φ(N), o número de valores de 1para Nque são relativamente primos para N. Então nós temos r**φ(10**k) = 1 (mod 10**k). Portanto, basta 3*e-1ser um múltiplo de φ(10**k).

Computamos

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

Então, queremos 3*e-1ser um múltiplo de4 * 10**(k-1)

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

Muitas opções são possíveis r, mas r=5dá a expressão curta

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

com eum número inteiro. Um pouco golfe usando encurta chão divisão epara 10**k*2/3+1, e expressando r = 3**e (mod 10**k)dá o resultado desejado r.

Python 2 (PyPy) , 55 50 bytes

-5 bytes graças a @HP Wiz !

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

Experimente online!

Calcula dígito (sem força bruta) por dígito, para que seja mais rápido que a força bruta.

Versão sem exec

Explicação

(Obrigado @Leaky Nun e @ user202729 por descobrir isso)

Primeiro, observe que esse n**3é um módulo de involução 10 (ou seja, se a função é chamada f, então f(f(n)) == n). Isso pode ser confirmado usando uma pesquisa exaustiva.

Podemos usar a indução matemática para encontrar o próximo dígito.
Let Ser o th dígito do número (da direita).dnn

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

Agora, suponha que sabemos o número até o kth dígito,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 ) (expansão binomial.)
(Observe que os outros dois termos podem ser ignorados, pois são 0 mod 10 k + 1 )
3 · d k + 1 x 2 · 10 k + x 3 ≡ 3 (mod 10 k + 1 )

Nós sabemos isso:

       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 )

Substituindo isso em:

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 é o inverso de 7 mod 10)

Wolfram Language (Mathematica) , 21 bytes

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

Experimente online!

05AB1E , 17 13 bytes

7IGD3mN°÷7*θì

Porta da resposta Python 2 (PyPy) da @ ASCII-only .
-4 bytes E correção de bugs para saídas com zeros à esquerda , graças a @Emigna , substituindo T%N°*+por θì.

Experimente online.

Explicação:

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

Porta da resposta Python 2 (PyPy) da @ ASCII-only .
-2 bytes graças a @Neil .
-20 bytes graças a @ ASCII-only .

NOTA: Já existe uma resposta Java muito mais curta do @ OlivierGrégoire usando uma abordagem algorítmica utilizando modPow.

Experimente online.

Explicação:

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 bytes

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

Experimente online!

Créditos

• Porta da resposta Python 2 do xnor .
• -6 bytes graças a Kevin Cruijssen

dc , 15

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

Usa exponenciação modular, como a resposta do @ xnor .

Experimente online!

O TIO calcula a entrada = 1000 em 21s.

Pyth , 12

.^3h/y^TQ3^T

Experimente online!

Novamente, usando exponenciação modular, como a resposta do @ xnor .

Haskell , 37 bytes

1 byte economizado graças ao ASCII-only!

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

Experimente online!

Eu uso uma abordagem semelhante apenas ao ASCII, mas evito usar divisão

Pitão , 23 bytes

Obviamente, isso usa a abordagem apenas do ASCII.

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

Experimente aqui!

Carvão , 26 22 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

≔⁷η

Inicialize o resultado para 7. (Não precisa ser 7, mas 0 não funciona.)

ＦＮ

Faça um loop sobre o número de dígitos necessários.

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

Agora usa a abordagem do @ HPWiz para economizar 4 bytes.

Ｉη

Imprima o resultado.

Aqui está uma versão de força bruta de 28 bytes que cria raízes cúbicas de valores arbitrários:

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

Experimente online! Link é a versão detalhada do código. A primeira entrada é o número de dígitos, a segunda é o valor para a raiz.

J , 33 bytes

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

TIO

porta da resposta do @ ASCII-only, mas usando o módulo fixo 10 ^ n

Geléia , 23 18 17 bytes

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

Experimente online!

Eu sei ƒque será útil.