जानने योग्य बातें:

सबसे पहले, भाग्यशाली संख्या।

भाग्यशाली संख्याएं इस तरह उत्पन्न होती हैं:

सभी प्राकृतिक संख्याएँ लें:

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20...

फिर, प्रत्येक दूसरे नंबर को हटा दें।

1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39...

अब, 3सुरक्षित है।

हर तीसरा नंबर निकालें:

1, 3, 7, 9, 13, 15, 19, 21, 25, 27, 31, 33, 37, 39, 43, 45, 49, 51, 55, 59...

अब, 7सुरक्षित है।

हर 7 वें नंबर को निकालें।

जारी रखें, और हर nवें नंबर को हटा दें , जहां nउन्मूलन के बाद पहली सुरक्षित संख्या है।

सुरक्षित नंबरों की अंतिम सूची भाग्यशाली संख्या है।

अशुभ संख्याओं की अलग-अलग सूचियों से बना है, जो हैं [U1, U2, U3... Un]।

U1 भाग्यशाली "उम्मीदवारों" से हटाए गए अंकों का पहला सेट है, इसलिए वे हैं:

2, 4, 6, 8, 10, 12, 14, 16, 18, 20...

U2 हटाए गए नंबरों का दूसरा सेट है:

5, 11, 17, 23, 29, 35, 41, 47, 53, 59...

और तो और आगे ( U3तीसरी सूची U4है, चौथा है, आदि)

चुनौती:

आपका कार्य है, जब दो इनपुट दिए जाते हैं mऔर n, mसूची में वें नंबर को उत्पन्न करते हैं Un।

उदाहरण इनपुट और आउटपुट:

(5, 2) -> 29
(10, 1) -> 20

चश्मा:

के लिए अपने कार्यक्रम होगा काम mकरने के लिए 1e6, और nअप करने के लिए 100।
- आपको गारंटी दी जाती है कि दोनों सकारात्मक हैं mऔर nपूर्णांक हैं।
- यदि आप उत्सुक हैं, U(1e6, 100)= 5,333,213,163। (साभार @pacholik!)
आपके प्रोग्राम को एक आधुनिक कंप्यूटर पर 1 दिन के भीतर गणना करनी चाहिए।

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा कोड है!

पुनश्च: यह अच्छा होगा यदि कोई व्यक्ति इन्हें उत्पन्न करने के लिए एक सामान्य सूत्र के साथ आए। यदि आपके पास कोई सूत्र है, तो कृपया इसे अपने उत्तर में रखें!

code-golf math sequence

— clismique
स्रोत

OEIS पर: A219178 और A255543

— Arnauld

6

सम्बंधित।

— मार्टिन एंडर

2

क्या आपने कोड लागू किया है जो वास्तव में प्रदर्शन कर सकता है (1e6,1e6)?

— जोनाथन एलन

2

यदि आप एक समय की आवश्यकता के लिए जा रहे हैं, तो आपको समय के वातावरण (जैसे आपकी मशीन, एक स्वतंत्र रूप से उपलब्ध ऑनलाइन वीएम, या "एक उचित आधुनिक कंप्यूटर") को निर्दिष्ट करने की आवश्यकता है।

— मेव

1

क्या यह कार्य के n=1मामले में काम नहीं करने के लिए स्वीकार्य है ? जैसा कि यह विशेष है - अन्य सभी मामलों के लिए, अगले भाग्यशाली संख्या का 0-आधारित सूचकांक है n-1।

— माइरिडियम

1

सीजेएम , 74 बाइट्स

