Wprowadzenie

W dziwnym świecie liczb całkowitych dzielniki są jak aktywa i nazywają „bogatymi” liczbami, które mają więcej dzielników niż ich odwrócenie, podczas gdy nazywają „biednymi” tymi, które mają mniej dzielników niż ich odwrócenie.

Na przykład liczba ma pięć dzielników: , , , , podczas gdy jej odwrócenie, , ma tylko cztery: 1, , . Więc nazywany jest bogata liczba, podczas gdy biedny numer.$2401$$1,7,49,343,2401$$1042$$1,2,521,1042$
$2401$1042$1042$

Biorąc pod uwagę tę definicję, możemy utworzyć następujące dwie liczby całkowite liczb bogatych i słabych:

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

Uwagi:

• jako „odwrócenie” liczby rozumiemy cyfrową rewers , tzn. odwrócenie cyfr w bazie-10. Oznacza to, że liczby kończące się jednym lub kilkoma zerami będą miały „krótsze” odwrócenie: np. Odwrócenie 1900jest 0091zatem91
• celowo wykluczamy liczby całkowite mające tę samą liczbę dzielników co ich odwrócenie, tj. należące do OEIS: A062895

Wyzwanie

Biorąc pod uwagę dwie sekwencje zdefiniowane powyżej, Twoim zadaniem jest napisanie programu lub funkcji, która, biorąc pod uwagę liczbę całkowitą n(możesz wybrać 0 lub indeks 1), zwraca n-tą słabą i n-tą bogatą liczbę.

Wejście

• Liczba całkowita ( >= 0jeśli indeksowane 0 lub indeksowane >= 11)

Wynik

• 2 liczby całkowite, jedna dla sekwencji słabej i jedna dla sekwencji bogatej, w preferowanej kolejności, o ile jest spójna

Przykłady:

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

Główne zasady:

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Do odpowiedzi mają zastosowanie standardowe reguły z domyślnymi regułami We / Wy , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i typem zwracanych, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem kodu (tj. TIO ).
• Zalecane jest również dodanie wyjaśnienia do odpowiedzi.

05AB1E , 16 bajtów

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

Wypróbuj online!

0-indeksowany [bogaty, słaby]:

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

Może ktoś może wyjaśnić, dlaczego ta wersja nie wydaje się kończyć, ale kiedy kliknę „anuluj wykonanie” na TIO, kończy się poprawną odpowiedzią, lub jeśli zaczekasz 60 sekund, otrzymasz poprawną odpowiedź. W przypadku wersji, która kończy się „poprawnie”, możesz użyć: T+nL.¡ÂÑgsÑg.S}¦ζsè+3 bajtów

JavaScript (ES6),  121 115 113  111 bajtów

Dane wejściowe są indeksowane 1. Wyjścia jak [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)]

Wypróbuj online!

Skomentował

Funkcja pomocnika

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

Główny

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)

Galaretka , 22 bajty

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

Wypróbuj online!

$n$

Wyjaśnienie

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

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

Wypróbuj online!

Jeśli przypuszczenie jest prawdziwe, to rozwiązanie z 140 bajtów również działa

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

Wypróbuj online!

Oto słaba vs bogata fabuła

Perl 6 , 81 bajtów

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

Wypróbuj online!

• * > *jest anonimową funkcją, która zwraca true, jeśli jej pierwszy argument jest większy niż drugi. Podobnie dla * < *. Pierwszy wybierze liczby należące do sekwencji bogatej, drugi wybierze te, które należą do złej sekwencji.
• (* > *, * < *).map(-> &c { ... }) tworzy parę nieskończonych sekwencji, z których każda oparta jest na jednej z funkcji komparatora: sekwencji bogatej i sekwencji słabej, w tej kolejności.
• »[$_]indeksuje do obu tych sekwencji za pomocą $_argumentu funkcji najwyższego poziomu, zwracając dwuelementową listę zawierającą $_th element bogatej sekwencji i $_th element złej sekwencji.
• grep $_ %% *, 1..$_tworzy listę dzielników $_.
• map { grep $_ %% *, 1..$_ }, $_, .fliptworzy dwuelementową listę dzielników $_i dzielników $_z odwróconymi cyframi („odwrócone”).
• [[&c]]zmniejsza tę dwuelementową listę z funkcją komparatora &c(większą lub mniejszą), tworząc wartość logiczną wskazującą, czy ta liczba należy do bogatej sekwencji złej sekwencji.

Python 2 , 142 141 bajtów

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

Wypróbuj online!

Nierekurencyjna alternatywa (bardzo podobna do innych odpowiedzi w języku Python)

Python 2 , 143 bajty

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]

Wypróbuj online!

Python 2 , 158 153 bajtów

^{-2 bajty dzięki 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]

Wypróbuj online!

Wejście jest indeksowane na 0. Wyjścia jak poor rich.

Rubin , 128 bajtów

Dane wejściowe są indeksowane od zera . Wykazuje jako [biedny, bogaty].

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

Wyjaśnienie

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

Wypróbuj online!

Perl 6 , 76 bajtów

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

Wypróbuj online!

Nie widziałem odpowiedzi Perla 6 Seana , ale działa to w inny sposób. Zauważ, że zakodowałem górną granicę jako n*3+99, co prawdopodobnie nie jest ściśle poprawne. Jednak mogę wymienić *3z ³bez dodatkowych bajtów, które sprawiają, że program znacznie mniej efektywne, jeśli bardziej poprawne.

Python 2 , 152 bajty

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]

Wypróbuj online!

W końcu jest bardzo podobny do odpowiedzi Rod . Zwraca zerową, nubogą, bogatą krotkę.

Ikona , 180 175 bajtów

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

Wypróbuj online!

APL (Dyalog Unicode) , 34 bajty

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

Wypróbuj online!

Podziękowania dla Adama i ngn za pomoc w grze w tę potworność.

Przekroczono limit czasu TIO dla większych indeksów (które wymagają ⍳1e5lub ⍳1e6), ale przy wystarczającej ilości czasu i pamięci funkcja zakończy się poprawnie.

R , 152 137 bajtów

-12 bajtów dzięki Giuseppe -3 bajtów dzięki 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

Wypróbuj online!

Tjest obecnie wypróbowywaną liczbą całkowitą; najnowsze słabe i bogate liczby są przechowywane w wektorze F.

Najkrótszym sposobem na odwrócenie liczby całkowitej było przekonwertowanie jej na cyfry w bazie 10 za pomocą arytmetyki modułowej, a następnie konwersja z mocami 10 odwróconych, ale spodziewam się, że zostanę obezwładniony na tym i innych frontach.

Objaśnienie (poprzedniej, podobnej wersji):

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 bajtów

Wyjścia jak [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}

Wypróbuj online!

Wyjaśnienie

d(n) Funkcjonować

Ten pomocnik znajduje liczbę czynników, które ma liczba.

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

Główna funkcja

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 # (interaktywny kompilator Visual C #) , 221 bajtów

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

Wypróbuj online!