বিভাজক ধনী এবং দরিদ্র সংখ্যা

Question

ভূমিকা

সংখ্যার অদ্ভুত বিশ্বে বিভাজনকারীরা সম্পদের মতো হয় এবং তারা তাদের বিপরীত ব্যবস্থার চেয়ে বেশি বিভাজনকারী সংখ্যাকে "ধনী" বলে অভিহিত করে এবং তারা "গরিব" বলে তাদের বিপরীতে তুলনামূলকভাবে কম বিভাজনকারী বলে অভিহিত করে।

উদাহরণস্বরূপ, $2401$ সংখ্যাটির পাঁচটি বিভাজক রয়েছে: $1,7,49,343,2401$ , যখন এর বিপরীত, $1042$ , কেবল চার: $1,2,521,1042$ ।
সুতরাং $2401$ একটি ধনী সংখ্যা বলা হয় , এবং $1042$ একটি দরিদ্র সংখ্যা।

এই সংজ্ঞাটি দেওয়া, আমরা ধনী এবং দরিদ্র সংখ্যার নিম্নলিখিত দুটি পূর্ণসংখ্যার ক্রমিক তৈরি করতে পারি:

(here we list the first 25 elements of the sequences)

 Index | Poor | Rich
-------|------|-------
     1 |   19 |   10
     2 |   21 |   12
     3 |   23 |   14
     4 |   25 |   16
     5 |   27 |   18
     6 |   29 |   20
     7 |   41 |   28
     8 |   43 |   30
     9 |   45 |   32
    10 |   46 |   34
    11 |   47 |   35
    12 |   48 |   36
    13 |   49 |   38
    14 |   53 |   40
    15 |   57 |   50
    16 |   59 |   52
    17 |   61 |   54
    18 |   63 |   56
    19 |   65 |   60
    20 |   67 |   64
    21 |   69 |   68
    22 |   81 |   70
    23 |   82 |   72
    24 |   83 |   74
    25 |   86 |   75
   ... |  ... |  ...

মন্তব্য :

• একটি সংখ্যার "বিপরীত" হিসাবে আমরা এর অর্থ এটির ডিজিটাল বিপরীত অর্থাত্ বেস -10 এ এর ​​অঙ্কগুলি বিপরীত করে। এর অর্থ এই যে এক বা একাধিক শূন্য দিয়ে শেষ সংখ্যার একটি "খাটো" উলটাপালটা হবে: যেমন এর উলটাপালটা 1900হয় 0091অত: পর91
• আমরা ইচ্ছাকৃতভাবে সংখ্যার বিভাজক হিসাবে একই সংখ্যক বিভাজক সংখ্যার সংখ্যাসমূহকে বাদ দিয়ে থাকি ie যেমন OEIS এর অন্তর্ভুক্ত: A062895

চ্যালেঞ্জ

উপরে বর্ণিত দুটি ক্রম বিবেচনা করে, আপনার কাজটি এমন একটি প্রোগ্রাম বা ফাংশন লিখতে হবে যা একটি পূর্ণসংখ্যা n(আপনি 0 বা 1-সূচক নির্বাচন করতে পারেন) দিয়ে এন-থ্রি দরিদ্র এবং এন-থ্রি সমৃদ্ধ সংখ্যা প্রদান করে।

ইনপুট

• একটি পূর্ণসংখ্যা নম্বর ( >= 0যদি 0-সূচকযুক্ত হয় বা >= 11-সূচকযুক্ত হয়)

আউটপুট

• 2-পূর্ণসংখ্যা, দুর্বল ক্রমের জন্য একটি এবং সমৃদ্ধ ক্রমের জন্য একটি, ক্রম হিসাবে আপনি যতক্ষণ এটি সুসংগত হিসাবে পছন্দ করেন

উদাহরণ:

INPUT          |   OUTPUT
----------------------------------
n (1-indexed)  |   poor    rich
----------------------------------
1              |   19      10
18             |   63      56
44             |   213     112
95             |   298     208
4542           |   16803   10282
11866          |   36923   25272
17128          |   48453   36466
22867          |   61431   51794
35842          |   99998   81888

