पूर्णांक की एक बहुतायत!

Question

एक प्रचुर संख्या वह संख्या है जहां मूल संख्या की तुलना में इसके समुचित विभाजकों का योग अधिक होता है। उदाहरण के लिए, 12 के उचित भाजक हैं:

1, 2, 3, 4, 6

और इन परिणामों को 16 में सम्‍मिलित करें। चूंकि 16 12 से बड़ा है, 12 प्रचुर मात्रा में है। ध्यान दें कि इसमें "परफेक्ट नंबर" शामिल नहीं है , उदाहरण के लिए संख्या जो इसके उचित विभाजक के योग के बराबर है, जैसे 6 और 28।

आज के लिए आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है जो यह निर्धारित करता है कि संख्या प्रचुर है या नहीं। आपके कार्यक्रम को इनपुट के रूप में एक पूर्णांक लेना चाहिए, और यह प्रचुर मात्रा में है या नहीं इसके आधार पर एक सत्य / मिथ्या मूल्य का उत्पादन करना चाहिए । आप मान सकते हैं कि इनपुट हमेशा मान्य और 0 से अधिक होगा, इसलिए खराब इनपुट के लिए, अपरिभाषित व्यवहार ठीक है।

आप अपने इनपुट और आउटपुट को किसी भी उचित प्रारूप में ले सकते हैं, उदाहरण के लिए STDIN / STDOUT, फाइलें, या तर्क / रिटर्न मान सभी स्वीकार्य होंगे।

संदर्भ के लिए, यहां 100 तक की प्रचुर संख्या है:

12,
18,
20,
24,
30,
36,
40,
42,
48,
54,
56,
60,
66,
70,
72,
78,
80,
84,
88,
90,
96,
100

और अधिक A005101 पर पाया जा सकता है

चूंकि यह कोड-गोल्फ है , मानक खामियों से इनकार किया जाता है, और आप जिस भी भाषा को चुनने के लिए होते हैं, वहां कम से कम संभव कोड लिखने की कोशिश कर सकते हैं!

Comments

"पहला विषम प्रचुर मात्रा में 945 = 3 ^ 3 * 5 * 7, 232 वां प्रचुर संख्या है!"

— mbomb007

Asymptotic घनत्व प्रचुर मात्रा में संख्या के अंतराल [0.24761748, 0.24764422] भीतर कहीं है। इस पेपर में शामिल स्रोत कोड का उपयोग करके गणना ।

— डेडकोड

मैं ज्यामिति डैश में ऐसा करने की कोशिश कर रहा हूं। यह एक बुरा सपना है

— मिल्कीवेय

Answer 1

ECMAScript रेगेक्स, 1085 855 597 536 511 508 504 बाइट्स

ECMAScript रेगेक्स में प्रचुर संख्या में मिलान करना व्यावहारिक रूप से किसी भी अन्य regex स्वाद में ऐसा करने की तुलना में एक पूरी तरह से अलग जानवर है। फॉरवर्ड / नेस्टेड बैकरेफेरेंस या रिकर्सन की कमी का मतलब है कि किसी भी चीज़ को सीधे चलाना या रखना असंभव है। तलाश के अभाव में अक्सर काम करने के लिए पर्याप्त जगह होना भी चुनौती बना देता है।

कई समस्याओं को एक पूरी तरह से अलग दृष्टिकोण से संपर्क किया जाना चाहिए, और आप सोच रहे होंगे कि क्या वे बिल्कुल हल कर सकते हैं। यह आपको यह पता लगाने के लिए बाध्य करता है कि जिन संख्याओं के साथ आप काम कर रहे हैं, उनके गणितीय गुणों का उपयोग किसी विशेष समस्या को हल करने में सक्षम किया जा सकता है।

मार्च-अप्रैल 2014 में मैंने ECMAScript regex में इस समस्या के समाधान का निर्माण किया। सबसे पहले मेरे पास समस्या पर संदेह करने के लिए हर कारण पूरी तरह से असंभव था, लेकिन तब गणितज्ञ टेकोन ने एक विचार को छोड़ दिया, जिसने इसे सभी के बाद हल करने योग्य बनाने के लिए एक उत्साहजनक मामला बनाया - लेकिन उन्होंने यह स्पष्ट किया कि उनका रेगेक्स के निर्माण का कोई इरादा नहीं था (वह पिछले रेगीक्स के निर्माण / गोल्फ पर मेरे साथ प्रतिस्पर्धा / सहयोग किया था, लेकिन इस बिंदु तक अपनी सीमा तक पहुंच गया और सिद्धांत के लिए अपने आगे के योगदान को प्रतिबंधित करने के लिए सामग्री थी)।

जैसा कि मेरे regex ने कुछ दिन पहले पोस्ट किया था, मैं एक चेतावनी देता हूँ : मैं अत्यधिक सीखने की सलाह देता हूँ कि ECMAScript regex में अनैतिक गणितीय समस्याओं को कैसे हल किया जाए। यह मेरे लिए एक आकर्षक यात्रा रही है, और मैं इसे किसी ऐसे व्यक्ति के लिए खराब नहीं करना चाहता, जो संभवतः इसे स्वयं प्रयास करना चाहते हैं, विशेष रूप से संख्या सिद्धांत में रुचि रखने वाले। एक-एक करके हल करने के लिए लगातार बिगाड़ने वाले टैग की गई समस्याओं की सूची के लिए उस पोस्ट को देखें ।

तो आगे पढ़िए नहीं अगर आप नहीं चाहते हैं कि आपके लिए कुछ गहरी एकरी रेगेक्स मैजिक खराब हो जाए । मेरा पिछला पोस्ट सिर्फ एक छोटा सा स्वाद था। यदि आप स्वयं इस जादू का पता लगाने के लिए एक शॉट लेना चाहते हैं, तो मैं उच्च स्तर पर उल्लिखित उस पोस्ट में उल्लिखित ECMAScript regex में कुछ समस्याओं को हल करके शुरू करने की सलाह देता हूं।

मेरी ECMAScript regex पोस्ट करने से पहले, मैंने सोचा कि यह मार्टिन Ender के विश्लेषण के लिए रुचिकर होगी नेट शुद्ध regex समाधान , ^(?!(1(?<=(?=(?(\3+$)((?>\2?)\3)))^(1+)))*1$)। यह उस रेगेक्स को समझने के लिए बहुत सीधा है, और यह अपनी सादगी में सुरुचिपूर्ण है। हमारे समाधानों के बीच कंट्रास्ट को प्रदर्शित करने के लिए, उनके रेक्स का एक टिप्पणी और सुंदर-मुद्रित (लेकिन अनमॉडिफाइड) संस्करण है:

# For the purpose of these comments, the input number will be referred to as N.

