পূর্ণসংখ্যার পূর্ণসংখ্যা!

40

একটি প্রচুর সংখ্যা হ'ল যে কোনও সংখ্যা যেখানে তার যথাযথ বিভাজকের যোগফল মূল সংখ্যার চেয়ে বেশি। উদাহরণস্বরূপ, 12 এর সঠিক বিভাজনগুলি হ'ল:

1, 2, 3, 4, 6

এবং 16 এ ফলাফলগুলি সংক্ষিপ্তসার। 16 যেহেতু 12 এর চেয়ে বড়, 12 প্রচুর। লক্ষ্য করুন এই আছে না "পারফেক্ট সংখ্যা", যেমন সংখ্যার যে অন্তর্ভুক্ত সমান যেমন 6 এবং 28 তার সঠিক ভাজক এর সমষ্টি চাপ দিতে থাকেন।

আজকের জন্য আপনার কাজ হ'ল এমন একটি প্রোগ্রাম বা ফাংশন লিখুন যা নির্ধারণ করে যে কোনও সংখ্যা প্রচুর পরিমাণে আছে কি না। আপনার প্রোগ্রামটি ইনপুট হিসাবে একটি একক পূর্ণসংখ্যার নেওয়া উচিত, এবং এটি প্রচুর পরিমাণে বা না তা নির্ভর করে একটি সত্য / মিথ্যা মান আউটপুট করে। আপনি ধরে নিতে পারেন যে ইনপুটটি সর্বদা বৈধ এবং 0 এর চেয়ে বেশি হবে, তাই খারাপ ইনপুটগুলির জন্য, অপরিজ্ঞাত আচরণটি ঠিক।

আপনি আপনার ইনপুট এবং আউটপুট যে কোনও যুক্তিসঙ্গত ফর্ম্যাটে নিতে পারেন, উদাহরণস্বরূপ STDIN / STDOUT, ফাইল, বা আর্গুমেন্ট / রিটার্ন মানগুলি সমস্ত গ্রহণযোগ্য হবে be

রেফারেন্সের জন্য, এখানে 100 পর্যন্ত প্রচুর সংখ্যা রয়েছে:

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

এবং আরও A005101 এ পাওয়া যাবে

যেহেতু এটি কোড-গল্ফ , তাই স্ট্যান্ডার্ড লুফোলগুলি অস্বীকার করা হয়েছে এবং আপনি যে ভাষায় বেছে নিতে পারেন তা সম্ভব সংক্ষিপ্ততম কোডটি লেখার চেষ্টা করুন!

code-golf  math  sequence  decision-problem 
— ডিজেএমসিএমহেম
সূত্র
11
"প্রথম অদ্ভুত প্রচুর পরিমাণ 945 = 3 ^ 3 * 5 * 7, 232 তম প্রচুর সংখ্যা!"
— mbomb007
মধ্যে asymptotic ঘনত্ব প্রচুর সংখ্যার ব্যবধান [0.24761748, 0.24764422] এর মধ্যে কোথাও। এই কাগজে অন্তর্ভুক্ত উত্স কোড ব্যবহার করে গণনা করা ।
— ডেডকোড
1
আমি জ্যামিতি ড্যাশে এটি করার চেষ্টা করছি। এটি একটি দুঃস্বপ্ন
— মিল্কিওয়ে 90

উত্তর:

41

ECMAScript Regex, 1085 855 597 536 511 508 504 বাইট

ব্যবহারিকভাবে অন্য কোনও রেইগেক্স স্বাদে এটি করার চেয়ে ইসকামাস্ক্রিপ্ট রিজেক্সে প্রচুর সংখ্যার মিল পাওয়া সম্পূর্ণ ভিন্ন প্রাণী is ফরোয়ার্ড / নেস্টেড ব্যাকরিফারেন্স বা পুনরাবৃত্তিগুলির অভাবের অর্থ হ'ল সরাসরি কিছু গণনা করা বা চালিয়ে যাওয়া মোটেই অসম্ভব। চেহারা পিছনের অভাব এমনকি প্রায়শই এটির পক্ষে কাজ করার পক্ষে পর্যাপ্ত জায়গা থাকাও একটি চ্যালেঞ্জ হয়ে দাঁড়ায়।

অনেকগুলি সমস্যার অবশ্যই সম্পূর্ণ ভিন্ন দৃষ্টিকোণ থেকে যোগাযোগ করা উচিত এবং আপনি যদি ভাবছেন যে এগুলি আদৌ সমাধানযোগ্য। আপনি যে সংখ্যাগুলির সাথে কাজ করছেন তার গাণিতিক বৈশিষ্ট্যগুলি কোনও নির্দিষ্ট সমস্যার সমাধানযোগ্য করতে সক্ষম হতে পারে তা সন্ধান করতে এটি আপনাকে আরও বিস্তৃত জাল ফেলতে বাধ্য করে।

