Розглянемо додатні цілі сили п'яти в десяткових. Ось перші 25, вирівняні праворуч:

 X                5^X
 1                  5
 2                 25
 3                125
 4                625
 5               3125
 6              15625
 7              78125
 8             390625
 9            1953125
10            9765625
11           48828125
12          244140625
13         1220703125
14         6103515625
15        30517578125
16       152587890625
17       762939453125
18      3814697265625
19     19073486328125
20     95367431640625
21    476837158203125
22   2384185791015625
23  11920928955078125
24  59604644775390625
25 298023223876953125

Зауважте, що найправіший стовпчик повноважень - це всі 5. Другий стовпець праворуч - це всі 2. Третій стовпець праворуч, зчитуватися зверху вниз, чергується 1, 6, 1, 6і т.д. починається наступний стовпець 3, 5, 8, 0а потім цикли.

Насправді, кожен стовпець (якщо ми спустимось досить далеко) має циклічну послідовність цифр, довжина яких удвічі більша за попередній цикл, за винятком початкових циклів 5s та 2s.

Викликаючи N номер стовпця, починаючи з N = 1 праворуч, перші кілька циклів:

N cycle at column N
1 5
2 2
3 16
4 3580
5 17956240
6 3978175584236200
7 19840377976181556439582242163600
8 4420183983595778219796176036355599756384380402237642416215818000

Виклик

Враховуючи додатне ціле число N, виведіть десяткові цифри циклу в стовпчик N, як описано вище. Наприклад, вихід для N = 4 буде 3580.

Цифри можуть виводитися у вигляді списку, такого як [3, 5, 8, 0]або в іншому розумному форматі, якщо:

• Цифри є в порядку, як прочитано зверху вниз у стовпцях потужності. наприклад 0853, недійсний.
• Цикл починається з верхнього числа в його стовпці потужності. наприклад 5803, недійсний, оскільки четвертий стовпець починається з 3не 5.
• Виводиться рівно один цикл. наприклад, 358або все 35803або 35803580було б недійсним.

Ваш код повинен працювати принаймні від N = 1 до 30.

За бажанням ви можете припустити, що стовпці є 0-індексованими замість 1-індексованих. Отже N = 0 дає 5, N = 1 дає 2, N = 2 дає 16, N = 3 дає 3580і т.д.

Виграє найкоротший код у байтах .

^{Завдяки Downgoat та DJ за підтримку викликів.}

Пітон 2, 62 61 58 байт

Нульова основа. Я припускаю, що суфікси L є прийнятними.

lambda n:[5**(n*3/7-~i)/2**n%10for i in range(2**n/2or 1)]

Вихід:

0 [5]
1 [2]
2 [1, 6]
3 [3, 5, 8, 0]
4 [1, 7, 9, 5, 6, 2, 4, 0]
5 [3, 9, 7, 8, 1, 7, 5, 5, 8, 4, 2, 3, 6, 2, 0, 0]
6 [1, 9, 8, 4, 0, 3, 7, 7, 9, 7, 6, 1, 8, 1, 5, 5, 6, 4, 3, 9, 5, 8, 2, 2, 4, 2L, 1L, 6L, 3
L, 6L, 0L, 0L]
7 [4, 4, 2, 0, 1, 8, 3, 9, 8, 3, 5, 9, 5, 7, 7, 8, 2, 1, 9, 7, 9, 6, 1, 7, 6L, 0L, 3L, 6L,
3L, 5L, 5L, 5L, 9L, 9L, 7L, 5L, 6L, 3L, 8L, 4L, 3L, 8L, 0L, 4L, 0L, 2L, 2L, 3L, 7L, 6L, 4L,
 2L, 4L, 1L, 6L, 2L, 1L, 5L, 8L, 1L, 8L, 0L, 0L, 0L]

Попереднє рішення:

lambda n:[5**int(n/.7-~i)/10**n%10for i in range(2**n/2or 1)]
lambda n:[str(5**int(n/.7-~i))[~n]for i in range(2**n/2)]or 5

Пояснення:

def f(n):
    r = max(2**n / 2, 1)
    m = int(n/0.7 + 1)
    for i in range(r):
        yield (5**(m+i) / 10**n) % 10

range(2**n/2)Використовує спостереження , що кожен цикл має довжину г = 2 ^п-1 , за винятком , коли п = 0, так що ми просто обчислити п-й цифру в протягом 5 ^м до 5 ^{м + т - 1} .

Початок циклу 5 ^м - це перше число, що перевищує 10 ^н . Розв’язування 5 ^m ≥ 10 ⁿ дає m ≥ n / log ₁₀ 5. Тут ми наближаємо log ₁₀ 5 ≈ 0.7, який вийде з ладу, коли n = 72. Ми можемо додати більше цифр для підвищення точності:

| approximation             | valid until        | penalty   |
|---------------------------|--------------------|-----------|
| .7                        | n = 72             | +0 bytes  |
| .699                      | n = 137            | +2 bytes  |
| .69897                    | n = 9297           | +4 bytes  |
| .698970004                | n = 29384          | +8 bytes  |
| .6989700043               | n = 128326         | +9 bytes  |
| .6989700043360189         | too large to check | +15 bytes |
| import math;math.log10(5) | same as above      | +23 bytes |

