0. परिभाषाएँ

एक क्रम संख्याओं की एक सूची है।
एक श्रृंखला संख्याओं की सूची का योग है। प्राकृतिक संख्याओं के
सेट में सभी "शून्य से अधिक गैर-नकारात्मक पूर्णांक होते हैं"। एक भाजक एक प्राकृतिक संख्या के (इस प्रसंग में) जे एक प्राकृतिक संख्या है मैं , ऐसा है कि जे ÷ मैं भी एक प्राकृतिक संख्या है।

1. पहले

इस साइट पर अन्य प्रश्न के एक जोड़े विभाज्य की अवधारणा, या एक प्राकृतिक संख्या की divisors के अनुक्रम का उल्लेख एक जो कम से कम कर रहे हैं एक । सौहार्दपूर्ण संख्या निर्धारित करने में इन विभाजकों का योग शामिल होता है, जिसे एक विभाज्य राशि या विभाज्य श्रृंखला कहा जाता है। हर प्राकृतिक संख्या का अपना एक अलग योग होता है, हालाँकि किसी संख्या के विभाज्य योग का मूल्य उस संख्या के लिए आवश्यक नहीं है। ( एग्जम्प्ली ग्राटिया , प्रत्येक प्राइम नंबर में 1 का कुल योग होता है)

2. चुनौती

एक प्राकृतिक संख्या को देखते हुए n, nविभाज्य रकम के अनुक्रम का वें अंक लौटाएं । 1 के लिए श्रृंखला के साथ शुरू होने वाले अनुक्रम में पहली कई श्रृंखलाएं हैं:

{0, 1, 1, 3, 1, 6, 1, 7, 4, 8, 1, 16, 1, 10, 9, 15, 1, 21, 1, 22, 11, 14, 1, 36, 6, 16, 13}

संबंधित, ये जैसे दिखते हैं:

0113161748116110915121122111413661613

इनपुट आपकी वरीयता के अनुसार शून्य-अनुक्रमित या एक-अनुक्रमित हो सकता है। समाधान प्रोग्राम या फ़ंक्शंस होने चाहिए जो 10,000 अंकों ( 9999या अप करने के लिए इनपुट 10000) को वापस करने में सक्षम हों । सबसे कम काम करने वाला समाधान जीतता है।

3. परीक्षण मामले

सही इनपुट-आउटपुट जोड़े शामिल होने चाहिए, लेकिन निम्नलिखित तक सीमित नहीं हैं:

   0 or     1    ->    0
   4 or     5    ->    1
  12 or    13    ->    6
9999 or 10000    ->    7

"या" से पहले की संख्या 0-अनुक्रमित है; निम्नलिखित संख्या 1-अनुक्रमित है।
अतिरिक्त परीक्षण मामलों के अनुरोध पर प्रदान किए जा सकते हैं।

4. संदर्भ

OEIS की संख्या और उनके विभाज्य रकम की एक सूची है।

— जो
स्रोत

2

अच्छी पहली चुनौती, btw। :)

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

1

अगर भाषा कठबोली 10k तार तार का प्रबंधन? (जैसे भयंकर ओरेकल SQL 4k सीमा ) उत्तर मान्य है अगर यह भाषा की सीमा है?

— जियाको गारबेलो

@MartinEnder, धन्यवाद! और उस लिंक के लिए धन्यवाद; यह ज्ञानवर्धक था। क्या वहाँ कुछ भी है जो बताता है कि सीमाओं के साथ भाषाओं में उत्तर का इलाज कैसे करें? मुझे कुछ नहीं मिला, लेकिन मुझे पता है कि इसका मतलब यह नहीं है कि यह वहाँ नहीं है। :)

— जो

मैं पूरी तरह से मोटा हो सकता हूं, लेकिन उस श्रृंखला में संख्याओं की गणना कैसे की जाती है?

— टॉम कारपेंटर

@TomCarpenter: पहले तत्व के लिए, 1 के सभी विभाजक लें जो 1 से कम हैं, और उन्हें एक साथ जोड़ें। (1 केवल 1 का विभाजक है, इसलिए पहला तत्व शून्य होने पर समाप्त होता है।) दूसरा तत्व, 2 का विभाजक जो 2 से कम है (केवल 1 इस पर फिट बैठता है); तीसरा, 3 के भाजक (अभी भी 1); और इसी तरह। 4 के विभाजक हैं {1, 2}, और 1 + 2 == 3, इसलिए चौथा तत्व है 3. मुझे यह पता लगाने में

— जो

6

05AB1E , 14 11 10 बाइट्स