মার্চ-এপ্রিল ২০১৪ এ ফিরে আমি ইসমাস্ক্রিপ্ট রিজেক্সে এই সমস্যার সমাধান তৈরি করেছি। প্রথমে আমার সন্দেহ ছিল যে সমস্যাটি সম্পূর্ণরূপে অসম্ভব বলে মনে করার প্রতিটি কারণ ছিল তবে তারপরে গণিতবিদ টিউকন এমন একটি ধারণা আঁকেন যা এটি সর্বোপরি দ্রবণীয় দেখানোর জন্য একটি উত্সাহজনক কেস তৈরি করেছিল - তবে তিনি স্পষ্ট করে দিয়েছিলেন যে রেজেক্স নির্মাণের কোনও উদ্দেশ্য তাঁর ছিল না (তিনি পূর্ববর্তী রেজিক্সগুলি নির্মাণ / গল্ফ করার বিষয়ে আমার সাথে প্রতিযোগিতা / সহযোগিতা করেছিল, তবে এ পর্যায়ে তার সীমা পৌঁছেছিল এবং তাত্ত্বিককরণে তার আরও অবদানকে সীমাবদ্ধ রাখতে সন্তুষ্ট ছিল)।

কিছুদিন আগে আমার রেজেক্স পোস্ট করার মতোই, আমি একটি সতর্কতা দেব : ECMAScript রেজেক্সে অযৌক্তিক গাণিতিক সমস্যাগুলি কীভাবে সমাধান করা যায় তা শেখার জন্য আমি অত্যন্ত পরামর্শ দিই। এটি আমার জন্য একটি আকর্ষণীয় ভ্রমণ ছিল এবং আমি যে কারও জন্য সম্ভবত এটি চেষ্টা করে দেখতে চাই না, বিশেষত যারা সংখ্যা তত্ত্বের প্রতি আগ্রহী তাদের জন্য আমি এটি লুণ্ঠন করতে চাই না। একের পর এক সমাধানের জন্য ক্রমাগত স্পয়লার-ট্যাগযুক্ত প্রস্তাবিত সমস্যার তালিকার জন্য সেই পোস্টটি দেখুন ।

সুতরাং আপনি যদি আরও গভীর ইউনারী রেজেক্স যাদু আপনার জন্য নষ্ট না করতে চান তবে আর পড়বেন না । আমার আগের পোস্টটি কেবল একটি ছোট স্বাদ ছিল। আপনি যদি এই যাদুটি নিজেই নির্ধারণ করতে শট নিতে চান তবে উপরের লিঙ্কযুক্ত পোস্টটিতে বর্ণিত ECMAScript রেজেক্সে কিছু সমস্যা সমাধানের মাধ্যমে আমি সুপারিশ করব।

আমার নাম ECMAScript Regex পোস্ট করার আগে, আমি ভেবেছিলাম এটা মার্টিন Ender এর বিশ্লেষণ আকর্ষণীয় হবে .NET বিশুদ্ধ Regex সমাধান , ^(?!(1(?<=(?=(?(\3+$)((?>\2?)\3)))^(1+)))*1$)। এটি Regex বুঝতে খুব সোজা হয়ে গেছে এবং এটি তার সরলতায় মার্জিত। আমাদের সমাধানগুলির মধ্যে বৈসাদৃশ্যটি প্রদর্শনের জন্য, এখানে তার রেজেক্সের একটি মন্তব্য করা হয়েছে এবং চমত্কার-মুদ্রিত (তবে অশোধিত) সংস্করণ:

# 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 রেজেক্স চেষ্টা করুন

এখন, আমার 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, .নেট সাথে সামঞ্জস্যের জন্য, এবং কার্যত প্রত্যেক অন্যান্য Regex গন্ধ যে এর নাম ECMAScript নয়)

এটি অনলাইন চেষ্টা করুন!
এটি অনলাইন চেষ্টা করুন! (রেগেক্সের দ্রুত, 537 বাইট সংস্করণ)

এবং এখন এর পেছনের গল্পটির একটি সংক্ষিপ্তসার।

কমপক্ষে আমার কাছে এটি খুব স্পষ্ট-স্পষ্ট ছিল, সাধারণ ক্ষেত্রে প্রাইমগুলির সাথে মিল পাওয়া এমনকি সম্ভব ছিল। এবং এটি সমাধানের পরে, একই 2 প্রয়োগ করার ক্ষমতা প্রয়োগ করা হয় এবং তারপরে সম্মিলিত সংখ্যার শক্তি। এবং তারপর নিখুঁত স্কোয়ার। এবং এটি সমাধান করার পরেও, সাধারণীকৃত গুণ করা প্রথমে অসম্ভব বলে মনে হয়েছিল।

