Hãy xem xét các số nguyên dương của năm số thập phân. Dưới đây là 25 đầu tiên, căn phải:

 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

Lưu ý rằng cột ngoài cùng bên phải của quyền hạn là tất cả 5. Cột thứ hai từ bên phải là tất cả 2. Cột thứ ba từ bên phải, đọc từ trên xuống dưới, xen kẽ 1, 6, 1, 6, vv cột tiếp theo bắt đầu 3, 5, 8, 0và sau đó chu kỳ.

Trên thực tế, mỗi cột (nếu chúng ta đi xuống đủ xa) có một chuỗi các chữ số có độ dài gấp đôi chu kỳ trước, ngoại trừ chu kỳ ban đầu 5và 2chu kỳ.

Gọi N là số cột, bắt đầu bằng N = 1 ở bên phải, một vài chu kỳ đầu tiên là:

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

Thử thách

Cho một số nguyên dương N, xuất ra các chữ số thập phân của chu kỳ tại cột N, như được mô tả ở trên. Ví dụ, đầu ra cho N = 4 sẽ là 3580.

Các chữ số có thể là đầu ra dưới dạng một danh sách, chẳng hạn như [3, 5, 8, 0]hoặc ở định dạng hợp lý khác, miễn là:

• Các chữ số theo thứ tự như đọc từ trên xuống dưới trong các cột nguồn. ví dụ 0853không hợp lệ
• Chu kỳ bắt đầu với số cao nhất trong cột năng lượng của nó. ví dụ 5803không hợp lệ vì cột thứ 4 bắt đầu bằng 3không 5.
• Chính xác một chu kỳ là đầu ra. ví dụ 358hay 35803hay 35803580tất cả sẽ là không hợp lệ.

Mã của bạn phải hoạt động ít nhất N = 1 đến 30.

Nếu muốn, bạn có thể giả sử các cột được lập chỉ mục 0 thay vì 1 chỉ mục. Vậy N = 0 cho 5, N = 1 cho 2, N = 2 cho 16, N = 3 cho 3580, v.v.

Mã ngắn nhất tính bằng byte thắng .

^{Cảm ơn Downgoat và DJ đã hỗ trợ thử thách.}

Con trăn 2 62 61 58 byte

Không dựa trên. Tôi giả sử các hậu tố L là chấp nhận được.

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

Đầu ra:

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]

Giải pháp trước đây:

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

Giải trình:

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

Việc range(2**n/2)sử dụng quan sát rằng mỗi chu kỳ có độ dài r = 2 ^n-1 trừ khi n = 0, vì vậy chúng tôi chỉ tính các chữ số thứ n cho 5 ^m đến 5 ^{m + r - 1} .

Bắt đầu của chu kỳ 5 ^m là số đầu tiên lớn hơn 10 ⁿ . Giải 5 ^m 10 ⁿ cho m ≥ n / log ₁₀ 5. Ở đây chúng tôi ước tính nhật ký ₁₀ 5 0,7 sẽ bị phá vỡ khi n = 72. Chúng tôi có thể thêm nhiều chữ số để tăng độ chính xác:

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

Trong / 10**n % 10vòng lặp chỉ cần trích xuất chữ số mong muốn. Một giải pháp thay thế khác sử dụng thao tác chuỗi. Tôi đã sử dụng thủ thuật~n == -n-1 ở đây để loại bỏ 1 byte.

Một đề cập trong bình luận, biểu thức 5**(m+i) / 10**ncó thể được đơn giản hóa hơn nữa theo cách này, đưa ra câu trả lời 58 byte hiện tại.

(Việc phân chia x/2**ncó thể được thực hiện bằng cách sử dụng dịch chuyển sang phải theo bit x>>n. Thật không may, do ưu tiên toán tử của Python, điều này không lưu bất kỳ byte nào.) Phân số 3/7 cũng có thể được cải thiện trong mannar tương tự:

| 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 byte

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

Lập chỉ mục dựa trên 0.

Điều này sử dụng số học số nguyên chính xác - không có xấp xỉ logarit. Nó sẽ làm việc với dung lượng bộ nhớ của máy tính.

Hãy thử chương trình dc trực tuyến!