^(?!                  # Attempt to add up all the divisors. Since this is a regex and we
                      # can only work within the available space of the input, that means
                      # if the sum of the divisors is greater than N, the attempt to add
                      # all the divisors will fail at some point, causing this negative
                      # lookahead to succeed, showing that N is an abundant number.

  (1                  # Cycle through all values of tail that are less than N, testing
                      # each one to see if it is a divisor of N.

    (?<=              # Temporarily go back to the start so we can directly operate both
                      # on N and the potential divisor. This requires variable-length
                      # lookbehind, a .NET feature – even though this special case of
                      # going back to the start, if done left-to-right, would actually be
                      # very easy to implement even in a regex flavour that has no
                      # lookbehind to begin with. But .NET evaluates lookbehinds right
                      # to left, so please read these comments in the order indicated,
                      # from [Step 1] to [Step 7]. The comment applying to entering the
                      # lookahead group, [Step 2], is shown on its closing parenthesis.
      (?=             # [Step 3] Since we're now in a lookahead, evaluation is left to
                      #          right.
        (?(\3+$)      # [Step 4] If \3 is a divisor of N, then...
          (           # [Step 5] Add it to \2, the running total sum of divisors:
                      #          \2 = \2 + \3         
            (?>\2?)   # [Step 6] Since \2 is a nested backref, it will fail to match on
                      #          the first iteration. The "?" accounts for this, making
                      #          it add zero to itself on the first iteration. This must
                      #          be done before adding \3, to ensure there is enough room
                      #          for the "?" not to cause the match to become zero-length
                      #          even if \2 has a value.
            \3        # [Step 7] Iff we run out of space here, i.e. iff the sum would
                      #          exceed N at this point, the match will fail, making the
                      #          negative lookahead succeed, showing that we have an
                      #          abundant number.
          )

        )
      )               # [Step 2] Enter a lookahead that is anchored to the start due to
                      #          having a "^" immediately to its right. The regex would
                      #          still work if the "^" were moved to the left of the
                      #          lookahead, but would be slightly slower, because the
                      #          engine would do some spurious matching before hitting
                      #          the "^" and backtracking.
      ^(1+)           # [Step 1] \3 = number to test for being a potential divisor – its
                      #               right-side-end is at the point where the lookbehind
                      #               started, and thus \3 cycles through all values from
                      #               1 to N-1.
    )
  )*1$                # Exclude N itself from being considered as a potential divisor,
                      # because if we included it, the test for proper abundance would be
                      # the sum of divisors exceeding 2*N. We don't have enough space for
                      # that, so instead what would happen if we did not exclude N as a
                      # divisor would be testing for "half-abundance", i.e. the sum of
                      # all divisors other than N exceeding N/2. By excluding N as a
                      # divisor we can let our threshold for abundance be the sum of
                      # divisors exceeding N.
)

.NET regex को ऑनलाइन आज़माएं

अब, मेरे ECMAScript रेगेक्स पर वापस। सबसे पहले, यह कच्चे, व्हाट्सएप और टिप्पणी मुक्त प्रारूप में है:

^(?=(((?=(xx+?)\3+$)(x+)\4*(?=\4$))+(?!\3+$)(?=(xx(x*?))\5*$)x)(x+))(?=\1(x(x*))(?=\8*$)\6\9+$)(?=(.*)((?=\8*$)\5\9+$))(?=(x*?)(?=(x\11)+$)(?=\12\10|(x))(x(x*))(?=\15*$)(?=\11+$)\11\16+$)(?=(x(x*))(?=\17*$)\7\18+$)((?=(x*?(?=\17+$)(?=\17+?(?=((xx(x*))(?=\18+$)\22*$))(x+).*(?=\17$)\24*(?=\24$)(?!(xx+)\25*(?!\22+$)\25$)\22+$)((?=(x\7)+$)\15{2}\14|)))(?=.*(?=\24)x(x(x*))(?=\28*$)\23\29*$)(?=.*(x((?=\28*$)\22\29+$)))(.*(?!\30)\20|(?=.*?(?!x\20)(?=\30*$)(x(x*))(?=\33*$)(?=\31+$)\31\34+$).*(?=\33\21$)))+$

^{(परिवर्तन \14करने के लिए \14?PCRE, .NET साथ संगतता के लिए, और व्यावहारिक रूप से हर दूसरे regex स्वाद कि ECMAScript नहीं है)}

इसे ऑनलाइन आज़माएं!
इसे ऑनलाइन आज़माएं! (रेगेक्स का 537 बाइट संस्करण)

और अब इसके पीछे की कहानी का एक संक्षिप्त सारांश।

पहले तो यह बहुत कम स्पष्ट था, मेरे लिए कम से कम, कि सामान्य मामलों में primes मैच करना भी संभव था। और इसे हल करने के बाद, 2 की शक्तियों के लिए एक ही लागू होता है। और फिर संयुक्त संख्या की शक्तियां। और फिर सही वर्ग। और इसे हल करने के बाद भी, सामान्यीकृत गुणा करना पहले असंभव था।

ECMAScript लूप में, आप केवल एक बदलते नंबर का ट्रैक रख सकते हैं; वह संख्या इनपुट से अधिक नहीं हो सकती, और उसे हर चरण पर घटाना पड़ता है। सही गुणन कथन A * B = C के मिलान के लिए मेरा पहला काम करने वाला regex 913 बाइट्स था, और A, B, और C को उनकी प्रमुख शक्तियों में विभाजित करके काम किया - प्रत्येक प्रमुख कारक के लिए, बार-बार A और C के मुख्य शक्ति कारकों की जोड़ी को विभाजित करें। जब तक A से संबंधित 1 तक नहीं पहुंच जाता, तब तक उनका प्रमुख आधार; सी के अनुरूप एक तो बी के प्रमुख शक्ति कारक की तुलना में है। एक ही प्राइम की इन दो शक्तियों को एक साथ जोड़कर एक ही संख्या में "गुणा" किया गया था; यह हमेशा लूप के बाद के प्रत्येक पुनरावृत्ति पर स्पष्ट रूप से अलग होने योग्य होगा, उसी कारण से जो स्थितिगत अंक प्रणाली काम करती है।

हमें पूरी तरह से अलग एल्गोरिथ्म का उपयोग करके 50 बाइट्स तक गुणा मिला (जो कि टेकोन और मैं स्वतंत्र रूप से आने में सक्षम थे, हालांकि इसमें उसे केवल कुछ ही घंटे लगे और वह सीधे इसके पास गया, जबकि मुझे इसके बाद भी कुछ दिन लगे। मेरे ध्यान में लाया गया कि एक छोटी विधि मौजूद है): A ,B के लिए, A * B = C यदि कोई हो तो C ही सबसे छोटी संख्या है जो C≡0 mod A और C≡B mod A-1 को संतुष्ट करता है। (आमतौर पर, A = 1 के अपवाद को regex में कोई विशेष हैंडलिंग की आवश्यकता नहीं है, जहां 0% 0 = 0 एक मैच देता है।) मैं बस यह नहीं कह सकता कि यह कितना साफ है कि गुणा करने का इतना सुंदर तरीका मौजूद है न्यूनतम रेगेक्स स्वाद। (और A≥B की आवश्यकता को एक आवश्यकता के साथ प्रतिस्थापित किया जा सकता है कि A और B एक ही शक्ति की प्रमुख शक्तियाँ हैं। A canB के मामले में, यह चीनी शेष प्रमेय का उपयोग करके सिद्ध किया जा सकता है।)

