Nombre de sommes de facteurs

12

Étant donné un entier positif n> 1, déterminez combien de nombres peuvent être faits en ajoutant des entiers supérieurs à 1 dont le produit est n . Par exemple, si n = 24, nous pouvons exprimer n comme un produit de la manière suivante

24 = 24             -> 24            = 24
24 = 12 * 2         -> 12 + 2        = 14
24 = 6 * 2 * 2      -> 6 + 2 + 2     = 10
24 = 6 * 4          -> 6 + 4         = 10
24 = 3 * 2 * 2 * 2  -> 3 + 2 + 2 + 2 = 9
24 = 3 * 4 * 2      -> 3 + 4 + 2     = 9
24 = 3 * 8          -> 3 + 8         = 11

Nous pouvons obtenir les numéros suivants de cette façon:

24, 14, 11, 10, 9

C'est un total de 5 nombres, donc notre résultat est 5.

Tâche

Écrivez un programme ou une fonction qui prend n en entrée et renvoie le nombre de résultats pouvant être obtenus de cette façon.

Il s'agit d'une question de donc les réponses seront notées en octets, avec moins d'octets étant mieux.

Séquence OEIS

OEIS A069016

Ad Hoc Garf Hunter
la source
1
Cas de test suggéré 240
Jonathan Allan
Étant donné que 36 a suscité beaucoup de débats, je le propose comme test.
user41805
3
@WheatWizard 12 * 3
Business Cat
1
J'ai 2,2,3,3 -> 10, 2,6,3 -> 11, 2,2,9 -> 13, 12,3 -> 15, 2,18 -> 20,36 -> 36
affaires Cat
2
36 devrait être 7 car (2*3)+(2*3)=12devrait également figurer dans la liste.
Jonathan Allan

Réponses:

6

Brachylog , 8 octets

{~×≜+}ᶜ¹

Essayez-le en ligne!

Explication

{    }ᶜ¹  Count unique results of this predicate:
 ~×       Create list of numbers whose product is the input.
   ≜      Label the list, forcing it to take a concrete value.
    +     Take its sum.

Je ne sais pas exactement pourquoi ne produit que des listes avec des éléments supérieurs à 1, mais cela semble le faire, ce qui fonctionne très bien dans ce défi.

Zgarb
la source
Il ne produit que des listes avec des éléments supérieurs à 1 car sinon il y a une infinité de listes, ce qui est souvent mauvais dans des défis comme ceux-ci.
Fatalize
4

Gaia , 9 14 13 octets

Bug corrigé au coût de 5 octets grâce à Jonathan Allan, puis 1 octet joué au golf.

ḍfḍ¦e¦Π¦¦Σ¦ul

Essayez-le en ligne! ou essayez comme suite de tests

Explication

ḍ              Prime factors
 f             Permutations
  ḍ¦           Get the partitions of each permutation
    e¦         Dump each list of partitions (1-level flatten the list)
      Π¦¦      Product of each partition
         Σ¦    Sum each group of products
           u   Deduplicate
            l  Length
Chat d'affaires
la source
Pouvez-vous fournir un lien TIO contenant les sorties correspondantes les numéros 1 à 36 inclus?
user41805
C'est exactement comme la réponse de Jelly ...
Erik the Outgolfer
1
L'OP dit que la sortie pour 36 devrait être 5, pas 6
user41805
1
Selon OEIS, 36 donne 7 au lieu de 5, mais le vôtre donne 6
user41805
1
Apparemment, Gaia laisse de côté[6 6]
user41805
2

Gelée ,  11 15  14 octets

+4 octets corrigeant un bogue (peut-être une meilleure façon?)
-1 octet en abusant de la symétrie

ÆfŒ!ŒṖ€ẎP€S€QL

Un lien monadique prenant et retournant des entiers positifs

Essayez-le en ligne! ou voir une suite de tests

Comment?

Mise à jour ...

ÆfŒ!ŒṖ€ẎP€S€QL - Link: number, n      e.g. 30
Æf             - prime factors of n        [2,3,5]
  Œ!           - all permutations          [[2,3,5],[2,5,3],[3,2,5],[3,5,2],[5,2,3],[5,3,2]]
    ŒṖ€        - all partitions for €ach   [[[[2],[3],[5]],[[2],[3,5]],[[2,3],[5]],[[2,3,5]]],[[[2],[5],[3]],[[2],[5,3]],[[2,5],[3]],[[2,5,3]]],[[[3],[2],[5]],[[3],[2,5]],[[3,2],[5]],[[3,2,5]]],[[[3],[5],[2]],[[3],[5,2]],[[3,5],[2]],[[3,5,2]]],[[[5],[2],[3]],[[5],[2,3]],[[5,2],[3]],[[5,2,3]]],[[[5],[3],[2]],[[5],[3,2]],[[5,3],[2]],[[5,3,2]]]]
       Ẏ       - tighten                   [[[2],[3],[5]],[[2],[3,5]],[[2,3],[5]],[[2,3,5]],[[2],[5],[3]],[[2],[5,3]],[[2,5],[3]],[[2,5,3]],[[3],[2],[5]],[[3],[2,5]],[[3,2],[5]],[[3,2,5]],[[3],[5],[2]],[[3],[5,2]],[[3,5],[2]],[[3,5,2]],[[5],[2],[3]],[[5],[2,3]],[[5,2],[3]],[[5,2,3]],[[5],[3],[2]],[[5],[3,2]],[[5,3],[2]],[[5,3,2]]]
        P€     - product for €ach          [[30],[6,5],[10,3],[2,3,5],[30],[10,3],[6,5],[2,5,3],[30],[6,5],[15,2],[3,2,5],[30],[15,2],[6,5],[3,5,2],[30],[10,3],[15,2],[5,2,3],[30],[15,2],[10,3],[5,3,2]]
               -   ...this abuses the symmetry saving a byte over P€€
          S€   - sum €ach                  [30,11,13,10,30,13,11,10,30,11,17,10,30,17,11,10,30,13,17,10,30,17,13,10][10,17,11,30,10,17,13,30,10,13,11,30,10,13,17,30,10,11,13,30,10,11,17,30]
            Q  - de-duplicate              [30,11,13,10,17]
             L - length                    5
