51

दशमलव में पाँच की सकारात्मक पूर्णांक शक्तियों पर विचार करें। यहां पहले 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 = 4 के लिए आउटपुट होगा 3580।

अंक एक सूची के रूप में [3, 5, 8, 0]या इतने लंबे समय तक किसी अन्य उचित प्रारूप में आउटपुट हो सकते हैं :

अंक बिजली के स्तंभों में ऊपर से नीचे तक पढ़ने के क्रम में हैं। उदा 0853अमान्य है।
चक्र अपने शक्ति स्तंभ में शीर्ष संख्या से शुरू होता है। उदाहरण के 5803लिए अमान्य है क्योंकि 4 वां कॉलम प्रारंभ 3नहीं होता है 5।
बिल्कुल एक चक्र आउटपुट है। जैसे 358या 35803या 35803580सभी अमान्य होगा।

आपका कोड 30 के माध्यम से कम से कम N = 1 के लिए काम करना चाहिए।

यदि आप चाहें तो मान सकते हैं कि कॉलम 1-अनुक्रमित के बजाय 0-अनुक्रमित हैं। तो N = 0 देता है 5, N = 1 देता है 2, N = 2 देता है 16, N = 3 देता है 3580, आदि।

बाइट्स में सबसे छोटा कोड जीतता है ।

^{चैलेंज सपोर्ट के लिए डाउनगेट और डीजे को धन्यवाद ।}

— केल्विन के शौक
स्रोत

आदेश यह काफी मुश्किल बना देता है।

— डेनिस

9

चक्र की लंबाई हमेशा 2^(N-2)छोड़कर होती हैN = 1

— जुंगह्वान मिन

1

क्या सन्निकटन का उपयोग किया जा सकता है? आउटपुट N = 72 तक मान्य है , जो सैद्धांतिक रूप से 2.36E + 21 अंकों को प्रिंट करेगा।

— जंगवान मिन

क्या यह अनुक्रम OEIS में है?

— StarWeaver

@StarWeaver नं।

— मेगो

26

अजगर 2, 62 61 58 बाइट्स

शून्य आधारित। मुझे लगता है कि एल प्रत्यय स्वीकार्य हैं।

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 ^मीटर से 5 ^{मीटर + आर - 1 के} लिए n-th अंक की गणना करते हैं ।

चक्र 5 ^मीटर की शुरुआत 10 ^एन से बड़ा पहला नंबर है । 5 ^mⁿ 10 ⁿ को हल करने से ^m log n / log ₁₀ 5 मिलता है। यहां हम लगभग ₁₀ 5 m 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पाश में बस इच्छित अंकों निकालें। एक अन्य वैकल्पिक समाधान स्ट्रिंग हेरफेर का उपयोग करता है। मैंने यहाँ 1 बाइट निकालने के लिए ट्रिक~n == -n-1 का उपयोग किया ।

टिप्पणी में उल्लिखित, अभिव्यक्ति 5**(m+i) / 10**nको इस तरह से सरल बनाया जा सकता है, जो वर्तमान 58-बाइट का जवाब देता है।

(विभाजन x/2**nको बिटवाइस राइट-शिफ्ट का उपयोग करके किया जा सकता है x>>n। दुर्भाग्य से, पायथन के ऑपरेटर पूर्वता के कारण यह कोई बाइट्स नहीं करता है।) 3/7 अंश भी इसी तरह मन्नार में सुधार किया जा सकता है:

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

— kennytm
स्रोत

1

(5**(n*3/7-~i)>>n)%10। क्योंकि आप 10 की एक (छोटी) शक्ति से विभाजित 5 की शक्ति ले रहे हैं, आप 5 की शक्ति को कम कर सकते हैं, और इसके बजाय सही स्थानांतरित कर सकते हैं। n/.7 - n→ n*10/7 - n→ n*3/7। Priciple में, यह 2 with ( 3/7 के साथ 1 / log for (5) के लिए एक सन्निकटन के साथ) 5 की सबसे छोटी शक्ति से अंक निकाल रहा है । इसके अलावा, इसके range(2**n/2or 1)बजाय का उपयोग करने से आपको लगातार आउटपुट मिलेगा।