यदि यह पता चला था कि गुणन के लिए कोई सरल एल्गोरिथ्म नहीं था, तो प्रचुर संख्या में रेगेक्स संभवतः दस हजार बाइट्स के आदेश पर होगा या (यहां तक ​​कि इस बात को ध्यान में रखते हुए कि मैंने 913 बाइट एल्गोरिथ्म को 651 बाइट्स तक नीचे कर दिया है)। यह कई गुणा और विभाजन करता है, और ECMAScript रेगेक्स में कोई सबरूटीन्स नहीं है।

मैंने २३ मार्च २०१४ को बहुतायत संख्या समस्या पर काम करना शुरू कर दिया था, जो उस समय की उप-समस्या के रूप में प्रतीत होने वाले समाधान का निर्माण करके: उच्चतम गुणन के प्रमुख कारक की पहचान करना, ताकि इसे N से विभाजित किया जा सके। शुरुआत में, कुछ आवश्यक गणना करने के लिए कमरे को छोड़कर। इस समय यह लगने वाला एक आशाजनक मार्ग प्रतीत हो रहा था। (मेरा प्रारंभिक समाधान 326 बाइट्स पर काफी बड़ा हो गया, बाद में 185 बाइट्स तक नीचे गिर गया।) लेकिन बाकी की विधि टेकोन स्केच्ड बेहद जटिल होती, इसलिए जैसा कि यह निकला, मैंने एक अलग मार्ग लिया। यह N पर सबसे बड़े अभाज्य गुणक के सबसे बड़े मुख्य कारक को विभाजित करने के लिए पर्याप्त साबित हुआ; उच्चतम बहुलता के प्रमुख के लिए ऐसा करने से regex में अनावश्यक जटिलता और लंबाई जुड़ गई होगी।

जो बना हुआ था, वह सीधे राशि के बदले रकम के उत्पाद के रूप में विभक्तों के योग को मान रहा था। के रूप में teukon से समझाया 14 मार्च 2014 को:

हमें एक नंबर n = p ₀ ^{a ₀} p ₁ ^{a ₁} ... p _k-1 ^{a _{k-1 दिया जाता है}} । हम n के कारकों के योग को संभालना चाहते हैं, जो कि (1 + p ₀ + p ₀ ² + ... + p ₀ ^{a ₀} ) (1 + p ₁ + p ₁ ² + ... + p ₁ ^{a ₁} ) ... (1 + p _k-1 + p _k-1 ² + ... + p _k-1 ^{a _k-1} )।

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

अंत में, N को जोड़ने या गुणा करने के परिणाम के परीक्षण के बजाय, या यह परीक्षण कि M द्वारा पूर्व-विभाजित किया गया ऐसा परिणाम N / M से अधिक है, मैं विभाजन के परिणाम से कम होने पर परीक्षण के साथ गया था। 7 अप्रैल 2014 को पहला कार्य संस्करण।

इस रेगेक्स के मेरे गोल्फ अनुकूलन का पूरा इतिहास जीथब पर है। एक निश्चित बिंदु पर एक अनुकूलन ने रेक्सक्स को बहुत धीमा बना दिया, इसलिए उस बिंदु से मैंने दो संस्करणों को बनाए रखा। वो हैं:

प्रचुर मात्रा में numbers.txt मिलान के लिए regex
प्रचुर मात्रा में संख्या से मेल खाते के लिए regex - shortest.txt

ये regexes ECMAScript और PCRE दोनों के साथ पूरी तरह से संगत हैं, लेकिन हाल ही में ऑप्टिमाइज़ेशन में संभावित गैर-भाग लेने वाले कैप्चर ग्रुप का उपयोग किया गया है \14, इसलिए PCRE कम्पेटिबिलिटी को छोड़ कर \14?और \14उन्हें बदलकर दोनों को 1 बाइट से कम किया जा सकता है।

यहां सबसे छोटा संस्करण है, उस अनुकूलन के साथ (इसे ECMAScript-only बनाकर) लागू किया गया है, जिसमें सुधार करने के लिए StackExchange कोड ब्लॉक में फिट होने के लिए (ज्यादातर) कोई क्षैतिज स्क्रॉलिंग आवश्यक नहीं है:

# Match abundant numbers in the domain ^x*$ using only the ECMAScript subset of regex
# functionality. For the purposes of these comments, the input number = N.
^
# Capture the largest prime factor of N, and the largest power of that factor that is
# also a factor of N. Note that the algorithm used will fail if N itself is a prime
# power, but that's fine, because prime powers are never abundant.
(?=
  (                      # \1 = tool to make tail = Z-1
    (                    # Repeatedly divide current number by its smallest factor
      (?=(xx+?)\3+$)
      (x+)\4*(?=\4$)
    )+                   # A "+" is intentionally used instead of a "*", to fail if N
                         #  is prime. This saves the rest of the regex from having to
                         #  do needless work, because prime numbers are never abundant.
    (?!\3+$)             # Require that the last factor divided out is a different prime.
    (?=(xx(x*?))\5*$)    # \5 = the largest prime factor of N; \6 = \5-2
    x                    # An extra 1 so that the tool \1 can make tail = Z-1 instead of just Z
  )
  (x+)                   # Z = the largest power of \5 that is a factor of N; \7 = Z-1
)
# We want to capture Z + Z/\5 + Z/\5^2 + ... + \5^2 + \5 + 1 = (Z * \5 - 1) / (\5 - 1),
# but in case Z * \5 > N we need to calculate it as (Z - 1) / (\5 - 1) * \5 + 1.
# The following division will fail if Z == N, but that's fine, because no prime power is
# abundant.
(?=
  \1                     # tail = (Z - 1)
  (x(x*))                # \8   = (Z - 1) / (\5 - 1); \9 = \8-1
  # It is guaranteed that either \8 > \5-1 or \8 == 1, which allows the following
  # division-by-multiplication to work.
  (?=\8*$)
  \6\9+$
)
(?=
  (.*)                   # \10 = tool to compare against \11
  (                      # \11 = \8 * \5  =  (Z - 1) / (\5 - 1) * \5; later, \13 = \11+1
    (?=\8*$)
    \5\9+$
  )
)
# Calculate Q = \15{2} + Q_R = floor(2 * N / \13). Since we don't have space for 2*N, we
# need to calculate N / \13 first, including the fractional part (i.e. the remainder),
# and then multiply the result, including the fractional part, by 2.
(?=
  (x*?)(?=(x\11)+$)      # \12 = N % \13; \13 = \11 + 1
  (?=\12\10|(x))         # \14 = Q_R = floor(\12 * 2 / \13)
                         #     = +1 carry if \12 * 2 > \11, or NPCG otherwise
  (x(x*))                # \15 = N / \13; \16 = \15-1
  (?=\15*$)
  (?=\11+$)              # must match if \15 <  \13; otherwise doesn't matter
  \11\16+$               # must match if \15 >= \13; otherwise doesn't matter
)
# Calculate \17 = N / Z. The division by Z can be done quite simply, because the divisor
# is a prime power.
(?=
  (x(x*))                # \17 = N / Z; \18 = \17-1
  (?=\17*$)
  \7\18+$
)
# Seed a loop which will start with Q and divide it by (P^(K+1)-1)/(P-1) for every P^K
# that is a factor of \17. The state is encoded as \17 * P + R, where the initial value
# of R is Q, and P is the last prime factor of N to have been already processed.
#
# However, since the initial R would be larger than \17 (and for that matter there would
# be no room for any nonzero R since with the initial value of P, it is possible for
# \17 * P to equal N), treat it as a special case, and let the initial value of R be 0,
# signalling the first iteration to pretend R=Q. This way we can avoid having to divide Q
# and \17 again outside the loop.
#
# While we're at it, there's really no reason to do anything to seed this loop. To seed
# it with an initial value of P=\5, we'd have to do some multiplication. If we don't do
# anything to seed it, it will decode P=Z. That is wrong, but harmless, since the next
# lower prime that \17 is divisible by will still be the same, as \5 cannot be a factor
# of \17.

