甲适当除数是一个除数的数的Ñ，这是不Ñ本身。例如，12的适当除数是1、2、3、4和6。

您将得到一个整数 X，X ≥2，X≤1000。您的任务是将2到x（含）的整数的所有最高适当除数求和（OEIS A280050）。

示例（带有x = 6）：

• 找到2到6（含）之间的所有整数：2,3,4,5,6。

• 从所有数字中获取适当的除数，然后从每个数字中选择最高的除数：

  • 2-> 1
  • 3-> 1
  • 4-> 1，2
  • 5-> 1
  • 6-> 1，2，3。

• 对最高除数进行求和：1 + 1 + 2 + 1 + 3 = 8。

• 最终结果是8。

测试用例

输入| 输出量
------- + ---------
       |
 2 | 1个
 4 | 4
 6 | 8
 8 | 13
 15 | 41
 37 | 229
 100 | 1690
 1000 | 165279

规则

• 默认漏洞适用。

• 您可以通过任何标准方法获取输入并提供输出。

• 这是代码高尔夫球，每种语言中最短的有效提交者将获胜！玩得开心！

绿洲，4字节

码：

nj+U

在线尝试！

说明：

扩大的视野：

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)

外壳，7个字节

ṁȯΠtptḣ

在线尝试！

说明

Husk还没有内置可直接计算除数的内置函数（因此），因此我使用素数分解。数的最大除数是除最小数以外的其他主要因子的乘积。我将此函数映射到2到输入的范围内，并对结果求和。

ṁȯΠ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个字节

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

这很慢，甚至无法应付TIO 上的输入15。

在线尝试！

但是，备注（感谢@ musicman523）可用于验证所有测试用例。

在线尝试！

备用版本，52字节

以2个字节为代价，我们可以选择要计算f(n,k+1)还是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))

由于有些技巧，即使在TIO上，这也适用于所有测试用例。

在线尝试！

果冻，6个字节

ÆḌ€Ṫ€S

在线尝试！

怎么运行的

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

Brachylog，10个字节

⟦bb{fkt}ᵐ+

在线尝试！

JavaScript（ES6），40个字节

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>

一个数字等于其最高除数与最小素数的乘积。

05AB1E，9 8字节

-1字节感谢Leaky Nun在其Pyth答案中的主要因素技巧

L¦vyÒ¦PO

在线尝试！

说明

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

备用8字节解决方案（在TIO上不起作用）

L¦vyѨθO    

和ofc替代9字节解决方案（适用于TIO）

L¦vyѨ®èO    

视网膜，31 24字节

感谢Martin Ender提供7个字节。

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

在线尝试！

怎么运行的

正则表达式/^(1+)\1+$/捕获一元表示的一定数量的最大适当除数。在代码中，\1+转换为前瞻语法。

Mathematica，30个字节

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

Pyth，13 9 8字节

1个字节，感谢jacoblaw。

tsm*FtPh

测试套件。

怎么运行的

除最小的因子外，最大的适当除数是质因子的乘积。

Python 2（PyPy），73 71 70字节

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

这不是最短的Python答案，但这只是测试案例中的轻而易举。TIO可以处理多达30,000,000个输入而不会费力；我的台式计算机在一分钟内可以处理300,000,000。

以2个字节为代价，该条件n>d可用于〜10％的加速。

感谢@xnor的r=[0]*n想法，它节省了3个字节！

在线尝试！

Haskell，48 46 43字节

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

在线尝试！

编辑：@rogaos保存了两个字节。谢谢！

编辑II：...和@xnor另外3个字节。

Japt，8 + 2 = 10 8 6字节

òâ1 xo

测试一下

• ETHproductions节省了1个字节。

说明

    :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个字节

q:Q"@Z\l_)vs

在MATL Online上尝试

说明

        % 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字节

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

在线尝试！

Prolog（SWI），72字节

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.

在线尝试！

Cubix，27 39字节

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

在线尝试！

集中化

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

观看运行