ECMAScript লুপে, আপনি কেবল একটি পরিবর্তিত সংখ্যার ট্র্যাক রাখতে পারেন; এই সংখ্যাটি ইনপুট অতিক্রম করতে পারে না এবং প্রতিটি পদক্ষেপে হ্রাস করতে হবে। আমার প্রথম গুণিত রেগেক্সের সঠিক গুণনের বিবৃতি A * B = C ছিল 913 বাইট, এবং এ, বি, এবং সি তাদের প্রধান ক্ষমতাগুলিতে ফ্যাক্টর করে কাজ করেছে - প্রতিটি প্রধান ফ্যাক্টরের জন্য, বারবার এ এবং সি এর প্রধান শক্তি কারণগুলির জোড়কে ভাগ করে নিন তাদের মূল বেস দ্বারা যতক্ষণ না এ এর ​​সাথে সম্পর্কিত একটি পৌঁছায় 1; সি এর সাথে সম্পর্কিত একটিটিকে তখন বি এর প্রধান শক্তি গুণকের সাথে তুলনা করা হয় একই প্রধানের এই দুটি শক্তি একসাথে যুক্ত করে একটি সংখ্যায় "মাল্টিপ্লেক্সড" হয়েছিল; এটি লুপের প্রতিটি পরবর্তী পুনরাবৃত্তির ক্ষেত্রে সর্বদা নির্বিঘ্নে পৃথক হতে পারে, একই কারণে স্থিতিক সংখ্যা সিস্টেমগুলি কাজ করে।

সম্পূর্ণ ভিন্ন অ্যালগরিদম ব্যবহার করে আমরা 50 বাইটে নেমে এসেছি (যা টিউকন এবং আমি স্বাধীনভাবে পৌঁছাতে পেরেছি, যদিও এটি কেবল কয়েক ঘন্টা সময় নিয়েছিল এবং তিনি সরাসরি সেখানে গিয়েছিলেন, যদিও এটি হওয়ার কয়েকদিন পরেও আমার সময় লেগেছিল আমার নজরে এনেছে যে একটি সংক্ষিপ্ত পদ্ধতিটি বিদ্যমান ছিল): A forB এর জন্য, A * B = C এর জন্য যদি সি হয় তবে সবচেয়ে কম সংখ্যক C যা C≡0 Mod A এবং C≡B Mod A-1 কে সন্তুষ্ট করে। (সুবিধার্থে, এ = 1 ব্যতিক্রমটির রেজিজেসে কোনও বিশেষ হ্যান্ডলিং দরকার নেই, যেখানে 0% 0 = 0 একটি ম্যাচ দেয় it) এটি ঠিক কতটা ঝরঝরে আমি বুঝতে পারছি না যে গুণটি করার মতো মার্জিত উপায়টি এর মধ্যে বিদ্যমান I ন্যূনতম রেইগেক্স স্বাদ। (এবং A≥B এর প্রয়োজনীয়তা এমন একটি প্রতিস্থাপন করা যেতে পারে যে A এবং B একই শক্তির প্রধান শক্তি ≥ A≥B এর ক্ষেত্রে এটি চীনা বাকী উপপাদ্যটি ব্যবহার করে প্রমাণিত হতে পারে))

যদি এটি প্রমাণিত হয় যে গুণনের জন্য কোনও সহজ অ্যালগরিদম নেই, তবে প্রচুর সংখ্যা রেজেক্স সম্ভবত দশ হাজার বাইট বা তার বেশি ক্রম হবে (এমনকি আমি বিবেচনা করেও যে 913 বাইট অ্যালগরিদমকে 651 বাইটে নামিয়েছি)। এটি প্রচুর গুণ এবং বিভাগ করে এবং ইসিএমএসক্রিপেট রেজেক্সের কোনও সাব্রুটাইন নেই।

আমি 23 মার্চ ২০১৪-তে প্রচুর সংখ্যার সমস্যাটির তানজিকভাবে কাজ শুরু করেছিলাম, তখন এর উপ-সমস্যা বলে মনে হয়েছিল তার জন্য একটি সমাধান তৈরি করে: সর্বাধিক সংখ্যাটির মূল উপাদানটি চিহ্নিত করা, যাতে এটি এন থেকে বিভক্ত হয়ে যায় could শুরুতে, কিছু প্রয়োজনীয় গণনা করার জন্য ঘর ছেড়ে। এই সময় এটি গ্রহণের জন্য একটি প্রতিশ্রুতিবদ্ধ রুট বলে মনে হয়েছিল। (আমার প্রাথমিক সমাধানটি 326 বাইটে বেশ বড় হয়ে শেষ পর্যন্ত গল্ফ হয়ে 185 টি বাইটে পড়েছে)) তবে টিউকন স্কেচ করা বাকী পদ্ধতিটি আরও জটিল হয়ে উঠত, সুতরাং এটি পরিণত হওয়ার সাথে সাথে আমি একটি ভিন্ন পথ নিয়েছি। এটি এন এর বৃহত্তম প্রধান মৌলিক ফ্যাক্টরের সাথে সম্পর্কিত এন এর বৃহত্তম প্রধান বিদ্যুৎ গুণককে বিভক্ত করার পক্ষে যথেষ্ট প্রমাণিত; সর্বোচ্চ সংখ্যাবৃদ্ধির প্রধানের জন্য এটি করার ফলে রিজেক্সে অযথা জটিলতা এবং দৈর্ঘ্য যুক্ত হত।