# Start the loop.
(
  (?=
    (                    # \20 = actual value of R
      x*?(?=\17+$)       # move forward by directly decoded value of R, which can be zero
      # The division by \17 can be done quite simply, because it is known that
      # the quotient is prime.
      (?=
        \17+?            # tail = \17 * (a prime which divides into \17)
        (?=
          (              # \21 = encoded value for next loop iteration
            (xx(x*))     # \22 = decoded value of next smaller P; \23 = (\22-1)-1
            (?=\18+$)    # iff \22 > \17, this can have a false positive, but never a false negative
            \22*$        # iff \22 < \17, this can have a false positive, but never a false negative
          )
        )
        # Find the largest power of \22 that is a factor of \17, while also asserting
        # that \22 is prime.
        (x+)             # \24 = the largest power of \22 that is a factor of \17
        .*(?=\17$)
        \24*(?=\24$)
        (?!
          (xx+)\25*
          (?!\22+$)
          \25$
        )
        \22+$
      )
      (
        (?=(x\7)+$)      # True iff this is the first iteration of the loop.
        \15{2}\14        # Potentially unset capture, and thus dependent on ECMAScript
                         # behavior. Change "\14" to "\14?" for compatibility with non-
                         # ECMAScript engines, so that it will act as an empty capture
                         # with engines in which unset backrefs always fail to match.
      |
      )
    )
  )
  # Calculate \30 = (\24 - 1) / (\22 - 1) * \22 + 1
  (?=
    .*(?=\24)x           # tail = \24 - 1
    (x(x*))              # \28 = (\24 - 1) / (\22 - 1); \29 = \28-1
    (?=\28*$)
    \23\29*$
  )
  (?=
    .*(x(                # \30 = 1 + \28 * \22 = (\28 - 1) / (\22 - 1) * \22 + 1; \31 = \30-1
      (?=\28*$)
      \22\29+$
    ))
  )
  # Calculate \33 = floor(\20 / \30)
  (
    .*(?!\30)\20         # if dividing \20 / \30 would result in a number less than 1,
                         # then N is abundant and we can exit the loop successfully
  |
    (?=
      .*?(?!x\20)(?=\30*$)
      (x(x*))            # \33 = \20 / \30; \34 = \33-1
      (?=\33*$)
      (?=\31+$)          # must match if \33 <  \30; otherwise doesn't matter
      \31\34+$           # must match if \33 >= \30; otherwise doesn't matter
    )
    # Encode the state for the next iteration of the loop, as \17 * \22 + \33
    .*(?=\33\21$)
  )
)+$

Comments

टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

— DJMcMayhem

-98 बाइट्स

— ग्रैमी

Answer 2

पायथन 2 , 41 40 बाइट्स

n=k=j=input()
while~k<0:j-=1;k-=j>>n%j*n

आउटपुट निकास कोड के माध्यम से है , इसलिए 0 सत्य है और 1 मिथ्या है।

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

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

STDIN से इनपुट में सभी n , k , और j सेट करने के बाद , हम लूप में प्रवेश करते हैं । कहा लूप जैसे ही टूट जाएगा -k - 1 = ~ k ie 0 , यानी, k / -1 / k <0 ।

प्रत्येक पुनरावृत्ति में, हम पहले n के केवल उचित विभाजक पर विचार करने के लिए j को घटाते हैं । यदि j n का विभाजक है , तो पैदावार 0 और j >> n% j * n = j / 2 ⁰ = j k से घटाया जाता है । हालांकि, अगर j , n को विभाजित नहीं करता है, तो सकारात्मक है, इसलिए कम से कम n> लॉग ₂ j और j >> n% j * n = j / 2 ^{n% j * n} = 0 k से घटाया जाता है ।n%jn%jn%j*n

प्रचुर मात्रा में नंबर के लिए, कश्मीर एक नकारात्मक मूल्य तक पहुंच जाएगा से पहले या जब j हो जाता है 1 , का योग के बाद से एन के उचित divisors से सख्ती से अधिक है n । इस मामले में, हम से बाहर तोड़ जबकि पाश और कार्यक्रम सामान्य रूप से खत्म।

हालांकि, यदि एन प्रचुर मात्रा में नहीं है , तो आखिरकार j 0 तक पहुंच जाता है । इस स्थिति में, n%jएक ZeroDivisionError फेंकता है और प्रोग्राम एक त्रुटि के साथ बाहर निकलता है।

Comments

~k<0फैंसी है, लेकिन मुझे लगता है कि -1<kयह भी चाल है;)

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

Answer 3

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

fk+>?

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

व्याख्या

f           Factors
 k          Knife: remove the last one (the input itself)
  +         Sum
   >?       Stricly greater than the Input

Answer 4

जेली , 3 बाइट्स

Æṣ>

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

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

Æṣ>  Main link. Argument: n

Æs   Get the proper divisor sum of n.
  >  Test if the result is greater than n.

Answer 5

पायथन , 44 बाइट्स

lambda n:sum(i*(n%i<1)for i in range(1,n))>n

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

Comments

यह शर्म की बात है कि आप ऐसा नहीं कर सकते range(n)। शून्य से यही परेशान मापांक

— DJMcMayhem

Answer 6

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

Tr@Divisors@#>2#&

व्याख्या

Tr@                 The sum of the main diagonal of
   Divisors@         the list of divisors of
            #         the first argument
             >      is greater than
              2#      twice the first argument.
                &   End of function.

Comments

मुझे आश्चर्य है कि गणितज्ञ ने इसके लिए कोई निर्माण नहीं किया है ..

— MrPaulch

