Quatre séquences entières

Dans ce défi, vous testerez quatre propriétés différentes d'un entier positif, données par les séquences suivantes. Un entier positif N est

1. parfait ( OEIS A000396 ), si la somme des diviseurs de N est égal à N . La séquence commence par 6, 28, 496, 8128, 33550336, 8589869056, 137438691328, 2305843008139952128 ...
2. refactorable ( OEIS A033950 ), si le nombre de diviseurs de N est un diviseur de N . La séquence commence par 1, 2, 8, 9, 12, 18, 24, 36, 40, 56, 60, 72, 80, 84, 88, 96, 104, 108, 128 ...
3. pratique ( OEIS A005153 ), si chaque nombre entier 1 ≤ K ≤ N est une somme de certains diviseurs distincts de N . La séquence commence par 1, 2, 4, 6, 8, 12, 16, 18, 20, 24, 28, 30, 32, 36, 40, 42, 48, 54, 56 ...
4. très composite ( OEIS A002128 ), si chaque nombre 1 ≤ K <N a strictement moins de diviseurs que N . La séquence commence par 1, 2, 4, 6, 12, 24, 36, 48, 60, 120, 180, 240, 360, 720, 840, 1260, 1680, 2520, 5040 ...

Quatre programmes

Votre tâche consiste à écrire quatre programmes (c'est-à-dire des programmes complets, des définitions de fonctions ou des fonctions anonymes qui effectuent des E / S par l'une des méthodes standard ). Chaque programme doit résoudre le problème d'appartenance à l'une de ces séquences. En d'autres termes, chaque programme prendra en entrée un entier positif N ≥ 1 et émettra une valeur vraie si N est dans la séquence et une valeur fausse sinon. Vous pouvez supposer que N est dans les limites du type entier standard de votre langage de programmation.

Les programmes doivent être liés de la manière suivante. Il y a quatre chaînes ABCDtelles que

1. AC est le programme qui reconnaît les nombres parfaits.
2. AD est le programme qui reconnaît les nombres refactorisables.
3. BC est le programme qui reconnaît les nombres pratiques.
4. BD est le programme qui reconnaît les nombres hautement composites.

Notation

Votre score est la longueur totale (en octets) des chaînes ABCD, ou en d'autres termes, le nombre total d'octets des quatre programmes divisé par deux. Le score le plus bas dans chaque langage de programmation est le gagnant. Les règles de code-golf standard s'appliquent.

Par exemple, si les quatre chaînes sont a{, b{n, +n}et =n}?, puis les quatre programmes sont a{+n}, a{=n}?, b{n+n}et b{n=n}?, et le score est de 2 + 3 + 3 + 4 = 12.

JavaScript (ES6), + 55 + 46 + 6 = 36 282 274 ... 158 143 octets

UNE:

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

RÉ:

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

Le résultat est de 4 fonctions anonymes qui donnent truthy / valeurs falsy pour leurs entrées respectives ( AC, ADet BCdonner true/ false, BDdonne 1/ 0).

Extrait de test

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>

Gelée , 8 + 17 + 2 1 + 2 = 29 28 octets

UNE:

Æṣ⁼$Ædḍ$

B:

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

C:

ƭ

RÉ:

0?

Pour les nombres pratiques (BC), 0est faux et tout autre résultat est véridique.

AC et BC sont des programmes complets, car ils ne sont pas réutilisables en tant que fonctions.

Haskell , 69 + 133 + 3 + 3 = score 208

UNE:

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

RÉ:

!!1

Essayez-le en ligne!

Oui, c'est assez bon marché mais je ne suis pas assez intelligent pour une solution plus cool. : P