যা বাকী ছিল সেগুলি বিভক্তকারীদের যোগফলকে সরাসরি যোগফলের পরিবর্তে অঙ্কের পণ্য হিসাবে বিবেচনা করে। যেমনটি 14 মার্চ 2014 তে টুকন ব্যাখ্যা করেছেন :

আমাদের কাছে n = p 0 a 0 p 1 a 1 ... p k-1 a k-1 নম্বর দেওয়া হয়েছে । আমরা n এর গুণনীয়কগুলির যোগফল পরিচালনা করতে চাই, যা (1 + পি 0 + পি 0 2 + ... + পি 0 এ 0 ) (1 + পি 1 + পি 1 2 + ... + পি 1 এ) 1 ) ... (1 + পি কে -1 + পি কে -1) 2 + ... + পি কে -1 এ কে -1 )।

এটি দেখে আমার মন উড়ে গেল। আমি সেইভাবে অ্যালিকোট যোগফলের ফ্যাক্টরিংয়ের কথা ভাবিওনি, এবং এটি এই সূত্রটি অন্য যে কোনও কিছুর চেয়ে বেশি ছিল যা ইসকামাস্ক্রিপ্ট রিজেক্সে প্রচুর সংখ্যার মিলের দ্রাব্যতাকে প্রশংসনীয় মনে হয়েছিল।

শেষের দিকে, N এর চেয়ে বেশি বা গুণনের ফলাফল পরীক্ষা করার পরিবর্তে বা এম দ্বারা বিভাজিত এমন ফলাফল এন / এম ছাড়িয়ে গেছে এমন পরীক্ষার পরিবর্তে, বিভাগের ফলাফল 1 এর চেয়ে কম হলে আমি পরীক্ষার সাথে গিয়েছিলাম I 7 এপ্রিল 2014 এ প্রথম কার্যকরী সংস্করণ।

এই রেজেেক্সটির আমার গল্ফ অপ্টিমাইজেশনের পুরো ইতিহাস গিথুবটিতে রয়েছে। একটি নির্দিষ্ট সময়ে একটি অপ্টিমাইজেশন শেষ করে রেজিটাকে অনেক ধীর করে তোলে, তাই সেই দিক থেকে আমি দুটি সংস্করণ বজায় রেখেছি। তারা হ'ল:

প্রচুর সংখ্যার সাথে মিলে যাওয়ার জন্য রেজেেক্স
abund

এই রেজেক্সগুলি ECMAScript এবং PCRE উভয়ের সাথে পুরোপুরি সামঞ্জস্যপূর্ণ, তবে সাম্প্রতিক অপ্টিমাইজেশনটি সম্ভাব্য অংশবিহীন ক্যাপচার গ্রুপ ব্যবহার করে জড়িত \14 অংশবিহীন , সুতরাং পিসিআরই সামঞ্জস্যতা বাদ দিয়ে এবং সেগুলিতে পরিবর্তন \14?করে \14উভয়ই 1 বাইট হ্রাস করা যায়।

এই অপ্টিমাইজেশানটি প্রয়োগ করা (এটি কেবলমাত্র একਮਾাস্ক্রিপ্ট-কেবল তৈরি করা) সহ সবচেয়ে ক্ষুদ্রতম সংস্করণ, একটি স্ট্যাকএক্সচেঞ্জ কোড ব্লকে ফিট করার জন্য পুনরায় ফর্ম্যাট করা (বেশিরভাগ) কোনও অনুভূমিক স্ক্রোলিংয়ের প্রয়োজন নেই:

# 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$)
  )
)+$
— Deadcode
সূত্র
মন্তব্যগুলি বর্ধিত আলোচনার জন্য নয়; এই কথোপকথন চ্যাটে সরানো হয়েছে ।
— DJMcMayhem
1
— গ্রিমি
27

পাইথন 2 , 41 40 বাইট

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

আউটপুট প্রস্থান কোড মাধ্যমে , তাই 0 truthy এবং 1 falsy হয়।

এটি অনলাইন চেষ্টা করুন!

কিভাবে এটা কাজ করে

সব নির্ধারণের পরে এন , ট , এবং ঞ stdin থেকে ইনপুট, আমরা প্রবেশ করার সময় লুপ। বলেছে লুপ -k - 1 = ~ k ≥ 0 অর্থাত্ কে ≤ -1 / কে <0 ভেঙে যাবে ।