সাধারণ নিয়ম:

• এটি কোড-গল্ফ , তাই বাইট জেতে সংক্ষিপ্ত উত্তর।
  কোড-গল্ফ ভাষাগুলি আপনাকে নন-কোডগলফিং ভাষার সাথে উত্তর পোস্ট করতে নিরুৎসাহিত করবেন না। 'যে কোনও' প্রোগ্রামিং ভাষার পক্ষে যতটা সম্ভব সংক্ষিপ্ত উত্তর নিয়ে আসার চেষ্টা করুন।
• আপনার উত্তরটির জন্য ডিফল্ট আই / ও বিধিগুলির সাথে মানক বিধিগুলি প্রযোজ্য , সুতরাং আপনাকে সঠিক পরামিতি এবং ফিরতি-টাইপ, সম্পূর্ণ প্রোগ্রাম সহ STDIN / STDOUT, ফাংশন / পদ্ধতি ব্যবহারের অনুমতি দেওয়া হবে। আপনার কল
• ডিফল্ট লুফোলগুলি নিষিদ্ধ।
• যদি সম্ভব হয় তবে আপনার কোডের (যেমন টিআইও ) একটি পরীক্ষার সাথে একটি লিঙ্ক যুক্ত করুন ।
• এছাড়াও, আপনার উত্তরের জন্য একটি ব্যাখ্যা যুক্ত করা অত্যন্ত প্রস্তাবিত।

Comments

অনুমান: দরিদ্র সংখ্যা সর্বদা n ত সমৃদ্ধ সংখ্যার চেয়ে বেশি is যদি কেউ এটি প্রমাণ করতে পারে তবে এটি সম্ভবত বহু উত্তর বাইট করে দেয়। $n$$n$

— রবিন রাইডার

@ রবিনরাইডার: আমি সন্দেহ করি যে এটি সত্য, তবে এটি প্রমাণ করা সম্পূর্ণ ভিন্ন গল্প :)

— ডিগএম সব

@ রবিনরাইডার বিবেচনা করুন যে শীর্ষস্থানীয় জিরোগুলির কারণে একাধিক সংখ্যা একই বিপরীত সংখ্যায় ম্যাপ করতে পারে (উদাঃ 51, 510, 5100 সমস্ত মানচিত্র 15 এ)। প্রতি NUMBER জন্য , একটি অসীম trailing শূণ্যসমূহ সঙ্গে ধনী সংশ্লিষ্ট বিপরীত সংখ্যার নম্বর (অতিরিক্ত কারণের সাথে থাকবে 10 , 100 , 1000 , ইত্যাদি।), যখন শুধুমাত্র দরিদ্র বিপরীত সংখ্যার একটি সসীম পরিমাণ। আমি মনে করি না এটি এটিকে পুরোপুরি প্রমাণ করে (সম্ভবত রেখার নিচে কোথাও দরিদ্র সংখ্যার একটি ভাগ্যবান শৃঙ্খলা রয়েছে) তবে এটি কমপক্ষে উল্লেখ করেছে যে দরিদ্রের চেয়ে অনেক বেশি সমৃদ্ধ সংখ্যা রয়েছে। $n$$10,100,1000$

— জো কিং

@ জোকিং "... দরিদ্রের চেয়ে অনেক বেশি সমৃদ্ধ সংখ্যা"। এই বিবৃতিটি স্পষ্ট করতে পারে; লিখিত হিসাবে এটি ব্যাখ্যা করা যেতে পারে যে দরিদ্র সংখ্যার সংখ্যার চেয়ে সমৃদ্ধ সংখ্যার সংখ্যার কার্ডিনালিটি বেশি থাকে। তবে অবশ্যই উভয় সেট অগণিত অসীম (কোন ক্রম সমাপ্ত হয় না): এটি প্রমাণ করার পক্ষে যথেষ্ট যে অসীম অনেকগুলি প্রাইম রয়েছে যার প্রথম অঙ্ক a 2। এর জন্য নীচের কাগজের শেষে 1.4 সমাপ্তি দেখুন, এর nসমান 19, 199, 1999, ...: m-hikari.com/ijcms-password/ijcms-password13-16-2006/…