• 0IU用一个累加器和起始整数设置堆栈。掉头进入外循环
• :(? 复制当前堆栈的顶部，递减并测试
• \pO@ 如果零在立方体周围绕到镜子，则抓住堆栈底部，输出并停止
• %\! 如果是肯定的，请修改，反映和测试。
  • u;.W 如果是真的，请掉头，移除改装结果并将车道变更回内循环
  • U;p+qu;;\(如果为假，请掉头，移除模结果，将累加器移至顶部，将当前整数（顶部）除数推入底部并掉头。清理堆栈，使之只有累加器和当前整数，减少该整数，然后再次进入外循环。

C＃（.NET Core），74 72字节

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

在线尝试！

• 多亏了Kevin Cruijssen，将2个字节减少了。

实际上，12个字节

u2x⌠÷R1@E⌡MΣ

在线尝试！

Python 3中，78个75 73 71字节

在字节数上甚至还不接近Leaky nun的python答案。

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

在线尝试！

Python 3中，69 63 59个字节

丹尼斯感谢4个字节。

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

在线尝试！

我将递归限制设置为2000，以使其能够工作1000。

木炭，37字节

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

在线尝试！

链接是详细版本。我几乎花了整整一天的时间来弄清楚如何解决“木炭”中与ASCII艺术无关的问题，但最终我明白了，我为我感到骄傲。:-D

是的，我相信这可以打很多。我刚刚翻译了我的C＃答案，并且我确信木炭可以用不同的方式完成。至少可以1000在几秒钟内解决问题。

Pari / GP，36 30字节

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

在线尝试！

Python 2（PyPy），145字节

因为将代码高尔夫球比赛转变为最快的代码比赛很有趣，所以这是一种O（n）算法，在TIO上，它可以在30秒内解决n = 5,000,000,000。（丹尼斯的筛子是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)

在线尝试！

怎么运行的

我们计算集合的大小

S = {（a，b）| 2≤ 一个 ≤ Ñ，2≤ b ≤最大-适当除数（一）}，

通过在所有素数p≤√n上将其重写为联合

小号_p = {（p ⋅ d，b）| 2≤ d ≤ Ñ / p，2≤ b ≤ d }，

并使用包含-排除原则：

| S | = ∑（−1）^{m − 1} | 小号_{p 1} ∩⋯∩ 小号_{p 米} | 在米 ≥1和素数p ₁ <⋯< p _米 ≤√N，

哪里

小号_{p 1} ∩⋯∩ 小号_{p 米} = {（p ₁ ⋯ p _米 ⋅ ë，b）| 1个≤ Ë ≤ ñ /（p ₁ ⋯ p _米），2≤ b ≤ p ₁ ⋯ p _{米 - 1} Ë }，
| 小号_{p 1} ∩⋯∩ 小号_{p 米} | =⌊ Ñ /（p ₁ ⋯ p _米）⌋⋅（p ₁ ⋯p _{米 - 1} ⋅（⌊ ñ /（p ₁ ⋯ p _米）⌋+ 1） - 2）/ 2。

之和有Ç ⋅ Ñ非零项，其中Ç收敛于某个常数这可能6⋅（1 - LN 2）/π ² ≈0.186544。最终结果是| S | + n − 1。

NewStack，5个字节

幸运的是，实际上是内置的。

Nᵢ;qΣ

细目：

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.

用实际的英语：

让我们为输入8运行一个示例。

Nᵢ：从1到8列出自然数： 1, 2, 3, 4, 5, 6, 7, 8

;：计算最大因素： 1, 1, 1, 2, 1, 3, 1, 4

q。删除第一个元素：1, 1, 2, 1, 3, 1, 4

Σ并取总和：1+1+2+1+3+1+4=13

Java 8，78 74 72字节

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

的港口 @CarlosAlejo的C＃答案的。

在这里尝试。

旧答案（78个字节）：

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

在这里尝试。

说明（旧答案）：

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个字节

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)

在线尝试！

J，18个字节

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

在线尝试！

堆叠，31字节

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

在线尝试！（除了1000个以外，所有测试用例都超过了60秒的在线时间限制。）

说明

[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个字节

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

在线尝试！

轻松地通过所有测试用例。