প্রতিটি পুনরাবৃত্তিতে আমরা প্রথমে n এর যথাযথ বিভাজন বিবেচনা করতে j হ্রাস করে । যদি ঞ একটি ভাজক হয় এন , উৎপাদ 0 এবং ঞ >> এন% ঞ * এন = ঞ / 2 0 = ঞ থেকে বিয়োগ পরার ট । যাইহোক, যদি ঞ নেই না ভাগ এন , ইতিবাচক, তাই অন্তত হয় এন> লগ ইন করুন 2 ঞ এবং ঞ >> এন% ঞ * এন = ঞ / 2 এন% ঞ * এন = 0 থেকে বিয়োগ করা হয় ট ।n%jn%jn%j*n

প্রচুর সংখ্যায় জন্য, ট একটি নেতিবাচক মান পৌঁছবে আগে বা যখন ঞ হয়ে 1 , এর সমষ্টি থেকে এন এর সঠিক ভাজক থেকে যথাযথভাবে বেশী হয় এন । এই ক্ষেত্রে, আমরা কিছুক্ষণের বাইরে চলে যাই এবং প্রোগ্রামটি সাধারণত শেষ হয়।

যাইহোক, যদি এন হয় না প্রচুর, ঞ অবশেষে ছুঁয়েছে 0 । এই ক্ষেত্রে, n%jএকটি জিরো ডিভিশনইরির ফেলে দেয় এবং প্রোগ্রামটি একটি ত্রুটি সহ প্রস্থান করে।

— ডেনিস
সূত্র
4
~k<0অভিনব, তবে আমার মনে -1<kহয়
— মার্টিন ইন্ডার
10

গণিত, 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.
— ngenisis
সূত্র
1
আমি আশ্চর্য হয়েছি যে ম্যাথামেটিকার পক্ষে এটির জন্য কোনও
— বিল্টই নেই
1
@ এমআরপলচ যদিও প্রোগ্রামটির দৈর্ঘ্য বিবেচনা করে, বিল্টইনটি নামটিতে দীর্ঘ হতে পারে>>>
— কনর ওব্রায়েন
1
@ কনরও'ব্রায়েন যদি এটির অস্তিত্ব থাকত তবে সম্ভবত এটিই হত AbundantNumberQ, সুতরাং এটি একটি দম্পতি বাইট সংরক্ষণ করতে পারে :)
— নেজিনিসিস
7

রেটিনা , 50 45 বাইট

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

আনারি ইনপুট 1, 0অন্যথায় প্রচুর সংখ্যার জন্য আউটপুট ।

এই সমাধান সম্পর্কে রেটিনা-নির্দিষ্ট কিছুই নেই। উপরেরটি একটি খাঁটি। নেট নেটওয়ার্ক যা কেবলমাত্র প্রচুর সংখ্যার সাথে মেলে।

এটি অনলাইন চেষ্টা করুন! (টেস্ট স্যুইট যা উপরের রেজেক্সের সাথে দশমিক ইনপুট ফিল্টার করে))

— মার্টিন ইন্ডার
সূত্র
6

রেটিনা , 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অন্যথায়।

— মার্টিন ইন্ডার
সূত্র
1
আপনি কীভাবে রেটিনাতে গণিত করতে পারেন তা আমাকে সর্বদা বিস্মিত করে। আমি একটি ব্যাখ্যা দেখতে চাই! :)
— ডিজেএমসিএমহেম
1
@ ডিজেএমসিএমহেম দুঃখিত, এটি যুক্ত করতে ভুলে গেছি। সম্পন্ন.
— মার্টিন এন্ডার
6

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

পরীক্ষার প্রোগ্রামের উদাহরণ, এন = [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

আউটপুট [২.১০০০]

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 বাইট) জন্য স্থির। পরামর্শের জন্য @ ডেডকোড ধন্যবাদ!
  • সরলিকৃত রিটার্ন লজিক (-৩ বাইট)। @ ডেডকোড থেকে আবারও সাহায্য করার জন্য Thx।
  • সিএমপি (-1 বাইট) এর পরিবর্তে টেস্ট ব্যবহার করুন। থেক্স থেকে @ l4m2!