@MrPaulch कार्यक्रम की लंबाई को ध्यान में रखते हुए, बिल्टइन बहुत अच्छी तरह से नाम में लंबा हो सकता है>।>

— कॉनर ओ'ब्रायन

@ ConorO'Brien अगर यह अस्तित्व में था, AbundantNumberQतो यह शायद होगा , इसलिए यह एक जोड़े को बचा लेगा :)

— ngenisis

Answer 7

05AB1E , 5 4 बाइट्स

-1 बाइट्स के लिए धन्यवाद scottinet

ѨO‹

इसे ऑनलाइन आज़माएं! या कोशिश करें 0 से 100 तक

Comments

@scottinet अच्छा लगा!

— रिले

Answer 8

रेटिना , 50 45 बाइट्स

^(?!(1(?<=(?=(?(\3+$)((?>\2?)\3)))^(1+)))*1$)

में इनपुट एकल , उत्पादन 1प्रचुर मात्रा में संख्या के लिए, 0अन्यथा।

इस समाधान के बारे में रेटिना-विशिष्ट कुछ भी नहीं है। ऊपर एक शुद्ध .NET रेगेक्स है जो केवल प्रचुर संख्या में मेल खाता है।

इसे ऑनलाइन आज़माएं! (परीक्षण सूट जो उपरोक्त रेगेक्स के साथ दशमलव इनपुट को फ़िल्टर करता है।)

Answer 9

रेटिना , 34 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

M!&`(1+)$(?<=^\1+)
1>`¶

^(1+)¶1\1

में इनपुट एकल , उत्पादन 1प्रचुर मात्रा में संख्या के लिए, 0अन्यथा।

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

व्याख्या

M!&`(1+)$(?<=^\1+)

हम इनपुट के सभी विभाजक प्राप्त करके शुरू करते हैं। ऐसा करने के लिए, हम रेगेक्स के !सभी ओवरलैपिंग ( &) मैचों ( M) से लौटते हैं (1+)$(?<=^\1+)। रेगेक्स इनपुट के कुछ प्रत्यय से मेल खाता है, बशर्ते कि पूरा इनपुट उस प्रत्यय का एक गुण है (जिसे हम प्रत्यय की केवल प्रतियों का उपयोग करके स्ट्रिंग तक पहुँचने की कोशिश करके सुनिश्चित करते हैं)। जिस तरह से रेगेक्स इंजन मैचों के लिए दिखता है, उसके कारण अवरोही क्रम में विभाजकों की सूची होगी (लाइनफीड द्वारा अलग)।

1>`¶

मंच ही लाइनफीड्स ( ¶) से मेल खाता है और उन्हें हटा देता है। हालाँकि, 1>एक सीमा है, जो पहले मैच को छोड़ देती है। इसलिए यह प्रभावी रूप से इनपुट को छोड़कर सभी विभाजकों को एक साथ जोड़ता है। हम पहली पंक्ति के इनपुट और दूसरी पंक्ति के सभी उचित विभाजकों के योग को समाप्त करते हैं।

^(1+)¶1\1

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

Comments

यह मुझे हमेशा चकित करता है कि आप रेटिना में गणित कैसे कर सकते हैं। मुझे एक स्पष्टीकरण देखना अच्छा लगेगा! :)

— डीजेएमकेम

@DJMcMayhem क्षमा करें कि पहले जोड़ना भूल गया था। किया हुआ।

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

Answer 10

8086 विधानसभा, 23 28 25 24 बाइट्स

8bc8 d1e9 33db 33d2 50f7 f158 85d2 7502 03d9 7204 e2f0 3bc3

unassembled:

; calculate if N (1 < N <= 65535) is abundant
; input: N (mem16/r16)
; output: CF=1 -> abundant, CF=0 -> not abundant
ABUND   MACRO   N 
        LOCAL DIV_LOOP, CONT_LOOP, END_ABUND
        IFDIFI <N>,<AX> ; skip if N is already AX
    MOV  AX, N          ; AX is dividend
        ENDIF
    MOV  CX, AX         ; counter starts at N / 2
    SHR  CX, 1          ; divide by 2
    XOR  BX, BX         ; clear BX (running sum of factors)
DIV_LOOP:
    XOR  DX, DX         ; clear DX (high word for dividend)
    PUSH AX             ; save original dividend
    DIV  CX             ; DX = DX:AX MOD CX, AX = DX:AX / CX
    POP  AX             ; restore dividend (AX was changed by DIV)
    TEST DX, DX         ; if remainder (DX) = 0, it divides evenly so CX is a divisor
    JNZ  CONT_LOOP      ; if not, continue loop to next
    ADD  BX, CX         ; add number to sum
    JC   END_ABUND      ; if CF=1, BX has unsigned overflow it is abundant (when CX < 65536)
CONT_LOOP:
    LOOP DIV_LOOP
    CMP  AX, BX         ; BX<=AX -> CF=0 (non-abund), BX>AX -> CF=1 (abund)
END_ABUND:
        ENDM

उदाहरण परीक्षण कार्यक्रम, परीक्षण N = [12..1000]:

    MOV  AX, 12         ; start tests at 12
LOOP_START:
    ABUND AX            ; call ABUND MACRO for N (in AX)
    JNC  LOOP_END       ; if not abundant, display nothing
    CALL OUTDECCSV      ; display AX as decimal (generic decimal output routine)
LOOP_END:
    INC  AX             ; increment loop counter
    CMP  AX, 1000       ; if less than 1000...
    JBE  LOOP_START     ; continue loop
    RET                 ; return to DOS

आउटपुट [2..1000]

12, 18, 20, 24, 30, 36, 40, 42, 48, 54, 56, 60, 66, 70, 72, 78, 80, 84, 88, 90, 96, 100, 102, 104, 108, 112, 114, 120, 126, 132, 138, 140, 144, 150, 156, 160, 162, 168, 174, 176, 180, 186, 192, 196, 198, 200, 204, 208, 210, 216, 220, 222, 224, 228, 234, 240, 246, 252, 258, 260, 264, 270, 272, 276, 280, 282, 288, 294, 300, 304, 306, 308, 312, 318, 320, 324, 330, 336, 340, 342, 348, 350, 352, 354, 360, 364, 366, 368, 372, 378, 380, 384, 390, 392, 396, 400, 402, 408, 414, 416, 420, 426, 432, 438, 440, 444, 448, 450, 456, 460, 462, 464, 468, 474, 476, 480, 486, 490, 492, 498, 500, 504, 510, 516, 520, 522, 528, 532, 534, 540, 544, 546, 550, 552, 558, 560, 564, 570, 572, 576, 580, 582, 588, 594, 600, 606, 608, 612, 616, 618, 620, 624, 630, 636, 640, 642, 644, 648, 650, 654, 660, 666, 672, 678, 680, 684, 690, 696, 700, 702, 704, 708, 714, 720, 726, 728, 732, 736, 738, 740, 744, 748, 750, 756, 760, 762, 768, 770, 774, 780, 784, 786, 792, 798, 800, 804, 810, 812, 816, 820, 822, 828, 832, 834, 836, 840, 846, 852, 858, 860, 864, 868, 870, 876, 880, 882, 888, 894, 896, 900, 906, 910, 912, 918, 920, 924, 928, 930, 936, 940, 942, 945, 948, 952, 954, 960, 966, 968, 972, 978, 980, 984, 990, 992, 996, 1000

