Somme des facteurs premiers

27

2013 a la factorisation principale 3*11*61. 2014 a la factorisation principale 2*19*53. Une propriété intéressante au sujet de ces factorisation est qu'il existe des nombres premiers distincts dans les décompositions de 2013 et 2014 cette somme au même numéro: 11+61=19+53=72.

Écrivez un programme ou une fonction qui prend en entrée deux entiers positifs supérieurs à 1 et renvoie une valeur vraie s'il existe une somme de facteurs premiers sélectionnés d'un nombre qui est égale à une somme de facteurs premiers sélectionnés dans le deuxième nombre, et un valeur falsey autrement.


Clarifications

  • Plus de deux facteurs premiers peuvent être utilisés. Il n'est pas nécessaire d'utiliser tous les facteurs premiers du nombre dans la somme. Il n'est pas nécessaire que le nombre de nombres premiers utilisés à partir des deux nombres soit égal.
  • Même si un nombre premier est élevé à une puissance supérieure à 1 dans la factorisation d'un nombre, il ne peut être utilisé qu'une seule fois dans la somme des nombres premiers pour le nombre.
  • 1 n'est pas premier.
  • Les deux nombres entrés seront inférieurs à 2^32-1.

Cas de test

5,6
    5=5
    6=2*3
    5=2+3
==>True

2013,2014
    2013=3*11*61
    2014=2*19*53
    11+61=19+53
==>True

8,15
    8=2^3
    15=3*5
    No possible sum
==>False

