क्या आप अभी तक खो गए हैं?

31

आपका कार्य पूर्णांक अनुक्रम A130826 को लागू करना है :

एक n छोटी से छोटी पूर्णांक सकारात्मक ऐसी है कि एक एन - एन के एक पूरे एकाधिक है 3 और दो बार की divisors की संख्या (एक एन - एन) / 3 देता n वें अनुक्रम के पहले मतभेद फ्लेवियस द्वारा उत्पादित में अवधि जोसेफस छलनी

अभी तक खो गया? खैर, यह वास्तव में काफी आसान है।

फ्लेवियस जोसेफस चलनी इस प्रकार एक पूर्णांक अनुक्रम को परिभाषित करता है।

  1. सकारात्मक पूर्णांक के अनुक्रम से शुरू करें और k = 2 सेट करें ।

  2. हर निकालें कश्मीर वें क्रम के पूर्णांक, के साथ शुरू कश्मीर वें ।

  3. वृद्धि k और चरण 2 पर वापस जाएं।

f n , n वें पूर्णांक (1-अनुक्रमित) है जो कभी भी हटाया नहीं जाता है।

है - हमेशा की तरह - σ 0 (के) पूर्णांक के सकारात्मक divisors की संख्या को दर्शाता है कश्मीर , हम परिभाषित कर सकते हैं एक n सकारात्मक पूर्णांक छोटी से छोटी ऐसी है कि के रूप में 2σ 0 ((एक n = च - एन) / 3) n + 1 - एफ एन ।

चुनौती

एक प्रोग्राम या समारोह है कि एक सकारात्मक पूर्णांक लेता लिखें n इनपुट और प्रिंट के रूप में या रिटर्न एक एन ।

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

काम के उदाहरण

यदि हम धनात्मक पूर्णांक के हर दूसरे तत्व को हटाते हैं, तो हम साथ रह जाते हैं

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

शेष के हर तीसरे तत्व को निकालने के बाद, हम प्राप्त करते हैं

 1  3  7  9 13 15 19 21 25 27 31 33 37 39 ...

अब हर चौथे, फिर पाँचवें, फिर छठे तत्व को निकालते हैं

 1  3  7 13 15 19 25 27 31 37 39 ...
 1  3  7 13 19 25 27 31 39 ...
 1  3  7 13 19 27 31 39 ...
 1  3  7 13 19 27 39 ...

अंतिम पंक्ति में एफ 1 से एफ 7 तक की शर्तें दिखाई गई हैं ।

इन शर्तों के लगातार तत्वों के अंतर हैं

 2  4  6  6  8 12

इन आगे के अंतरों को 2 से विभाजित करके , हम प्राप्त करते हैं

 1  2  3  3  4  6

ये लक्ष्य विभाजक गणना हैं।

  • 4 पहले पूर्णांक है कश्मीर ऐसी है कि σ 0 = 1 - (1) / 3 (के) । वास्तव में, σ 0 (1) = 1 ।
  • 8 पहले पूर्णांक है कश्मीर ऐसी है कि σ 0 = 2 - (2) / 3 (के) । वास्तव में, σ 0 (2) = 2 ।
  • 15 पहले पूर्णांक है कश्मीर ऐसी है कि σ 0 = 3 - (3) / 3 (के) । वास्तव में, σ 0 (4) = 3 ।
  • 16 पहले पूर्णांक है कश्मीर ऐसी है कि σ 0 = 3 - (4) / 3 (के) । वास्तव में, σ 0 (4) = 3 ।
  • 23 पहले पूर्णांक है कश्मीर ऐसी है कि σ 0 = 4 - (5) / 3 (के) । वास्तव में, σ 0 (6) = 4 ।
  • 42 पहले पूर्णांक है कश्मीर ऐसी है कि σ 0 = 6 - (6) / 3 (के) । वास्तव में, σ 0 (12) = 6 ।