आउटपुट [12500..12700]

12500, 12504, 12510, 12512, 12516, 12520, 12522, 12528, 12530, 12534, 12540, 12544, 12546, 12552, 12558, 12560, 12564, 12570, 12572, 12576, 12580, 12582, 12584, 12588, 12594, 12600, 12606, 12612, 12618, 12620, 12624, 12628, 12630, 12636, 12640, 12642, 12648, 12650, 12654, 12656, 12660, 12666, 12670, 12672, 12678, 12680, 12684, 12688, 12690, 12696, 12700

आउटपुट [25100..25300]

25100, 25104, 25110, 25116, 25120, 25122, 25128, 25130, 25134, 25140, 25144, 25146, 25152, 25158, 25160, 25164, 25168, 25170, 25172, 25176, 25180, 25182, 25188, 25194, 25200, 25206, 25212, 25216, 25218, 25220, 25224, 25228, 25230, 25232, 25236, 25240, 25242, 25245, 25248, 25254, 25256, 25260, 25266, 25270, 25272, 25278, 25280, 25284, 25290, 25296, 25300

अपडेट:

• 16-बिट अतिप्रवाह (+5 बाइट्स) के लिए निश्चित। सुझाव के लिए धन्यवाद @deadcode!
• सरलीकृत वापसी तर्क (-3 बाइट्स)। Thx एक बार फिर से @ डीडकोड से मदद करने के लिए।
• CMP (-1 बाइट) के बजाय TEST का उपयोग करें। Thx को @ l4m2!

Comments

मैं जगह सुझाव है JLEसाथ JBEसंख्या की सीमा इस कर सकते हैं परीक्षण दोगुना करने से पहले अतिप्रवाह के कारण यह मिथ्या नकारात्मक देने के लिए शुरू करते हैं। इसके बाद 12600 (विभाज्य राशि 35760) में असफल होने के बजाय, यह 25200 (विभाज्य राशि 74744) पर विफल होना शुरू हो जाएगा। इससे भी बेहतर होगा कि कैरी फ्लैग का पता लगाएं और वास्तविक> 16 बिट राशि की गणना किए बिना एक प्रचुर संख्या के रूप में व्यवहार करें।

— डेडकोड

अच्छा कैच @Deadcode। मैंने कम कूद के बजाय नीचे कूदने के लिए कोड अपडेट किया है। मैं देखता हूं कि आपका क्या मतलब है, ADD BX के बाद JC कर रहा है, CX वहां अहस्ताक्षरित अतिप्रवाह को पकड़ लेगा और इसे N = 65535 तक सही कर देगा। ध्वज परीक्षण की शिकायत करता है और राज्य को थोड़ा लौटाता है, क्योंकि पहले सीएफ ने गलत आरोप लगाया था। फिक्स के साथ भी अपडेट किया गया।

— 640KB

यदि आप प्रचुर मात्रा में और स्पष्ट नहीं हैं तो CF सेट होने के साथ, आप अपने वापसी मूल्य के विनिर्देश को प्राप्त करके 3 बाइट्स बचा सकते हैं। लेकिन मैं सबसे पहले आउटपुट डॉक्यूमेंटेशन को सही करने के लिए एडिट करने की सलाह दूंगा, इसलिए एडिट हिस्ट्री में यह अच्छी लगती है।

— डेडकोड

इसके अलावा, चीजों को सरल रखने के लिए, विनिर्देश यह होना चाहिए कि वापसी का मूल्य कैरी फ्लैग में हो, और अन्य झंडे के साथ कोई भी उपद्रव न हो। कॉल करने वाले का उपयोग करना चाहिए JCया इस JNCपर कार्रवाई करनी चाहिए कि संख्या प्रचुर है या नहीं।

— डेडकोड

आपकी मदद और आपकी टिप्पणियों के लिए बहुत बहुत धन्यवाद। मैंने इनलाइन डॉक्यूमेंटेशन को अपडेट कर दिया है और इस शब्द को हटा दिया है। ईमानदारी से यह कभी नहीं सोचा था लेकिन मैं इसके बारे में आपकी बात देख रहा हूं, क्योंकि यह इनलाइन टिप्पणियों के अपवाद के साथ अलग नहीं है। साथ ही रिटर्न फ्लैग क्लीयर बनाने के बारे में भी सहमति व्यक्त करें। उस पर थोड़ा काम करेंगे। ध्यान और सहायता के लिए धन्यवाद!

— 640KB

Answer 11

दरअसल , 5 बाइट्स

;÷Σ½>

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

;     # Duplicate input
 ÷    # Get divisors
  Σ   # Sum
   ½  # Divide by 2 (float)
    > # Test is greater than input

Answer 12

05AB1E , 4 बाइट्स

ѨO‹

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

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

Ñ        #list of divisors
 ¨       #remove last element (i.e the input from the list of factors)
  O      #sum the list 
   ‹     #is this sum less than the input? 

पुराने प्रश्न में पोस्ट करने के लिए क्षमा करें, मैं अभी अभ्यास के लिए पुरानी पोस्ट से गुजर रहा था और देखा कि मेरा समाधान अगले सर्वश्रेष्ठ 05AB1E समाधान से कम था।

Comments

Sorry to post in old questionइसके बारे में चिंता मत करो! मैं अपनी पुरानी चुनौतियों पर जवाब देखकर हमेशा खुश हूं, और यह वास्तव में यहां के लिए प्रोत्साहित किया गया है । :)

— DJMcMayhem

Answer 13

PARI / GP , 15 बाइट्स

n->sigma(n)>2*n

वैरिएंट n->sigma(n,-1)>2, दुर्भाग्य से, लंबा है।

Answer 14

जावा 8, 53 बाइट्स (अगर आप औपचारिक कोड शामिल करते हैं तो बहुत कुछ)

return IntStream.range(1,n).filter(e->n%e<1).sum()>n;

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

स्पष्टीकरण:

IntStream.range(1,n) \\ numbers from 1 to n-1
filter(e->n%e<1)     \\ filter in numbers that perfectly divide the number n
sum()>n              \\ sum and compare to original number

Comments

शानदार उत्तर, लेकिन जावा 8 के साथ आपको अपनी बाइट-गिनती में फ़ंक्शन को शामिल करना होगा। फिर से, returnयदि आप गलत नहीं हैं तो आप इसे छोड़ सकते हैं , इसलिए यह और भी छोटा होगा: n->IntStream.range(1,n).filter(e->n%e<1).sum()>n(100% नहीं अगर यह सही है, तो मैं जावा 8 में लगभग कभी भी कार्यक्रम नहीं कर सकता)। PPCG में आपका स्वागत है!