लगभग 15 सेकंड में n = 9999 की गणना करें। कोड:

ÌL€Ñ€¨OJ¹è

स्पष्टीकरण:

Ì           # Increment implicit input by 2
 L          # Generate the list [1 .. input + 2]
  €Ñ        # For each, get the divisors
    €¨      # For each, pop the last one out
      O     # Sum all the arrays in the array
       J    # Join them all together
        ¹è  # Get the nth element

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

— अदनान
स्रोत

6

गणितज्ञ, 51 बाइट्स

Array[##&@@IntegerDigits[Tr@Divisors@#-#]&,#][[#]]&

एक अनाम फ़ंक्शन जो पूर्णांक लेता है और लौटाता है और 1-आधारित अनुक्रमण का उपयोग करता है। 10000तुरन्त इनपुट संभालता है।

व्याख्या

यह परिभाषा का एक बहुत ही सीधा-सीधा कार्यान्वयन है, इस तथ्य का उपयोग करते हुए कि वें अंक nनिर्धारित करने के लिए पहले विभाजक रकम हमेशा पर्याप्त होती है n। हमेशा की तरह, गोल्फ मैथमेटिका का पठन क्रम थोड़ा अजीब है, हालांकि:

Array[...&,#]...&

यह सभी मानों को समावेशी iसे बाईं ओर अनाम फ़ंक्शन को लागू करने के सभी परिणामों के साथ एक सूची बनाता है ।1n

...Tr@Divisors@#-#...

हम डिवाइडर की गणना करके शुरू करते हैं i, उनके साथ जोड़ते हैं Trऔर iखुद को घटाते हैं ताकि यह केवल डिवाइडर के योग से कम हो i।

...IntegerDigits[...]...

यह परिणाम को उसके दशमलव अंकों की सूची में बदल देता है।

##&@@...

और यह "सूची" सिर को हटा देता है, ताकि सभी अंकों की सूची स्वचालित रूप से के परिणाम में संक्षिप्त हो जाए Array। कैसे ##काम करता है, इस बारे में अधिक जानकारी के लिए , इस पोस्ट में "तर्क के अनुक्रम" अनुभाग देखें ।

...[[#]]

अंत में, हम nपरिणाम से वें अंक का चयन करते हैं ।

— मार्टिन एंडर
स्रोत

4

ब्रेकीलॉग , 40 बाइट्स

:2-I,?:?:1yrc:Im.;0.
:1e:2f+.
>.>0,?:.%0

यह 1-अनुक्रमित है N = 100, 15 सेकंड के लिए, लगभग 0.15 सेकंड लेता है N = 1000। मैं वर्तमान में इसके लिए चल रहा हूं N = 10000, मैं इसे समाप्त करने के बाद रन टाइम की रिपोर्ट करूंगा (यदि मेरा अनुमान सही है, तो लगभग 8 घंटे लगने चाहिए)

संपादित करें : Brachylog में समय से पहले की कमी को ठीक करके, यह अब (एक 3 बाइट्स लंबे कोड पर) 2.5मिनट के लिए लेता है , 10000लेकिन एक out of global stackत्रुटि देता है ।

व्याख्या

मुख्य विधेय: Input = N

:2-I,                 I = N - 2
     ?:?:1y           Find the N first valid outputs of predicate 1 with input N
           rc         Reverse and concatenate into a single number
             :Im.     Output is the Ith digit of that number
                 ;    Or (I strictly less than 0)
                  0.  Output is 0

विधेय 1: विभाजकों के योग की गणना करता है

:1e                   Get a number between N and 1
   :2f                Find all valid outputs of predicate 2 with that number as input
      +.              Output is the sum of those outputs

विधेय 2: इनपुट के एक भाजक के साथ आउटपुट को एकीकृत करता है
```
>.>0,                 Output is a number between Input and 0
     ?:.%0            Input is divisible by Output
```

— Fatalize
स्रोत

1

आप -Gविकल्प के साथ अधिक वैश्विक स्टैक आवंटित कर सकते हैं । डिफ़ॉल्ट केवल है 128M। आप उदाहरण के लिए उपयोग कर सकते हैं: swipl -G2G2 GO का उपयोग करने के लिए।

— मैट

4

पायथ, 26 21 20 15 बाइट्स

@sm`sf!%dTtUdSh

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

0-आधारित अनुक्रमण का उपयोग करता है। कार्यक्रम ओ (n²) है और मेरी 2008 मशीन पर लगभग 14 मिनट में n = 9999 के लिए पूरा होता है ।

— PurkkaKoodari
स्रोत

उस जटिल भाजक खोज के साथ क्या हो रहा है? f!%dTr1dबहुत छोटा है (लेकिन यह भी धीमा है)

— Jakube

@Jakube वूप्स, 20 बाइट समाधान के लिए गलत संस्करण को संशोधित किया।

— पुरकाकूदरी

f!%TYtUTमेरे पास जो है, वह मेरे पास था।

— पुरकाकूदरी

@ जाकुब मैं उस में बदल गया। यह अभी भी n = 9999 के लिए चल रहा है, अब 5 मिनट से अधिक हो गया है: \

— पुरकाकूदरी

4

जेली, 13 11 10 बाइट्स

2 बाइट्स @ अदनान के लिए और 1 अधिक धन्यवाद @ डेनिस के लिए।

ÆDṖSDµ€Fị@

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

1-आधारित अनुक्रमण का उपयोग करता है। ऑनलाइन 2 सेकंड के तहत n = 10000 के लिए पूरा करता है ।

— PurkkaKoodari
स्रोत

ÆDṖSDµ€Fị@एक बाइट बचाता है।

— डेनिस

@ डेनिस ऐसा करता है जो €पूरी पहली श्रृंखला पर लागू होता है ?

— पुरकाकूदरी

@ Pietu1998: हाँ, ठीक है: सामान्य तौर पर, पार्स समय पर, €पर लागू होता है chain.pop() if chain else chains.pop()। नई शुरू की गई श्रृंखला खाली है, इसलिए अंतिम समाप्त श्रृंखला का उपयोग किया जाता है।

— लिन

3

PHP, 90 बाइट्स

0 अनुक्रमित

<?php for(;strlen($s)<=$a=$argv[1];$s.=$n)for($n=0,$j=++$i;--$j;)$i%$j||$n+=$j;echo$s[$a];

बिल्कुल सूक्ष्म या बिल्कुल भी इसके निकट आने के चतुर तरीके से नहीं।
इसके अलावा, हमेशा की तरह, तीन नोटिस का उत्पादन किया जाता है जिसे अनदेखा किया जाता है।

— user55641
स्रोत

3

जे , 34 बाइट्स

{[:;1<@":@(-~>:@#.~/.~&.q:)@+i.@>:

यह शून्य-अनुक्रमित है और विभाजक रकम की गणना करने के लिए नीचे दिए गए सूत्र का उपयोग करता है।

सूत्र

व्याख्या

{[:;1<@":@(-~>:@#.~/.~&.q:)@+i.@>:  Input: n
                                >:  Increment n
                             i.@    Create the range [0, 1, ..., n]
    1                       +       Add one to each to get [1, 2, ..., n+1]
          (               )@        For each value
                        q:            Get the prime factors
                   /.~&.              For each group of equal prime factors
                #.~                     Raise the first to the first power, the second
                                        squared and so on, and sum them
             >:@                        Increment that sum
                      &.q:            Reduce the groups using multiplication
           -~                         Subtract the initial value from that sum
       ":@                            Convert each to a string
     <@                               Box each
 [:;                                Unbox each and concatenate the strings
{                                   Select the character from that string at index n
                                    and return it

— मील की दूरी पर
स्रोत

2

MATL , 16 15 बाइट्स

:"@@q:\~fsV]vG)

अनुक्रमण 1-आधारित है।

अंतिम परीक्षण का समय ऑनलाइन कंपाइलर में निकलता है, लेकिन यह ऑफ़लाइन कंपाइलर के साथ लगभग 15 सेकंड में सही परिणाम देता है।

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

:         % Take input n. Push [1 2 ... n]
"         % For each k in [1 2 ... n]
  @       %   Push k
  @q:     %   Push [1 2 ... k-1]
  \       %   Modulo. Zero values correspond to divisors
  ~f      %   Indices of zeros. These are the divisors
  s       %   Sum
  V       %   Convert to string
]         % End for each
v         % Concatenate all stack contents vertically
G)        % Take n-th digit. Implicitly display

— लुइस मेंडो
स्रोत

2

हास्केल, 52 बाइट्स

(([1..]>>= \n->show$sum[m|m<-[1..n-1],mod n m<1])!!)

प्रयोग उदाहरण: (([1..]>>= \n->show$sum[m|m<-[1..n-1],mod n m<1])!!) 12-> 6।

यह परिभाषा का सीधा कार्यान्वयन है: foreach nsum यह divisers है और इसे एक स्ट्रिंग में परिवर्तित करें। ऐसे सभी तारों को समेटें और अनुरोधित सूचकांक पर तत्व चुनें। हास्केल का आलस्य nअनंत सूची से केवल उतना ही लेता है जितना [1..]कि जरूरत है।

— nimi
स्रोत

1

पायथन 3.5, 103 93 92 बाइट्स:

R=range;A=lambda f:''.join([str(sum([j for j in R(1,i)if i/j%1==0]))for i in R(1,f+1)])[f-1]

पोस्ट में वर्णित विधि का बहुत सीधा कार्यान्वयन।

यह ऑनलाइन की कोशिश करो! (Ideone)

इनपुट के लिए ऑनलाइन संकलक में आवंटित 5 सेकंड के भीतर काफी खत्म नहीं होता है 10000, लेकिन यह 8.5 सेकंड के भीतर उसी इनपुट के लिए मेरी मशीन पर खत्म करता है।

— आर। कप
स्रोत

1

ऑक्टेव, 71 बाइट्स

यह केवल अष्टक है। यह MATLAB में काम नहीं करेगा। एक वर्चुअल फ़ंक्शन बनाया जाता है जो 1-अनुक्रमित संख्याओं पर काम करता है। इसे शायद थोड़ा और सरल बनाया जा सकता है। आज शाम को देख लेंगे।

@(x)c((c=num2str(arrayfun(@(n)sum(b(~rem(n,b=(1:n-1)))),1:x)))~=' ')(x)

आप यहाँ ऑनलाइन कोशिश कर सकते हैं ।

बस ऊपर दिए गए कमांड को चलाएं, a=जो पहले से या जो भी हो (सिर्फ इतना है कि आप इसे कई बार उपयोग कर सकते हैं), और फिर a(10000)या जो भी करें। यह गणना करने में लगभग 7 सेकंड लगते हैं कि 10000 वां अंक 7 है।

— टॉम बढ़ई
स्रोत

1

जावा 8, 220 बाइट्स

import java.util.stream.IntStream;
char a(int n){return IntStream.range(1,n+2).map(i->IntStream.range(1,i).filter(k->i%k==0).sum()).mapToObj(Integer::toString).collect(java.util.stream.Collectors.joining("")).charAt(n);}

खैर, यह कम से कम तेजी से है। मेरी मशीन पर 9999/10000 वां तत्व प्राप्त करने के लिए औसतन 0.3 सेकंड का समय है। यह आपके द्वारा निर्दिष्ट सूचकांक के रूप में केवल कई विभाज्य राशि उत्पन्न करता है। इसका मतलब यह है कि स्ट्रिंग ज्यादातर मामलों में आपके सूचकांक से थोड़ा लंबा होगा, क्योंकि कुछ विभाजनों में 2 या अधिक अंक होते हैं, लेकिन अधिकांश भाग के लिए, यह केवल एक स्ट्रिंग के लंबे समय तक उत्पन्न करता है, जैसा कि हमें चाहिए।

उपयोग:

public static void main(String[] args) {
    System.out.println(a(0));
    System.out.println(a(4));
    System.out.println(a(12));
    System.out.println(a(9999));
}

Ungolfed:

public static void main(String[] args) {
    System.out.println(all(0));
    System.out.println(all(4));
    System.out.println(all(12));
    System.out.println(all(9999));
}

static int aliquotSum(int n) {
    return IntStream.range(1, n).filter(k -> n % k == 0).sum();
}

static IntStream sums(int n) {
    return IntStream.range(1, n + 2).map(i -> aliquotSum(i));
}

static String arraycat(IntStream a) {
    return a.mapToObj(Integer::toString).collect(java.util.stream.Collectors.joining(""));
}

static char all(int index) {
    return arraycat(sums(index)).charAt(index);
}

— जस्टिन
स्रोत

विभाज्य श्रृंखला के अनुक्रम का nth अंक लौटाएं

0. परिभाषाएँ

1. पहले

2. चुनौती

3. परीक्षण मामले

4. संदर्भ

05AB1E , 14 11 10 बाइट्स

गणितज्ञ, 51 बाइट्स

व्याख्या

ब्रेकीलॉग , 40 बाइट्स

व्याख्या

पायथ, 26 21 20 15 बाइट्स

जेली, 13 11 10 बाइट्स

PHP, 90 बाइट्स

जे , 34 बाइट्स

व्याख्या

MATL , 16 15 बाइट्स

हास्केल, 52 बाइट्स

पायथन 3.5, 103 93 92 बाइट्स:

ऑक्टेव, 71 बाइट्स

जावा 8, 220 बाइट्स