— 640KB
সূত্র
1
আমি প্রতিস্থাপন সুপারিশ করবে JLEসঙ্গে JBEসংখ্যার পরিসর এই করতে পারেন পরীক্ষা দ্বিগুণ করার আগে উপচে ঘটাচ্ছে একে মিথ্যা নেগেটিভ দিতে শুরু। তারপরে 12600 (অ্যালিকোট সমষ্টি 35760) এ ব্যর্থ হওয়া শুরু করার পরিবর্তে এটি 25200 (অ্যালিকোট যোগফল 74744) এ ব্যর্থ হতে শুরু করবে। আরও ভাল ক্যারি পতাকা সনাক্ত করা এবং প্রকৃত> 16 বিট যোগফল গণনা করার প্রয়োজন ছাড়াই একটি প্রচুর সংখ্যা হিসাবে বিবেচনা করা ভাল।
— ডেডকোড
1
ভাল ডেডকোড আমি কম লাফের পরিবর্তে নীচে জাম্পের জন্য কোড আপডেট করেছি। আমি আপনার বক্তব্যটি দেখতে পাচ্ছি, এডিডি বিএক্সের পরে জিসি করার পরে, সিএক্স সেখানে স্বাক্ষরযুক্ত ওভারফ্লোটি ধরে ফেলবে এবং এন = 65535 অবধি এটি সংশোধন করবে। এর আগে সিএফ মিথ্যা বলে অভিহিত করা হওয়ায় পতাকা পরীক্ষার জটিলতা এবং কিছুটা ফেরত নেওয়ার বিষয়টিকে জটিল করে তোলে। আপডেট সহ আপডেট করা হয়েছে।
— 640 কেবি
1
আপনার ফিরতি মানের স্পেসিফিকেশন উল্টিয়ে 3 বাইট সংরক্ষণ করতে পারেন, সিএফ প্রচুর পরিমাণে সেট করা থাকলে এবং যদি তা পরিষ্কার না হয়। তবে আমি প্রথমে আউটপুট ডকুমেন্টেশন সংশোধন করার জন্য সম্পাদনা করার পরামর্শ দিই, তাই সম্পাদনার ইতিহাসে এটি দুর্দান্ত দেখাচ্ছে।
— ডেডকোড
1
এছাড়াও, জিনিসগুলি সহজ রাখার জন্য, স্পেসিফিকেশনটি হওয়া উচিত যে রিটার্নের মানটি ক্যারি ফ্ল্যাগের মধ্যে থাকে এবং অন্য পতাকাগুলির সাথে এর কোনওটিই গোলমাল করে না। ফোনটি ব্যবহারকারীর ব্যবহার করা উচিত JCবা JNCসংখ্যাটি প্রচুর পরিমাণে রয়েছে কিনা তা নিয়ে কাজ করা উচিত।
— ডেডকোড
1
আপনার সমস্ত সাহায্য এবং আপনার মন্তব্যের জন্য অনেক ধন্যবাদ। আমি ইনলাইন ডকুমেন্টেশন আপডেট করেছি এবং অসম্পূর্ণ শব্দটি সরিয়েছি। সত্যই এটিকে কখনই বেশি ভাবনা দেয়নি তবে আমি এ সম্পর্কে আপনার বক্তব্যটি দেখতে পাচ্ছি, কারণ ইনলাইন মন্তব্যগুলি ব্যতীত এটি কোনও আলাদা নয়। ফিরতি পতাকাগুলি আরও পরিষ্কার করা সম্পর্কে মাকিন্ট সম্পর্কেও সম্মত হন। এটি একটি বিট মধ্যে কাজ করবে। মনোযোগ এবং সহায়তার জন্য ধন্যবাদ!
— 640 কেবি
5

05 এ বি 1 ই , 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 সমাধানের চেয়ে কম।

— স্পেস জাঙ্ক
সূত্র
4
Sorry to post in old questionএটা নিয়ে চিন্তা করবেন না! আমি আমার পুরানো চ্যালেঞ্জগুলির উত্তর দেখতে সর্বদা খুশি এবং এটি প্রায় কাছাকাছি উত্সাহিত হয়েছিল । :)
— ডিজেএমসিএমহেম
4

জাভা 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
— গৌতম ডি
সূত্র
4
দুর্দান্ত উত্তর, তবে জাভা 8 এর সাথে আপনাকে অবশ্যই বাইট-কাউন্টে ফাংশনটি অন্তর্ভুক্ত করতে হবে। তারপরে আবারও, আপনি returnযদি ভুল না হয়ে থাকেন তবে আপনি এটিকে ফেলে দিতে পারেন, তাই এটি আরও খাটো হবে: n->IntStream.range(1,n).filter(e->n%e<1).sum()>n(এটি যদি সঠিক হয় তবে 100% নয়, আমি জাভা 8 তে প্রায়শই প্রোগ্রাম করি না)। পিপিসিজিতে আপনাকে স্বাগতম!
— কেভিন ক্রুইজসেন
1
স্ট্যান্ডার্ড কাউন্টের মাধ্যমে সঠিক গণনা হবে n->java.util.stream.IntStream.range(1,n).filter(e->n%e<1).sum()>n65 বাইটের জন্য (ধরে নিলাম প্যাকেজটি আমার মাথার উপরের অংশ থেকে ঠিক পেয়েছি)
— CAD97
4

পাওয়ারশেল, 51 49 বাইট

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

আমি আশা করি আমি কিছু বন্ধনী সরিয়ে ফেলতে পারতাম।

-2 অ্যাডমবর্কবার্ককে ধন্যবাদ, প্রাথমিক পরিসরে ইনপুটটি গণনা না করে আমরা কেবল চূড়ান্ত পরীক্ষায় এটি বিবেচনায় নিই।