— केविन क्रूज़सेन

मानक गिनती के माध्यम से सही गणना n->java.util.stream.IntStream.range(1,n).filter(e->n%e<1).sum()>n65 बाइट्स के लिए होगी (यह मानते हुए कि मुझे पैकेज मेरे सिर के ऊपर से सही मिला है)

— CAD97

Answer 15

पॉवर्सशेल, 51 49 बाइट्स

param($i)((1..$i|?{!($i%$_)})-join"+"|iex)-gt2*$i

काश मैं कुछ कोष्ठक निकाल सकता।

-2 AdmBorkBork के लिए धन्यवाद, प्रारंभिक रेंज में इनपुट की गिनती नहीं करने के बजाय, हम इसे अंतिम जांच में ध्यान में रखते हैं।

की सीमा के माध्यम से लूप 1..करने के लिए $iNput, शून्य से 1, लगता है जहां ( ?) वर्तमान संख्या से इनपुट का प्रतिलोम सापेक्ष है $true(उर्फ केवल 0) - तो -joinउन सभी संख्याओं को एक साथ के साथ की +और iexजिसके परिणामस्वरूप स्ट्रिंग यह गणना करने के लिए, तो अगर देखना इन भागों का योग इनपुट से अधिक है।

PS C:\++> 1..100 | ? {.\abundance.ps1 $_}
12
18
20
24
30
36
40
42
48
54
56
60
66
70
72
78
80
84
88
90
96
100

Comments

आप दो बाइट्स को शीर्ष मान की गणना करके और यह जांच कर सकते हैं कि यह 2x से बड़ा है -param($i)((1..$i|?{!($i%$_)})-join"+"|iex)-gt2*$i

— AdmBorkBork

Answer 16

MATL, 6 बाइट्स

Z\sGE>

प्रचुर संख्या में 1 के लिए आउटपुट, 0 अन्यथा।

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

Z\      % list the divisors of the implicit input
s       % add them
G       % push the input again
E       % double it
>       % compare
        % implicitly display result

Answer 17

QBIC , 22 बाइट्स

:[a/2|~a%b|\p=p+b}?p>a

यह QBIC प्रायोगिक परीक्षण के लिए एक अनुकूलन है । विभाजकों को गिनने और जाँचने के बजाय अगर यह तीन से कम है, तो यह समुचित विभाजकों को बताता है। यह केवल आधे भाग के साथ चलता है 1 to n, जहाँ पर प्राण-परीक्षण 1 to nपूरी तरह से चलता है ।

स्पष्टीकरण:

:       Get the input number, 'a'
[a/2|   FOR(b=1, b<=(a/2), b++)
~a%b    IF a MOD b != 0  --> QBasic registers a clean division  (0) as false. 
        The IF-branch ('|') therefor is empty, the code is in the ELSE branch ('\')
|\p=p+b THEN add b to runnning total p
}       Close all language constructs: IF/END IF, FOR/NEXT
?p>a    Print '-1' for abundant numbers, 0 otherwise.

Answer 18

जावास्क्रिप्ट (ईएस 6), 33 बाइट्स

let g =
x=>(f=n=>--n&&n*!(x%n)+f(n))(x)>x

<input type=number min=1 value=1 step=1 oninput="O.innerHTML=g(+value)"><br>
<pre id=O>false</pre>

Comments

मुझे यकीन था कि एक पुनरावर्ती उत्तर सबसे अच्छा होगा लेकिन मैंने नहीं सोचा था कि यह अच्छा होगा।

— नील

Answer 19

जाप , ९ apt ६ बाइट्स

<Uâ1 x

सहेजे गए 2 बाइट्स ETHproductions के लिए धन्यवाद। Obarakon के लिए 1 बाइट का धन्यवाद सहेजा गया।

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

Comments

9 अक्षर, 10 बाइट्स।

— मेटोनीम

@Metoniem मुझे यकीन है कि â1 बाइट है, यूनिकोड में कम से कम (0xE2)।

— टॉम

@Metoniem Japt ISO-8859-1 एन्कोडिंग का उपयोग करता है , जिसमें âएक सिंगल बाइट है।

— ETHproductions

यदि âएक सत्य तर्क दिया जाता है, तो यह शेष सूची से वास्तविक संख्या को हटा देगा, इसलिए आप â1 x >Uएक युगल बाइट्स को बचाने के लिए कर सकते हैं :-)

— ETHproductions

@TomDevs अच्छा लगा! आप <Uâ1 xएक बाइट को बचाने के लिए कर सकते हैं । जाप Uकार्यक्रम के सामने जोड़ता है ।

— ओलिवर

Answer 20

क्यूबिक्स , 38 बाइट्स

/..?%?(O;0I:^.<.>;rrw+s;rUO?-<...O0L.@

इसे यहाँ आज़माएँ

      / . .
      ? % ?
      ( O ;
0 I : ^ . < . > ; r r w
+ s ; r U O ? - < . . .
O 0 L . @ . . . . . . .
      . . .
      . . .
      . . .

0I:- स्टैक को 0, n, n (s, n, d) के साथ सेट करता है
^- लूप की शुरुआत )?- डेक्रिमेंट d और 0. 0 से बाहर निकलने के लिए टेस्ट करें
%?- n और टेस्ट के खिलाफ मॉड। 0 कारण ;rrw+s;rUजो एस को ऊपर की ओर घुमाता है और डी जोड़ता है, एस को नीचे की ओर घुमाता है और लूप को फिर से जोड़ता है
;<- क्लीनअप और लूप को फिर से जोड़ देता है।
लूप से बाहर निकलने पर
;<- स्टैक से डी हटाएं और रीडायरेक्ट करें
-?- एन को एस और टेस्ट से हटा दें, 0 LOU@बाएं मुड़ें, आउटपुट और बाहर निकलता है, नकारात्मक 0O@शून्य, आउटपुट और बाहर निकलता है। सकारात्मकता ;Oअंतर को दूर करती है और आउटपुट n। रास्ता फिर बाएं मोड़ से होकर जाता है जो @निकास के लिए पुनर्निर्देशित करता है

Answer 21

शुद्ध बैश, 37 बाइट्स

for((;k++<$1;s+=$1%k?0:k)){((s>$1));}

कोड को फिर से व्यवस्थित करने के लिए @ डेनिस के लिए धन्यवाद - 6 बाइट की बचत और स्टडर के लिए आकस्मिक उत्पादन को समाप्त करना।

इनपुट को एक तर्क के रूप में पारित किया जाता है।

बाहर निकलने के कोड में आउटपुट वापस आ जाता है: 0 प्रचुर मात्रा में, 1 प्रचुर मात्रा में नहीं।

Stderr के उत्पादन को नजरअंदाज किया जाना चाहिए।

टेस्ट रन:

for n in {1..100}; do if ./abundant "$n"; then echo $n; fi; done 2>/dev/null
12
18
20
24
30
36
40
42
48
54
56
60
66
70
72
78
80
84
88
90
96
100

Comments

STDERR को आवारा आउटपुट से बचाते हुए आप 6 बाइट्स बचा सकते हैं। tio.run/nexus/bash#S04sUbBTSEwqzUtJzCtRsLFRUHf1d1P/…

— डेनिस

Answer 22

RProgN , 8 बाइट्स

~_]k+2/<