— mathmandan

Answer 1

05 এ বি 1 ই , 16 বাইট

∞.¡ÂÑgsÑg.S}¦ζsè

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

---

0-সূচকযুক্ত [ধনী, দরিদ্র]:

∞                # Push infinite list.
 .¡        }     # Split into three lists by...
   ÂÑgsÑg.S      # 1 if rich, 0 if nothing, -1 if poor.
            ¦ζ   # Remove list of nothings, and zip rich/poor together.
              sè # Grab nth element.

সম্ভবত কেউ ব্যাখ্যা করতে পারেন যে এই সংস্করণটি কেন শেষ হচ্ছে না বলে মনে হয় তবে আমি যখন টিআইওতে "বাতিলকরণ বাতিল" ক্লিক করি তখন এটি সঠিক উত্তর দিয়ে শেষ হয়, বা আপনি যদি 60 সেকেন্ড অপেক্ষা করেন তবে আপনি সঠিক উত্তরটি পেয়েছেন। এমন একটি সংস্করণের জন্য যা "সঠিকভাবে" সমাপ্ত করে আপনি ব্যবহার করতে পারেন:T+nL.¡ÂÑgsÑg.S}¦ζsè +3 বাইট

Comments

স্প্লিট বাই অসীম তালিকার সাথে খুব সুন্দরভাবে কাজ করবে বলে মনে হয় না।

— এমিগিনা

এমনিগা ব্যক্তিগতভাবে, আমার জানা নেই যে এমনকি অসীম তালিকা কীভাবে সম্ভব।

— যাদু অক্টোপাস উরন

অলস মূল্যায়ন। আপনার প্রয়োজন নেই এমন নম্বর গণনা করবেন না। সুতরাং ∞n5èশুধুমাত্র প্রথম 6 সংখ্যা গণনা করা হবে। আমি মনে করি যখন এই ধরণের লুপিং / গোষ্ঠীকরণ / বিভাজন নির্মাণগুলি খেলতে আসে তখন অলস ইওল ব্যর্থ হয় এবং এটি ফিরে আসার আগে সমস্ত আইটেম গণনা করার চেষ্টা করে।

— এমিগানা

আমি এখনও মনে করি এর জন্য 1 বাইট অন্তর্নির্মিত হওয়া উচিত €g.. আমি এটি প্রায়শই ব্যবহার করি। (এখন সমান বাইট) বিকল্পের সাহায্যে এখানে একটি বাইট সংরক্ষণ করতে পারত ‚рgÆ.±। ভাল উত্তর যদিও! দুর্দান্ত ব্যবহার .¡!

— কেভিন ক্রুইজসেন

@ কেভিন ক্রুইজসেন আরও 2 বাইট লোল এটির জন্য δg।

— ম্যাজিক অক্টোপাস উরান

Answer 2

জাভাস্ক্রিপ্ট (ES6),  121 115 113  111 বাইট

ইনপুটটি 1-সূচকযুক্ত। আউটপুট হিসাবে [poor, rich]।

x=>[(s=h=(n,i=x)=>i?h(++n,i-=(g=(n,k=n)=>k&&!(n%k)*~-s+g(n,k-1))(n)>g([...n+''].reverse().join``)):n)``,h(s=2)]

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

মন্তব্য

সহায়ক ফাংশন

g = (n,                   // g is a helper function taking n and returning either the
        k = n) =>         // number of divisors or its opposite; starting with k = n
  k &&                    // if k is not equal to 0:
    !(n % k)              //   add either 1 or -1 to the result if k is a divisor of n
    * ~-s                 //   use -1 if s = 0, or 1 if s = 2
    + g(n, k - 1)         //   add the result of a recursive call with k - 1

