Мне нравится думать о 10-адическом числе как о числе, которое идет бесконечно влево, или о целом числе по очень очень большой степени 10.

Вещи несут бесконечно налево и исчезают. Чтобы понять, что я имею в виду, обратите внимание, что ...6667 * 3 = 1в 10-адической стране, так как «2», которая несет налево, уходит в бесконечность.

Сложение и умножение имеют смысл для 10-адических чисел, поскольку последние nцифры суммы / произведения зависят только от последних nцифр слагаемых / мультипликатов.

Учитывая n, вам нужно вывести последние nцифры 10-адического кубического корня из 3, то есть xудовлетворительно x*x*x = 3.

Это конец:

...878683312291648481630318492665160423850087895134587

Ваш код должен прекратить действие n=1000до отправки.

Предположим, что если число, которое вам нужно напечатать, начинается с нуля, то вам не нужно печатать ведущие нули, так как на самом деле нет смысла печатать лишние нули.

Это код-гольф . Кратчайший ответ в байтах побеждает.

Python 2 , 33 байта

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

Попробуйте онлайн!

powФункция эффективно вычисляет модульный показатель 3**(10**k*2/3+1)%10**k.

Нас просят найти решение r**3 = 3 (mod 10**k). Мы хотим найти экспоненту, eдля которой карта x -> x**eобратна модулю x -> x**3работы куба 10**k, так же, как экспоненты дешифрования и шифрования в RSA отменяют, чтобы получить исходное значение. Это значит, что (x**3)**e = x (mod 10**k)для всех x. (Мы будем предполагать на протяжении всего этого gcd(x,10) = 1.) Затем мы можем восстановить r, перевернув куб, чтобы получить r = 3**e (mod 10**k).

Расширяясь (r**3)**e = r (mod 10**k), мы получаем

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

Мы ищем показатель, 3*e-1который гарантирует умножение, которое дает нам столько копий 1.

Умножение по модулю 10**kобразует группу для обратимых чисел, то есть с gcd(x,10) = 1. По теореме Лагранжа, x**c = 1где cчисло элементов в группе. Для группы по модулю N, что граф является значением Эйлера φ(N), число значений от 1до N, взаимно простое с N. Итак, у нас есть r**φ(10**k) = 1 (mod 10**k). Следовательно, его достаточно для 3*e-1кратности φ(10**k).

Мы вычисляем

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

Итак, мы хотим 3*e-1быть кратным4 * 10**(k-1)

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

Возможны многие варианты r, но r=5дает краткое выражение

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

с eцелым номером. Небольшая игра в гольф с использованием разделения пола сокращает eдо 10**k*2/3+1, а экспрессия r = 3**e (mod 10**k)дает желаемый результат r.

Python 2 (PyPy) , 55 50 байт

-5 байт благодаря @HP Wiz !

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

Попробуйте онлайн!

Вычисляет (не брутфорс) цифра за цифрой, поэтому это быстрее, чем грубая сила.

Версия без exec

объяснение

(Спасибо @Leaky Nun и @ user202729 за это)

Во-первых, обратите внимание, что n**3это инволюция по модулю 10 (то есть, если функция вызывается f, то f(f(n)) == n). Это можно подтвердить с помощью исчерпывающего поиска.

Мы можем использовать математическую индукцию, чтобы найти следующую цифру.
Позвольте быть th цифрой числа (справа).dnn

д 1 3 ≡ 3 (мод 10)
 д 1 3 3 (мод 10)
    ≡ 27 (мод 10)
    ≡ 7 (мод 10)

Теперь предположим, что мы знаем число с точностью до kдесятой цифры,x

              х 3 х 3 (мод 10 к )
  (d k + 1 · 10 k + x) 3 ≡ 3 (мод 10 k + 1 )
3 · d k + 1 x 2 · 10 k + x 3 ≡ 3 (мод 10 k + 1 ) (биномиальное расширение.)
(Обратите внимание, что два других члена можно игнорировать, поскольку они равны 0 mod 10 k + 1 )
3 · d k + 1 x 2 · 10 k + x 3 ≡ 3 (мод 10 k + 1 )

Мы знаем это:

       х 7 (мод 10)
      х 2 49 (мод 10)
         № 9 (мод 10)
  x 2 · 10 k ≡ 9 · 10 k   (мод 10 k + 1 )
3 · x 2 · 10 k ≡ 27 · 10 k (мод 10 k + 1 )
         · 7 · 10 К   (мод 10 К + 1 )

Подставляя это в:

3 · d k + 1 x 2 · 10 k + x 3 ≡ 3 (мод 10 k + 1 )
  7 · d k + 1 · 10 k + x 3 ≡ 3 (мод 10 k + 1 )
             d k + 1 ≡ (3 - x 3 ) ÷ (7 · 10 k ) (мод 10)
                 ≡ (3 - x 3 ) ÷ (7 · 10 к ) (мод 10)
           K d k + 1 ≡ 3 · (3 - x 3 ) ÷ 10 k    (мод 10) (3 - обратная величина 7 мод 10)

Wolfram Language (Mathematica) , 21 байт

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

Попробуйте онлайн!

05AB1E , 17 13 байт

7IGD3mN°÷7*θì

Порт ответа @ ASCII-только Python 2 (PyPy) .
-4 байта И исправлена ​​ошибка для выходов с ведущими нулями благодаря @Emigna , заменяя T%N°*+на θì.

Попробуйте онлайн.

Объяснение:

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 байтов

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

Порт ответа @ ASCII-только Python 2 (PyPy) .
-2 байта благодаря @Neil .
-20 байт благодаря @ ASCII-only .

ПРИМЕЧАНИЕ. Ответ @ OlivierGrégoire на Java уже намного короче. использованием алгоритмического подхода modPow.

Попробуйте онлайн.

Объяснение:

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 байт

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

Попробуйте онлайн!

кредиты

• Порт xnor's Python 2 ответ .
• -6 байт благодаря Кевину Круйссену

дк , 15

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

Использует модульное возведение в степень, как и ответ @ xnor .

Попробуйте онлайн!

TIO рассчитывает ввод = 1000 в 21 с.

Пиф , 12

.^3h/y^TQ3^T

Попробуйте онлайн!

Снова, используя модульное возведение в степень, как ответ @ xnor .

Haskell , 37 байт

1 байт сохранен благодаря ASCII-только!

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

Попробуйте онлайн!

Я использую аналогичный подход только к ASCII, но я избегаю использования деления

Pyth , 23 байта

Конечно, это использует подход только ASCII.

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

Попробуй это здесь!

Древесный уголь , 26 22 байта

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

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение:

≔⁷η

Инициализируйте результат до 7. (Не должно быть 7, но 0 не работает.)

ＦＮ

Цикл по количеству необходимых цифр.

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

Теперь использует подход @ HPWiz для сохранения 4 байтов.

Ｉη

Распечатайте результат.

Вот 28-байтовая версия с перебором, которая берет кубические корни произвольных значений:

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

Попробуйте онлайн! Ссылка на подробную версию кода. Первый ввод - это число цифр, второй - значение для корня.

J , 33 байта

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

TIO

порт ответа @ ASCII-only, но с использованием фиксированного значения по модулю 10 ^ n

Желе , 23 18 17 байт

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

Попробуйте онлайн!

Я знаю, ƒбудет полезно.