Beşinci sayıdaki pozitif tamsayı güçlerini düşünün. İşte ilk 25, sağa hizalı:

 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

Güçlerin en sağ sütununun tümü olduğuna dikkat edin 5. Sağdan ikinci sütun ise hepsi 2. Yukarıdan aşağıya, dönüşümlü olarak okundu sağ üçüncü sütun 1, 6, 1, 6Bir sonraki sütun başlar, vs. 3, 5, 8, 0ve daha sonra çevrimleri.

Aslında, her kolon (aşağı kadar yeterli ise) uzunluğu, iki kez bir önceki çevrimin ise, ilk haricinde basamaklı bir bisiklet dizisine sahiptir 5s ve 2'nin çevrim.

Sütun numarası N olarak adlandırılır, sağdaki N = 1 ile başlar, ilk birkaç döngü:

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

Meydan okuma

Pozitif bir tamsayı N verildiğinde, yukarıda anlatıldığı gibi N sütunundaki döngünün ondalık basamağını verin. Örneğin, N = 4 için çıktı olacaktır 3580.

Rakamlar, aşağıdakiler olduğu sürece aşağıdaki gibi bir liste halinde [3, 5, 8, 0]veya başka bir makul formatta çıkarılabilir :

• Rakamlar, güç sütunlarında yukarıdan aşağıya doğru okunur. örneğin 0853geçersiz.
• Çevrim, güç sütununda en üstteki numara ile başlar. örneğin 58034 sütun ile başlar başlamaz geçersiz 3değil 5.
• Tam olarak bir döngü çıktı. mesela 358ya 35803ya 35803580tüm geçersiz olacaktır.

Kodunuz en az N = 1 - 30 arasında çalışmalıdır.

İstenirse, sütunların 1 dizinli yerine 0 dizinli olduğunu varsayabilirsiniz. N = 0 verir 5, N = 1 verir 2, N = 2 verir 16, N = 3 verir 3580, vb.

Bayt cinsinden en kısa kod kazanır .

^{Yarışmayı desteklediği için Downgoat ve DJ'e teşekkürler .}

Python 2, 62 61 58 bayt

Sıfır tabanlı. L eklerinin kabul edilebilir olduğunu varsayıyorum.

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

Çıktı:

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]

Önceki çözüm:

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

Açıklama:

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)Gözlem kullanan her bir döngü uzunluğu r = 2 sahiptir ^{, n-1} , n = 0 hariç, bu yüzden sadece 5 n-inci basamak hesaplamak ^m 5'e ^{m + r - 1} .

