Giới thiệu

Trong thế giới kỳ lạ của các số nguyên, các ước số giống như các tài sản và chúng sử dụng để gọi "giàu" là các số có nhiều ước hơn so với đảo ngược của chúng, trong khi chúng gọi "nghèo" là các ước có ít ước hơn so với đảo ngược.

Ví dụ: số $2401$ có năm ước: $1,7,49,343,2401$ , trong khi đảo ngược của nó, $1042$ , chỉ có bốn: $1,2,521,1042$ .
Vì vậy, $2401$ được gọi là số giàu , trong khi $1042$ là số nghèo .

Với định nghĩa này, chúng ta có thể tạo hai chuỗi số nguyên sau đây gồm các số giàu và nghèo:

(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
   ... |  ... |  ...

Ghi chú:

• là "đảo ngược" của một số, chúng tôi có nghĩa là đảo ngược kỹ thuật số của nó , tức là có các chữ số của nó trong cơ sở 10 đảo ngược. Điều này có nghĩa là các số kết thúc bằng một hoặc nhiều số 0 sẽ có đảo ngược "ngắn hơn": ví dụ: đảo ngược 1900là 0091do91
• chúng tôi cố ý loại trừ các số nguyên có cùng số ước với số đảo của chúng, tức là các số thuộc về OEIS: A062895

Thử thách

Xem xét hai chuỗi được xác định ở trên, nhiệm vụ của bạn là viết một chương trình hoặc hàm, được đưa ra một số nguyên n(bạn có thể chọn 0 hoặc 1 chỉ mục), trả về số giàu thứ n và thứ n.

Đầu vào

• Một số nguyên ( >= 0nếu được lập chỉ mục 0 hoặc >= 1nếu được lập chỉ mục 1)

Đầu ra

• 2 số nguyên, một cho chuỗi kém và một cho chuỗi giàu, theo thứ tự bạn thích miễn là phù hợp

Ví dụ:

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

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Quy tắc chuẩn áp dụng cho câu trả lời của bạn với quy tắc I / O mặc định , vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn (ví dụ TIO ).
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

05AB1E , 16 byte

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

Hãy thử trực tuyến!

Chỉ số 0 [giàu, nghèo]:

∞                # 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.

Có lẽ ai đó có thể giải thích lý do tại sao phiên bản này dường như không chấm dứt, nhưng khi tôi nhấp vào "hủy thực thi" trên TIO, nó sẽ kết thúc với câu trả lời đúng hoặc nếu bạn đợi 60 giây bạn sẽ có câu trả lời đúng. Đối với phiên bản chấm dứt "chính xác", bạn có thể sử dụng: T+nL.¡ÂÑgsÑg.S}¦ζsè+3 byte

JavaScript (ES6),  121 115 113  111 byte

Đầu vào là 1 chỉ mục. Đầu ra như [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)]

Hãy thử trực tuyến!

Đã bình luận

Chức năng trợ giúp

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

Chủ yếu

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)

Thạch , 22 byte

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

Hãy thử trực tuyến!

$n$ trên stdin và trả về một danh sách các số nguyên nghèo và giàu thứ n theo thứ tự đó.

Giải trình

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

Ngôn ngữ Wolfram (Mathicala) , 152 byte

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

Hãy thử trực tuyến!

Nếu phỏng đoán là đúng, thì giải pháp 140 byte này cũng hoạt động

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

Hãy thử trực tuyến!

Đây là cốt truyện nghèo vs giàu

Perl 6 , 81 byte

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

Hãy thử trực tuyến!

• * > *là một hàm ẩn danh trả về true nếu đối số đầu tiên của nó lớn hơn đối số thứ hai của nó. Tương tự cho * < *. Cái trước sẽ chọn những con số thuộc về chuỗi giàu, cái sau sẽ chọn những con số thuộc về chuỗi nghèo.
• (* > *, * < *).map(-> &c { ... }) tạo ra một cặp chuỗi vô hạn, mỗi chuỗi dựa trên một trong các hàm so sánh: chuỗi giàu và chuỗi kém, theo thứ tự đó.
• »[$_]lập chỉ mục vào cả hai chuỗi đó bằng cách sử dụng $_, đối số cho hàm cấp cao nhất, trả về danh sách hai phần tử chứa $_thành viên thứ của chuỗi giàu và $_thành viên thứ của chuỗi kém.
• grep $_ %% *, 1..$_tạo ra một danh sách các ước của $_.
• map { grep $_ %% *, 1..$_ }, $_, .fliptạo ra một danh sách hai yếu tố của các ước của $_và các ước của $_với các chữ số của nó đảo ngược ("lật").
• [[&c]]giảm danh sách hai phần tử đó với hàm so sánh &c(lớn hơn hoặc nhỏ hơn), tạo ra giá trị boolean cho biết số này có thuộc chuỗi giàu của chuỗi kém hay không.

Python 2 , 142 141 byte

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

Hãy thử trực tuyến!

Thay thế không đệ quy (rất giống với các câu trả lời khác của Python)

Python 2 , 143 byte

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]

Hãy thử trực tuyến!

Con trăn 2 , 158 153 byte

^{-2 byte nhờ 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]

Hãy thử trực tuyến!

Đầu vào là 0 chỉ mục. Đầu ra như poor rich.

Hồng ngọc , 128 byte

Đầu vào là không có chỉ mục . Đầu ra là [nghèo, giàu].

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

Giải trình

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

Hãy thử trực tuyến!

Perl 6 , 76 byte

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

Hãy thử trực tuyến!

Tôi không thấy câu trả lời Perl 6 của Sean , nhưng cách này hoạt động theo một cách khác. Lưu ý rằng tôi đã mã hóa phần trên như là n*3+99, điều này có lẽ không hoàn toàn chính xác. Tuy nhiên, tôi có thể thay thế *3bằng ³không có thêm byte, điều này sẽ làm cho chương trình kém hiệu quả hơn, nếu chính xác hơn.

Con trăn 2 , 152 byte

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]

Hãy thử trực tuyến!

Kết thúc khá giống với câu trả lời của Rod . Trả về không có chỉ nsố nghèo, tuple giàu.

Biểu tượng , 180 175 byte

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

Hãy thử trực tuyến!

APL (Dyalog Unicode) , 34 byte

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

Hãy thử trực tuyến!

Cảm ơn Adám và ngn đã giúp tôi đánh golf sự quái dị này.

TIO hết thời gian cho các chỉ số lớn hơn (yêu cầu ⍳1e5hoặc ⍳1e6), nhưng được cung cấp đủ thời gian và bộ nhớ, chức năng sẽ chấm dứt chính xác.

R , 152 137 byte

-12 byte nhờ Giuseppe -3 byte nhờ 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

Hãy thử trực tuyến!

Tlà số nguyên hiện đang được thử; số nghèo và giàu mới nhất được lưu trữ trong vectorF .

Cách ngắn nhất mà tôi có thể tìm thấy để đảo ngược một số nguyên là chuyển đổi nó thành các chữ số trong cơ sở 10 với số học mô-đun, sau đó chuyển đổi trở lại với lũy thừa 10, nhưng tôi hy vọng sẽ vượt xa trên mặt trận này và các mặt trận khác.

Giải thích (của phiên bản trước, tương tự):

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 byte

Đầu ra như [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}

Hãy thử trực tuyến!

Giải trình

d(n) Chức năng

Người trợ giúp này tìm thấy số lượng các yếu tố mà một số có.

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
};

Chức năng chính

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 # (Trình biên dịch tương tác Visual C #) , 221 byte

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};}

Hãy thử trực tuyến!