introduction

Dans le monde étrange des nombres entiers, les diviseurs sont comme des actifs et ils utilisent pour appeler "riches" les nombres ayant plus de diviseurs que leur inversion, alors qu'ils appellent "pauvres" ceux qui ont moins de diviseurs que leur inversion.

Par exemple, le nombre a cinq diviseurs: , tandis que son renversement, , n'en a que quatre: . Ainsi, est appelé un nombre riche , tandis que un nombre pauvre .$2401$$1,7,49,343,2401$$1042$$1,2,521,1042$
$2401$1042$1042$

Compte tenu de cette définition, nous pouvons créer les deux séquences entières suivantes de nombres riches et pauvres:

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

Remarques :

• par "inversion" d'un nombre, nous entendons son inverse numérique , c'est-à-dire que ses chiffres en base 10 sont inversés. Cela signifie que les nombres se terminant par un ou plusieurs zéros auront une inversion "plus courte": par exemple, l'inversion de 1900est 0091donc91
• nous excluons intentionnellement les nombres entiers ayant le même nombre de diviseurs que leur inversion c'est-à-dire ceux appartenant à OEIS: A062895

Défi

Compte tenu des deux séquences définies ci-dessus, votre tâche consiste à écrire un programme ou une fonction qui, étant donné un entier n(vous pouvez choisir 0 ou 1 indexé), renvoie le nième nombre pauvre et le nième nombre riche.

Contribution

• Un nombre entier ( >= 0si indexé 0 ou >= 1si indexé 1)

Production

• 2 entiers, un pour la séquence pauvre et un pour la séquence riche, dans l'ordre que vous préférez tant qu'il est cohérent

Exemples :

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

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse avec des règles d'E / S par défaut , vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code (par exemple TIO ).
• De plus, l'ajout d'une explication à votre réponse est fortement recommandé.

05AB1E , 16 octets

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

Essayez-le en ligne!

0 indexé [riche, pauvre]:

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

Peut-être que quelqu'un peut expliquer pourquoi cette version ne semble pas se terminer, mais lorsque je clique sur "annuler l'exécution" sur TIO, elle se termine par la bonne réponse, ou si vous attendez 60 secondes, vous obtenez la bonne réponse. Pour une version qui se termine "correctement", vous pouvez utiliser: T+nL.¡ÂÑgsÑg.S}¦ζsè+3 octets

JavaScript (ES6),  121 115 113  111 octets

L'entrée est indexée sur 1. Sorties comme [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)]

Essayez-le en ligne!

Commenté

Fonction d'assistance

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

Principale

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)

Gelée , 22 octets

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

Essayez-le en ligne!

$n$

Explication

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

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

Essayez-le en ligne!

Si la conjecture est vraie, cette solution de 140 octets fonctionne également

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

Essayez-le en ligne!

Voici l' intrigue pauvre vs riche

Perl 6 , 81 octets

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

Essayez-le en ligne!

• * > *est une fonction anonyme qui renvoie true si son premier argument est supérieur au second. De même pour * < *. Les premiers sélectionneront les nombres qui appartiennent à la séquence riche, les seconds sélectionneront ceux qui appartiennent à la séquence pauvre.
• (* > *, * < *).map(-> &c { ... }) produit une paire de séquences infinies, chacune basée sur l'une des fonctions de comparaison: la séquence riche et la séquence pauvre, dans cet ordre.
• »[$_]indexe dans ces deux séquences à l'aide de $_l'argument de la fonction de niveau supérieur, renvoyant une liste à deux éléments contenant le $_e membre de la séquence riche et le $_e membre de la séquence pauvre.
• grep $_ %% *, 1..$_produit une liste des diviseurs de $_.
• map { grep $_ %% *, 1..$_ }, $_, .flipproduit une liste à deux éléments des diviseurs de $_, et les diviseurs de $_avec ses chiffres inversés ("inversés").
• [[&c]]réduit cette liste à deux éléments avec la fonction de comparaison &c(supérieure ou inférieure à), produisant une valeur booléenne indiquant si ce nombre appartient à la séquence riche de la séquence pauvre.

Python 2 , 142 141 octets

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

Essayez-le en ligne!

Alternative non récursive (très similaire aux autres réponses Python)

Python 2 , 143 octets

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]

Essayez-le en ligne!

Python 2 , 158 153 octets

^{-2 octets grâce à 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]

Essayez-le en ligne!

L'entrée est indexée 0. Sorties comme poor rich.

Rubis , 128 octets

L'entrée est indexée zéro . Sorties comme [pauvres, riches].

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

Explication

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

Essayez-le en ligne!

Perl 6 , 76 octets

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

Essayez-le en ligne!

Je n'ai pas vu la réponse Perl 6 de Sean , mais cela fonctionne d'une manière différente. Notez que j'ai codé en dur la limite supérieure en tant que n*3+99, ce qui n'est probablement pas strictement correct. Cependant, je pourrais remplacer *3avec ³pour aucun octets supplémentaires, ce qui rendrait le programme beaucoup moins efficace, si plus correct.

Python 2 , 152 octets

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]

Essayez-le en ligne!

Finit par être assez similaire à la réponse de Rod . Renvoie un ntuple pauvre et riche indexé sur zéro .

Icône , 180 175 octets

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

Essayez-le en ligne!

APL (Dyalog Unicode) , 34 octets

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

Essayez-le en ligne!

Merci à Adám et ngn de m'avoir aidé à jouer au golf cette monstruosité.

TIO expire pour les plus gros indices (qui nécessitent ⍳1e5ou ⍳1e6), mais avec suffisamment de temps et de mémoire, la fonction se terminera correctement.

R , 152 137 octets

-12 octets grâce à Giuseppe -3 octets grâce à 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

Essayez-le en ligne!

Test l'entier actuellement en cours d'essai; les derniers nombres pauvres et riches sont stockés dans le vecteur F.

La façon la plus courte que j'ai pu trouver pour inverser un entier était de le convertir en chiffres en base 10 avec une arithmétique modulaire, puis de reconvertir avec des puissances de 10 inversées, mais je m'attends à être dépassé sur ce front et sur d'autres.

Explication (de la précédente version similaire):

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 octets

Sorties comme [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}

Essayez-le en ligne!

Explication

d(n) Une fonction

Cet assistant trouve le nombre de facteurs dont dispose un nombre.

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

Fonction principale

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 octets

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

Essayez-le en ligne!