Contexte

Une paire Ruth-Aaron est une paire d'entiers positifs consécutifs net n+1telle que la somme des facteurs premiers (en comptant les facteurs premiers répétés) de chaque entier est égale. Par exemple, (714,715)une paire Ruth-Aaron, depuis 714=2*3*7*17, 715=5*11*13et 2+3+7+17=5+11+13=29. Le nom de la paire Ruth-Aaron a été choisi par Carl Pomerance en référence au total de circuits en carrière de Babe Ruth714 , qui a battu le record du monde du 25 mai 1935 au 8 avril 1974, date à laquelle Hank Aaron a frappé son 715cinquième circuit. Vous pouvez en apprendre plus sur l'histoire fascinante de ces chiffres dans cette vidéo Numberphile .

Objectif

Écrivez un programme ou une fonction complète qui, étant donné un entier positif n, sort le nnombre Aaron, où le nnombre est défini comme étant le plus grand entier de la npaire Ruth-Aaron. Ainsi, le ne nombre d'Aaron est a(n)+1, où a(n)est le ne terme dans la séquence OEIS A039752 .

Cas de test

Les premiers chiffres d'Aaron sont

6,9,16,78,126,715,949,1331,1521,1863,2492,3249,4186,4192,5406,5561,5960,6868,8281,8464,10648,12352,14588,16933,17081,18491,20451,24896,26643,26650,28449,28810,33020,37829,37882,41262,42625,43216

Règles

• Les failles standard sont interdites.

• L'entrée et la sortie peuvent être dans n'importe quel format pratique.

• C'est le code-golf , la réponse la plus courte (en octets) l'emporte.

05AB1E , 11 10 9 octets

-1 octet grâce à Emigna
-1 octet grâce à Adnan

µN>Ð<‚ÒOË

Explication:

µ            While the counter variable (which starts at 0) is not equal to the input:
 N>          Store the current iteration index + 1, and then create an array with
   Ð<‚       [current iteration index + 1, current iteration index]
      ÒO     Get the sum of the prime factors of each element
        Ë    If all elements in the array are equal,
             implicitly increment the counter variable

1 indexé.

Essayez-le en ligne!

Husk , 11 9 octets

-2 octets grâce à un golf intelligent de @Leo

€∫Ẋ¤=oΣpN

Essayez-le en ligne!

Explication

  Ẋ     N   -- map function over all consecutive pairs ... of natural numbers           [(1,2),(2,3),(3,4),(4,5)...]
   ¤=       --   are the results of the following function equal for both in the pair?
     oΣp    --     sum of prime factors                                                   [0,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0]
 ∫          -- cumulative sum                                                           [0,0,0,0,0,1,1,1,2,2,2,2,2,2,2,3,3,3,3,3]                
€           -- the index of the first value equal to the input

Pyth , 23 20 octets

Ceci est indexé 1.

WhQ=-QqsPZsPhZ=+Z1;Z

Testez la suite ou essayez-la en ligne!

Explication

WhQ = -QqsPZsPhZ = + Z1; Z - Programme complet. Prend l'entrée de l'entrée standard.

WhQ - Alors que Q est toujours supérieur à 0.
       sPZ - Somme des facteurs premiers de Z.
          sPhZ - Somme des facteurs premiers de Z + 1.
      q - Si les éléments ci-dessus sont égaux:
   = -Q - Décrémente Q de 1 si elles sont égales et de 0 si elles ne le sont pas.
              = + Z1; - Incrémentez Z à chaque itération.
                   Z - Sortie Z. 

Gelée , 12 octets

;‘ÆfS€Eµ⁸#Ṫ‘

Un lien monadique prenant et renvoyant des nombres non négatifs

Essayez-le en ligne!

Comment?

;‘ÆfS€Eµ⁸#Ṫ‘ - Link: number, n
         #   - n-find (counting up, say with i, from implicit 1)
        ⁸    - ...number of matches to find: chain's left argument, n
       µ     - ...action: the monadic chain with argument i:
 ‘           -   increment = i+1
;            -   concatenate = [i,i+1]
  Æf         -   prime factors (with duplicates, vectorises)
    S€       -   sum €ach
      E      -   all (two of them) equal?
          Ṫ  - tail, the last matching (hence nth) i
           ‘ - increment (need to return i+1)

