दिव्यांग अमीर और गरीब नंबर

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
• हम जानबूझकर पूर्णांक संख्या को अपने उत्क्रमण के रूप में छोड़ते हैं, अर्थात OEIS से संबंधित : A062895

चुनौती

ऊपर परिभाषित दो अनुक्रमों को ध्यान में रखते हुए, आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है, जो पूर्णांक दिया गया है n(आप 0 या 1-अनुक्रमित चुन सकते हैं), एन-वें गरीब और एन-वें समृद्ध संख्या देता है।

इनपुट

• एक पूर्णांक संख्या ( >= 0यदि 0-अनुक्रमित या >= 1यदि 1-अनुक्रमित)

उत्पादन

• 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

सामान्य नियम:

• यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
  कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव कम उत्तर के साथ आने की कोशिश करें।
• डिफ़ॉल्ट I / O नियमों के साथ आपके उत्तर के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा फोन।
• डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
• यदि संभव हो, तो कृपया अपने कोड (यानी TIO ) के लिए एक परीक्षण के साथ एक लिंक जोड़ें ।
• साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ने की अत्यधिक अनुशंसा की जाती है।

Comments

अनुमान: ध गरीब संख्या हमेशा n ध समृद्ध संख्या से अधिक होती है । अगर कोई इसे साबित कर सकता है, तो यह शायद कई जवाबों से बाइट्स निकाल देगा। $n$$n$

— रॉबिन राइडर

@ रॉबिन राइडर: मुझे संदेह है कि यह सच है, लेकिन यह साबित करना एक पूरी अलग कहानी है :)

— digEmAll

@RobinRyder इस बात पर विचार करें कि अग्रणी शून्य (उदाहरण 51, 510, 5100 से 15 तक सभी मानचित्र) के कारण कई संख्याएं एक ही उलट संख्याओं के लिए मैप कर सकती हैं। प्रत्येक संख्या , अनुगामी शून्य ( 10 , 100 , 1000 , आदि के अतिरिक्त कारकों के साथ) के साथ संबंधित अनुवर्ती संख्याओं की एक अनंत संख्या होगी , जबकि केवल एक सीमित मात्रा में गरीब उलट संख्याएं होती हैं। मुझे नहीं लगता कि यह पूरी तरह से यह साबित करता है (शायद लाइन के नीचे कहीं गरीब संख्याओं की एक भाग्यशाली श्रृंखला है), लेकिन यह कम से कम यह निर्दिष्ट करता है कि गरीबों की तुलना में कहीं अधिक समृद्ध संख्याएं हैं। $n$$10,100,1000$

— जो राजा

@JoKing "... गरीबों की तुलना में अधिक समृद्ध संख्या।" इस कथन को स्पष्ट करना चाहते हैं; जैसा कि लिखा गया है, यह व्याख्या की जा सकती है कि अमीर संख्या के सेट में गरीब संख्या के सेट की तुलना में अधिक कार्डिनैलिटी है। लेकिन निश्चित रूप से दोनों सेट अनंत रूप से अनंत हैं (न ही अनुक्रम समाप्त होता है): यह साबित करने के लिए पर्याप्त है कि असीम रूप से कई प्राइम हैं जिनका पहला अंक ए है 2। इसके लिए, निम्नलिखित पेपर के अंत में Corollary 1.4 देखें, इसके nबराबर 19, 199, 1999, ...: m-hikari.com/ijcms-password/ijcms-password13-16-2006/…

— मैथमैडैन

Answer 1

05AB1E , 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.

शायद कोई समझा सकता है कि यह संस्करण समाप्त क्यों नहीं होता है, लेकिन जब मैं TIO पर "रद्द निष्पादन" पर क्लिक करता हूं तो यह सही उत्तर के साथ समाप्त होता है, या यदि आप 60 सेकंड तक प्रतीक्षा करते हैं तो आपको सही उत्तर मिलता है। एक ऐसे संस्करण के लिए जो "सही ढंग से" समाप्त करता है आप उपयोग कर सकते हैं: T+nL.¡ÂÑgsÑg.S}¦ζsè+3 बाइट्स

Comments

स्प्लिट-बाय अनंत सूचियों के साथ बहुत अच्छी तरह से काम नहीं करता है।

— एमिगा

व्यक्तिगत रूप से @Emigna, मुझे नहीं पता कि अनंत सूचियाँ भी कैसे संभव हैं।

— मैजिक ऑक्टोपस Urn