Döngünün başlangıcı 5 ^m , 10 ^n'den büyük ilk sayıdır . 5 ^m ≥ 10 ^n'yi çözmek m ≥ n / log _{10'u verir.} 5. Burada n = 72 olduğunda ayrılacak olan log ₁₀ 5 ≈ 0,7 değerini tahmin ediyoruz. Doğruluğunu artırmak için daha fazla rakam ekleyebiliriz:

| 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 % 10Döngüde sadece istenen değere çıkarmak. Başka bir alternatif çözüm string manipülasyon kullanır. Buradaki numarayı~n == -n-1 1 baytı kaldırmak için kullandım .

Yorumda belirtildiği gibi, ifade 5**(m+i) / 10**nbu şekilde basitleştirilebilir ve mevcut 58 baytlık cevabı verir.

(Bölme x/2**n, bitsel sağa kaydırma kullanılarak yapılabilir x>>n. Ne ​​yazık ki, Python'un operatör önceliğinden dolayı bu herhangi bir baytı kurtarmaz.) Fraksiyon 3/7 de benzer mannarda geliştirilebilir:

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

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

0 tabanlı indeksleme.

Bu, tamsayı aritmetik kullanır - logaritma yaklaşımı yok. Bilgisayarın hafıza kapasitesine kadar çalışacaktır.

DC programını çevrimiçi olarak deneyin!

DC kodu Bash çözümüne çevrilebilir:

Bash + GNU yardımcı programları, 96 77 75 bayt

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

Bash sürümünü çevrimiçi olarak deneyin!

Mathematica, 66 60 52 bayt

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

Anonim işlev, 0 dizinli. Log5 (10) (≈ 0,7) yaklaşımını kullanır

Nasıl çalışır?

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

2 ^ (giriş) / 2 ve 1'den büyük alın. {1..that sayı} oluşturun

...+#/.7

Giriş ekle / .7

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

Sonucun gücüne 5 yükseltin (5 üretme gücü), 10 ^ girişine bölün (basamaklardan kurtulmak istediğiniz sütunun sağında)

Mod[ ...,10]

Modül 10'u uygulayarak birinin rakamını alın (istenen sütun).

Tam sürüm, 58 bayt

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

JavaScript (ES7), 78 76 bayt

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 indeksli, yani f(0)verir 2.

Test pasajı

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

Snippet, tarayıcılar arası uyumluluk Math.powyerine kullanır **.

CJam, 35

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

Çevrimiçi deneyin

Alan açısından verimli ve aşırı derecede yavaş değil, bilgisayarımda 30 girişi (Java tercümanı kullanarak) birkaç dakika sürdü.

Jöle , 26 21 bayt

Kennytm'in 0.7 yaklaşım fikrini kullanan -2 bayt

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

Çevrimiçi deneyin! ( n> 15 için zaman aşımına uğradı )

Rakamların bir listesini verir.
Sıfır tabanlı. Teorik olarak n <= 72 için çalışır ( kayan nokta doğruluğunu elde etmek için .7ile değiştirin 5l⁵¤).

Nasıl?

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

Yerel olarak: n = 17 çalışma kümesi hafızası 750 MB'a çıktı, sonra 1GB'a çıktı ; için n = 18 yavaşça ulaştı 2.5GB sonra etrafında rakamına ulaştı 5GB .

Perl 6 , 52 bayt

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

Yeterli bellek (örneğin logaritma yaklaşımı yok) verilen keyfi yüksek girişler için çalışır .
Rakamların listesini döndürür.

Çevrimiçi deneyin!

Nasıl çalışır

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

"Element atlama" kısmı şu şekilde çalışır:

• Bir listeyi yasa dışı bir dizinde dizine ekleme , "tanımsız" bir değer olarak sayılan bir Hata verir.
• // "tanımlanmış veya" işlecidir.
• |()esas olarak geçerli öğenin atlandığından emin olarak dış elemanlar içinde 0 eleman olarak çözülen boş bir Kayma döndürür .

Kenar durumu n=1iyi sonuç verir, çünkü 2**n/4olur 0.5ve ^(0.5)" 0 ..^ 0.5aka (0 (dahil) ve 0,5 (dahil değil) arasındaki tam sayılar", yani tek elemanlı 0 olan bir liste anlamına gelir .

J, 50 bayt

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

Not: uzun sayıları geçmeli

Kullanımı:

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

Haskell , 73 bayt

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

Çevrimiçi deneyin! 0 indeksleme kullanır.

Açıklama:

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

Toplu iş, 294 bayt

@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

Her basamağı kendi satırında çıkarır. 5 longhand'in güçlerini hesaplayarak çalışır, ancak yalnızca N=33kaç basamak basılacağını hesaplamak için 32 bit tam sayı kullanmak nedeniyle çalışır . s(geri) son ihtiva Nederken, 5, mevcut güç basamak tiçerir x, ancak dolgu olarak kullanılan s x=0sonraki güç hesaplandığında bunları sıfır olarak değerlendirilmesi yapar. Örnek 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 bayt

1 endeksli. ES7'nin yanıtından biraz daha kısa , ancak daha erken 3 adımda başarısız oluyor (N = 13'te).

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

gösteri

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 Bayt

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 Çevrimiçi