প্রধান

x => [                    // x = input
  ( s =                   // initialize s to a non-numeric value (coerced to 0)
    h = (n,               // h is a recursive function taking n
            i = x) =>     // and using i as a counter, initialized to x
      i ?                 // if i is not equal to 0:
        h(                //   do a recursive call ...
          ++n,            //     ... with n + 1
          i -=            //     subtract 1 from i if:
            g(n)          //       the number of divisors of n (multiplied by ~-s within g)
            >             //       is greater than
            g(            //       the number of divisors of the reversal of n obtained ...
              [...n + ''] //         ... by splitting the digits
              .reverse()  //             reversing them
              .join``     //             and joining back
            )             //       (also multiplied by ~-s within g)
        )                 //   end of recursive call
      :                   // else:
        n                 //   we have reached the requested term: return n
  )``,                    // first call to h for the poor one, with n = s = 0 (coerced)
  h(s = 2)                // second call to h for the rich one, with n = s = 2
]                         // (it's OK to start with any n in [0..9] because these values
                          // are neither poor nor rich and ignored anyway)

Answer 3

জেলি , 22 বাইট

ṚḌ;⁸Æd
Ç>/$Ɠ©#żÇ</$®#Ṫ

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

$n$ এবং সেই ক্রমে n-th দরিদ্র এবং ধনী পূর্ণসংখ্যার একটি তালিকা ফেরত।

ব্যাখ্যা

ṚḌ;⁸Æd | Helper link: take an integer and return the count of divisors fof its reverse and the original number in that order

Ṛ      | Reverse
 Ḍ     | Convert back from decimal digits to integer
  ;⁸   | Concatenate to left argument
    Æd | Count divisors


Ç>/$Ɠ©#żÇ</$®#Ṫ | Main link

    Ɠ©          | Read and evaluate a line from stdin and copy to register
   $  #         | Find this many integers that meet the following criteria, starting at 0 and counting up
Ç               | Helper link
 >/             | Reduce using greater than (i.e. poor numbers)
       ż        | zip with
           $®#  | Find the same number of integers meeting the following criteria
        Ç       | Helper link
         </     | Reduce using less than (i.e. rich numbers)
              Ṫ | Finally take the last pair of poor and rich numbers

Answer 4

ওল্ফ্রাম ভাষা (গণিত) , 152 বাইট

