考虑十进制的五的正整数幂。这是前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

请注意，幂的最右列是all 5。右边的第二列是all 2。从右侧，读从上到下，交替第三列1，6，1，6，等下一列开始3，5，8，0和然后循环。

实际上，每列（如果我们走得足够远的话）都有一个数字循环序列，其长度是前一个循环的两倍，除了初始5的和2循环。

调用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无效，因为第4列以3not 开头5。
• 正好输出一个周期。例如358，35803或35803580全部无效。

您的代码必须至少在N = 1到30之间工作。

如果需要，您可以假定列是0索引而不是1索引。因此N = 0给出5，N = 1给出2，N = 2给出16，N = 3给出3580，依此类推。

以字节为单位的最短代码获胜。

^{感谢Downgoat和DJ的挑战支持。}

Python 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)使用该观察每个周期具有长度r = 2 ^n-1个不同的n = 0时，所以我们只计算5第n位数字^米至5 ^{米+ R - 1}。

循环的开始5 ^m是大于10 ⁿ的第一个数字。解决5 ^米 ≥10 ^ñ给人米≥N /登录₁₀ 5.在这里，我们大概数₁₀ 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 |

dc，72个字节

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

基于0的索引。

这使用精确的整数算术-无对数近似。它将达到计算机的存储容量。

在线尝试直流程序！

直流代码可以变成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版本！

Mathematica，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 ^（input）/ 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)#%}*;

在线尝试

它节省空间且不算太慢，在我的计算机上（使用Java解释器）在输入30上花费了几分钟。

果冻，26 21 字节

使用kennytm 0.7近似思想的-2个字节

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的工作集内存增加到750MB左右，然后猛增到1GB左右；在n = 18时，它缓慢达到2.5GB，然后飙升至5GB左右。

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，该失败将计为“未定义”值。
• // 是“定义或”运算符。
• |()返回一个空的Slip，它将作为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计算下一个幂时使s 取值为零。示例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沙盒在线