Un diviseur propre est un diviseur d'un nombre n , qui n'est pas n lui-même. Par exemple, les diviseurs appropriés de 12 sont 1, 2, 3, 4 et 6.

Vous recevrez un entier x , x ≥ 2, x ≤ 1000 . Votre tâche consiste à additionner tous les diviseurs propres les plus élevés des nombres entiers de 2 à x (inclus) (OEIS A280050 ).

Exemple (avec x = 6):

• Trouver tous les entiers entre 2 et 6 (inclus): 2,3,4,5,6.

• Obtenez les diviseurs appropriés de chacun d'eux, et choisissez les plus élevés de chaque nombre:

  • 2 -> 1
  • 3 -> 1
  • 4 -> 1, 2
  • 5 -> 1
  • 6 -> 1, 2, 3 .

• Additionner les plus diviseurs: 1 + 1 + 2 + 1 + 3 = 8.

• Le résultat final est 8.

Cas de test

Entrée | Production
------- + ---------
       |
 2 | 1
 4 | 4
 6 | 8
 8 | 13
 15 | 41
 37 | 229
 100 | 1690
 1000 | 165279

Règles

• Les échappatoires par défaut s'appliquent.

• Vous pouvez prendre des entrées et fournir des sorties par n'importe quelle méthode standard .

• C'est le code-golf , la soumission valide la plus courte dans chaque langue gagne! S'amuser!

Oasis , 4 octets

Code:

nj+U

Essayez-le en ligne!

Explication:

Version étendue:

nj+00

    0   = a(0)
   0    = a(1)

a(n) =

n       # Push n
 j      # Get the largest divisor under n
  +     # Add to a(n - 1)

Husk , 7 octets

ṁȯΠtptḣ

Essayez-le en ligne!

Explication

Husk n'a pas encore intégré de calcul direct des diviseurs, donc j'utilise plutôt la factorisation principale. Le plus grand diviseur propre d'un nombre est le produit de ses facteurs premiers, à l'exception du plus petit. Je mappe cette fonction sur une plage de 2 à l'entrée et je résume les résultats.

ṁȯΠtptḣ  Define a function:
      ḣ  Range from 1 to input.
     t   Remove the first element (range from 2).
ṁ        Map over the list and take sum:
 ȯ        The composition of
    p     prime factorization,
   t      tail (remove smallest prime) and
  Π       product.

Python 2 , 50 octets

f=lambda n,k=2:n/k and(f(n,k+1),n/k+f(n-1))[n%k<1]

C'est lent et ne peut même pas faire face à l'entrée 15 sur TIO.

Essayez-le en ligne!

Cependant, la mémorisation ( merci @ musicman523 ) peut être utilisée pour vérifier tous les cas de test.

Essayez-le en ligne!

Version alternative, 52 octets

Au prix de 2 octets, nous pouvons choisir de calculer f(n,k+1)ou n/k+f(n-1).

f=lambda n,k=2:n>1and(n%k and f(n,k+1)or n/k+f(n-1))

Avec quelques astuces, cela fonctionne pour tous les cas de test, même sur TIO.

Essayez-le en ligne!

Gelée , 6 octets

ÆḌ€Ṫ€S

Essayez-le en ligne!

Comment ça fonctionne

ÆḌ€Ṫ€S
ÆḌ€    map proper divisor (1 would become empty array)
           implicitly turns argument into 1-indexed range
   Ṫ€  map last element
     S sum

Brachylog , 10 octets

⟦bb{fkt}ᵐ+

Essayez-le en ligne!

JavaScript (ES6), 40 octets

f=(n,i=2)=>n<2?0:n%i?f(n,i+1):n/i+f(n-1)

<input type=number oninput=o.textContent=f(this.value)><pre id=o>

Un nombre est égal au produit de son diviseur propre le plus élevé et de son plus petit facteur premier.

05AB1E , 9 8 octets

-1 octet grâce à l' astuce facteur principal de Leaky Nun dans sa réponse Pyth

L¦vyÒ¦PO

Essayez-le en ligne!

Explication

L¦vyÒ¦PO
L¦       # Range [2 .. input]
  vy     # For each...
    Ò¦    # All prime factors except the first one
      P   # Product
       O  # Sum with previous results
         # Implicit print

Solution alternative à 8 octets (qui ne fonctionne pas sur TIO)

L¦vyѨθO    

et ofc alternative 9 octets solution (qui fonctionne sur TIO)

L¦vyѨ®èO    

Rétine , 31 24 octets

7 octets grâce à Martin Ender.