21,25
    21=3*7
    25=5^2
    No possible sum (can't do 3+7=5+5 because of exponent)
==>False

C'est le golf de code. Des règles standard s'appliquent. Le code le plus court en octets gagne.

Arcturus
la source
6
J'aime les défis comme celui-ci, mais pour les langues de golf, ce sera une chaîne de fonctions intégrées: factoriser, unifier, sous-ensembles, sommes, chevauchement.
2015
Pouvons-nous prendre l'entrée comme un tableau à deux éléments?
ETHproductions
@ETHproductions Par défaut, oui.
lirtosiast
Qu'en est-il de 14 (2 * 7) et 21 (3 * 7), est-ce cela true, car ils partagent le facteur 7?
Simon Forsberg
@SimonForsbergMcFeely Oui
Arcturus

Réponses:

10

Julia, 95 93 octets

g(x)=reduce(vcat,map(p->map(sum,p),partitions([keys(factor(x))...])))
f(a,b)=g(a)∩g(b)!=[]

La fonction principale est fet elle appelle une fonction d'aide g.

Non golfé:

function g(x::Integer)
    # Find the sum of each combination of prime factors of the input
    return reduce(vcat, map(p -> map(sum, p), partitions([keys(factor(x))...])))
end

function f(a::Integer, b::Integer)
    # Determine whether there's a nonzero intersection of the factor
    # sums of a and b
    return !isempty(g(a)  g(b))
end

Enregistré 2 octets grâce à Dark Alephalpha

Alex A.
la source
3
J'ai remarqué que cela avait été rejeté. Y a-t-il quelque chose que j'ai oublié? Si c'est faux, je serais heureux de le réparer, mais en l'état, cela fonctionne bien pour moi et réussit tous les cas de test.
Alex A.
Je pense que map(p->mapc'est plus court que (m=map)(p->m.
alephalpha
@DarthAlephalpha Bon appel, merci.
Alex A.
7

Pyth, 11 octets

t@FmsMy{PdQ

Saisie dans le formulaire 30,7.

t@FmsMy{PdQ     implicit: Q=input tuple
      y         powerset of
       {        unique elements of
        Pd      prime factorizations of d
    sM          Map sum over each element of the powerset
    sMy{Pd      lambda d: all sums of unique prime factors of d
   m      Q     Map over Q. Produces a two-element list.
 @F             Fold list intersection
t               Remove first element, which is a 0.
                If no other common sums, the remaining empty list is falsy.
lirtosiast
la source
1
Ceci est maintenant identique à l'autre réponse Pyth, à l'exception d'une lettre déplacée;)
ETHproductions
@ETHproductions J'ai répondu avant que Maltysen ne corrige la leur; donc je vais le garder.
lirtosiast
7

Pyth - 17 12 11 octets

Merci à @FryAmTheEggman pour avoir corrigé ma réponse et enregistré un octet.

@FmsMty{PdQ

Suite de tests .

Maltysen
la source
Je pense que l'utilisation d' tyœuvres et sauve un bye?
FryAmTheEggman
@FryAmTheEggman merci!
Maltysen
17
@Maltysen vous avez raté une occasion en or de dire "ty"
undergroundmonorail
4

Haskell, 115 106 octets

import Data.Numbers.Primes
import Data.List
p=map sum.tail.subsequences.nub.primeFactors
a#b=p a/=p a\\p b

Exemple d'utilisation: 2013 # 2014-> True.

pfait une liste de tous les facteurs premiers de son argument, supprime les doublons, fait une liste de toutes les sous-séquences, supprime le premier (qui est toujours la liste vide) et résume finalement les sous-séquences. #vérifie s'il p an'est pas égal à la différence p a \\ p b. S'ils ne sont pas égaux, ils ont au moins un élément commun.

nimi
la source
3

Japt, 25 octets

[UV]=N®k â à mx};Ud@J<VbX

Sorties trueou false. Essayez-le en ligne!

Non golfé et explication

[UV]=N®   k â à mx};Ud@ J<VbX
[UV]=NmZ{Zk â à mx};UdX{J<VbX

          // Implicit: N = list of inputs
[UV]=N    // Set variables U and V to the first to items in N,
mZ{    }  // with each item Z mapped to:
Zk        //  Generate list of Z's factors.
â         //  Keep only the unique items.
à         //  Generate all combinations.
mx        //  Sum each combination.
UdX{      // Check if any item X in U fulfills this condition:
J<VbX     //  -1 is less than V.indexOf(X).
          // Implicit: output last expression

Pour un octet supplémentaire, vous pouvez fractionner le code factoriser-unique-combiner-somme entre les deux entrées, avec l'avantage supplémentaire d'avoir une complexité temporelle de O(O(25-byte version)^2):

Uk â à mx d@J<Vk â à mx bX
ETHproductions
la source
3

CJam, 23 octets

q~{mf_&0a\{1$f++}/}/&0-

Testez-le ici.

La valeur véridique sera toutes les sommes communes concaténées, la valeur fausse est la chaîne vide.

Explication

q~     e# Read and evaluate input.
{      e# For each of the two numbers...
  mf   e# Get the prime factors.
  _&   e# Remove duplicates.
  0a\  e# Put an array containing a 0 below to initialise the list of possible sums.
  {    e# For each prime factor...
    1$ e#   Make a copy of the available sums so far.
    f+ e#   Add the current factor to each of them.
    +  e#   Combine with the list of sums without that factor.
  }/
}/
&      e# Set intersection between the two lists of sums.
0-     e# Remove the 0 which is always in the intersection.
Martin Ender
la source
3

Brachylog , 10 9 octets

{ḋd⊇+ℕ₁}ᵛ

Essayez-le en ligne!

Le prédicat réussit à retourner [the sum, the sum]s'il existe et échoue si la somme n'existe pas.

{            Start of inline predicate.
 ḋ           The prime factors of the input,
  d          with duplicates removed.
   ⊇         Some subset of the unique prime factors
    +ℕ₁      has a sum greater than 0 which is output.
       }ᵛ    The predicate can have the same output for both elements of the input.

-1 octet grâce à Fatalize (le créateur de Brachylog) me rappelant que le méta-prédicat de vérification existe.

Chaîne indépendante
la source
1
Vous pouvez utiliser ᵛ - verifyau lieu de ˢ=pour enregistrer un octet.
Fatalize
2

MATL , 23 octets

2:"iYfutn2w^1-:B!Y*]!=z

Utilise la version actuelle, 2.0.2 , antérieure à ce défi.

Les chiffres sont fournis sous forme de deux entrées distinctes. La sortie est 0ou 1.

Exemple

>> matl 2:"iYfutn2w^1-:B!Y*]!=z
> 2013
> 2014
1

Explication

2:           % vector of two numbers, to generate two iterations
"            % for loop
  i          % input number                                                 
  Yfu        % get prime factors without repetitions
  tn         % duplicate and get number of elements in array N 
  2w^1-:     % numbers from 1 to 2^N                                        
  B!Y*       % convert to binary, transpose and matrix multiply to produce all sums
]            % end                                                      
!=z          % true if any value is equal to any other
Luis Mendo
la source
2

Mathematica, 58 octets

Tr/@Rest@Subsets[#&@@@FactorInteger@#]&/@IntersectingQ@##&

Explication:

Il s'agit d'une fonction anonyme.

Tout d'abord, IntersectingQvérifie si deux listes se croisent. Mais les entrées sont des nombres au lieu de listes, donc cela reste non évalué. Par exemple, si les entrées sont 2013et 2014, puis IntersectingQ@##&retourne IntersectingQ[2013, 2014].

Tr/@Rest@Subsets[#&@@@FactorInteger@#]&est une autre fonction anonyme qui prend un entier, obtient une liste de ses facteurs premiers sans répétitions, prend l'ensemble de puissance, supprime l'ensemble vide, puis prend la somme de chaque ensemble. Tr/@Rest@Subsets[#&@@@FactorInteger@#]&[2013]Retourne donc {3, 11, 61, 14, 64, 72, 75}.

Mappez Tr/@Rest@Subsets[#&@@@FactorInteger@#]&ensuite l'expression IntersectingQ[2013, 2014]. Tr/@Rest@Subsets[#&@@@FactorInteger@#]&[2013]et Tr/@Rest@Subsets[#&@@@FactorInteger@#]&[2014]]sont des listes, afin que nous puissions obtenir le résultat de la collecte cette fois.

alephalpha
la source
Appeler en IntersectingQpremier est incroyable! :)
Martin Ender
Pourriez-vous ajouter une explication?
Lynn
2

PARI / GP , 98 octets

Factor, grab prime ( [,1]), boucle sur des sous-ensembles non vides, sum et uniq, puis coupez le résultat de ceci pour les deux nombres. La valeur retournée est le nombre d'intersections, ce qui est vrai à moins qu'elles ne soient égales à 0.

f(n,v=factor(n)[,1])=Set(vector(2^#v-1,i,vecsum(vecextract(v,i))))
g(m,n)=#setintersect(f(m),f(n))
Charles
la source
2

APL (Dyalog Extended) , 23 17 octets SBCS

-5 grâce à ngn

Fonction infixe tacite anonyme.

1<≢⍤∩⍥(∊0+⍀.,∪⍤⍭)

Essayez-le en ligne!

⍥{} Appliquez la fonction anonyme suivante aux deux arguments:

 facteurs premiers

 puis

 les uniques de ceux

0+⍀., tableau d'addition réduction de zéro concaténée à chaque facteur

ϵ nlist (aplatir)

 le carrefour

 puis

 le décompte de ceux

1< y en a-t-il plus d'un? (un parce que la somme d'aucun facteur)

Adam
la source
en utilisant uniquement les fonctionnalités de dyalog: p+.×⊤1↓⍳2*≢p←->1↓∊(⊢,+)/0,⍨
ngn
encore plus court:1↓∊∘.+/0,¨
ngn
qui est 1↓∊0∘.+.,un produit inouter - combien de fois voyez-vous cela :)
ngn
si je comprends bien, cela devrait aussi fonctionner:1<∘≢∩⍥{∊0∘.+.,∪⍭⍵}
ngn
@ngn Merci. Terminé.
Adám
2

05AB1E , 10 8 octets

f€æO`å¦à

-2 octets grâce à @Emigna .

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

f         # Get all distinct prime factors of both values in the (implicit) input-list
          #  i.e. [2013,2014] → [[3,11,61],[2,19,53]]
 ۾       # Get the powerset for each
          #  → [[[],[3],[11],[3,11],[61],[3,61],[11,61],[3,11,61]],
          #     [[],[2],[19],[2,19],[53],[2,53],[19,53],[2,19,53]]]
   O      # Sum each inner-most list
          #  → [[0,3,11,14,61,64,72,75],[0,2,19,21,53,55,72,74]]
    `     # Push both lists to the stack
     å    # Check for each value in the second list if it's present in the first list
          #  → [1,0,0,0,0,0,1,0]
      ¦   # Remove the first item (since the powerset included empty leading lists)
          #  → [0,0,0,0,0,1,0]
       à  # Check if any are truthy by taking the maximum (which is output implicitly)
          #  → 1
Kevin Cruijssen
la source
1
f€æO`å¦àdevrait fonctionner pour 8.
Emigna
1

Python 3 , 206 octets

Il s'agit d'une fonction lambda (m), qui prend 2 nombres et renvoie un ensemble contenant toutes les sommes des facteurs premiers qu'ils ont en commun. En Python, il s'agit d'une valeur véridique lorsqu'elle n'est pas vide et d'une valeur de falsey lorsqu'elle est vide.

Edit: Il s'avère que ma réponse d'origine n'a pas fonctionné pour les entrées principales, comme l'a souligné @JoKing. Cela a été corrigé (avec quelques autres bugs) au coût tragique de 40 octets.

q=__import__('itertools').permutations
def p(n):
 i,s=2,set()
 while~-n:
  if n%i:i+=1
  else:n//=i;s|={i}
 return s
s=lambda f:{sum(i)for l in range(1,len(f)+1)for i in q(f,l)}
m=lambda a,b:s(p(a))&s(p(b))

Explication rapide à l'aide de commentaires:

#Alias for permutations function
q=__import__('itertools').permutations
#Returns set of prime factors of n, including n, if prime
def p(n):
 i,s=2,set()
 while~-n:
  if n%i:i+=1
  else:n//=i;s|={i}
 return s
#Returns all possible sums of 2 or more elements in the given set
s=lambda f:{sum(i)for l in range(1,len(f)+1)for i in q(f,l)}
#Returns any shared possible sums of prime factors of a and b (the intersection of the sets)
m=lambda a,b:s(p(a))&s(p(b))

Essayez-le en ligne!

senox13
la source
Cela ne fonctionne pas pour le premier cas de test 5,6, car il ne gère pas les entrées principales
Jo King
@JoKing Merci d'avoir attrapé ça. La réponse a été mise à jour.
senox13
1

APL (NARS), 50 caractères, 100 octets

{⍬≢↑∩/+/¨¨{⍵∼⊂⍬}¨{0=⍴⍵:⊂⍬⋄s,(⊂1⌷⍵),¨s←∇1↓⍵}¨∪¨π¨⍵}

ici π trouverait le tableau des facteurs sur son argument;

{0=⍴⍵:⊂⍬⋄s,(⊂1⌷⍵),¨s←∇1↓⍵} 

serait la fonction qui trouve tous les sous-ensembles ... je dois dire qu'il semble que {⍵operator itsArguments} ¨ (pour chaque gauche) et ¨ (pour chaque droite) peut imiter une boucle avec un nombre fixe de cycles et ¨¨ est ok dans pour voir des sous-ensembles d'un ensemble ... cette façon de voir semble réduire les symboles dans les boucles de description ...; tester

  h←{⍬≢↑∩/+/¨¨{⍵∼⊂⍬}¨{0=⍴⍵:⊂⍬⋄s,(⊂1⌷⍵),¨s←∇1↓⍵}¨∪¨π¨⍵}
  h 5 6
1
  h 2013 2014
1
  h 8 15
0
  h 21 25
0

Une petite analyse:

π¨⍵  for each arg apply factor 
∪¨ for each arg apply unique
{0=⍴⍵:⊂⍬⋄s,(⊂1⌷⍵),¨s←∇1↓⍵}¨ for each arg apply subsets
{⍵∼⊂⍬}¨ for each argument subtract Zilde enclosed (that would be the void set)
+/¨¨ for each arg (for each arg apply +/)
⍬≢↑∩/ apply intersection, get the first argument and see if it is Zilde (this it is right because enclosed Zilde it seems is the void set)
RosLuP
la source
1

Japt , 14 octets

®k â ã mx
rf Ê

Enregistré 3 octets grâce à @Shaggy

Essayez-le

Incarnation de l'ignorance
la source
La deuxième ligne peut être ÎfUÌ lou, encore plus courte, rf l. serait le moyen le plus court de le faire, mais Oliver vous a battu.
Shaggy
1

Gelée , 18 9 octets

ÆfŒPḊ§)f/

Essayez-le en ligne!

Merci à @Jonathan Allan pour -9 et l'aide incroyable :).

Prend l'entrée comme un tableau de deux éléments. Explication du code:

      )    Call Chain 1 for each integer in the input array

ÆfŒPḊ§     Chain 1:
Æf           Compute a list of the prime factors of the integer
  ŒP         Powerset of P, with duplicates and an empty element
    Ḋ        Drop said empty element
     §       Vectorized sum: sum every combination

       f/  Chain 2:
        /    Reduce (the resulting list of two lists of possible sums) by...
       f     ...removing elements to the left that are not in the right

¹

Ven
la source
Prenez l'entrée comme une liste de deux valeurs et évitez le ,. Le ẒƇest redondant, il n'y a pas de facteurs premiers non premiers. Alors ÆFḢ€ est juste Æf, sauf que celui - ci nous donne les répétitions que nous pourrions réellement besoin, par exemple 26=2*13et 125=5*5*5tout 2+13=5+5+5. Cependant, même avec cela, ce n'est pas assez bon, par exemple au lieu d' 26utiliser, 182=2*7*13ce qui devrait également trouver cela 2+13=5+5+5mais ne le fait pas - au lieu de cela, nous voulons le power-set ( ŒP) sans l'élément principal, vide, (que nous pouvons utiliser ). S€ici peut être remplacé par §. - Vous pouvez probablement enregistrer des octets avec $et Ɗ-.
Jonathan Allan
Pas besoin de ces rapides que j'ai mentionnés à la fin, nous pouvons utiliser )et avec mes correctifs pour le faire fonctionner correctement (plus le remplacer œ&par f) le code est de 9 octets: ÆfŒPḊ§)f/ essayez-le
Jonathan Allan
Mis à jour avec une explication. Merci encore :)!
Ven
1
J'ai un peu mis à jour votre explication.
Jonathan Allan
0

Gaia , 16 11 octets

ḍzΣ¦
↑@↑&ỵ!

Essayez-le en ligne!

La fonction supérieure (première ligne) calcule les sommes de l'ensemble des facteurs premiers et la deuxième fonction trouve si l'un des éléments de l'intersection est différent de zéro.

Giuseppe
la source