(a=b=k=1;m=n={};p=AppendTo;While[a<=#||b<=#,#==#2&@@(s=0~DivisorSigma~#&/@{k,IntegerReverse@k++})||If[#<#2&@@s,m~p~k;a++,n~p~k;b++]];{m[[#]],n[[#]]}-1)&

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

যদি অনুমানটি সত্য হয় তবে এই 140 বাইট সমাধানটিও কাজ করে

(a=k=1;m=n={};p=AppendTo;While[a<=#,#==#2&@@(s=0~DivisorSigma~#&/@{k,IntegerReverse@k++})||If[#<#2&@@s,m~p~k;a++,n~p~k]];{m[[#]],n[[#]]}-1)&   

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

এখানে দরিদ্র বনাম সমৃদ্ধ প্লট রয়েছে

Comments

তারা সত্যিই কাছাকাছি আসে যে বিন্দু কি?

— জো কিং

@ জোকিং আমি বিশ্বাস করি যে এটিa(27635)= {70003, 65892}

— J42161217

গ্রেট! বিটিডাব্লু, এটি সম্ভবত কয়েকটি সমাধানগুলির মধ্যে একটি (সম্ভবত একমাত্র)

— টিআইওতে

Answer 5

পার্ল 6 , 81 বাইট

{(*>*,* <*).map(->&c {grep
{[[&c]] map {grep $_%%*,1..$_},$_,.flip},1..*})»[$_]}

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

• * > *এটি একটি অনামী কাজ যা এর প্রথম যুক্তিটি এর দ্বিতীয়টির চেয়ে বেশি হলে সত্য ফিরে আসে। একইভাবে * < *। প্রাক্তনগুলি সমৃদ্ধ অনুক্রমের সাথে সম্পর্কিত এমন সংখ্যা নির্বাচন করবে, পরবর্তীগুলি দুর্বল ক্রমের সাথে সম্পর্কিত তাদের নির্বাচন করবে।
• (* > *, * < *).map(-> &c { ... }) তুলনামূলক ফাংশনগুলির উপর ভিত্তি করে প্রতিটি অনন্ত ক্রমের একজোড়া উত্পাদন করে: সমৃদ্ধ ক্রম এবং দুর্বল ক্রম, সেই ক্রমে।
• »[$_]উভয় সিকোয়েন্স ব্যবহার করে সূচিগুলি ব্যবহার $_করে শীর্ষ-স্তরের ফাংশনের পক্ষে যুক্তি, $_সমৃদ্ধ সিকোয়েন্সের $_তম সদস্য এবং দুর্বল সিকোয়েন্সের তম সদস্য সমন্বিত একটি দ্বি-উপাদান তালিকা ফিরে আসে ।
• grep $_ %% *, 1..$_এর বিভাজকের একটি তালিকা তৈরি করে $_।
• map { grep $_ %% *, 1..$_ }, $_, .flipএর বিভাজকের একটি দ্বি-উপাদান তালিকা তৈরি করে $_এবং $_এর অঙ্কগুলি বিপরীতমুখী করে ("উল্টানো") করে।
• [[&c]]তুলনামূলক ফাংশন &c( যেহেতু এর চেয়ে বেশি বা কম-বেশি) এর সাথে দ্বি-উপাদান তালিকাটি হ্রাস করে , এটি একটি বুলিয়ান মান তৈরি করে যা নির্দেশ করে যে এই সংখ্যাটি দরিদ্র ক্রমের সমৃদ্ধ ক্রমের সাথে সম্পর্কিত কিনা to

Comments

1..$_হতে পারে ^$_। আপনি [$_]মানচিত্রের অভ্যন্তরের অভ্যন্তরেও স্থানান্তর করতে পারেন । 78 বাইট

— জো কিং

Answer 6

পাইথন 2 , 142 141 বাইট

f=lambda i,n=1,a=[[],[]]:zip(*a)[i:]or f(i,n+1,[a[j]+[n]*(cmp(*[sum(x%y<1for y in range(1,x))for x in int(`n`[::-1]),n])==1|-j)for j in 0,1])

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

---

---

নন-রিকার্সিভ বিকল্প (অন্যান্য পাইথনের উত্তরের সাথে খুব মিল)

পাইথন 2 , 143 বাইট

i=input()
a=[[],[]];n=1
while~i+len(zip(*a)):([[]]+a)[cmp(*[sum(x%i<1for i in range(1,x))for x in int(`n`[::-1]),n])]+=n,;n+=1
print zip(*a)[i]

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

Answer 7

পাইথন 2 , 158 153 বাইট

^{-২ বাইট শূকিকে ধন্যবাদ}

n=input()
p=[];r=[];c=1
while min(len(p),len(r))<=n:[[],r,p][cmp(*[sum(x%-~i<1for i in range(x))for x in c,int(str(c)[::-1])])]+=[c];c+=1
print p[n],r[n]

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

ইনপুট 0-সূচকযুক্ত। আউটপুট হিসাবে poor rich।

Comments

Would +=[c]পরিবর্তে .append(c)কাজ করে?

— shooqie

@shooqie এটা would

— Grimmy

Answer 8

রুবি , 128 বাইট

ইনপুটটি শূন্য-সূচকযুক্ত । ফলাফলগুলি [দরিদ্র, ধনী] হিসাবে।

->n,*a{b=[];i=0;d=->z{(1..z).count{|e|z%e<1}};(x=d[i+=1];y=d[i.digits.join.to_i];[[],b,a][x<=>y]<<i)until a[n]&b[n];[a[n],b[n]]}

ব্যাখ্যা

->n,*a{                             # Anonymous function, initialize poor array
       b=[];i=0;                    # Initialize rich array and counter variable
    d=->z{(1..z).count{|e|z%e<1}};  # Helper function to count number of factors
    (                               # Start block for while loop
     x=d[i+=1];                     # Get factors for next number
     y=d[i.digits.join.to_i];       # Factors for its reverse
                                    # (digits returns the ones digit first, so no reversing)
     [[],b,a][x<=>y]                # Fetch the appropriate array based on
                                    #  which number has more factors
                    <<i             # Insert the current number to that array
    )until a[n]&b[n];               # End loop, terminate when a[n] and b[n] are defined
    [a[n],b[n]]                     # Array with both poor and rich number (implicit return)
}                                   # End function

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

Answer 9

পার্ল 6 , 76 বাইট

{classify({+(.&h <=>h .flip)},^($_*3+99)){-1,1}[*;$_]}
my&h={grep $_%%*,^$_}

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

আমি শানের পার্ল 6 উত্তরটি দেখতে পাইনি তবে এটি অন্যরকমভাবে কাজ করে। মনে রাখবেন যে আমি উপরের দিকে যেমন হার্ডকোড করেছি n*3+99, যা সম্ভবত কঠোরভাবে সঠিক নয়। যাইহোক, আমি কোনও অতিরিক্ত বাইট না *3দিয়ে এর সাথে প্রতিস্থাপন করতে পারি ³, যা আরও সঠিক হলে প্রোগ্রামটি আরও কম দক্ষ করে তুলবে।

Answer 10

পাইথন 2 , 152 বাইট

def f(n):
 a,b=[],[];i=1
 while not(a[n:]and b[n:]):[[],b,a][cmp(*[sum(m%-~i<1for i in range(m))for m in i,int(`i`[::-1])])]+=[i];i+=1
 return a[n],b[n]

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

রডের উত্তরের সাথে বেশ মিল হয়ে যায় । শূন্য-সূচকযুক্ত nদরিদ্র, সমৃদ্ধ টুপল ফিরিয়ে দেয়।

Comments

ডিফল্ট ফাংশন পরামিতি এবং জিপ ফাংশন ব্যবহার করে 148 বাইট।

— মান কালি

Answer 11

আইকন , 180 175 বাইট

procedure f(n)
a:=[];b:=[];k:=1
while{s:=t:=0 
i:=1to k+(m:=reverse(k))&(k%i=0&s+:=1)|(m%i=0&t+:=1)&\x
s>t&n>*a&push(a,k)
s<t&n>*b&push(b,k)
k+:=1;n>*a|n>*b}
return[!b,!a];end

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

Answer 12

এপিএল (ডায়ালগ ইউনিকোড) , 34 বাইট

{⍵⌷⍉1↓⊢⌸{×-/{≢∪⍵∨⍳⍵}¨⍵,⍎⌽⍕⍵}¨⍳1e3}

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

এই মনস্ট্রোসিটি আমাকে গল্ফকে সহায়তা করার জন্য আদম এবং এনএনজিকে ধন্যবাদ Thanks

বড় সূচকগুলির জন্য তিন বার সময় বের হয়ে যায় (যার প্রয়োজন হয় ⍳1e5বা ⍳1e6) তবে পর্যাপ্ত সময় এবং মেমরির কারণে ফাংশনটি সঠিকভাবে শেষ হবে।

Answer 13

আর , 152 137 বাইট

-জয়ুস্পে -২ বাইট ধন্যবাদ -3 বাইট ধন্যবাদ ডিগএমএলকে ধন্যবাদ

n=scan()
F=i=!1:2
`?`=sum
while(?n>i)if(n==?(i[s]=i[s<-sign((?!(r=?rev((T=T+1)%/%(e=10^(0:log10(T)))%%10)*e)%%1:r)-?!T%%1:T)]+1))F[s]=T
F

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

Tবর্তমানে পূর্ণসংখ্যা চেষ্টা করা হচ্ছে; সর্বশেষতম দরিদ্র এবং সমৃদ্ধ সংখ্যা ভেক্টরে সঞ্চিত রয়েছে F।

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

ব্যাখ্যা (পূর্ববর্তী, একই সংস্করণ):

n=scan() # input
i=0*1:3  # number of poor, middle class, and rich numbers so far
S=sum
while(S(n>i)){ # continue as long as at least one of the classes has less than n numbers
  if((i[s]=i[
    s<-2+sign(S(!(           # s will be 1 for poor, 2 for middle class, 3 for rich
      r=S((T<-T+1)%/%10^(0:( # reverse integer T with modular arithmetic
        b=log10(T)%/%1       # b is number of digits
        ))%%10*10^(b:0)) 
      )%%1:r)-               # compute number of divisors of r
      S(!T%%1:T))            # computer number of divisors of T
    ]+1)<=n){                # check we haven't already found n of that class
    F[s]=T
  }
}
F[-2] # print nth poor and rich numbers

Comments

146 বাইট ; ডিজিগ এমএল এর প্রতিক্রিয়া কী তা জানেন না

— জিউসেপ

@ জিউসেপ ধন্যবাদ! আমি এর ব্যবহার পছন্দ করি nchar।

— রবিন রাইডার

142 বাইট ; অপারেটরের অগ্রাধিকার নিয়ে আমার আগে সমস্যা হয়েছিল তবে তা আশ্চর্য হয়ে গেল।

— জিউসেপ

দারূন কাজ! 140 বিপরীত কৌশল পরিবর্তন করছে

— ই

@ ডিজিমএল 138 বাইট ফিরে যাচ্ছে log10!

— জিউসেপ

Answer 14

জাভাস্ক্রিপ্ট (নোড.জেএস) ,190 180 বাইট

আউটপুট হিসাবে [poor, rich]।

n=>{let p,r,f=h=i=0;while(f<n){k=d(i),e=d(+(i+"").split``.reverse().join``);if(k<e){p=i;f++}if(k>e&&h<n){r=i;h++}i++}return[p,r]}
d=n=>{c=0;for(j=1;j<=n;j++)if(n%j==0)c++;return c}

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

ব্যাখ্যা

d(n) ক্রিয়া

এই সহায়ক কোনও সংখ্যার যে কারণের সংখ্যা রয়েছে তা সন্ধান করে।

d=n=>{              // Equivalent to `function d(n) {
  c=0;              // Counter
  for(j=1;j<=n;j++) // Check every integer from 1 to n
    if(n%j==0)c++;  // If the number is a factor, add 1 to the counter
  return c
};

প্রধান ফাংশন

n=>{ 
  let p,r,f=h=i=0; // p -> the poor number, r -> the rich number, f -> the number of poor numbers found, h -> the number of rich numbers found, i -> the current number being checked
  while(f<n){ // While it's found less than n poor numbers (assumes that it will always find the rich number first)
    k=d(i),        // k -> number of factors of i
    e=d(+((i+"").split``.reverse().join``)); // e -> number of factors of reversed i
    if(k<e){p=i;f++}  // If it hasn't found enough poor numbers and i is poor, save it and count it
    if(k>e&&h<n){r=i;h++}  // If it hasn't found enough rich numbers and i is rich, save it and count it
    i++
  };
  return[p,r]
}

Answer 15

সি # (ভিজ্যুয়াল সি # ইন্টারেক্টিভ সংকলক) , 221 বাইট

n=>{int g,h,i,j=9,k,l,m,o,r,p;m=o=r=p=0;while(m<n||o<n){k=g=h=0;l=++j;while(l!=0){k=k*10+l%10;l/=10;}for(i=2;i<j+k;i++){if(j%i<1&&i<j)g++;if(k%i<1&&i<k)h++;}if(g<h&&o<n){o++;p=j;}if(g>h&&m<n){m++;r=j;}}return new{n,p,r};}

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