পরিসীমা মাধ্যমে লুপ 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
— colsw
সূত্র
উপরের মানটি গণনা করে এবং এটি 2x ইনপুট থেকে বড় কিনা তা পরীক্ষা করে আপনি দুটি বাইট সংরক্ষণ করতে পারেন -param($i)((1..$i|?{!($i%$_)})-join"+"|iex)-gt2*$i
— অ্যাডমবর্কবার্ক
3

এমএটিএল, 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
— বি মেহতা
সূত্র
3

কিউবিআইসি , 22 বাইট

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

এটি কিউবিআইসি আদিমতার পরীক্ষার একটি অভিযোজন । বিভাজকগুলি গণনা করা এবং এটি তিনটির চেয়ে কম কিনা তা পরীক্ষা করার পরিবর্তে এটি যথাযথ বিভাজনকারীদের যোগফল। এটি কেবলমাত্র অর্ধেকের সাথে চলে 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.
— steenbergh
সূত্র
3

জাভাস্ক্রিপ্ট (ES6), 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>
স্নিপেট প্রসারিত করুন

— ETHproductions
সূত্র
আমি নিশ্চিত যে একটি পুনরাবৃত্ত উত্তর ভাল হবে তবে আমি মনে করি না যে এটি ভাল হবে।
— নিল
3

জাপট , 9 7 6 বাইট

<Uâ1 x

ETH প্রডাকশনগুলির জন্য 2 বাইট সংরক্ষণ করা হয়েছে। ওবারাকনকে ধন্যবাদ 1 বাইট সংরক্ষণ করা হয়েছে।

এটি অনলাইন চেষ্টা করুন!

— টম
সূত্র
9 টি অক্ষর, 10 বাইট
— মেটোনিয়াম
@ মেটোনিয়েম আমি নিশ্চিত âযে ইউনিকোডে কমপক্ষে (0xE2) 1 বাইট।
— টম
1
@ মেটোনিয়েম জ্যাপ্ট আইএসও -8859-1 এনকোডিং ব্যবহার করে , এতে âএকক বাইট রয়েছে।
— ETH প্রোডাকশনগুলি
যদি âসত্যবাদী যুক্তি দেওয়া হয়, তবে এটি অবশিষ্ট তালিকা থেকে আসল সংখ্যাটি সরিয়ে ফেলবে, তাই আপনি â1 x >Uএকটি দম্পতি বাইট সংরক্ষণ করতে পারেন :-)
— ETH প্রোডাকশনগুলি
@ টমডেভস চমৎকার! আপনি <Uâ1 xবাইট সংরক্ষণ করতে পারেন । জাপট Uপ্রোগ্রামটির সামনে যোগ করে ।
— অলিভার
3

কিউবিক্স , 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) দিয়ে স্ট্যাক সেট আপ করুন
^- লুপের সূচনা )?- হ্রাস ডি এবং পরীক্ষার জন্য 0 0 প্রস্থান লুপ
%?- এন এবং পরীক্ষার বিপরীতে মোড। 0 টি কারণ ;rrw+s;rUযা এসকে শীর্ষে আবর্তন করে এবং ডি যোগ করে, গুলি নীচে থেকে ঘুরিয়ে দেয় এবং লুপটিতে পুনরায়
;<যোগদান করে - ক্লিনআপ এবং লুপটিতে পুনরায় যোগদান করে oin
লুপ
;<থেকে বেরিয়ে যাওয়ার সময় - স্ট্যাক থেকে ডি সরান এবং পুনর্নির্দেশ করুন
-?- এন এবং গুলি এবং পরীক্ষা থেকে সরান, 0 LOU@টি বাম, আউটপুট এবং প্রস্থান, নেতিবাচক 0O@শূন্য, আউটপুট এবং প্রস্থানকে ধাক্কা দেয়। ধনাত্মক ;Oপার্থক্য এবং আউটপুট সরান n। পথটি তখন বাম দিকে ঘুরবে যা @প্রস্থানটিতে পুনঃনির্দেশ করে

— MickyT
সূত্র
3

খাঁটি বাশ, 37 বাইট

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

কোডটি পুনরায় সাজানোর জন্য @ ডেনিসকে ধন্যবাদ - 6 বাইট সংরক্ষণ এবং স্ট্যাডারে ঘটনামূলক আউটপুটকে সরিয়ে দেওয়ার জন্য।

ইনপুটটি আর্গুমেন্ট হিসাবে পাস করা হয়।

আউটপুটটি প্রস্থান কোডটিতে ফিরে আসবে: 0 প্রচুর জন্য, 1 প্রচুর পরিমাণে নয়।

স্টাডারের আউটপুট উপেক্ষা করা উচিত।

টেস্ট রান:

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
— মিচেল স্পেক্টর
সূত্র
এসটিডিআরআরতে বিপথগামী আউটপুট এড়িয়ে গিয়ে আপনি 6 বাইট সংরক্ষণ করতে পারেন। tio.run/nexus/bash#S04sUbBTSEwqzUtJzCtRsLFRUHf1d1P/…
— ডেনিস
2