Цикл / 10**n % 10у циклі просто витягує потрібну цифру. Ще одне альтернативне рішення використовує маніпуляції зі струнами. Тут я використав хитрість,~n == -n-1 щоб видалити 1 байт.

Згаданий у коментарі вираз 5**(m+i) / 10**nможна додатково спростити таким чином, що дає поточну 58-байтну відповідь.

(Поділ x/2**nможна здійснити за допомогою бітового зсуву вправо x>>n. На жаль, завдяки перевазі оператора Python це не економить жодних байтів.) Фракцію 3/7 можна також покращити в аналогічних маннарах:

| approximation                   | valid until         | penalty   |
|---------------------------------|---------------------|-----------|
| n*3/7                           | n = 72              | +0 bytes  |
| n*31/72                         | n = 137             | +2 bytes  |
| n*59/137                        | n = 476             | +3 bytes  |
| n*351/815                       | n = 1154            | +4 bytes  |
| n*643/1493                      | n = 10790           | +5 bytes  |
| n*8651/20087                    | n = 49471           | +7 bytes  |
| int(n*.43067655807339306)       | too large to check  | +20 bytes |
| import math;int(n/math.log2(5)) | same as above       | +26 bytes |

постійного струму , 72 байти

[3Q]sq2?dsa^1+2/dsusk[Ola^/O%plk1-dsk1>q]sp1[d5r^dOla^<psz1+d4/lu>t]dstx

Індексація на основі 0.

При цьому використовується точна ціла арифметика - ніяких наближень логарифмів. Він працюватиме до ємності пам'яті комп'ютера.

Спробуйте програму dc онлайн!

Код постійного струму можна перетворити на рішення Bash:

Утиліти Bash + GNU, 96 77 75 байт

u=$[(2**$1+1)/2]
dc -e "[O$1^/O%p]sp1[d5r^dO$1^<psz1+d4/$u>t]dstx"|head -$u

Спробуйте версію Bash онлайн!

Математика, 66 60 52 байти