परीक्षण के मामलों

   n     a(n)

   1        4
   2        8
   3       15
   4       16
   5       23
   6       42
   7       55
   8      200
   9       81
  10       46
  11      119
  12      192
  13      205
  14   196622
  15    12303
  16       88
  17      449
  18      558
  19      127
  20     1748
  21   786453
  22       58
  23     2183
  24     3096
  25     1105
  26   786458
  27 12582939
  28      568
  29     2189
  30     2730
code-golf  math  sequence  number-theory 
— डेनिस
स्रोत
14
OEIS पर कीवर्ड: गूंगा ("एक महत्वहीन अनुक्रम")।
— orlp
15
बेवकूफ? यह दुनिया को बचा सकता है!
— डेनिस
3
यही कारण है कि यमक हालांकि ...
— Mego

जवाबों:

7

जेली, 30 29 27 25 बाइट्स

सहेजे गए 2 बाइट्स @ धन्यवाद के बारे में मुझे सूचित करने के Ædलिए और दो चेन के संयोजन के लिए एक और 2 बाइट्स।

RUð÷‘Ċ×µ/
‘Ç_ÇH0Æd=¥1#×3+

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

यह शायद सबसे मजेदार था जो मैंने कभी जेली के साथ किया था। मैं दूसरी पंक्ति है, जो गणना करता है से शुरू च n से n OEIS पर सूत्र का उपयोग कर, और काफी सुंदर है।

व्याख्या

F n की गणना करने के लिए RUµ per 'ð × µ / हेल्पर लिंक । तर्क: एन
R नंबर प्राप्त करें [1..n]
 यू रिवर्स
        / "अगले 2 गुणकों तक गोल" द्वारा कम करें:
   । अगले नंबर से विभाजित करें
    'एक से अधिक छोड़ने के लिए वृद्धि
     Ċ छत (राउंड अप)
      × अगली संख्या से गुणा करें

'¥_ #H0Æd = Ç 1 # × 3 + मुख्य लिंक। तर्क: एन
'वृद्धि एन
 Ç गणना F n + 1। 
   गणना F n
  _ घटाना
    एच द्वारा विभाजित 2
     0 1 # 0 से शुरू, ( एन -एन) / 3 के लिए पहला उम्मीदवार खोजें
                   वह संतुष्ट करता है ...
      Æd Æ 0 ((ए एन -एन) / 3)
        = = (एफ एन + 1- एफ एन ) / 2
            × 3 को 3 से गुणा करके ( n -n) / 3 को n -n में बदल दें
              + एक चालू करने के लिए n जोड़े n एक में -n n
— PurkkaKoodari
स्रोत
3

पायथन 2 , 121 119 118 बाइट्स

n=input();r=range(1,4**n);d=s,=r*1,
for k in r:del s[k::k+1];d+=sum(k%j<1for j in r)*2,
print d.index(s[n]-s[n-1])*3+n

रन टाइम O (4 n ) मेमोरी के उपयोग के साथ लगभग O (16 n ) होना चाहिए । जगह के साथ - जो मैं लगता है कि पर्याप्त है - यह नाटकीय रूप से सुधार होगा, लेकिन मैं आश्वस्त नहीं हूँ कि इसके बारे में मनमाने ढंग से बड़े मूल्यों के लिए काम करता है एन ।4**n5<<n

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

असममित व्यवहार और एक n के ऊपरी सीमा

परिभाषित ख n के रूप में (एक n / 3 - एन) , यानी, छोटी से छोटी सकारात्मक पूर्णांक कश्मीर ऐसी है कि σ 0 (के) = ½ (च n + 1 - च n ) ।

जैसा कि OEIS पृष्ठ पर नोट किया गया है, f n ~ , n 2 , इसलिए f n + 1 - f n ~ 1 (n + 1) 2 - =n 2 = ¼π (2n + 1) ~ .n ।

इस तरह,) (f n + 1 - f n ) ~ .n । यदि वास्तविक संख्या एक प्रमुख पी है , तो p divisers के साथ सबसे छोटा धनात्मक पूर्णांक 2 p-1 है , इसलिए b n को 2 c n , जहां c n ~ .n द्वारा अनुमानित किया जा सकता है ।

