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.

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

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.

Pyth - 17 12 11 octets

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

@FmsMty{PdQ

Suite de tests .

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.

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

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.

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.

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

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.

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

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)

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

Japt, 12 octets

®k â à mx
rø

Exécutez-le en ligne

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!

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)

Japt -¡ , 14 octets

®k â ã mx
rf Ê

Enregistré 3 octets grâce à @Shaggy

Essayez-le

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

¹

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.