四个整数序列

在此挑战中，您将测试正整数的四个不同属性，由以下序列给出。正整数N为

1. 如果N的适当除数之和等于N，则为完美（OEIS A000396）。序列以6，28，496，8128，33550336，8589869056，137438691328，2305843008139952128 ...开始
2. 如果N的除数为N的除数，则可重构（OEIS A033950）。序列以1，2，8，8，9，12，18，24，36，40，56，60，72，80，84，88，96，104，108，128 ...开始
3. 实际（OEIS A005153）中，如果每个整数1≤ķ≤Ñ是一些不同的除数的总和Ñ。序列以1，2，4，4，6，12，12，18，20，24，28，30，32，36，40，42，48，54，56 ...开始
4. 如果每个数字1≤K <N的除数严格小于N，则为高度复合（OEIS A002128）。该序列以1、2、4、6、12、24、36、48、60、120、180、240、360、720、840、1260、1680、2520、5040开头。

四个程序

您的任务是编写四个程序（表示完整程序，函数定义或通过任何标准方法执行I / O的匿名函数）。每个程序应解决这些序列之一的成员资格问题。换句话说，每个程序将以N≥1的正整数作为输入，如果N在序列中，则输出真实值；否则，输出虚假值。您可以假定N在编程语言的标准整数类型的范围内。

程序必须以以下方式关联。有四根弦ABCD，使得

1. AC 是识别完美数字的程序。
2. AD 是识别可重构数字的程序。
3. BC 是识别实际数字的程序。
4. BD 是识别高度合成数字的程序。

计分

您的分数是字符串的总长度（以字节为单位）ABCD，或者换句话说，是四个程序的总字节数除以2。每种编程语言中得分最低的是获胜者。适用标准代码高尔夫球规则。

例如，如果四个字符串是a{，b{n，+n}和=n}?，然后将四个节目是a{+n}，a{=n}?，b{n+n}和b{n=n}?，比分是2 + 3 + 3 + 4 = 12。

的JavaScript（ES6），46 + 55 + 6 + 36 = 282 274 ... 158个 143字节

A：

n=>(r=0,D=x=>x&&D(x-1,n%x||(r++?q-=x:q=n)))(n)

B：

n=>(q=(g=D=x=>x&&!(n%x||(g|=m>2*(m=x),0))+D(x-1))(m=n))

C：

?!g:!q

D：

?(P=k=>--k?D(n=k)<q&P(k):1)(n):n%r<1

结果是4个匿名功能这给truthy /对各自的输入端falsy值（AC，AD，和BC给予true/ false，BD给出1/ 0）。

测试片段

let AC =
n=>(r=0,D=x=>x&&D(x-1,n%x||(r++?q-=x:q=n)))(n)
?!g:!q

let AD =
n=>(r=0,D=x=>x&&D(x-1,n%x||(r++?q-=x:q=n)))(n)
?(P=k=>--k?D(n=k)<q&P(k):1)(n):n%r<1

let BC =
n=>(q=(g=D=x=>x&&!(n%x||(g|=m>2*(m=x),0))+D(x-1))(m=n))
?!g:!q

let BD =
n=>(q=(g=D=x=>x&&!(n%x||(g|=m>2*(m=x),0))+D(x-1))(m=n))
?(P=k=>--k?D(n=k)<q&P(k):1)(n):n%r<1

let update = n => O.innerText = [
  'perfect: ' + AC(n),
  'refactorable: ' + AD(n),
  'practical: ' + BC(n),
  'highly composite: ' + BD(n)
].join("\n")

<input type=number value=1 min=1 oninput=update(this.value)>
<pre id=O></pre>

果冻，8 + 17 + 2 1 + 2 = 29 28字节

A：

Æṣ⁼$Ædḍ$

B：

ÆDŒPS€QṢwRµṖÆdṀ<Ʋ

C：

ƭ

D：

0?

对于实际数字（BC），0是虚假的，其他任何结果都是真实的。

AC和BC是完整程序，因为它们不能作为功能重复使用。

Haskell，69 + 133 + 3 + 3 =得分208

A：

d n=filter((<1).mod n)[1..n]
f n=[sum(d n)-n==n,length(d n)`elem`d n]

B：

import Data.List
d n=filter((<1).mod n)[1..n]
f n=[all(\n->any(==n)$sum$subsequences$d n)[1..n],all((<length(d n)).length.d)[1..n-1]]

C：

!!0

D：

!!1

在线尝试！

是的，它很便宜，但我还不够聪明，无法使用更酷的解决方案。：P