Quatro seqüências inteiras

Neste desafio, você testará quatro propriedades diferentes de um número inteiro positivo, dadas pelas seguintes seqüências. Um número inteiro positivo N é

1. perfeito ( OEIS A000396 ), se a soma dos divisores próprios de N é igual a N . A sequência começa com 6, 28, 496, 8128, 33550336, 8589869056, 137438691328, 2305843008139952128 ...
2. refactorable ( OEIS A033950 ), se o número de divisores de N é um divisor de N . A sequência começa com 1, 2, 8, 9, 12, 18, 24, 36, 40, 56, 60, 72, 80, 84, 88, 96, 104, 108, 128 ...
3. prático ( OEIS A005153 ), se cada inteiro 1 ≤ K ≤ N é uma soma de alguns divisores distintos de N . A sequência começa com 1, 2, 4, 6, 8, 12, 16, 18, 20, 24, 28, 30, 32, 36, 40, 42, 48, 54, 56 ...
4. altamente compósito ( OEIS A002128 ), se cada número 1 ≤ K <N tem estritamente menos divisores do que N . A sequência começa com 1, 2, 4, 6, 12, 24, 36, 48, 60, 120, 180, 240, 360, 720, 840, 1260, 1680, 2520, 5040 ...

Quatro programas

Sua tarefa é escrever quatro programas (ou seja, programas completos, definições de funções ou funções anônimas que executam E / S por qualquer um dos métodos padrão ). Cada programa deve resolver o problema de associação de uma dessas seqüências. Em outras palavras, cada programa terá um número inteiro positivo N ≥ 1 como entrada e emitirá um valor verdadeiro se N estiver na sequência e um valor falso se não estiver. Você pode supor que N esteja dentro dos limites do tipo inteiro padrão da sua linguagem de programação.

Os programas devem estar relacionados da seguinte maneira. Existem quatro seqüências de caracteres ABCDque

1. AC é o programa que reconhece números perfeitos.
2. AD é o programa que reconhece números refatoráveis.
3. BC é o programa que reconhece números práticos.
4. BD é o programa que reconhece números altamente compostos.

Pontuação

Sua pontuação é o comprimento total (em bytes) das seqüências de caracteres ABCD, ou seja, a contagem total de bytes dos quatro programas divididos por dois. A pontuação mais baixa em cada linguagem de programação é a vencedora. Aplicam-se as regras padrão de código de golfe .

Por exemplo, se as quatro cordas são a{, b{n, +n}e =n}?, em seguida, os quatro programas são a{+n}, a{=n}?, b{n+n}e b{n=n}?, e o marcador é 2 + 3 + 3 + 4 = 12.

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

UMA:

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

O resultado é 4 funções anónimos que dão truthy / Falsas valores para as respectivas entradas ( AC, AD, e BCdar true/ false, BDdá 1/ 0).

Snippet de teste

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éia , 8 + 17 + 2 1 + 2 = 29 28 bytes

UMA:

Æṣ⁼$Ædḍ$

B:

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

C:

ƭ

D:

0?

Para números práticos (BC), 0é falso e qualquer outro resultado é verdadeiro.

AC e BC são programas completos, pois não são reutilizáveis ​​como funções.

Haskell , 69 + 133 + 3 + 3 = pontuação 208

UMA:

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

Experimente online!

Sim, é bem barato, mas não sou inteligente o suficiente para uma solução mais legal. : P