— प्रिमो

1

@primo धन्यवाद, अद्यतन। (x>>n)%10इस पर कोई सुधार नहीं होता है, x/2**n%10इसलिए मैं अभी के लिए बिट शिफ्ट का उपयोग नहीं करता हूं, क्योंकि हो सकता है कि आम को बाहर करने का एक तरीका हो 2**n।

— kennytm

दिलचस्प विचार फैक्टरिंग 2**n, हालांकि थोड़ा लंबा लगता है: int(5**(-~i-n*log(2,5)%1))%10( int(n*log(2,5))-n*log(2,5)जैसा मैंने सरल किया है -(n*log(2,5)%1))।

— प्रिमो

@primo दिलचस्प है, लेकिन मेरा मतलब है कि 2**nयहाँ और सीमा तर्क है।

— kennytm

10

डीसी , 72 बाइट्स

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

0-आधारित अनुक्रमण।

यह सटीक पूर्णांक अंकगणित का उपयोग करता है - कोई लघुगणक सन्निकटन नहीं। यह कंप्यूटर की मेमोरी क्षमता तक काम करेगा।

ऑनलाइन डीसी कार्यक्रम की कोशिश करो!

डीसी कोड को बैश समाधान में बदला जा सकता है:

बैश + जीएनयू उपयोगिताओं, 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

ऑनलाइन बैश संस्करण का प्रयास करें!

— मिशेल स्पेक्टर
स्रोत

9

गणितज्ञ, 66 60 52 बाइट्स

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

अनाम फ़ंक्शन, 0-अनुक्रमित। लॉग 5 (10) (ation 0.7) के सन्निकटन का उपयोग करता है

यह काम किस प्रकार करता है?

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

2 ^ (इनपुट) / 2 और 1. बड़ा बनाएं {1..that नंबर}

...+#/.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]&

— जंगहवान मिन
स्रोत

5

जावास्क्रिप्ट (ईएस 7), 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बजाय स्निपेट का उपयोग करता **है।

— ETHproductions
स्रोत

4

सीजेएम, 35

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

इसे ऑनलाइन आज़माएं

यह अंतरिक्ष-कुशल है और बहुत धीमी गति से नहीं है, मेरे कंप्यूटर पर इनपुट 30 के लिए कई मिनट लग गए (जावा दुभाषिया का उपयोग करके)।

— aditsu
स्रोत

3

जेली , 26 21 बाइट्स

-2 बाइट्स काइनेटम के 0.7 सन्निकटन विचार का उपयोग करते हुए

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 के लिए काम करने वाली मेमोरी लगभग 750 एमबी तक चढ़ गई और फिर लगभग 1 जीबी तक बढ़ गई ; के लिए एन = 18 यह धीरे धीरे पहुँच 2.5GB तो चारों ओर करने के लिए बाढ़ सी आ गई 5GB ।

— जोनाथन एलन
स्रोत

3

पर्ल 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 के साथ एक सूची।

— SMLS
स्रोत

2

जे, 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

— ljeabmreosn
स्रोत

2

डाउनवोट क्यों?

— ljeabmreosn

2

हास्केल , 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

— Laikoni
स्रोत

1

बैच, 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=3332-बिट पूर्णांक का उपयोग करने के कारण काम करता है ताकि कितने अंकों को प्रिंट किया जा सके। 5 की वर्तमान शक्ति का sअंतिम (उल्टा) समाहित है N, जबकि tइसमें xपेडिंग के रूप में उपयोग किया जाता है, हालांकि 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)

— नील
स्रोत

1

जावास्क्रिप्ट (ईएस 6), 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)

डेमो