Einführung

In der seltsamen Welt der Ganzzahlen sind Divisoren wie Assets und sie bezeichnen Zahlen mit mehr Divisoren als deren Umkehrung als "reich", während sie Zahlen mit weniger Divisoren als deren Umkehrung als "arm" bezeichnen.

Zum Beispiel hat die Zahl fünf Teiler: , während die Umkehrung nur vier hat: . So wird eine reiche Zahl genannt, während eine arme Zahl ist.$2401$$1,7,49,343,2401$$1042$$1,2,521,1042$
$2401$$1042$

Aufgrund dieser Definition können wir die folgenden zwei ganzzahligen Folgen von reichen und armen Zahlen erstellen:

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

Anmerkungen :

• als "Umkehrung" einer Zahl meinen wir die digitale Umkehrung , dh die Umkehrung der Ziffern in der Basis 10. Dies bedeutet , dass Zahlen mit einem oder mehreren Nullen enden wird eine „kürzere“ Umkehrung: zB die Umkehrung 1900ist 0091daher91
• Wir schließen absichtlich die ganzzahligen Zahlen mit der gleichen Anzahl von Teilern wie deren Umkehrung aus, dh diejenigen, die zu OEIS gehören: A062895

Herausforderung

Unter Berücksichtigung der beiden oben definierten Sequenzen besteht Ihre Aufgabe darin, ein Programm oder eine Funktion zu schreiben, die bei einer Ganzzahl n(Sie können zwischen 0 und 1 wählen) die n-te arme und n-te reiche Zahl zurückgibt.

Eingang

• Eine Ganzzahl ( >= 0wenn 0-indiziert oder >= 11-indiziert)

Ausgabe

• 2 ganze Zahlen, eine für die arme und eine für die reiche Sequenz, in der Reihenfolge, die Sie bevorzugen, solange sie konsistent sind

Beispiele:

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

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp, verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu (z. B. TIO ).
• Außerdem wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

05AB1E , 16 Bytes

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

Probieren Sie es online!

0-indiziert [reich, arm]:

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

Vielleicht kann jemand erklären, warum diese Version nicht zu terminieren scheint, aber wenn ich bei TIO auf "Ausführung abbrechen" klicke, endet sie mit der richtigen Antwort, oder wenn Sie 60 Sekunden warten, erhalten Sie die richtige Antwort. Für eine Version, die "korrekt" endet, können Sie Folgendes verwenden: T+nL.¡ÂÑgsÑg.S}¦ζsè+3 Bytes

JavaScript (ES6),  121 115 113  111 Byte

Die Eingabe ist 1-indiziert. Ausgänge als [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)]

Probieren Sie es online!

Kommentiert

Hilfsfunktion

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

Main

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 Bytes

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

Probieren Sie es online!

$n$

Erläuterung

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

Probieren Sie es online!

Wenn die Vermutung wahr ist, funktioniert diese 140-Byte- Lösung ebenfalls

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

Probieren Sie es online!

Hier ist arm gegen reich Handlung

Perl 6 , 81 Bytes

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

Probieren Sie es online!

• * > *ist eine anonyme Funktion, die true zurückgibt, wenn das erste Argument größer als das zweite ist. Ähnliches gilt für * < *. Ersteres wählt die Nummern aus, die zur fetten Sequenz gehören, letzteres wählt die Nummern aus, die zur schlechten Sequenz gehören.
• (* > *, * < *).map(-> &c { ... }) erzeugt ein Paar unendlicher Folgen, die jeweils auf einer der Komparatorfunktionen basieren: der reichen Folge und der schlechten Folge, in dieser Reihenfolge.
• »[$_]Indiziert beide dieser Sequenzen mit $_dem Argument für die Funktion der obersten Ebene und gibt eine Liste mit zwei Elementen zurück, die das $_dritte Mitglied der reichen Sequenz und das $_dritte Mitglied der schlechten Sequenz enthält.
• grep $_ %% *, 1..$_erstellt eine Liste der Teiler von $_.
• map { grep $_ %% *, 1..$_ }, $_, .flipErzeugt eine aus zwei Elementen bestehende Liste der Teiler von $_und der Teiler von $_mit umgekehrten Ziffern ("gespiegelt").
• [[&c]]reduziert die Liste mit zwei Elementen mit der Komparatorfunktion &c(entweder größer als oder kleiner als) und erzeugt einen Booleschen Wert, der angibt, ob diese Zahl zur fetten Sequenz der schlechten Sequenz gehört.

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

Probieren Sie es online!

Nicht-rekursive Alternative (sehr ähnlich zu den anderen Python-Antworten)

Python 2 , 143 Bytes

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]

Probieren Sie es online!

Python 2 , 158 153 Bytes

^{-2 Bytes dank 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]

Probieren Sie es online!

Eingang ist 0-indiziert. Ausgänge als poor rich.

Ruby , 128 Bytes

Die Eingabe ist nullindexiert . Ausgabe als [arm, reich].

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

Erläuterung

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

Probieren Sie es online!

Perl 6 , 76 Bytes

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

Probieren Sie es online!

Ich habe Seans Perl 6-Antwort nicht gesehen , aber das funktioniert auf andere Weise. Beachten Sie, dass ich den oberen Rand als hardcodiert habe n*3+99, was wahrscheinlich nicht unbedingt korrekt ist. Allerdings konnte ich die ersetzen *3mit ³ohne zusätzliches Bytes, das das Programm weit weniger effizient machen würde, wenn mehr richtig.

Python 2 , 152 Bytes

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]

Probieren Sie es online!

Endet ziemlich ähnlich zu Rods Antwort . Gibt das narme, reiche Tupel mit dem Index Null zurück .

Icon , 180 175 Bytes

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

Probieren Sie es online!

APL (Dyalog Unicode) , 34 Byte

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

Probieren Sie es online!

Vielen Dank an Adám und ngn, die mir beim Golfspielen geholfen haben.

TIO hat eine Zeitüberschreitung für die größeren Indizes (die ⍳1e5oder erfordern ⍳1e6), aber wenn genügend Zeit und Speicher zur Verfügung stehen, wird die Funktion ordnungsgemäß beendet.

R , 152 137 Bytes

-12 Bytes dank Giuseppe -3 Bytes dank 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

Probieren Sie es online!

Tist die Ganzzahl, die gerade ausprobiert wird; Die neuesten armen und reichen Zahlen werden im Vektor gespeichert F.

Der kürzeste Weg, eine Ganzzahl umzukehren, bestand darin, sie mit modularer Arithmetik in Ziffern zur Basis 10 umzuwandeln und dann mit Potenzen von 10 invertiert zurückzuwandeln.

Erklärung (der vorherigen, ähnlichen Version):

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 Bytes

Ausgänge als [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}

Probieren Sie es online!

Erläuterung

d(n) Funktion

Dieser Helfer ermittelt die Anzahl der Faktoren, die eine Zahl hat.

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

Hauptfunktion

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

Probieren Sie es online!