आलसी मूल्यांकन। आप की जरूरत नहीं है संख्या की गणना मत करो। तो ∞n5èकेवल पहले 6 नंबरों की गणना करेगा। मुझे लगता है कि जब इस प्रकार के लूपिंग / ग्रुपिंग / स्प्लिटिंग कंस्ट्रक्शन खेलने के लिए आते हैं, तो आलसी निष्कासन विफल हो जाता है और यह लौटने से पहले सभी वस्तुओं की गणना करने की कोशिश करता है।

— एमिगा

मुझे अभी भी लगता है कि वहाँ के लिए एक 1-बाइट बनाया जाना चाहिए €g.. मैं इसे अक्सर इस्तेमाल किया। यहाँ (अब बराबर बाइट) विकल्प के साथ एक बाइट को बचाया होगा ‚рgÆ.±। हालांकि अच्छा जवाब! के महान उपयोग .¡!

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

@KevinCruijssen इसके लिए एक और 2 बाइट लोल है δg।

— मैजिक ऑक्टोपस Urn

Answer 2

जावास्क्रिप्ट (ईएस 6),  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$

व्याख्या

ṚḌ;⁸Æ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

महान! BTW, यह शायद कुछ समाधानों में से एक है (शायद केवल एक ही) TIO पर n = 35842 तक पहुंचने में सक्षम है :)

— digEmAll

Answer 5

पर्ल 6 , 81 बाइट्स

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

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

• * > *एक अनाम फ़ंक्शन है जो सही लौटाता है यदि इसका पहला तर्क इसके दूसरे से अधिक है। इसी तरह के लिए * < *। पूर्व उन संख्याओं का चयन करेगा जो समृद्ध अनुक्रम से संबंधित हैं, बाद वाले उन का चयन करेंगे जो खराब अनुक्रम से संबंधित हैं।
• (* > *, * < *).map(-> &c { ... }) अनंत क्रमों की एक जोड़ी का निर्माण करता है, प्रत्येक एक तुलनित्र कार्यों के आधार पर: अमीर अनुक्रम और खराब क्रम, उस क्रम में।
• »[$_]उन दोनों अनुक्रमों का उपयोग करता है $_, जो शीर्ष-स्तरीय फ़ंक्शन का तर्क देता है, दो-तत्व सूची देता है जिसमें $_समृद्ध अनुक्रम के $_वें सदस्य और खराब अनुक्रम के वें सदस्य होते हैं।
• grep $_ %% *, 1..$_के विभाजकों की सूची तैयार करता है $_।
• map { grep $_ %% *, 1..$_ }, $_, .flipके विभाजकों की दो-तत्व सूची बनाता है $_, और $_इसके अंकों के विभाजक उलट जाते हैं ("फ़्लिप")।
• [[&c]]तुलनित्र फ़ंक्शन के साथ उस दो-तत्व सूची को कम कर देता है &c(या तो-से-कम या उससे कम), एक बूलियन मान का उत्पादन जो यह दर्शाता है कि क्या यह संख्या खराब अनुक्रम के समृद्ध अनुक्रम से संबंधित है।

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 बाइट्स

^{-2 बाइट्स शुकी के लिए धन्यवाद}

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

काम के +=[c]बदले होगा .append(c)?

— शौकी

@shooqie यह होगा

— ग्रिमी

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}

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

Adám और ngn की मदद करने के लिए धन्यवाद मुझे इस मठ में गोल्फ।

बड़े सूचकांकों के लिए TIO बार बाहर (जिसकी आवश्यकता होती है ⍳1e5या होती है ⍳1e6), लेकिन पर्याप्त समय और स्मृति को देखते हुए फ़ंक्शन सही ढंग से समाप्त हो जाएगा।

Answer 13

आर , 152 137 बाइट्स

-12 बाइट्स Giuseppe -3 बाइट्स के लिए धन्यवाद digEmAll धन्यवाद

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 बाइट्स ; कोई विचार नहीं है कि डाइजेक्जेल की प्रतिक्रिया क्या है

— ग्यूसेप

@Giuseppe धन्यवाद! मैं का उपयोग प्यार करता हूँ nchar।

— रॉबिन राइडर

142 बाइट्स ; मैं पहले से ऑपरेटर ऑपरेटर की समस्या से परेशान था, लेकिन इसे बाहर निकाल दिया।

— ग्यूसेप

अच्छा काम! 140 रिवर्स रणनीति को बदलते हुए

— digEmAll

@digEmAll 138 बाइट्स वापस जा रहे हैं log10!

— ग्यूसेप

Answer 14

जावास्क्रिप्ट (Node.js) ,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};}

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