इसलिए b n <4 n पर्याप्त रूप से बड़े n के लिए धारण करेगा , और उस 2 2n <2 n << (2 n ) 2 = 4 n को देखते हुए , मुझे विश्वास है कि कोई प्रतिपक्ष नहीं हैं।

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

n=input();r=range(1,4**n);d=s,=r*1,

यह हमारी पुनरावृत्ति प्रक्रिया के लिए कुछ संदर्भ निर्धारित करता है।

  • n उपयोगकर्ता इनपुट है: एक सकारात्मक पूर्णांक।

  • आर सूची [1, ..., 4 एन - 1] है ।

  • s , r की एक प्रति है ।

    के साथ एक बार सूची दोहरा r*1एक उथले कॉपी बन जाती है, तो संशोधित रों बदलाव नहीं करेगी आर ।

  • d को tuple (s) के रूप में आरंभीकृत किया गया है ।

    यह पहला मूल्य महत्वपूर्ण नहीं है। अन्य सभी पॉजिटिव पूर्णांक की भाजक गणना करेंगे।

for k in r:del s[k::k+1];d+=sum(k%j<1for j in r)*2,

1 से 4 n - 1 से प्रत्येक पूर्णांक k के लिए , हम निम्नलिखित करते हैं।

  • del s[k::k+1]प्रत्येक (k + 1) वें पूर्णांक को s - (k + 1) वें से शुरू करता है - और उस स्लाइस को s से हटाता है ।

    इस में चलनी फ्लेवियस जोसेफस की एक प्रारंभिक अंतराल को संग्रहीत करने का सीधा रास्ता है रों । यह आवश्यक n + 1 प्रारंभिक शब्दों की तुलना में बहुत अधिक गणना करेगा , लेकिन s और dfor दोनों को अपडेट करने के लिए एक लूप का उपयोग करके कुछ बाइट्स बचाता है।

  • d+=sum(k%j<1for j in r)*2,मायने रखता है कि कैसे के कई तत्वों आर विभाजित कश्मीर समान रूप से और जोड़ देती 2σ 0 (के) के लिए घ ।

    चूंकि घ एक सिंगलटन टपल के रूप में प्रारंभ किया गया था, 2σ 0 (के) सूचकांक में संग्रहीत किया जाता है कश्मीर ।

print d.index(s[n]-s[n-1])*3+n

यह पाता के पहले सूचकांक च n + 1 - च n में घ , जो सबसे छोटी है कश्मीर ऐसी है कि 2σ 0 (के) = च n + 1 - च n है, तो गणना करता है एक n के रूप में 3k + 1 और परिणाम प्रिंट करता है।

— डेनिस
स्रोत
2

जावा 8, 336 , 305 , 303 , 287 , 283 279 बाइट्स

57 बाइट्स ने कृतिका लिथोस को धन्यवाद दिया

golfed

class f{static int g(int s,int N){return s<1?N+1:g(s-1,N+N/s);}static int h(int k){int u=0,t=1,i;for(;u!=(g(k,k)-g(k,k-1))/2;t++)for(i=1,u=0;i<=t;)if(t%i++<1)u++;return 3*t-3+k;}public static void main(String[]a){System.out.print(h(new java.util.Scanner(System.in).nextInt()));}}

Ungolfed

class f {
    static int g(int s,int N){return s < 1 ? N + 1 : g(s - 1, N + N / s);}

    static int h(int k) {
        int u = 0, t = 1, i;
        // get the first number with v divisors
        while(u != (g(k, k) - g(k, k - 1))/2){
            u = 0;
            for (i = 1; i <= t; i++)
                if (t % i < 1) u++;
            t++;
        }
        // 3*(t-1)+k = 3*t+k-3
        return 3 * t + k - 3;
    }