Mã dc có thể được biến thành một giải pháp Bash:

Tiện ích Bash + GNU, 96 77 75 byte

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

Hãy thử phiên bản Bash trực tuyến!

Toán học, 66 60 52 byte

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

Hàm ẩn danh, được lập chỉ mục 0. Sử dụng xấp xỉ log5 (10) (≈ 0,7)

Làm thế nào nó hoạt động?

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

Lấy lớn hơn 2 ^ (đầu vào) / 2 và 1. Tạo {1. số thứ tự}

...+#/.7

Thêm đầu vào / .7

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

Tăng 5 lên sức mạnh của kết quả (tạo ra sức mạnh của 5), ​​chia cho 10 ^ đầu vào (loại bỏ các chữ số ở bên phải của cột mong muốn)

Mod[ ...,10]

Áp dụng modulo 10, lấy chữ số của một người (cột mong muốn).

Phiên bản chính xác, 58 byte

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

JavaScript (ES7), 78 76 byte

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-index, tức là f(0)cho 2.

Kiểm tra đoạn

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

Đoạn mã sử dụng Math.powthay vì **khả năng tương thích giữa nhiều trình duyệt.

CJam, 35

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

Dùng thử trực tuyến

Đó là không gian hiệu quả và không quá chậm, mất vài phút cho đầu vào 30 trên máy tính của tôi (sử dụng trình thông dịch java).

Thạch , 26 21 byte

-2 byte sử dụng ý tưởng gần đúng 0,7 của kennytm

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

Hãy thử trực tuyến! (hết thời gian cho n> 15 )

Trả về một danh sách các số nguyên, các chữ số.
Không dựa. Về mặt lý thuyết hoạt động cho n <= 72 (thay thế .7bằng5l⁵¤ , để có được độ chính xác của dấu phẩy động).

Làm sao?

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

Tại địa phương: bộ nhớ làm việc cho n = 17 đã tăng lên khoảng 750 MB sau đó tăng lên khoảng 1GB ; với n = 18, nó từ từ đạt 2,5 GB sau đó tăng vọt lên khoảng 5 GB .

Perl 6 , 52 byte

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

Hoạt động cho các đầu vào cao tùy ý, được cung cấp đủ bộ nhớ (nghĩa là không có xấp xỉ logarit) .
Trả về một danh sách các chữ số.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Phần "bỏ qua phần tử" hoạt động như thế này:

• Lập chỉ mục một danh sách tại một chỉ mục bất hợp pháp sẽ trả về Thất bại , được tính là giá trị "không xác định".
• // là toán tử "được xác định hoặc".
• |()trả về một Trượt rỗng , hòa tan vào danh sách bên ngoài dưới dạng 0 phần tử, về cơ bản đảm bảo rằng phần tử hiện tại được bỏ qua.

Trường hợp cạnh n=1hoạt động tốt, bởi vì 2**n/4trở thành 0.5, và ^(0.5)có nghĩa 0 ..^ 0.5là "số nguyên giữa 0 (bao gồm) và 0,5 (không bao gồm)", tức là một danh sách với một phần tử 0 duy nhất.

J, 50 byte

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

Lưu ý: phải vượt qua với số lượng mở rộng

Sử dụng:

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

Haskell , 73 byte

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

Hãy thử trực tuyến! Sử dụng chỉ mục 0.

Giải trình:

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

Mẻ, 294 byte

@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

Xuất ra mỗi chữ số trên dòng riêng của nó. Hoạt động bằng cách tính toán sức mạnh của 5 tay dài, nhưng chỉ hoạt động tối đa N=33do sử dụng số nguyên 32 bit để giữ số lượng chữ số cần in. schứa các Nchữ số cuối (đảo ngược) của công suất hiện tại là 5, trong khi tchứa xs được sử dụng làm phần đệm, mặc dù điều này x=0làm cho chúng đánh giá bằng 0 khi tính công suất tiếp theo. Ví dụ cho 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 byte

1 chỉ mục. Hơi ngắn hơn câu trả lời ES7 , nhưng thất bại 3 bước trước đó (tại 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)

Bản giới thiệu

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 byte

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 Sandbox trực tuyến