व्याख्या की

~_]k+2/<
~           # Zero Space Segment
 _          # Convert the input to an integer
  ]         # Duplicate the input on the stack
   k+       # Get the sum of the divisors of the top of the stack
     2/     # Divded by 2
       <    # Is the Input less than the sum of its divisors/2.

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

Answer 23

बैच, 84 बाइट्स

@set/ak=%1*2
@for /l %%j in (1,1,%1)do @set/ak-=%%j*!(%1%%%%j)
@cmd/cset/a"%k%>>31

-1एक प्रचुर संख्या के लिए आउटपुट , 0अन्यथा। से सभी कारकों को घटाकर काम करता है 2nऔर फिर परिणाम को 31 स्थानों पर स्थानांतरित करने के लिए साइन बिट निकालने के लिए। वैकल्पिक सूत्रीकरण, 84 बाइट्स:

@set k=%1
@for /l %%j in (1,1,%1)do @set/ak-=%%j*!(%1%%%%j)
@if %k% lss -%1 echo 1

1एक प्रचुर संख्या के लिए आउटपुट । सभी कारकों को घटाकर nऔर फिर परिणाम की तुलना करने से काम करता है -n। ( set/aबैच का अंकगणित करने का एकमात्र तरीका है ताकि मैं आसानी से लूप को समायोजित न कर सकूं।)

Comments

"(% 1% %%% j)" ओह, बैच :)

— ब्रायन बोएचर

Answer 24

पर्ल 6, 72 24 बाइट्स

{$_ <sum grep $_%%*,^$_}

• कार्यक्रम का तर्क: ए।
• से एक सूची तैयार करें 1..a।
• उन सभी नंबरों को लें जो डिवोर्स के हैं a।
• उन्हें योग करें।
• जाँच करें कि क्या यह राशि से अधिक है a।

@ B2gills का धन्यवाद।

Comments

$^aपहले एक के बाद की हर घटना को छोटा किया जा सकता है $a। लेकिन यह बहुत छोटा है यदि आप इसे लिखते हैं {$_ <sum grep $_%%*,^$_}इसके अलावा एक पुराने संस्करण को देखते हुए, [+](LIST)काम करता है (कोई रिक्त स्थान नहीं)

— ब्रैड गिल्बर्ट b2gills

@ ब्रैडगिल्बर्ब २गिल्स धन्यवाद! :)

— शुक्र

Answer 25

जे, 19 बाइट्स

इसे 19 बाइट्स में काटने के लिए कॉनर ओ'ब्रायन को धन्यवाद!

<[:+/i.#~i.e.]%2+i.

पिछला: (34 बाइट्स)

f=:3 :'(+/((i.y)e.y%2+i.y)#i.y)>y'

अगर यह प्रचुर मात्रा में है और अगर यह नहीं है तो 1 लौटाता है।

आउटपुट:

   f 3
0
   f 12
1
   f 11
0
   f 20
1

Comments

PPCG में आपका स्वागत है! हम अनाम फ़ंक्शंस की अनुमति देते हैं, ताकि आप f=:अपने बाइट काउंट के हिस्से के रूप में अग्रणी को हटा सकें । इसके अलावा, आप एक टैसिट क्रिया में परिवर्तित होकर 19 से नीचे जा सकते हैं:<[:+/i.#~i.e.]%2+i.

— कॉनर ओ'ब्रायन

सलाह के लिए धन्यवाद! हालाँकि, क्या आप कृपया कैप वर्ब ([:) और स्विच वर्ब (~) समझा सकते हैं। मुझे वास्तव में वे नहीं मिल रहे हैं जो वे इस मौन क्रिया में करने वाले हैं।

— ब्लॉक

~ स्विच तो यह # i है। लेकिन क्या उद्देश्य है: [?

— ब्लॉक

तो आप कांटे के बारे में जानते हैं, है ना? (f g h) y' is the same as (fy) g ( . When हाइट ) f` एक कैप है, ([: g h) yमोटे तौर पर जैसा है g h y। के रूप में ~, यह बाएँ और दाएँ तर्क स्विच करता है। यह जानना महत्वपूर्ण है कि ~क्रिया नहीं है, बल्कि वास्तव में क्रिया विशेषण है। यह एक क्रिया को संशोधित करता है। उदाहरण के लिए, हम कुछ ऐसा कर सकते हैं 2 %~ 8। यहां, अपने तर्कों को स्विच करने के लिए ~संशोधित करता %है, इसलिए अभिव्यक्ति के बराबर है 8 % 2।

— कॉनर ओ'ब्रायन

कांटा श्रृंखला में, #~क्रियाओं के मूल्यांकन के बाद इसके दाईं ओर क्रियान्वित किया जाता है, इसलिए यह बाएं तर्क दायीं ओर परिणाम हो जाता है

— कॉनर ओ'ब्रायन

Answer 26

अजगर, 11 बाइट्स

>sPf!%QTS

पुराना:

L!%Qb>sPy#S

मैं !%इसके लिए pfn के रूप में उपयोग नहीं कर सकता #, क्योंकि यह दो कार्य हैं। मुझे उदास करता है :(।

---

L!%Qb>sPy#SQ    Program's argument: Q
L!%Qb           Define a lambda y, that takes b as an argument
 !%Qb           Return true if Q is divisible by b
          S     Make a range 1..Q
        y#      Filter that range with the lambda (y)
       P        Remove the last element (Q itself)
      s         Sum them
     >     Q    Check if that sum is greater than the program's argument

Comments

एक फ़ंक्शन को परिभाषित नहीं करना कम प्रतीत होता है:>sPf!%QTS

— FryAmTheEggman

Answer 27

k , 19 16 15 बाइट्स

{x<+/&~(!x)!'x}

रिटर्न 1सच के लिए, और 0झूठे के लिए।

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

{             } /function(x)
       (!x)     /{0, 1, ..., x-1}
            '   /for each n in {0, 1, ..., x-1}:
           ! x  /    do (x mod n)
      ~         /for each, turn 0 -> 1, * -> 0 (map not)
     &          /get indices of 1's
   +/           /sum (fold add)
 x<             /check if x < the sum

Answer 28

पॉवरशेल , 43 बाइट्स

param($n)1..$n|%{$s+=$_*!($n%$_)}
$s-gt2*$n

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

Answer 29

आम लिस्प, 63 बाइट्स

(lambda(n)(>(loop for i from 1 below n if(=(mod n i)0)sum i)n))

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

Answer 30

एफ #, 51 बाइट्स

let f n=Seq.filter(fun x->n%x=0){1..n-1}|>Seq.sum>n

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

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