pengantar

Dalam dunia aneh angka integer, pembagi seperti aset dan mereka gunakan untuk menyebut "kaya" angka yang memiliki lebih banyak pembagi daripada pembalikannya, sementara mereka menyebut "miskin" yang memiliki pembagi yang lebih sedikit daripada pembalikannya.

Misalnya, angka $2401$ memiliki lima pembagi: $1,7,49,343,2401$ , sedangkan pembalikannya, $1042$ , hanya memiliki empat: $1,2,521,1042$ .
Jadi $2401$ disebut angka kaya , sedangkan $1042$ angka miskin .

Dengan definisi ini, kita dapat membuat dua urutan bilangan bulat kaya dan miskin berikut:

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

Catatan:

• sebagai "pembalikan" dari angka yang kami maksudkan pembalikan digitalnya , yaitu memiliki digit pada basis-10 terbalik. Ini berarti bahwa nomor yang berakhir dengan satu atau lebih angka nol akan memiliki "lebih pendek" reversal: misalnya pembalikan 1900adalah 0091maka91
• kami sengaja mengecualikan angka integer yang memiliki jumlah pembagi yang sama dengan pembalikannya, yaitu yang dimiliki oleh OEIS: A062895

Tantangan

Mempertimbangkan dua urutan yang didefinisikan di atas, tugas Anda adalah menulis sebuah program atau fungsi yang, diberi bilangan bulat n(Anda dapat memilih 0 atau 1-diindeks), mengembalikan angka ke-n miskin dan ke-n kaya.

Memasukkan

• Nomor integer ( >= 0jika 0-diindeks atau >= 1jika 1-diindeks)

Keluaran

• 2-bilangan bulat, satu untuk urutan yang buruk dan satu untuk urutan kaya, dalam urutan yang Anda sukai selama konsisten

Contoh:

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

Aturan umum:

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.
  Jangan biarkan bahasa kode-golf mencegah Anda memposting jawaban dengan bahasa non-codegolf. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa saja'.
• Aturan standar berlaku untuk jawaban Anda dengan aturan I / O default , sehingga Anda diizinkan untuk menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat dan tipe pengembalian, program penuh. Panggilanmu.
• Celah default tidak diperbolehkan.
• Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda (yaitu TIO ).
• Juga, menambahkan penjelasan untuk jawaban Anda sangat dianjurkan.

05AB1E , 16 byte

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

Cobalah online!

Diindeks [kaya, miskin]:

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

Mungkin seseorang dapat menjelaskan mengapa versi ini tampaknya tidak berakhir, tetapi ketika saya mengklik "batalkan eksekusi" pada TIO selesai dengan jawaban yang benar, atau jika Anda menunggu 60 detik Anda mendapatkan jawaban yang benar. Untuk versi yang mengakhiri "dengan benar" Anda bisa menggunakan: T+nL.¡ÂÑgsÑg.S}¦ζsè+3 byte

JavaScript (ES6),  121 115 113  111 byte

Input diindeks 1. Output sebagai [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)]

Cobalah online!

Berkomentar

Fungsi pembantu

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

Utama

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)

Jelly , 22 byte

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

Cobalah online!

$n$

Penjelasan

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

Bahasa Wolfram (Mathematica) , 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)&

Cobalah online!

Jika dugaan itu benar, maka solusi 140 byte ini juga berfungsi

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

Cobalah online!

Berikut adalah plot miskin vs kaya

Perl 6 , 81 byte

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

Cobalah online!

• * > *adalah fungsi anonim yang mengembalikan true jika argumen pertama lebih besar dari yang kedua. Demikian pula untuk * < *. Yang pertama akan memilih nomor yang termasuk dalam urutan kaya, yang terakhir akan memilih orang-orang yang termasuk dalam urutan yang buruk.
• (* > *, * < *).map(-> &c { ... }) menghasilkan sepasang urutan tak terbatas, masing-masing berdasarkan pada salah satu fungsi pembanding: urutan kaya dan urutan miskin, dalam urutan itu.
• »[$_]mengindeks ke dalam kedua sekuens tersebut menggunakan $_, argumen ke fungsi tingkat atas, mengembalikan daftar dua elemen yang berisi $_anggota th dari urutan kaya dan $_anggota th urutan buruk.
• grep $_ %% *, 1..$_menghasilkan daftar pembagi $_.
• map { grep $_ %% *, 1..$_ }, $_, .flipmenghasilkan daftar dua elemen pembagi $_, dan pembagi $_dengan digitnya terbalik ("terbalik").
• [[&c]]mengurangi daftar dua elemen dengan fungsi komparator &c(baik lebih besar atau lebih kecil dari), menghasilkan nilai boolean yang menunjukkan apakah nomor ini milik urutan kaya dari urutan buruk.

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

Cobalah online!

Alternatif non-rekursif (sangat mirip dengan jawaban Python lainnya)

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]

Cobalah online!

Python 2 , 158 153 byte

^{-2 byte terima kasih kepada 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]

Cobalah online!

Input diindeks 0. Output sebagai poor rich.

Ruby , 128 byte

Masukan diindeks nol . Output sebagai [miskin, kaya].

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

Penjelasan

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

Cobalah online!

Perl 6 , 76 byte

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

Cobalah online!

Saya tidak melihat jawaban Perl 6 Sean , tetapi ini bekerja dengan cara yang berbeda. Perhatikan bahwa saya telah mengkodekan upperbound sebagai n*3+99, yang mungkin tidak sepenuhnya benar. Namun, saya bisa mengganti *3dengan ³tanpa byte tambahan, yang akan membuat program jauh lebih efisien, jika lebih benar.

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

Cobalah online!

Berakhir menjadi sangat mirip dengan jawaban Rod . Mengembalikan nol ntuple miskin dan kaya yang diindeks .

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

Cobalah online!

APL (Dyalog Unicode) , 34 byte

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

Cobalah online!

Terima kasih kepada Adám dan ngn untuk membantu saya bermain golf monster ini.

TIO time out untuk indeks yang lebih besar (yang membutuhkan ⍳1e5atau ⍳1e6), tetapi diberi waktu dan memori yang cukup, fungsi tersebut akan berakhir dengan benar.

R , 152 137 byte

-12 byte terima kasih kepada Giuseppe -3 byte terima kasih untuk 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

Cobalah online!

Tadalah integer yang saat ini sedang dicoba; angka miskin dan kaya terbaru disimpan dalam vektor F.

Cara terpendek yang dapat saya temukan untuk membalik bilangan bulat adalah mengonversinya menjadi angka di basis 10 dengan aritmatika modular, kemudian mengonversi kembali dengan kekuatan 10 terbalik, tetapi saya berharap akan kalah dalam hal ini dan bidang lainnya.

Penjelasan (dari versi sebelumnya yang serupa):

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

Output sebagai [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}

Cobalah online!

Penjelasan

d(n) Fungsi

Penolong ini menemukan sejumlah faktor yang dimiliki suatu angka.

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

Fungsi utama

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 Compiler) , 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};}

Cobalah online!