Jonathan Allan
la source
1

Python 2 , 206 octets

k=lambda n,i=2:n/i*[k]and[k(n,i+1),[i]+k(n/i)][n%i<1]
def l(t):
 r=[sum(t)]
 for i,a in enumerate(t):
    for j in range(i+1,len(t)):r+=l(t[:i]+[a*t[j]]+t[i+1:j]+t[j+1:])
 return r
u=lambda n:len(set(l(k(n))))

Essayez-le en ligne!

Explication

    # Finds the prime factors
k=lambda n,i=2:n/i*[k]and[k(n,i+1),[i]+k(n/i)][n%i<1]
    # Function for finding all possible numbers with some repetition
def l(t):
    # Add the current sum
 r=[sum(t)]
    # For each number in the current factors
 for i,a in enumerate(t):
    # For all numbers further back in the current factors, find all possible numbers when we multiply together two of the factors
    for j in range(i+1,len(t)):r+=l(t[:i]+[a*t[j]]+t[i+1:j]+t[j+1:])
 return r
    # Length of set for distinct elements
u=lambda n:len(set(l(k(n))))
Halvard Hummel
la source
1
194 octets
ovs
1

Mathematica, 110 octets

If[#==1,1,Length@Union[Tr/@Select[Array[f~Tuples~{#}&,Length[f=Rest@Divisors[s=#]]]~Flatten~1,Times@@#==s&]]]&
J42161217
la source
1

JavaScript (ES6) 107 octets

f=(n,o,s=0,i=2,q=n/i)=>(o||(o={},o[n]=t=1),i<n?(q>(q|0)|o[e=s+i+q]||(o[e]=t+=1),f(q,o,s+i),f(n,o,s,i+1)):t)

Non golfé:

f=(n,                                 //input
   o,                                 //object to hold sums
   s=0,                               //sum accumulator
   i=2,                               //start with 2
   q=n/i                              //quotient
  )=>(
  o||(o={},o[n]=t=1),                 //if first call to function, initialize o[n]
                                      //t holds the number of unique sums
  i<n?(                               //we divide n by all numbers between 2 and n-1
    q>(q|0)|o[e=s+i+q]||(o[e]=t+=1),  //if q is integer and o[s+i+q] is uninitialized,
                                      //... make o[s+i+q] truthy and increment t
    f(q,o,s+i),                       //recurse using q and s+i
    f(n,o,s,i+1)                      //recurse using n with the next i
  ):t                                 //return t
)

Cas de test:

Pour vérifier que la fonction calcule les sommes correctes, nous pouvons sortir les clés de l'objet au lieu de t:

f=(n,o,s=0,i=2,q=n/i)=>(o||(o={},o[n]=t=1),i<n?(q>(q|0)|o[e=s+i+q]||(o[e]=t+=1),f(q,o,s+i),f(n,o,s,i+1)):Object.keys(o))

console.log(f(24));  //9, 10, 11, 14, 24

Rick Hitchcock
la source
1

Python 3 , 251 octets

lambda n:1 if n==1else len(set(sum(z)for z in t(f(n))))
f=lambda n:[]if n==1else[[i]+f(n//i)for i in range(2,n+1)if n%i==0][0]
t=lambda l:[l] if len(l)==1else[[l[0]]+r for r in t(l[1:])]+[r[:i]+[l[0]*e]+r[i+1:]for r in t(l[1:])for i,e in enumerate(r)]

Essayez-le en ligne!

Le design est basique:

  1. factoriser n en ses facteurs premiers (un facteur premier peut apparaître plusieurs fois:) 16 -> [2,2,2,2]. Voilà la fonction f.

  2. calculer les partitions de la liste des facteurs premiers et multiplier les facteurs dans chaque partition. Les partitions se trouvent comme dans /programming//a/30134039 , et les produits sont calculés à la volée. Voilà la fonction t.

  3. La fonction finale obtient les produits de chaque partition de n et les additionne, pour obtenir le nombre de valeurs différentes.

Le résultat pour 2310=2*3*5*7*11est 49.

EDIT : Peut-être besoin de réparer, mais je n'ai pas le temps de le regarder maintenant (je suis pressé). Astuce: le résultat est-il correct 2310=2*3*5*7*11? Je ne pense pas.

EDIT2 : énorme correctif. Voir au dessus. La version précédente (buggy) était: Essayez-la en ligne!

fcalcule les facteurs (, avec un (0, n)au lieu de (1, n)comme premier élément.

Le lambda divise chaque facteur en "sous-facteurs" et additionne ces "sous-facteurs".

jferard
la source
1
-19 octets.
notjagan
Merci à @notjagan, mais le code initial était tellement faux ...
jferard
Merci à @HalvardHummel, mais même remarque que ci-dessus.
jferard