บทนำ

ในโลกที่แปลกประหลาดของตัวเลขจำนวนเต็มตัวหารเป็นเหมือนสินทรัพย์และพวกเขาใช้เรียกว่า "รวย" ตัวเลขที่มีตัวหารมากกว่าการกลับรายการในขณะที่พวกเขาเรียกว่า "ไม่ดี" คนที่มีตัวหารน้อยกว่าการกลับรายการ

ยกตัวอย่างเช่นหมายเลข$2401$มีห้าตัวหาร: $1,7,49,343,2401$ , ในขณะที่การพลิกกลับของ$1042$มีเพียงสี่: $1,2,521,1042$ 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-indexed) จะส่งกลับจำนวนที่ไม่สมบูรณ์และ n-th

อินพุต

• หมายเลขจำนวนเต็ม ( >= 0ถ้า 0-indexed หรือ>= 11-indexed)

เอาท์พุต

• 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

กฎทั่วไป:

• นี่คือcode-golfดังนั้นคำตอบที่สั้นที่สุดในจำนวนไบต์ชนะ
  อย่าปล่อยให้ภาษาที่ใช้รหัสกอล์ฟกีดกันคุณจากการโพสต์คำตอบด้วยภาษาที่ไม่ codegolfing พยายามหาคำตอบสั้น ๆ ที่เป็นไปได้สำหรับภาษาโปรแกรม 'ใด ๆ '
• กฎมาตรฐานใช้สำหรับคำตอบของคุณด้วยกฎ I / O เริ่มต้นดังนั้นคุณจึงได้รับอนุญาตให้ใช้ STDIN / STDOUT ฟังก์ชั่น / วิธีการที่มีพารามิเตอร์ที่เหมาะสมและประเภทผลตอบแทนโปรแกรมเต็มรูปแบบ การโทรของคุณ
• ช่องโหว่เริ่มต้นเป็นสิ่งต้องห้าม
• หากเป็นไปได้โปรดเพิ่มลิงก์พร้อมทดสอบรหัสของคุณ (เช่นTIO )
• นอกจากนี้ขอแนะนำให้เพิ่มคำอธิบายสำหรับคำตอบของคุณ

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 ไบต์

JavaScript (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)

เยลลี่ , 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

ภาษา Wolfram (Mathematica) 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)&   

ลองออนไลน์!

นี่คือพล็อตที่ น่าสงสารกับรวย

Perl 6 , 81 ไบต์

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

ลองออนไลน์!

• * > *เป็นฟังก์ชั่นที่ไม่ระบุชื่อที่คืนค่าจริงถ้าอาร์กิวเมนต์แรกมีค่ามากกว่าวินาที ในทำนองเดียวกันสำหรับ* < *ในทำนองเดียวกันสำหรับอดีตจะเลือกหมายเลขที่อยู่ในลำดับที่สมบูรณ์หลังจากนั้นจะเลือกหมายเลขที่อยู่ในลำดับที่ไม่ดี
• (* > *, * < *).map(-> &c { ... }) สร้างคู่ของลำดับอนันต์แต่ละอันขึ้นอยู่กับฟังก์ชันตัวเปรียบเทียบอย่างใดอย่างหนึ่ง: ลำดับที่สมบูรณ์และลำดับที่ไม่ดีตามลำดับนั้น
• »[$_]ดัชนีลงในทั้งสองลำดับที่ใช้$_อาร์กิวเมนต์ของฟังก์ชันระดับบนสุดส่งคืนรายการองค์ประกอบสองรายการที่มี$_สมาชิกลำดับที่ 3 และ$_สมาชิกลำดับที่ไม่ดี
• grep $_ %% *, 1..$_$_ผลิตรายการของตัวหารที่
• map { grep $_ %% *, 1..$_ }, $_, .flipสร้างรายการสององค์ประกอบของตัวหาร$_และตัวหารของ$_ด้วยตัวเลขที่กลับรายการ ("พลิก")
• [[&c]]ลดรายการสององค์ประกอบที่มีฟังก์ชั่นเปรียบเทียบ&c(ทั้งมากกว่าหรือน้อยกว่า) สร้างค่าบูลีนที่ระบุว่าหมายเลขนี้เป็นของลำดับที่สมบูรณ์ของลำดับที่ไม่ดี

Python 2 , 142 141 bytes

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])

ลองออนไลน์!

ทางเลือกที่ไม่เกิดซ้ำ (คล้ายกับคำตอบของงูหลามอื่น ๆ )

Python 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]

ลองออนไลน์!

Python 2 , 158 153 bytes

^{-2 ไบต์ขอบคุณ shooqie}

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ขาออกเป็น

ทับทิม , 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

ลองออนไลน์!

Perl 6 , 76 ไบต์

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

ลองออนไลน์!

ฉันไม่เห็นคำตอบ Perl 6 ของ Seanแต่วิธีนี้ทำงานในวิธีที่ต่างออกไป โปรดทราบว่าฉัน hardcoded ส่วนบนเป็นn*3+99ซึ่งอาจไม่ถูกต้องอย่างเคร่งครัด อย่างไรก็ตามฉันสามารถแทนที่*3ด้วย³สำหรับไม่มีไบต์พิเศษซึ่งจะทำให้โปรแกรมมีประสิทธิภาพน้อยลงถ้าถูกต้องมากขึ้น

Python 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]

ลองออนไลน์!

สิ้นสุดขึ้นเป็นสวยคล้ายกับคำตอบของร็อด ส่งคืนntuple ที่ไม่มีการจัดทำดัชนีที่ไม่ดีและรวย

ไอคอน , 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

ลองออนไลน์!

APL (Dyalog Unicode) , 34 ไบต์

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

ลองออนไลน์!

ขอบคุณAdámและ ngn ที่ช่วยฉันตีกอล์ฟให้กับสิ่งมหัศจรรย์นี้

TIO หมดเวลาสำหรับดัชนีใหญ่ (ซึ่งต้องการ⍳1e5หรือ⍳1e6) แต่ให้เวลาและหน่วยความจำเพียงพอฟังก์ชั่นจะยุติอย่างถูกต้อง

R , 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

JavaScript (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]
}

C # (Visual C # Interactive คอมไพเลอร์) , 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};}

ลองออนไลน์!