Quattro sequenze di numeri interi

In questa sfida, testerai quattro diverse proprietà di un numero intero positivo, dato dalle seguenti sequenze. Un numero intero positivo N è

1. perfetto ( OEIS A000396 ), se la somma dei divisori propri di N è uguale a N . La sequenza inizia con 6, 28, 496, 8128, 33550336, 8589869056, 137438691328, 2305843008139952128 ...
2. refactorable ( OEIS A033950 ), se il numero di divisori di N è un divisore di N . La sequenza inizia con 1, 2, 8, 9, 12, 18, 24, 36, 40, 56, 60, 72, 80, 84, 88, 96, 104, 108, 128 ...
3. pratico ( OEIS A005153 ), se ogni intero 1 ≤ k ≤ N è una somma di alcuni divisori distinti di N . La sequenza inizia con 1, 2, 4, 6, 8, 12, 16, 18, 20, 24, 28, 30, 32, 36, 40, 42, 48, 54, 56 ...
4. estremamente composita ( OEIS A002128 ), se ogni numero 1 ≤ K <N trovi strettamente meno divisori di N . La sequenza inizia con 1, 2, 4, 6, 12, 24, 36, 48, 60, 120, 180, 240, 360, 720, 840, 1260, 1680, 2520, 5040 ...

Quattro programmi

Il tuo compito è scrivere quattro programmi (ovvero programmi completi, definizioni di funzioni o funzioni anonime che eseguono I / O con uno dei metodi standard ). Ciascun programma risolve il problema dell'appartenenza a una di queste sequenze. In altre parole, ogni programma prenderà un intero positivo N ≥ 1 come input e produrrà un valore di verità se N è nella sequenza e un valore di falsa in caso contrario. Puoi presumere che N sia entro i limiti del tipo intero standard del tuo linguaggio di programmazione.

I programmi devono essere correlati nel modo seguente. Ci sono quattro stringhe ABCDtali

1. AC è il programma che riconosce i numeri perfetti.
2. AD è il programma che riconosce i numeri refactorable.
3. BC è il programma che riconosce i numeri pratici.
4. BD è il programma che riconosce numeri altamente compositi.

punteggio

Il tuo punteggio è la lunghezza totale (in byte) delle stringhe ABCDo, in altre parole, il conteggio totale dei byte dei quattro programmi diviso per due. Il punteggio più basso in ciascun linguaggio di programmazione è il vincitore. Code-golf standard applicano le regole .

Ad esempio, se i quattro stringhe sono a{, b{n, +n}e =n}?, quindi i quattro programmi sono a{+n}, a{=n}?, b{n+n}e b{n=n}?, e il punteggio è 2 + 3 + 3 + 4 = 12.

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

UN:

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

Il risultato è 4 funzioni anonime che conferiscono truthy / valori falsy per i loro rispettivi ingressi ( AC, ADe BCdare true/ false, BDdà 1/0 ).

Snippet di prova

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>

Gelatina , 8 + 17 + 2 1 + 2 = 29 28 byte

UN:

Æṣ⁼$Ædḍ$

B:

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

C:

ƭ

D:

0?

Per i numeri pratici (BC), 0è falsa e ogni altro risultato è verità.

AC e BC sono programmi completi, poiché non sono riutilizzabili come funzioni.

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

UN:

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

Provalo online!

Sì, è abbastanza economico ma non sono abbastanza intelligente per una soluzione più interessante. : P