Considera i poteri interi positivi di cinque in decimale. Ecco i primi 25, allineati a destra:

 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

Si noti che la colonna più a destra dei poteri è tutto 5. La seconda colonna da destra è tutto 2. La terza colonna da destra, leggere da cima a fondo, alterna 1, 6, 1, 6, ecc Si avvia colonna successiva 3, 5, 8, 0e poi cicli.

In effetti, ogni colonna (se scendiamo abbastanza lontano) ha una sequenza ciclica di cifre la cui lunghezza è doppia rispetto a quella del ciclo precedente, ad eccezione dei cicli iniziali 5e iniziali 2.

Chiamando N il numero di colonna, iniziando con N = 1 a destra, i primi cicli sono:

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

Sfida

Dato un numero intero positivo N, emettere le cifre decimali del ciclo nella colonna N, come descritto sopra. Ad esempio, l'uscita per N = 4 sarebbe 3580.

Le cifre possono essere emesse come un elenco come [3, 5, 8, 0]o in un altro formato ragionevole purché:

• Le cifre sono in ordine come lette dall'alto verso il basso nelle colonne di potenza. ad es 0853. non è valido.
• Il ciclo inizia con il numero superiore nella sua colonna di potenza. es. 5803non è valido poiché la quarta colonna inizia con 3non 5.
• Viene emesso esattamente un ciclo. ad esempio 358o 35803o non 35803580sarebbero tutti validi.

Il codice deve funzionare per almeno N = 1 a 30.

Se lo si desidera, è possibile supporre che le colonne siano indicizzate 0 anziché 1 indicizzate. Quindi N = 0 dà 5, N = 1 dà 2, N = 2 dà 16, N = 3 dà 3580, ecc.

Vince il codice più breve in byte .

^{Grazie a Downgoat e DJ per il supporto alle sfide.}

Python 2, 62 61 58 byte

Zero-based. Presumo che i suffissi L siano accettabili.

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

Produzione:

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]

Soluzione precedente:

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

Spiegazione:

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

Il range(2**n/2)utilizza l'osservazione che ogni ciclo ha lunghezza r = 2 ^n-1 , tranne quando n = 0, quindi abbiamo calcoliamo la n-esima cifre per 5 ^m per 5 ^{m + r - 1} .

L'inizio del ciclo 5 ^m è il primo numero maggiore di 10 ⁿ . Risolvendo 5 ^m ≥ 10 ^{n si} ottiene m ≥ n / log ₁₀ 5. Qui approssimiamo il log ₁₀ 5 ≈ 0,7 che si romperà quando n = 72. Potremmo aggiungere più cifre per aumentare la precisione:

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

Il / 10**n % 10nel ciclo estrae semplicemente la cifra desiderata. Un'altra soluzione alternativa utilizza la manipolazione di stringhe. Ho usato il trucco~n == -n-1 qui per rimuovere 1 byte.

Una menzione nel commento, l'espressione 5**(m+i) / 10**npuò essere ulteriormente semplificata in questo modo, il che fornisce l'attuale risposta a 58 byte.

(La divisione x/2**npuò essere fatta usando lo spostamento a destra bit a bit x>>n. Sfortunatamente, a causa della precedenza dell'operatore di Python, questo non salva alcun byte.) La frazione 3/7 può anche essere migliorata in mannar simili:

| 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

Indicizzazione basata su 0.

Questo utilizza l'aritmetica intera esatta - nessuna approssimazione logaritmica. Funzionerà fino alla capacità di memoria del computer.

Prova il programma dc online!

Il codice cc può essere trasformato in una soluzione Bash:

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

Prova la versione di Bash online!

Mathematica, 66 60 52 byte

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

Funzione anonima, indicizzata 0. Utilizza l'approssimazione di log5 (10) (≈ 0.7)

Come funziona?

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

Prendi un numero maggiore di 2 ^ (input) / 2 e 1. Genera {1..quel numero}

...+#/.7

Aggiungi input / .7

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

Aumenta 5 alla potenza del risultato (generando potenze di 5), dividi per 10 ^ input (eliminando le cifre a destra della colonna desiderata)

Mod[ ...,10]

Applicare il modulo 10, prendendo la cifra di una (la colonna desiderata).

Versione esatta, 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-indicizzato, cioè f(0)dà 2.

Test snippet

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

Lo snippet utilizza Math.powinvece che **per la compatibilità tra browser.

CJam, 35

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

Provalo online

È efficiente in termini di spazio e non eccessivamente lento, ci sono voluti diversi minuti per l'ingresso 30 sul mio computer (usando l'interprete Java).

Gelatina , 26 21 byte

-2 byte usando l' idea di approssimazione 0.7 di kennytm

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

Provalo online! (timeout per n> 15 )

Restituisce un elenco di numeri interi, le cifre.
Basato su zero. Teoricamente funziona per n <= 72 (sostituire .7con 5l⁵¤, per ottenere la precisione in virgola mobile).

Come?

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

A livello locale: la memoria del set di lavoro per n = 17 è salita a circa 750 MB, quindi è aumentata a circa 1 GB ; per n = 18 ha raggiunto lentamente 2,5 GB, quindi è aumentato a circa 5 GB .

Perl 6 , 52 byte

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

Funziona con input arbitrariamente alti, con memoria sufficiente (cioè nessuna approssimazione logaritmica) .
Restituisce un elenco di cifre.

Provalo online!

Come funziona

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

La parte "salta elemento" funziona in questo modo:

• L'indicizzazione di un elenco in un indice illegale restituisce un errore , che viene considerato come un valore "non definito".
• // è l'operatore "definito o".
• |()restituisce uno slip vuoto , che si dissolve nell'elenco esterno come 0 elementi, assicurandosi essenzialmente che l'elemento corrente venga saltato.

Il caso limite n=1funziona bene, perché 2**n/4diventa 0.5, e ^(0.5)significa 0 ..^ 0.5anche "numeri interi compresi tra 0 (inclusivo) e 0,5 (non inclusivo)", ovvero un elenco con il singolo elemento 0.

J, 50 byte

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

Nota: deve passare il numero esteso

Uso:

   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]

Provalo online! Utilizza l'indicizzazione 0.

Spiegazione:

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

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

Emette ogni cifra su una propria riga. Funziona calcolando le potenze di 5 longhand, ma funziona solo N=33grazie all'uso di numeri interi a 32 bit per tenere conto del numero di cifre da stampare. scontiene le ultime Ncifre (invertite) della potenza corrente di 5, mentre tcontiene xs usate come riempimento, sebbene le x=0facciano valutare come zero quando viene calcolata la potenza successiva. Esempio per 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-indicizzati. Leggermente più breve della risposta ES7 , ma fallisce 3 passaggi prima (a 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)

dimostrazione

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 online