Échangez le programme de moitié pour tester les diviseurs

19

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 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.

Zgarb
la source
Lié , Lié , Lié .
M. Xcoder

Réponses:

6

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

ETHproductions
la source
1
J'aime la façon dont vous avez réparti le code réel sur les 4 parties et l'a mélangé avec les "conditions" contrairement à moi (j'ai le code sur les parties A et B et les "conditions" sur les parties C et D.)
Erik the Outgolfer
2

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.

Erik le Outgolfer
la source
BC et BD ne semblent pas fonctionner correctement.
Jonathan Allan
ÆDŒPS€ḟ@RṆµṖÆd<ÆdẠµfonctionne comme B pour un coût de deux octets (et fait que BC retourne 0 et 1 seulement comme les autres).
Jonathan Allan
@JonathanAllan Oh non, il semble que j'ai confondu ŒPavec ŒṖ. C'est dommage! Cela fonctionne-t-il si vous corrigez cela? (c'est-à-dire essayer ma nouvelle édition) Ce n'est pas que ce soit très facile à tester de toute façon, c'est pourquoi je n'ai pas encore inclus de lien TIO.
Erik the Outgolfer
0

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

totalement humain
la source
1
Je ne sais pas grand chose sur Haskell mais cela pourrait vous aider avecsubsequences
Asone Tuhid
[x|x<-[1..n],mod n x<1]est plus court que filter((<1).mod n)[1..n].
Laikoni