    public static void main(String[] a) {
        System.out.print(h(new java.util.Scanner(System.in).nextInt()));
    }
}
— Bobas_Pett
स्रोत
मुझे लगता है कि कमांड-लाइन के तर्कों को पार्स करने का intउपयोग करने की तुलना में कम है java.util.Scanner। लेकिन भले ही आप स्कैनर का उपयोग कर रहे हों, आप कर सकते हैं System.out.print(h(new java.util.Scanner().nextInt()))और पिछली पंक्ति को हटा सकते हैं
— Kritii Lithos
@KritiiLithos thx, अब ठीक हो रहा है ...
— Bobas_Pett
अंदर int h(), आप इसे बदल सकते हैं int v = (g(k,k)-g(k,k-1))/2,u = 0,t = 1;। आप अपने अगर बयान (आपके अंदर है कि के लिए लूप) से बदल सकते हैं if(t%i==0)करने के लिएif(t%i<1)
— Kritixi lithos
साथ ही, आप अपने कार्य को बदल सकते हैं gत्रिगुट ऑपरेटर्स का उपयोग कर की तरह कुछ वापस जाने के लिए return s==0?N+1:g(s-1,N+N/2)-ish
— Kritixi lithos
2
@KritiiLithos lol इस बिंदु पर यू सिर्फ उर अलग समाधान के रूप में पोस्ट करना चाहिए
— Bobas_Pett
1

मैथेमेटिका, 130 116 106 103 बाइट्स

