Giriş

Tamsayı sayıların garip dünyasında, bölücüler varlık gibidirler ve geri dönüşlerinden daha fazla bölücüye sahip olan sayıları "zengin" olarak adlandırırken, geri dönüşlerinden daha az bölenlere "fakir" diyorlar.

Örneğin, sayısının beş vardır: , tersi ise sadece dört: 1,2,521,1042 . Yani 2401 bir denir zengin iken, sayı 1042 bir fakir sayısı.$2401$$1,7,49,343,2401$$1042$$1,2,521,1042$
$2401$$1042$

Bu tanım göz önüne alındığında, zengin ve zayıf sayıların aşağıdaki iki tamsayı dizisini oluşturabiliriz:

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

Notlar:

• bir sayının "tersine çevrilmesi" olarak dijital tersini kastediyoruz , yani taban-10'daki rakamlarını tersine çevirmek . Bir veya daha fazla sıfır ile biten sayılar "daha kısa" ters olacağı Bu araçlar: ör ters 1900olduğunu 0091, dolayısıyla91
• ters çevrimleriyle aynı sayıda bölücüye sahip tamsayı sayılarını kasten hariç tutuyoruz , yani OEIS'e ait olanlar : A062895

Meydan okuma

Yukarıda tanımlanan iki diziyi göz önünde bulundurarak, göreviniz bir tamsayı verildiğinde n(0 veya 1 dizinli seçebilirsiniz) n'inci fakir ve n'inci zengin zengin sayısını döndüren bir program veya işlev yazmaktır .

Giriş

• Bir tam sayı ( >= 00 dizinli veya >= 11 dizinli ise)

Çıktı

• Biri zayıf dizi için ve diğeri zengin dizi için tutarlı olduğu sürece tercih ettiğiniz sırayla 2 tamsayı

Örnekler:

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

Genel kurallar:

• Bu kod golf , bayt en kısa cevap kazanır.
  Kod golf dillerinin, kod yazmayan dillerle yanıt göndermenizi engellemesine izin vermeyin. Herhangi bir programlama dili için mümkün olduğunca kısa bir cevap bulmaya çalışın.
• Varsayılan I / O kuralları ile cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT, fonksiyonlar / yöntem uygun parametreler ve dönüş tipi, tam programlar ile kullanılabilir. Çağrınız.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuz için bir test içeren bir bağlantı ekleyin (örn. TIO ).
• Ayrıca, cevabınız için bir açıklama eklemeniz şiddetle tavsiye edilir.

05AB1E , 16 bayt

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

Çevrimiçi deneyin!

0 endeksli [zengin, fakir]:

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

Belki birisi bu sürümün neden sona ermediğini açıklayabilir, ancak TIO'da "yürütmeyi iptal et" i tıkladığımda doğru cevapla biter veya 60 saniye beklerseniz doğru cevabı alırsınız. "Doğru" olarak sona eren bir sürüm için şunları kullanabilirsiniz: T+nL.¡ÂÑgsÑg.S}¦ζsè+3 bayt

JavaScript (ES6),  121 115 113  111 bayt

Giriş 1 dizinli. Çıkışları [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)]

Çevrimiçi deneyin!

Yorumlananlar

Yardımcı işlevi

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

Ana

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)

Jöle , 22 bayt

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

Çevrimiçi deneyin!

$n$

açıklama

ṚḌ;⁸Æ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 Dili (Mathematica) , 152 bayt

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

Çevrimiçi deneyin!

Eğer varsayım doğruysa, bu 140 baytlık çözüm de işe yarar

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

Çevrimiçi deneyin!

İşte fakir ve zengin arsa

Perl 6 , 81 bayt

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

Çevrimiçi deneyin!

• * > *ilk argümanı ikincisinden büyükse true döndüren anonim bir işlevdir. Benzer şekilde * < *. Birincisi zengin diziye ait sayıları, ikincisi zayıf diziye ait olanları seçecektir.
• (* > *, * < *).map(-> &c { ... }) her biri karşılaştırma işlevlerinden birini temel alan bir çift sonsuz dizi üretir: bu sırada zengin dizi ve kötü dizi.
• »[$_]$_en üst düzey işlev argümanını kullanarak bu dizilerin her ikisine de indeksler $_, zengin dizinin $_th üyesini ve zayıf dizinin th üyesini içeren iki elemanlı bir liste döndürür .
• grep $_ %% *, 1..$_'nin bölücülerinin bir listesini üretir $_.
• map { grep $_ %% *, 1..$_ }, $_, .flip' $_nin bölücülerinin $_ve basamaklarının tersine çevrilmiş bölücülerinin ("ters çevrilmiş") iki elemanlı bir listesini üretir .
• [[&c]]bu iki elemanlı listeyi karşılaştırma işleviyle &c(daha büyük veya daha küçük) azaltır ve bu sayının zayıf dizinin zengin dizisine ait olup olmadığını gösteren bir boole değeri üretir.

Python 2 , 142 141 bayt

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

Çevrimiçi deneyin!

Özyinelemesiz alternatif (diğer Python cevaplarına çok benzer)

Python 2 , 143 bayt

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]

Çevrimiçi deneyin!

Python 2 , 158153 bayt

^{Shooqie sayesinde -2 bayt}

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]

Çevrimiçi deneyin!

Giriş 0 dizinlidir. Çıkışları poor rich.

Yakut , 128 bayt

Giriş sıfır endekslidir . Çıktılar [fakir, zengin].

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

açıklama

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

Çevrimiçi deneyin!

Perl 6 , 76 bayt

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

Çevrimiçi deneyin!

Sean'ın Perl 6 cevabını görmedim , ama bu farklı bir şekilde çalışıyor. n*3+99Büyük olasılıkla kesinlikle doğru olmayan üst sınırı olarak kodladığımı unutmayın . Ancak, ben yerini alabilecek *3ile ³daha doğru ise, program çok daha az verimli kılacak hiçbir ekstra bayt için.

Python 2 , 152 bayt

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]

Çevrimiçi deneyin!

Sonunda Rod'un cevabına oldukça benziyor . nZayıf, zengin demetin sıfır indeksli değerini döndürür .

Simge , 180 175 bayt

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

Çevrimiçi deneyin!

APL (Dyalog Unicode) , 34 bayt

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

Çevrimiçi deneyin!

Adám ve ngn'e bu canavarlığı golf etmeme yardımcı oldukları için teşekkürler.

TIO daha büyük endeksler için zaman aşımına uğrar ( ⍳1e5veya ister ⍳1e6), ancak yeterli zaman ve bellek verildiğinde işlev doğru şekilde sonlanır.

R , 152137 bayt

Giuseppe sayesinde -12 bayt digEmAll sayesinde -3 bayt

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

Çevrimiçi deneyin!

Tşu anda denenen tam sayıdır; en son fakir ve zengin sayılar vektörde saklanır F.

Bir tamsayıyı tersine çevirmenin en kısa yolu, onu modüler aritmetik ile taban 10'daki rakamlara dönüştürmek, daha sonra tersine çevrilmiş 10'luk güçlerle geri dönüştürmekti, ancak bu ve diğer cephelerde geride kalmayı bekliyorum.

Açıklama (önceki benzer sürümün):

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 bayt

Çıkışları [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}

Çevrimiçi deneyin!

açıklama

d(n) fonksiyon

Bu yardımcı, bir sayının sahip olduğu faktör sayısını bulur.

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

Ana işlev

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 # Etkileşimli Derleyici) , 221 bayt

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

Çevrimiçi deneyin!