PHP, 93 92 91 + 1 octets

while(2+$argn-=$a==$b)for($b=$a,$a=!$x=$n+=$k=1;$k++<$x;)for(;$x%$k<1;$x/=$k)$a+=$k;echo$n;

Exécuter en tant que pipe avec -nRou l' essayer en ligne .

-2 octets avec 3 indexés (premier nombre Aaron pour argument 3): supprimer 2+.

panne

while(2+$argn       # loop until argument reaches -2 (0 and 1 are false positives)
    -=$a==$b)           # 0. if factors sum equals previous, decrement argument
    for($b=$a,          # 1. remember factors sum
        $a=!            # 3. reset factors sum $a
        $x=$n+=         # 2. pre-increment $n and copy to $x
        $k=1;$k++<$x;)  # 4. loop $k from 2 to $x
        for(;$x%$k<1;       # while $k divides $x
            $x/=$k)             # 2. and divide $x by $k
            $a+=$k;             # 1. add $k to factors sum
echo$n;             # print Aaron number $n

MATL , 17 octets

`@:"@Yfs]vd~sG<}@

1 basé. Très lent.

Essayez-le en ligne!

Explication

`        % Do...while
  @      %   Push iteration index k, starting at 1
  :      %   Range [1 2 ... k]
  "      %   For each j in [1 2 ... k]
    @    %     Push j
    Yf   %     Row vector of prime factors
    s    %     Sum
  ]      %   End
  v      %   Concatenate whole stack into a column vector
  d      %   Consecutive differences. A zero indicates a Ruth-Aaron pair
  ~s     %   Number of zeros
  G<     %   Is it less than the input? If so: next k. Else: exit loop
}        % Finally (execute right before when the loop is exited)
  @      %   Push current k
         % Implicit end. Implicit display

Mathematica, 97 octets

(t=r=1;While[t<=#,If[SameQ@@(Plus@@((#&@@# #[[2]])&/@FactorInteger@#)&/@{#,#+1}&@r),t++];r++];r)&

Essayez-le en ligne!

Pyth, 12 11 octets

e.fqsPtZsPZ

L'indexation à partir de 1 supprime un octet et place Pyth avant Jelly

Explication

e.fqsPtZsPZ - Programme complet. Prend l'entrée de l'entrée standard.

ef - Dernier élément de la liste des premiers numéros d'entrée $ pour lesquels
   q - Sont égaux 
    ss - La somme de
     PtZ PZ - Facteurs premiers de $ nombre-1 et $ nombre

Gelée , 17 octets

ÆfS=’ÆfS$$µ³‘¤#ṖṪ

Essayez-le en ligne!

Explication

ÆfS=’ÆfS$$µ³‘¤#ṖṪ  Main link, argument is z
              #    Find the first       elements that satisfy condition y: <y><z>#
           ³‘¤                    z + 1
          µ        Monadic link, where the condition is:
  S                The sum of
Æf                            the array of primes that multiply to the number
   =               equals
       S           The sum of
     Æf                       the prime factors of
    ’                                              the number before it
        $$         Last two links as a monad, twice
               Ṗ   k -> k[:-1]
                Ṫ  Last element (combined with `pop`, gets the second last element)

1 indexé

Rubis , 89 86 octets

->n{(1..1/s=0.0).find{|x|r,c=2,0
0while x%r<1?(x/=r;c+=r):x>=r+=1
(c==s)?0>n-=1:!s=c}}

Essayez-le en ligne!

Japt , 19 octets

1+_°k x ¥Zk x «U´}a

Utilise l'indexation 1.

Essayez-le en ligne!

Python 2 , 119104102101 octets

f=lambda n,k=2:n/k and(f(n,k+1),k+f(n/k))[n%k<1]
i=input();g=0
while-~i:i-=f(g)==f(g+1);g+=1
print(g)

Essayez-le en ligne!

-17 octets grâce à @ovs!

-1 octet grâce à @notjagan

Le mérite revient à Dennis pour l'algorithme de factorisation premier. 1 indexé.

Remarque: Ceci est extrêmement lent et inefficace. Les entrées supérieures à 7 planteront à moins que vous ne les définissiez import syset le fassiez sys.setrecursionlimit(100000), mais cela fonctionne en théorie.