ব্যাচ, 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 টি স্থান সাইন বিটটি বের করার জন্য স্থান পরিবর্তন করে Works বিকল্প সূত্র, এছাড়াও 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ব্যাচের পাটিগণিত করার একমাত্র উপায় তাই আমি সহজেই লুপটি সামঞ্জস্য করতে পারি না))

— নিল
সূত্র
1
"(% 1 %% %% j)" ওহ, ব্যাচ :)
— ব্রায়ান বোয়েচার
2

পার্ল 6, 72 24 বাইট

{$_ <sum grep $_%%*,^$_}
  • প্রোগ্রাম যুক্তি: ক।
  • থেকে একটি তালিকা তৈরি করুন 1..a।
  • বিভাজক যে সমস্ত সংখ্যা নিন a।
  • তাদের সমষ্টি।
  • সেই যোগফলের চেয়ে বড় কিনা তা পরীক্ষা করে দেখুন a।

@ বি 2 গিলসকে ধন্যবাদ।

— ভেন
সূত্র
$^aপ্রথমটির পরে প্রতিটি ঘটনাকে সংক্ষিপ্ত করে সংক্ষিপ্ত করা যায় $a। তবে আপনি যদি এটি লেখেন তবে এটি আরও সংক্ষিপ্ত {$_ <sum grep $_%%*,^$_}হয় পূর্ববর্তী সংস্করণটির দিকে তাকালে, [+](LIST)কাজ করে (কোনও জায়গা নেই)
— ব্র্যাড গিলবার্ট বিবিগিল
@ ব্র্যাডজিলবার্টবিলগিলস ধন্যবাদ! :)
— ভেন
2

জে, 19 বাইট

এটি 19 বাইটে কেটে দেওয়ার জন্য কনর ও ব্রায়েনকে ধন্যবাদ!

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

পূর্ববর্তী: (34 বাইট)

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

এটি প্রচুর পরিমাণে থাকলে 1 এবং এটি যদি না থাকে তবে 0 প্রদান করে।

আউটপুট:

   f 3
0
   f 12
1
   f 11
0
   f 20
1
— ব্লক
সূত্র
পিপিসিজিতে আপনাকে স্বাগতম! আমরা বেনামে ফাংশনগুলির অনুমতি দিই, যাতে আপনি f=:আপনার বাইট গণনার অংশ হিসাবে শীর্ষস্থানীয়টিকে সরাতে পারেন । এছাড়াও, আপনি একটি স্পষ্ট ক্রিয়া রূপান্তর করে 19 এ নামতে পারেন:<[:+/i.#~i.e.]%2+i.
— কনর ও'ব্রায়েন
পরামর্শের জন্য ধন্যবাদ! তবে, আপনি দয়া করে ক্যাপ ক্রিয়া ([:) :) এবং স্যুইচ ক্রিয়া (~) ব্যাখ্যা করতে পারেন। এই স্পষ্ট ক্রিয়াপদে তারা যা করার কথা তা আমি সত্যিই পাই না।
— ব্লক
it সুইচ তাই এটি # আমি। তবে [:? এর উদ্দেশ্য কী?
— ব্লক
সুতরাং আপনি কাঁটাচলা সম্পর্কে জানেন, তাই না? (f g h) y' is the same as (fy) g (hy) . When f` একটি ক্যাপ, ([: g h) yপ্রায় একই রকম g h y। হিসাবে ~, এটি বাম এবং ডান যুক্তি স্যুইচ করে। এটি জেনে রাখা গুরুত্বপূর্ণ যে ~এটি একটি ক্রিয়া নয় বরং আসলে একটি বিশেষণ এটি একটি ক্রিয়া পরিবর্তন করে। উদাহরণস্বরূপ, আমাদের মতো কিছু থাকতে পারে 2 %~ 8। এখানে, এর আর্গুমেন্টগুলি ~পরিবর্তন %করতে পরিবর্তিত করে, তাই প্রকাশটি সমান 8 % 2।
— কনর ও'ব্রায়েন
কাঁটা চেইনে, #~তার ডানদিকে ক্রিয়াগুলি কার্যকর করার পরে মূল্যায়ন করা হয়, সুতরাং এটির বাম যুক্তি ডানদিকে ফলাফল হয়ে যায়
— কনর ওব্রায়েন
2

পাইথ, 11 বাইট

>sPf!%QTS

পুরানো:

L!%Qb>sPy#S

আমি !%পিএফএন হিসাবে ব্যবহার করতে পারি না #, কারণ এটি দুটি ফাংশন। আমাকে দু: খিত করে তোলে :(।

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
— ভেন
সূত্র
কোনও ক্রিয়াকলাপটি সংজ্ঞায়িত করা সংক্ষিপ্ত বলে মনে হচ্ছে:>sPf!%QTS
— FryAmTheEggman
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.