.+
$*
M!&`(1+)(?=\1+$)
1

Essayez-le en ligne!

Comment ça fonctionne

Le regex /^(1+)\1+$/capture le plus grand diviseur propre d'un certain nombre représenté en unaire. Dans le code, le \1+est transformé en une syntaxe d'anticipation.

Mathematica, 30 octets

Divisors[i][[-2]]~Sum~{i,2,#}&

Pyth , 13 9 8 octets

1 octet grâce à jacoblaw.

tsm*FtPh

Suite de tests .

Comment ça fonctionne

Le plus grand diviseur propre est le produit des facteurs premiers sauf le plus petit.

Python 2 (PyPy) , 73 71 70 octets

n=input();r=[0]*n;d=1
while n:n-=1;r[d+d::d]=n/d*[d];d+=1
print sum(r)

Pas la réponse Python la plus courte, mais cela passe simplement par les cas de test. TIO gère les entrées jusqu'à 30 000 000 sans transpirer; mon ordinateur de bureau gère 300 000 000 en une minute.

Au prix de 2 octets , la condition n>dpourrait être utilisée pour une accélération de ~ 10%.

Merci à @xnor pour l' r=[0]*nidée, qui a économisé 3 octets!

Essayez-le en ligne!

Haskell, 48 46 43 octets

f 2=1
f n=until((<1).mod n)pred(n-1)+f(n-1)

Essayez-le en ligne!

Modifier: @rogaos a enregistré deux octets. Merci!

Edit II: ... et @xnor 3 autres octets.

Japt , 8 + 2 = 10 8 6 octets

òâ1 xo

Essaye-le

• 1 octet économisé grâce à ETHproductions.

Explication

    :Implicit input of integer U.
ò   :Generate an array of integers from 1 to U, inclusive
â   :Get the divisors of each number,
1   :  excluding itself.
x   :Sum the main array
o   :by popping the last element from each sub-array.
    :Implicit output of result

MATL, 12 octets

q:Q"@Z\l_)vs

Essayez-le sur MATL Online

Explication

        % Implicitly grab input (N)
q       % Subtract one
:       % Create an array [1...(N-1)]
Q       % Add one to create [2...N]
"       % For each element
  @Z\   % Compute the divisors of this element (including itself)
  l_)   % Grab the next to last element (the largest that isn't itself)
  v     % Vertically concatenate the entire stack so far
  s     % Sum the result

PHP , 56 octets

for($i=1;$v||$argn>=$v=++$i;)$i%--$v?:$v=!$s+=$v;echo$s;

Essayez-le en ligne!

Prolog (SWI) , 72 octets

f(A,B):-A=2,B=1;C is A-1,f(C,D),between(2,A,E),divmod(A,E,S,0),B is D+S.

Essayez-le en ligne!

Cubix , 27 39 octets

?%\(W!:.U0IU(;u;p+qu.@Op\;;

Essayez-le en ligne!

Cubifié

      ? % \
      ( W !
      : . U
0 I U ( ; u ; p + q u .
@ O p \ ; ; . . . . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

Regardez-le courir

• 0IUConfigurez la pile avec un accumulateur et l'entier de départ. Demi-tour dans la boucle extérieure
• :(? dupliquer le haut actuel de la pile, décrémenter et tester
• \pO@ si zéro boucle autour du cube vers un miroir, saisissez le bas de la pile, sortez et arrêtez
• %\! si positif, modifiez, relectez et testez.
  • u;.W si véridique, demi-tour, supprimez le résultat du mod et changez de voie dans la boucle intérieure
  • U;p+qu;;\(si falsey, demi-tour, supprimer le résultat du mod, amener l'accumulateur en haut, ajouter le diviseur entier actuel (haut) pousser en bas et demi-tour. Nettoyez la pile pour n'avoir que l'accumulateur et l'entier actuel, décrémentez l'entier et entrez à nouveau dans la boucle externe.

C # (.NET Core) , 74 72 octets

n=>{int r=0,j;for(;n>1;n--)for(j=n;--j>0;)if(n%j<1){r+=j;j=0;}return r;}

Essayez-le en ligne!

• 2 octets rasés grâce à Kevin Cruijssen.

En fait , 12 octets

u2x⌠÷R1@E⌡MΣ

Essayez-le en ligne!

Python 3 , 78 75 73 71 octets

Pas même proche de la réponse de Leaky nun en python en nombre d'octets.

f=lambda z:sum(max(i for i in range(1,y)if 1>y%i)for y in range(2,z+1))

Essayez-le en ligne!

Python 3 , 69 63 59 octets

4 octets grâce à Dennis.

f=lambda n:n-1and max(j for j in range(1,n)if n%j<1)+f(n-1)

Essayez-le en ligne!

J'ai défini la limite de récursivité à 2000 pour que cela fonctionne pour 1000.

Fusain , 37 octets

Ａ⁰βＦ…·²Ｎ«Ａ⟦⟧δＦ⮌…¹ι«¿¬﹪ικ⊞δκ»Ａ⁺β⌈δβ»Ｉβ

Essayez-le en ligne!

Le lien est vers la version détaillée. Il m'a fallu presque toute la journée pour trouver comment résoudre une question non liée à l'art ASCII dans Charcoal, mais j'ai finalement compris et je suis très fier de moi. :-RÉ

Oui, je suis sûr que cela peut être joué beaucoup. Je viens de traduire ma réponse C # et je suis sûr que les choses peuvent être faites différemment dans Charcoal. Au moins, cela résout l' 1000affaire en quelques secondes ...

Pari / GP , 36 30 octets

n->sum(i=2,n,i/divisors(i)[2])

Essayez-le en ligne!

Python 2 (PyPy) , 145 octets

Parce que transformer des compétitions de code-golf en compétitions de code les plus rapides est amusant, voici un algorithme O ( n ) qui, sur TIO, résout n = 5 000 000 000 en 30 secondes. ( Le tamis de Dennis est O ( n log n ).)

import sympy
n=input()
def g(i,p,k,s):
 while p*max(p,k)<=n:l=k*p;i+=1;p=sympy.sieve[i];s-=g(i,p,l,n/l*(n/l*k+k-2)/2)
 return s
print~g(1,2,1,-n)

Essayez-le en ligne!

Comment ça fonctionne

Nous comptons la taille de l'ensemble

S = {( a , b ) | 2 ≤ a ≤ n , 2 ≤ b ≤ le plus grand diviseur propre ( a )},

en le réécrivant comme l'union, sur tous les nombres premiers p ≤ √n, de

S _p = {( p ⋅ d , b ) | 2 ≤ d ≤ n / p , 2 ≤ b ≤ d },

et en utilisant le principe d'inclusion-exclusion :

| S | = ∑ (−1) ^{m - 1} | S _{p 1} ∩ ⋯ ∩ S _{p m} | sur m ≥ 1 et les nombres premiers p ₁ <⋯ < p _m ≤ √n,

où

S _{p 1} ∩ ⋯ ∩ S _{p m} = {( p ₁ ⋯ p _m ⋅ e , b ) | 1 ≤ e ≤ n / ( p ₁ ⋯ p _m ), 2 ≤ b ≤ p ₁ ⋯ p _{m - 1} e },
| S _{p 1} ∩ ⋯ ∩ S _{p m} | = ⌊ n / ( p ₁ ⋯ p _m ) ⌋⋅ ( p ₁ ⋯p _{m - 1} ⋅ (⌊ n / ( p ₁ ⋯ p _m ) ⌋ + 1) - 2) / 2.

La somme a C ⋅ n termes non nuls, où C converge vers une constante qui est probablement 6⋅ (1 - ln 2) / π ² ≈ 0,186544. Le résultat final est alors | S | + n - 1.

NewStack , 5 octets

Heureusement, il y a en fait un système intégré.

Nᵢ;qΣ

La panne:

Nᵢ       Add the first (user's input) natural numbers to the stack.
  ;      Perform the highest factor operator on whole stack.
   q     Pop bottom of stack.
    Σ    Sum stack.

En anglais réel:

Exécutons un exemple pour une entrée de 8.

Nᵢ: Faites la liste des nombres naturels de 1 à 8: 1, 2, 3, 4, 5, 6, 7, 8

;: Calculez les plus grands facteurs: 1, 1, 1, 2, 1, 3, 1, 4

q. Supprimez le premier élément:1, 1, 2, 1, 3, 1, 4

ΣEt prenez la somme: 1+1+2+1+3+1+4=13

Java 8, 78 74 72 octets

n->{int r=0,j;for(;n>1;n--)for(j=n;j-->1;)if(n%j<1){r+=j;j=0;}return r;}

Port de la réponse C # de @CarlosAlejo .

Essayez-le ici.

Ancienne réponse (78 octets):

n->{int r=0,i=1,j,k;for(;++i<=n;r+=k)for(j=1,k=1;++j<i;k=i%j<1?j:k);return r;}

Essayez-le ici.

Explication (de l'ancienne réponse):

n->{                    // Method with integer parameter and integer return-type
  int r=0,              //  Result-integers
      i=1,j,k;          //  Some temp integers
  for(;++i<=n;          //  Loop (1) from 2 to `n` (inclusive)
      r+=k)             //    And add `k` to the result after every iteration
    for(j=1,k=1;++j<i;  //   Inner loop (2) from `2` to `i` (exclusive)
      k=i%j<1?j:k       //    If `i` is dividable by `j`, replace `k` with `j`
    );                  //   End of inner loop (2)
                        //  End of loop (2) (implicit / single-line body)
  return r;             //  Return result-integer
}                       // End of method

Lua , 74 octets

c=0 for i=2,...do for j=1,i-1 do t=i%j<1 and j or t end c=c+t end print(c)

Essayez-le en ligne!

J , 18 octets

[:+/1}.&.q:@+}.@i.

Essayez-le en ligne!

Empilé , 31 octets

[2\|>[divisors:pop\MAX]map sum]

Essayez-le en ligne! (Tous les tests, sauf 1000, qui dépasse le délai de 60 secondes en ligne.)

Explication

[2\|>[divisors:pop\MAX]map sum]
 2\|>                               range from 2 to the input inclusive
     [                ]map          map this function over the range
      divisors                      get the divisors of the number (including the number)
              :pop\                 pop a number off the array and swap it with the array
                   MAX              gets the maximum value from the array
                           sum      sum's all the max's

C (gcc) , 53 octets

x;s;f(n){for(s=0;n>1;--n){for(x=n;n%--x;);s+=x;}n=s;}

Essayez-le en ligne!

Confortablement et passe rapidement tous les cas de test.