10의 양의 정수 제곱을 고려하십시오. 다음은 처음 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's 및 2의주기를.

오른쪽에서 N = 1로 시작하여 열 번호 N을 N이라고하면 처음 몇주기는 다음과 같습니다.

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유효하지 않습니다.
• 사이클은 전원 열의 최상위 숫자로 시작합니다. 예를 들어 58034 번째 열이 3not로 시작하므로 유효하지 않습니다 5.
• 정확히 하나의 사이클이 출력됩니다. 예를 들면 358나 35803또는 35803580유효하지 않은 모든 것.

코드는 최소한 N = 1에서 30까지 작동해야합니다.

원하는 경우 열이 1 색인 대신 0 색인으로 가정 할 수 있습니다. 따라서 N = 0은 5, N = 1은 2, N = 2는 16, N = 3은 3580등을 제공합니다 .

바이트 단위의 최단 코드가 이깁니다 .

^{도전 지원을위한 Downgoat 및 DJ 에게 감사합니다 .}

파이썬 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 번째 숫자 계산 ^m 5 ^{m + R을 - 1} .

사이클 ^5m 의 시작은 ¹⁰ⁿ 보다 큰 첫 번째 숫자 입니다. 5 ^m ≥ 10 ^n을 구하면 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은 비트 단위 오른쪽 시프트를 사용하여 수행 할 수 있습니다 x>>n. 불행히도, 파이썬의 연산자 우선 순위로 인해 바이트가 절약되지 않습니다.) 분수 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 인덱스. 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]&

자바 스크립트 (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는 다음 주위에 아군 5기가바이트 .

펄 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 (포함)와 0.5 (포함하지 않음) 사이의 정수".

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

하스켈 , 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 비트 정수를 사용해야 만 작동합니다 . 는 현재 거듭 제곱 5 s의 (반전 된) 마지막 N자릿수를 t포함 하고, 다음 거듭 제곱이 계산 될 때 0으로 평가 x되지만 패딩으로 사용되는 s 를 포함 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)

자바 스크립트 (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 샌드 박스 온라인