Floor@Mod[5^Floor[Range@Max[2^#/2,1]+#/.7]/10^#,10]&

Анонімна функція, 0-індексована. Використовує наближення log5 (10) (≈ 0,7)

Як це працює?

Range@Max[2^#/2,1]

Візьміть більше 2 ^ (вхід) / 2 і 1. Створіть {1..це число}

...+#/.7

Додайте вхід / .7

5^Floor[...]/10^#

Підніміть 5 до потужності результату (генеруючи сили 5), розділіть на вхід 10 ^ (позбавлення від цифр праворуч від потрібного стовпця)

Mod[ ...,10]

Застосуйте модуль 10, взявши цифру (потрібний стовпець).

Точна версія, 58 байт

Floor@Mod[5^Floor[Range@Max[2^#/2,1]+#/5~Log~10]/10^#,10]&

JavaScript (ES7), 78 76 байт

f=(N,z=5,s,X=2**N,q=z/10**N|0)=>s|q?X>0?q+f(N,z*5%10**-~N,1,X-2):"":f(N,z*5)

0-індексується, тобто f(0)дає 2.

Фрагмент тесту

f=(N,z=5,s,X=1<<N,q=z/Math.pow(10,N)|0)=>s|q?X>0?q+f(N,z*5%Math.pow(10,-~N),1,X-2):"":f(N,z*5)

for (let i = 0; i < 10; i++) console.log(`f(${i}):`, f(i));

Фрагмент використовує Math.powзамість **сумісності між браузерами.

CJam, 35

5ri(:N.7/i)#2N(#mo{_AN#/o5*AN)#%}*;

Спробуйте в Інтернеті

Це просторово і не надто повільно, на введення 30 на моєму комп'ютері (за допомогою інтерпретатора java) пішло кілька хвилин.

Желе , 26 21 байт

-2 байти, використовуючи ідею наближення 0,7 Кеннітма

2*HĊR+÷.7$Ḟ*@5:⁵*⁸¤%⁵

Спробуйте в Інтернеті! (тайм-аути для n> 15 )

Повертає список цілих чисел, цифр.
Нульова основа. Теоретично працює при n <= 72 (замінити .7на 5l⁵¤, щоб отримати точність з плаваючою точкою).

Як?

2*HĊR+÷.7$Ḟ*@5:⁵*⁸¤%⁵ - Main link: n
2*                    - 2 raised to the power of n
  H                   - halved: 2 raised to the power of n-1
   Ċ                  - ceiling: adjust 2**-1 = 0.5 up to 1 for the n=0 edge case
    R                 - range: [1,2,...,ceiling(2**(n-1))] - has length of the period
         $            - last two links as a monad:
      ÷.7             -     divide by 0.7 (approximation of log(5, 10), valid up to n=72)
     +                - add (vectorises)
          Ḟ           - floor (vectorises)
             5        - 5
           *@         - exponentiate (vectorises) with reversed @arguments
                  ¤   - nilad followed by link(s) as a nilad
               ⁵      -     10
                 ⁸    -     left argument, n
                *     -     exponentiate: 10 raised to the power of n
              :       - integer division: strips off last n digits
                   %⁵ - mod 10: extracts the last digit

Місцево: об'єм оперативної пам’яті для n = 17 піднявся до приблизно 750 МБ, а потім досяг близько 1 ГБ ; для n = 18 вона повільно сягала 2,5 Гб, а потім зростала приблизно до 5 ГБ .

Perl 6 , 52 байти

->\n{(map {.comb[*-n]//|()},(5 X**1..*))[^(2**n/4)]}

Працює для довільно високих входів, даючи достатню кількість пам'яті (тобто немає наближення логарифмів) .
Повертає список цифр.

Спробуйте в Інтернеті!

Як це працює

->\n{                                              }  # A lambda with argument n.
                            (5 X**1..*)               # The sequence 5, 25, 125, 625...
      map {               },                          # Transform each element as such:
           .comb[*-n]                                 #   Extract the n'th last digit,
                     //|()                            #   or skip it if that doesn't exist.
     (                                 )[^(2**n/4)]   # Return the first 2^(n-2) elements.

Частина "пропуск елемента" працює так:

• Індексація списку за незаконним індексом повертає Failure , який вважається значенням, що не визначається.
• // є "визначеним або" оператором.
• |()повертає порожній слайп , який розчиняється у зовнішній список як 0 елементів, по суті переконуючись, що поточний елемент пропущений.

Крайній регістр n=1чудово працює, тому що 2**n/4стає 0.5і ^(0.5)означає 0 ..^ 0.5"цілі числа між 0 (включно) і 0,5 (не включно)", тобто список з єдиним елементом 0.

J, 50 байт

(2^0>.2-~]){.' '-.~-{"1[:([:":[:|:[:,:5^[:>:i.)2^]

Примітка: повинна проходити в розширеній кількості

Використання:

   q =: (2^0>.2-~]){.' '-.~-{"1[:([:":[:|:[:,:5^[:>:i.)2^]
   q 1x
5
   q 2x
2
   q 4x
3580

Haskell , 73 байти

f 0="5"
f n=take(2^(n-1))[reverse x!!n|x<-show<$>iterate(*5)1,length x>n]

Спробуйте в Інтернеті! Використовує 0-індексацію.

Пояснення:

f 0="5"              -- if the input is 0, return "5"
f n=                 -- otherwise for input n
  take(2^(n-1))      -- return the first 2^(n-1) elements of the list
    [reverse x!!n    -- of the nth column of x
      |x<-show<$>    --    where x is the string representation
        iterate(*5)1 --    of the elements of the infinite list [5,25,125,...]
      ,length x>n    -- if x has at least n+1 columns
    ]                -- this yields a list of characters, which is equivalent to a string

Пакетна, 294 байт

@echo off
if %1==1 echo 5
set/a"l=1<<%1-2,x=0,s=1
set t=
for /l %%i in (2,1,%1)do call set t=%%t%%x
:l
if %l%==0 exit/b
set t=%s%%t%
set s=
set c=
:d
set/ac+=%t:~,1%*5,r=c%%10,c/=10
set s=%s%%r%
set t=%t:~1%
if "%t%"=="" echo %r%&set/al-=1&goto l
if %c%%t:~,1%==0x goto l
goto d

Виводить кожну цифру на свій рядок. Працює, обчислюючи потужність 5 довгих рук, але працює лише N=33завдяки використанню 32-бітових цілих чисел для підрахунку кількості цифр для друку. sмістить (обернені) останні Nцифри поточної потужності 5, в той час як tмістить xs, використовувані як прокладки, хоча x=0змушує їх оцінювати як нуль при обчисленні наступної потужності. Приклад для N=4:

s   t
1   xxx (initial values before the first power of 5 is calculated)
5   xxx
52  xx
521 x
526 x
5213    (print 3)
5265    (print 5)
5218    (print 8)
5260    (print 0)

JavaScript (ES6), 73 байти

1-індексований. Трохи коротший, ніж відповідь ES7 , але провалюється на 3 кроки раніше (при N = 13).

n=>(g=x=>k>>n?'':(s=''+x*5%1e15)[n-1]?s.substr(-n,1)+g(s,k+=4):g(s))(k=1)

Демо

let f =

n=>(g=x=>k>>n?'':(s=''+x*5%1e15)[n-1]?s.substr(-n,1)+g(s,k+=4):g(s))(k=1)

console.log(f(1))
console.log(f(2))
console.log(f(3))
console.log(f(4))
console.log(f(5))
console.log(f(6))
console.log(f(7))
console.log(f(8))

PHP> = 7,1, 104 байт

for($s=1;$i++<2**(-1+$a=$argn);)~($s=bcmul($s,5))[-$a]?$g.=$s[-$a]:0;echo substr($g,0,max(2**($a-2),1));

PHP Пісочниця Інтернет