3Catch@Do[f=#2⌈#/#2+1⌉&~Fold~Reverse@Range@#&;If[Tr[2+0Divisors@k]==f[#+1]-f@#,Throw@k],{k,∞}]+#&

या

3Catch@Do[f=#2⌈#/#2+1⌉&~Fold~Reverse@Range@#&;If[2DivisorSum[k,1&]==f[#+1]-f@#,Throw@k],{k,∞}]+#&

समाप्त हो गया लगभग @ Pietu1998 के जेली कोड के समान ...

व्याख्या

Catch@

Catchजो कुछ भी Throw-ed (फेंका गया) हो।

Do[ ... ,{k,∞}]

अनंत लूप; kसे शुरू होता है 1और हर पुनरावृत्ति को बढ़ाता है।

f= ...

असाइन करें f:

Reverse@Range@#

का पता लगाएं {1, 2, ... , n}। इसे उलट दें।

#2⌈#/#2+1⌉&

एक फ़ंक्शन जो सीमेट्स (एन 1 / एन 2 + 1) * एन 2 आउटपुट करता है

f= ... ~Fold~ ... &

fएक फ़ंक्शन को असाइन करें जो उपरोक्त फ़ंक्शन को दो चरणों से ऊपर की सूची में लागू करता है, प्रत्येक आउटपुट को पहले इनपुट के रूप में और दूसरे इनपुट के रूप में सूची के प्रत्येक तत्व का उपयोग करता है। प्रारंभिक "आउटपुट" (पहला इनपुट) सूची का पहला तत्व है।

Tr[2+0Divisors@k]==f[#+1]-f@#

जांचें कि क्या दो बार के विभाजकों की संख्या kf (n + 1) - f (n) के बराबर है।

If[ ... ,Throw@k]

अगर हालत है True, Throwका मूल्य k। यदि नहीं, तो लूपिंग जारी रखें।

3 ... +#&

आउटपुट को 3 से गुणा करें और n जोड़ें।

130 बाइट संस्करण

Catch@Do[s=#+1;a=k-#;If[3∣a&&2DivisorSigma[0,a/3]==Differences[Nest[i=1;Drop[#,++i;;;;i]&,Range[s^2],s]][[#]],Throw@k],{k,∞}]&
— जंगवान मिन
स्रोत
1

पर्ल 6 , 154 149 136 107 बाइट्स

->\n{n+3*first ->\o{([-] ->\m{m??&?BLOCK(m-1).rotor(m+0=>1).flat!!1..*}(n)[n,n-1])/2==grep o%%*,1..o},^Inf}

Ungolfed:

-> \n {                    # Anonymous sub taking argument n
  n + 3 * first -> \o {    # n plus thrice the first integer satisfying:
    (                      #
      [-]                  #
      -> \m {              # Compute nth sieve iteration:
        m                  # If m is nonzero,
          ?? &?BLOCK(m-1).rotor(m+0=>1).flat # then recurse and remove every (m+1)-th element;
          !! 1..*          # the base case is all of the positive integers
      }                    #
      (n)                  # Get the nth sieve
      [n,n-1]              # Get the difference between the nth and (n-1)th elements (via the [-] reduction operator above)
    ) / 2                  # and divide by 2;
    ==                     # We want the number that equals
    grep o %% *, 1..o      # the number of divisors of o.
  }
  ,^Inf
}
— शॉन
स्रोत
1

05AB1E ,35 34 39 बाइट्स

1Qi4ë[N3*¹+NÑg·¹D>‚vyy<LRvy/>îy*}}‚Æ(Q#

यह भयानक लग रहा है, इसलिए रनटाइम प्रदर्शन है। इनपुट के लिए कई सेकंड लगते हैं जो छोटे मान प्राप्त करते हैं। 14 की तरह संख्या की कोशिश मत करो; अंततः इसका परिणाम मिल जाएगा लेकिन इसमें उम्र लग जाएगी।

व्याख्या

यह क्रमिक रूप से कहे जाने वाले कार्यक्रमों के रूप में 2 काम करता है। पहला एक F n + 1 - F n की गणना करता है और दूसरा एक bruteforce दृष्टिकोण का उपयोग करते हुए, इसकी परिभाषा के आधार पर एक n निर्धारित करता है ।

एफ एन + 1 - एफ एन का मूल्यांकन प्रत्येक चाल के लिए किया जाता है, भले ही यह लूप इनवेरिएंट हो। यह कोड समय को अक्षम बनाता है, लेकिन यह कोड को छोटा बनाता है।

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

— Osable
स्रोत
मुझे यकीन नहीं कि मैं समझा हूँ। यह 65,536 के ऊपर चलनी की गणना क्यों नहीं कर सकता है?
— डेनिस
यह इस तथ्य से आता है कि यह 0 और 65536 ( žHL) के बीच सभी पूर्णांकों को उत्पन्न करता है और फिर छलनी की कमी को पूरा नहीं करने वाले मूल्यों को फ़िल्टर करता है। मुझे लगता है कि इस कार्यक्रम के पहले भाग को पूरी तरह से अलग दृष्टिकोण के साथ फिर से लिखा जाना चाहिए ताकि इसे गोल्फ बनाया जा सके।
— Osable
जब तक सीमाएं नहीं हैं (निश्चित चौड़ाई पूर्णांक की तरह) जो आपको ऐसा करने से रोकती हैं, तो किसी भी इनपुट के लिए जवाब देने की अपेक्षा की जाती है, पर्याप्त समय और स्मृति दी जाती है।
— डेनिस
यही कारण है कि मैं एक और छलनी एल्गोरिथ्म के साथ आया था। यह गोल्फ हो सकता है लेकिन मैं 05AB1E में बेहतर नहीं पाया हूं। हालाँकि, वहाँ एक जवाबी कार्रवाई है given enough time and memory, क्योंकि मैंने पहले से ही अन्य सवालों पर कई जवाब देखे जो इतनी धीमी गति से चले थे कि यह कहना लगभग असंभव था कि उन्होंने सही आउटपुट का उत्पादन किया या नहीं। इस कारण से मैंने चलनी की गणना को लूप से अलग रखा और मुझे 2 बाइट्स देने पड़े।
— Osable
अपने कोड को कुशल बनाने की आवश्यकता नहीं है। आप अपने जमा करने के लिए गोल्फ / धीमी गति से कार्यान्वयन कर सकते हैं और तेज / लंबे समय तक एक साइड नोट के रूप में शामिल कर सकते हैं। मुझे डर है कि मुझे गतिशील सीमा पर जोर देना होगा, भले ही यह एक बाइट खर्च हो।
— डेनिस
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.