ri0Lri:U{1$W%{1$\(1e>/+}/)+}/2t:A0@{@:B:(_0#):D{D(_A=tD<BD>+}&@)@DU=-}h]1=

इसे ऑनलाइन आज़माएं! बड़े मामलों के लिए समय निकल जाएगा, नीचे समय की कमी पर अधिक।

स्पष्टीकरण:

हमारा कार्यक्रम बेशर्मी से विज्ञापन के कोड के लिए एन लकी नंबर की सूची बनाने के लिए उधार लेता है , 1 की जगह 2 को छलनी के प्रत्येक चरण में वेतन वृद्धि देता है। जब तक एक शून्य नहीं पाया जाता है तब तक हर तत्व पर शेष कोड घटता है (एक संयुक्त-विखंडित पूंछ को टुकड़ा करके और जोड़कर) और छलनी के प्रत्येक N चरणों में एक बार में प्रभावी ढंग से गिना जाता है ।

ri                               e# read M
0Lri:U{1$W%{1$\(1e>/+}/)+}/2t:A  e# list steps (also becomes B)
0@                               e# arrange stack [B I M]
{                                e# while M
   @:B                           e#   get current B
   :(                            e#   decrement every element in B
   _0#):D                        e#   find first 0
   {                             e#   if there is a 0
      D(_A=t                     e#     reset that element in B
      D<BD>+                     e#     replace tail after 0
   }&                            e#   end if
   @)                            e#   increment I
   @DU=-                         e#   decrement M if N-th phase of sieve
}h                               e# end loop
]1=                              e# return I

समय:

यदि आप ब्राउज़र में प्रोग्राम को बड़ी संख्या में चलाना चाहते हैं, तो आप इस दुभाषिया का उपयोग कर सकते हैं और यदि संकेत दिया जाए तो स्क्रिप्ट को जारी रखने की अनुमति दे सकते हैं , लेकिन यह योग्यता प्राप्त करने के लिए बहुत धीमा है। का उपयोग करना ( एम , एन ) = (100,100) ~ 247s लेता है। एम के संदर्भ में प्रोग्राम पुनरावृत्ति अपेक्षाकृत रैखिक है , इसलिए कंप्यूटिंग (1e6,100) में ~ 29 दिन लग सकते हैं।

एक पीसी पर शेल दुभाषिया का उपयोग करके ~ 6s में कार्यक्रम गणना (100,100) और ~ 463s में गणना (1e4,100)। कार्यक्रम ~ 13-17hrs में (1e6,100) गणना करने में सक्षम होना चाहिए। इस मामले में मुझे लगता है कि कार्यक्रम योग्य है।

नोट हर समय माप और गणना दोनों में गोल किया जाता था।

— लीनुस
स्रोत

7

पर्ल, 87 85 82 81 बाइट्स

के लिए +4 शामिल है -pX

STDIN पर इनपुट पहले n के साथ एक लाइन के रूप में दें (ध्यान दें कि यह चुनौती में दिए गए आदेश का उल्टा है)। तो गणना करने के लिए U(1000000, 100):

unlucky.pl <<< "100 1000000"

एल्गोरिथम aditsu के भाग्यशाली नंबरों के आधार पर उत्तर देता है कि समय की जटिलता O(n^2)इतनी है कि यह आवश्यक सीमा के लिए तेज है। 100, 1000000मामले देता है 53332131630.7 सेकंड में। समस्याओं के कारण perl do$0आधारित पुनरावृत्ति के साथ स्मृति का बहुत उपयोग करता है। इसे एक फ़ंक्शन के रूप में फिर से लिखने से मेमोरी का उपयोग होता है O(n)लेकिन कई बाइट्स की संख्या लंबी होती है

unlucky.pl:

#!/usr/bin/perl -pX
$_=$a{$_}||=/\d+$/>--$_?2*$&+$^S:($_=$_.A.(do$0,$^S?0|$&+$&/~-$_:$&*$_-1),do$0)

यह दिखाया गया है, लेकिन ^Sदावा किए गए स्कोर को प्राप्त करने के लिए शाब्दिक का उपयोग करें ।

मैं $^Sperlgolf में किसी भी पहले के उपयोग के बारे में पता नहीं है ।

— टन हास्पेल
स्रोत

लेकिन इसमें कितना समय लगता है (1e6,100)?

— Myridium

@ मिरिडियम मेमोरी विस्फोट के कारण do$0मूल रूप से किसी भी यथार्थवादी कंप्यूटर पर पहुंच से बाहर है। लेकिन अगर उस स्मृति में लगभग 2 साल मौजूद थे। मैंने वास्तव में सामान्य सबरूटीन आधारित संस्करण का परीक्षण नहीं किया है, लेकिन मैं उम्मीद करूंगा कि कुछ महीनों में समाप्त हो जाए और बहुत कम मेमोरी वाले कंप्यूटर पर भी चले। इसलिए यह अच्छी बात है कि ये मूल्य इस चुनौती के लिए आवश्यक सीमा में नहीं हैं।

— 18:59 पर टन हास्पेल

(1e6,100)एक दिन के भीतर गणना करने की चुनौती नहीं है? आपका क्या मतलब है इन मूल्यों की आवश्यकता नहीं है?

— Myridium

@ मेरिडियम नोटिस है कि मेरे कार्यक्रम में nऔर mरिवर्स ऑर्डर में दिए गए हैं। 100 1000000इनपुट की गणना करता है U(1000000, 100)और देता है 5,333,213,1630.7 सेकंड में। यह अब तक का सबसे तेज़ कार्यक्रम है, जो वर्तमान में पोस्ट किया गया है

— टोन इंस्पेक्टर

आह ठीक है, मुझे उम्मीद थी कि यह (100,1e6)बहुत तेजी से होगा (1e6,100), और मुझे लगा कि यह तेज 0.7 सेकंड बिजली की व्याख्या है!

— मीडियमियम

7

पायथन 3, 170

from itertools import*
def L(n,k=1):
 if n<2:yield from count(2+k,2)
 t=L(n-1);l=next(t)
 for i in t:
  n+=1
  if(n%l>0)==k:yield i
U=lambda m,n:sum(islice(L(n,0),m-1,m))

फंक्शन L संभावित भाग्यशाली संख्याओं की पंक्ति उत्पन्न करता है (यदि k सही है) या Un (यदि गलत है)। मूल्यांकन किया गया आलसी (इसलिए मुझे एन -1 अनंत सूची उत्पन्न नहीं करनी है, यदि मैं अन चाहता हूं )।

फ़ंक्शन यू चलाएं ।

गति

U (1,000,000; 100) PyPy के साथ मेरी मशीन पर चलने के लिए लगभग 1h 45min लेता है। मुझे सीपीथॉन के साथ कुछ चार घंटे का संदेह है। (हां, 4h 20 मिनट सटीक होने के लिए।)

यदि मैंने जनरेटर के बजाय एक सूची का उपयोग किया है, तो मैं कुछ गति प्राप्त कर सकता हूं, लेकिन मुझे अजगर की तुलना में अधिक आकार की सूची की आवश्यकता होगी। और अगर ऐसा होता, तो उसे दर्जनों गीगाबाइट रैम की जरूरत होती।

हां, और यू (1,000,000; 100) = 5,333,213,163 ।

— pacholik
स्रोत

अब मान्य होना चाहिए।

— २०:

3

हास्केल

N = 1: 175 160 बाइट्स के लिए गणना करने में सक्षम नहीं

जब संकलित किया गया, तो इसे (1000000,100)उपयोग करने के इनपुट के लिए गणना करने के लिए मेरे कंप्यूटर को 2h 35m लिया गया :

n#s=y:(n#p)where y:p=drop(n-1)s
n%s=f n s$[]where f n s=(take(n-1)s++).f n(drop n s) 
l 2=[1,3..]
l m=((l$m-1)!!(m-2))%(l$m-1)
m?n=(((l n)!!(n-1))#(l$n))!!(m-1)

मैंने whereमॉड्यूल से छुटकारा पाने की कोशिश की , लेकिन वे गति को प्रभावित करते हैं और मुझे यकीन नहीं है कि क्यों ... लेकिन मुझे लगता है कि यहां किया जाना अधिक संभावना है।

उपयोग करने के लिए विधि है m?nइस सवाल का जवाब एक दिए गए क्वेरी करने के लिए mऔर n।

Ungolfed

everynth n xs = y:(everynth n ys) -- Takes every nth element from a list 'xs'
  where y:ys = drop (n-1) xs

skipeverynth n xs = f' n xs $ []  -- Removes every nth element from a list 'xs'
  where f' n xs = (take (n-1) xs ++) . f' n (drop n xs) 

l 2 = [1,3..] -- The base case of the list of lucky numbers for 'n=2'
l m = skipeverynth ((l$m-1)!!(m-2)) (l$m-1) -- Recursively defining next case as being the last one with every 'ath' element skipped. Here, 'a' is the (m-1)th elemnent of the (l (m-1)) list.
ul m = everynth ((l m)!!(m-1)) (l$m) -- This is not used other than to compute the final, required unlucky number list. It picks out every 'ath' element.

ans m n = (ul n)!!(m-1) -- The function giving the answer.

मुझे लगता है कि 'स्काइपवेल्थ' और 'एवर्नथ' के फंक्शन को एक ही फंक्शन में मिलाना संभव हो सकता है जो एक जोड़ी को लौटाता है।

मैंने इस तरह के व्यक्ति के कोड का इस्तेमाल हर nth तत्व को छोड़ने के लिए किया। मैंने खुद इसे कुछ बार किया, लेकिन यह हमेशा बहुत अधिक अक्षम था और मैं यह पता नहीं लगा सका कि क्यों।

सभी n: 170 बाइट्स के लिए गणना करने में सक्षम

यह मूल रूप से एक ही है, लेकिन maxविशेष के मामले को संभालने के लिए कुछ कार्यों को फेंकना पड़ा n=1।

n#s=y:(n#p)where y:p=drop(n-1)s
n%s=f n s$[]where f n s=(take(n-1)s++).f n(drop n s) 
l 1=[1..]
l m=((l$m-1)!!(max 1$m-2))%(l$m-1)
m?n=(((l n)!!(max 1$n-1))#(l$n))!!(m-1)

— Myridium
स्रोत

2

आर 82 बाइट्स

f<-function(m,n){a=1:2e8
i=1
while(i<n){a=c(0,a)[c(F,rep(T,i))]
i=i+1}
a[(n+1)*m]}

प्रयोग

f(5,2)
Returns 29

इसे शुरू करने के लिए एक बड़े पर्याप्त वेक्टर की आवश्यकता होती है ताकि मूल्य वापस करने के लिए पर्याप्त संख्याएं बची रहें। वेक्टर पहले से ही 800Mb के बारे में है और फ़ंक्शन m = 1e4 और n = 100 तक संभाल सकता है इसलिए लक्ष्य से अभी भी बहुत कम है।

च (1e6,100) की गणना करने के लिए एक बड़ा पर्याप्त वेक्टर बनाने के लिए 1: 2e10 का एक प्रारंभिक वेक्टर लगेगा। रु। डेटा आवंटन प्रक्रियाओं के कारण यह एक वेक्टर> 70Gb बनाता है जिसे किसी भी कंप्यूटर पर नहीं चलाया जा सकता है, मुझे पता है कि हालांकि कोड चलेगा।

Error: cannot allocate vector of size 74.5 Gb

संदर्भ के लिए एफ (1e4,100) लगभग 30 सेकंड में चलता है। इसके आधार पर और एक छोटे से परीक्षण f (1e6,100) में लगभग एक घंटा लगेगा।

— gtwebb
स्रोत

अपने जवाब को गैर-प्रतिस्पर्धी के रूप में चिह्नित करना चुनौती की आवश्यकताओं को पूरा करने में विफल होने से बहाना नहीं करता है।

— Mego

@ मेगो इवे ने बहुत सारे उत्तर देखे जो आवश्यकताओं को पूरा करने में विफल रहते हैं (इस चुनौती में कम से कम 1 अन्य है)। मैंने इसे कोडित किया और मुझे लगता है कि यह कोडिंग अनुरोध की भावना को पूरा करता है, मैंने यह भी स्पष्ट रूप से कहा था कि यह कहां गिर गया। जैसा कि आप अपनी टिप्पणी में इस सवाल का उल्लेख करते हैं कि यह किस प्रकार के कंप्यूटर पर परीक्षण करने की आवश्यकता नहीं है। यकीन है कि वहाँ कंप्यूटर वहाँ रहे हैं कि 7 जीबी मेमोरी और इसे संसाधित करने के लिए लिख सकते हैं। जिस पर मैं नहीं कर सकता था, लेकिन मैं अभी भी पोस्ट करना चाहता था और मुझे लगा कि स्पष्ट बयान एक वैध समझौता था।

— gtwebb

हमारे पास स्पष्ट विनिर्देश को पूरा नहीं करने वाले उत्तरों के बारे में स्पष्ट नीति है । कहा जा रहा है, मुझे यकीन नहीं है कि आपने अपने जवाब को गैर-प्रतिस्पर्धात्मक क्यों करार दिया। अगर मैं सही तरीके से समझूं, तो इसे पर्याप्त मेमोरी दी जानी चाहिए , लेकिन आप इसका परीक्षण नहीं कर सकते क्योंकि आपके पास पर्याप्त रैम नहीं है। क्या वो सही है?

— डेनिस

1

1. यह नीति लागू की जा रही है, लेकिन चार मध्यस्थ साइट पर सभी उत्तरों का परीक्षण नहीं कर सकते हैं। यदि आपको कोई ऐसा सबमिशन मिल जाता है जो नियमों का पालन नहीं करता है, तो इसे मध्यस्थता के लिए ध्वजांकित करें ताकि हम देख सकें। 2. आपको भाग लेने के लिए एक गोल्फ भाषा सीखना नहीं है। आर जैसी उत्पादन भाषाएं सिर्फ स्वागत योग्य हैं। मैं पायथन को अपने आप को नियमित रूप से जवाब देता हूं।

— डेनिस

1

3. कल्पना किसी भी स्मृति सीमा का उल्लेख नहीं करती है, लेकिन 24 घंटे की समय सीमा है। इस पर परीक्षण करने के लिए 70 GiB (या आप का मतलब गीगा बिट्स ) वाले कंप्यूटर की अनुपस्थिति में , यह निर्धारित करना कठिन है कि यह उत्तर मान्य है या नहीं। मेरा सुझाव है कि रनटाइम को अतिरिक्त रूप से पूरा करने की कोशिश करें। यदि यह एक दिन से कम है, तो गैर-प्रतिस्पर्धा वाले हेडर को हटा दें और पोस्ट में अपना एक्सट्रपलेशन शामिल करें। यदि इससे अधिक समय लगता है, तो आपका सबमिशन ऑप्टिमाइज़ या हटा दिया जाना चाहिए।

— डेनिस

1

रैकेट 332 बाइट्स

(λ(N m n)(let loop((l(filter odd?(range 1 N)))(i 1))(define x (list-ref l i))(if(= i (sub1 n))
(begin(set! l(for/list((j(length l))#:when(= 0(modulo(add1 j)x)))(list-ref l j)))(list-ref l(sub1 m)))
(begin(set! l(for/list((j(length l))#:unless(= 0(modulo(add1 j) x)))(list-ref l j)))(if(>= i(sub1 (length l)))l
(loop l(add1 i)))))))

Ungolfed संस्करण:

(define f
  (λ(N m n)
    (let loop ((l (filter odd? (range 1 N))) (i 1))
      (define x (list-ref l i))
      (if (= i (sub1 n))
          (begin (set! l (for/list ((j (length l)) 
                                   #:when (= 0 (modulo (add1 j) x)))
                           (list-ref l j)))
                 (list-ref l (sub1 m)))
          (begin (set! l (for/list ((j (length l)) 
                                   #:unless (= 0 (modulo (add1 j) x)))
                           (list-ref l j)))
                 (if (>= i (sub1 (length l)))
                     l
                     (loop l (add1 i))))))))

परिक्षण:

(f 100 5 2)

आउटपुट:

— rnso
स्रोत

1

क्लोजर, 221 बाइट्स

ताकतवर लंबे लेकिन मामले को संभालता है (f 1)। उस विशेष मामले के बिना यह 183 बाइट्स था। इसे पोस्ट न करने के लिए यह बहुत प्रयास था।

(defn f([n](if(< n 2)(take-nth 2(drop 2(range)))(f n 1(take-nth 2(rest(range))))))([n i c](if (< n 2)c(let[N(first(drop i c))F #((if(= 2 n)= >)(mod(inc %)N)0)](f(dec n)(inc i)(filter some?(map-indexed #(if(F %)%2)c)))))))

नमूना आउटपुट:

(pprint (map #(take 10 (f %)) (range 1 10)))
((2 4 6 8 10 12 14 16 18 20)
 (5 11 17 23 29 35 41 47 53 59)
 (19 39 61 81 103 123 145 165 187 207)
 (27 57 91 121 153 183 217 247 279 309)
 (45 97 147 199 253 301 351 403 453 507)
 (55 117 181 243 315 379 441 505 571 633)
 (85 177 277 369 471 567 663 757 853 949)
 (109 225 345 465 589 705 829 945 1063 1185)
 (139 295 447 603 765 913 1075 1227 1377 1537))

1000000 100 मामले की गणना लगभग 4.7 घंटे में की गई, कम से कम यह दुर्घटना नहीं हुई।

java -jar target\stackoverflow-0.0.1-SNAPSHOT-standalone.jar 1000000 100
5333213163
"Elapsed time: 1.7227805535565E7 msecs"

— NikoNyrh
स्रोत

अशुभ अंक!

जानने योग्य बातें:

चुनौती:

उदाहरण इनपुट और आउटपुट:

चश्मा:

सीजेएम , 74 बाइट्स

स्पष्टीकरण:

समय:

पर्ल, 87 85 82 81 बाइट्स

पायथन 3, 170

गति

हास्केल

N = 1: 175 160 बाइट्स के लिए गणना करने में सक्षम नहीं

Ungolfed

सभी n: 170 बाइट्स के लिए गणना करने में सक्षम

आर 82 बाइट्स

रैकेट 332 बाइट्स

क्लोजर, 221 बाइट्स