พิจารณาพลังจำนวนเต็มบวกของห้าในทศนิยม นี่คือ 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และจากนั้นรอบ

อันที่จริงแล้วทุกคอลัมน์ (ถ้าเราลงไปมากพอ) มีลำดับการหมุนเวียนของตัวเลขที่มีความยาวสองเท่าของรอบก่อนหน้ายกเว้นรอบแรก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 เริ่มต้นด้วยไม่ได้35
• ว่าหนึ่งรอบคือเอาท์พุท เช่น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 ไบต์

Zero-based ฉันถือว่าคำต่อท้าย 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 ดังนั้นเราก็คำนวณตัวเลข n-TH 5 ^ม. 5 ^{ม. + R -} 1

จุดเริ่มต้นของวงจร 5 ^เมตรเป็นจำนวนแรกที่มีขนาดใหญ่กว่า 10 n การแก้ 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สามารถทำได้โดยใช้ bitwise right-shift x>>nแต่น่าเสียดายที่เนื่องจากตัวดำเนินการของ Python สิ่งนี้ไม่ได้บันทึกไบต์ใด ๆ ) เศษส่วน 3/7 ยังสามารถปรับปรุงใน mannar ที่คล้ายกัน:

| 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

สิ่งนี้ใช้เลขคณิตเลขจำนวนเต็ม - ไม่มีการประมาณลอการิทึม มันจะทำงานได้ถึงความจุหน่วยความจำของคอมพิวเตอร์

ลองใช้โปรแกรม dc ออนไลน์!

รหัส 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 ออนไลน์!

Mathematica, 66 60 52 ไบต์

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

ฟังก์ชั่นไม่ระบุชื่อ, 0-indexed ใช้การประมาณ log5 (10) (≈ 0.7)

มันทำงานอย่างไร?

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

ใช้ขนาดใหญ่กว่า 2 ^ (อินพุต) / 2 และ 1 สร้าง {1..that number}

...+#/.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ของ kennytm

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.

ส่วน "การข้ามองค์ประกอบ" ทำงานได้ดังนี้:

• การทำดัชนีรายการที่ดัชนีผิดกฎหมายจะส่งกลับค่าความล้มเหลวซึ่งนับเป็นค่า "ไม่ได้กำหนด"
• // เป็นตัวดำเนินการ "ที่กำหนดหรือ"
• |()ส่งคืนสลิปที่ว่างเปล่าซึ่งจะแบ่งออกเป็นรายการภายนอกเป็นองค์ประกอบ 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 longhand แต่ใช้ได้เฉพาะ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 Sandbox ออนไลน์