Il 2013 ha la scomposizione in fattori primi 3*11*61. Il 2014 ha la scomposizione in fattori primi 2*19*53. Una proprietà interessante per quanto riguarda questi fattorizzazione è che esistono primi distinti nelle fattorizzazioni di 2013 e 2014 tale somma allo stesso numero: 11+61=19+53=72.

Scrivi un programma o una funzione che accetta come input due numeri interi positivi maggiori di 1 e restituisce un valore di verità se esiste una somma di fattori primi selezionati di un numero che è uguale a una somma di fattori primi selezionati nel secondo numero e un valore falso altrimenti.

chiarimenti

• È possibile utilizzare più di due fattori primi. Non tutti i fattori primi del numero devono essere utilizzati nella somma. Non è necessario che il numero di numeri primi utilizzati dai due numeri sia uguale.
• Anche se un numero primo viene elevato a una potenza maggiore di 1 nella fattorizzazione di un numero, può essere usato solo una volta nella somma dei numeri primi per il numero.
• 1 non è un numero primo.
• Entrambi i numeri di input saranno inferiori a 2^32-1.

Casi 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

Questo è il codice golf. Si applicano le regole standard. Vince il codice più breve in byte.

Julia, 95 93 byte

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

La funzione principale è fe chiama una funzione di supporto g.

Ungolfed:

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

Salvato 2 byte grazie a Darth Alephalpha

Pyth, 11 byte

t@FmsMy{PdQ

Inserisci nel modulo 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 byte

Grazie a @FryAmTheEggman per aver corretto la mia risposta e salvato un byte.

@FmsMty{PdQ

Test Suite .

Haskell, 115 106 byte

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

Esempio di utilizzo: 2013 # 2014-> True.

pcrea un elenco di tutti i fattori primi del suo argomento, rimuove i duplicati, crea un elenco di tutte le sottosequenze, elimina il primo (che è sempre l'elenco vuoto) e infine somma le sottosezioni. #controlla se p anon è uguale alla differenza p a \\ p b. Se non uguali, hanno almeno un elemento comune.

Japt, 25 byte

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

Uscite trueo false. Provalo online!

Ungolfed e spiegazione

[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

Per un byte extra, puoi dividere il codice factorize-unique-combinare-somma tra entrambi gli input, con l'ulteriore vantaggio di avere una complessità temporale di O(O(25-byte version)^2):

Uk â à mx d@J<Vk â à mx bX

CJam, 23 byte

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

Provalo qui.

Il valore di verità sarà tutte le somme comuni concatenate, il valore di falsa è la stringa vuota.

Spiegazione

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 byte

{ḋd⊇+ℕ₁}ᵛ

Provalo online!

Il predicato riesce a ritornare [the sum, the sum]se esiste e fallisce se la somma non esiste.

{            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 byte grazie a Fatalize (il creatore di Brachylog) che mi ricorda che esiste il meta-predicato di verifica .

MATL , 23 byte

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

Utilizza la versione corrente, 2.0.2 , che è precedente a questa sfida.

I numeri sono forniti come due ingressi separati. L'output è 0o 1.

Esempio

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

Spiegazione

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 byte

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

Spiegazione:

Questa è una funzione anonima.

Innanzitutto, IntersectingQcontrolla se due elenchi si intersecano. Ma gli input sono numeri anziché elenchi, quindi rimane non valutato. Ad esempio, se gli input sono 2013e 2014, quindi IntersectingQ@##&ritorna IntersectingQ[2013, 2014].

Tr/@Rest@Subsets[#&@@@FactorInteger@#]&è un'altra funzione anonima che accetta un numero intero, ottiene un elenco dei suoi fattori primi senza ripetizioni, prende il set di potenza, rimuove il set vuoto e quindi prende la somma di ogni set. Quindi Tr/@Rest@Subsets[#&@@@FactorInteger@#]&[2013]ritorna {3, 11, 61, 14, 64, 72, 75}.

Quindi mappare Tr/@Rest@Subsets[#&@@@FactorInteger@#]&sopra l'espressione IntersectingQ[2013, 2014]. Tr/@Rest@Subsets[#&@@@FactorInteger@#]&[2013]e Tr/@Rest@Subsets[#&@@@FactorInteger@#]&[2014]]sono elenchi, quindi questa volta possiamo ottenere il risultato della raccolta.

PARI / GP , 98 byte

Factor, grab primes ( [,1]), loop su sottoinsiemi non vuoti, sum e uniq, quindi interseca il risultato di questo per i due numeri. Il valore restituito è il numero di intersezioni, che è vero a meno che non siano 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 byte ^SBCS

-5 grazie a ngn

Funzione anonimo di tacita infissione.

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

Provalo online!

⍥{... } applica la seguente funzione anonima ad entrambi gli argomenti:

 ⍭ fattori primari

 ⍤ poi

 ∪ quelli unici di quelli

 0+⍀., riduzione della tabella di addizione di zero concatenata a ciascun fattore

 ∊ ϵ nlist (appiattisci)

∩ l'intersezione

⍤ poi

≢ il conteggio di quelli

1< ce n'è più di uno? (uno perché le somme di nessun fattore)

05AB1E , 10 8 byte

f€æO`å¦à

-2 byte grazie a @Emigna .

Provalo online o verifica tutti i casi di test .

Spiegazione:

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 byte

®k â à mx
rø

Eseguilo online

Python 3 , 206 byte

Questa è una funzione lambda (m), che accetta 2 numeri e restituisce un set contenente tutte le somme di fattori primi che hanno in comune. In Python questo è un valore di verità quando non è vuoto e un valore di falsa quando è vuoto.

Modifica: risulta che la mia risposta originale non ha funzionato per gli input primi, come sottolineato da @JoKing. Questo problema è stato risolto (insieme ad altri bug) al tragico costo di 40 byte.

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

Spiegazione rapida tramite commenti:

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

Provalo online!

APL (NARS), 50 caratteri, 100 byte

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

qui π troverebbe la matrice di fattori sul suo argomento;

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

sarebbe la funzione che trova tutti i sottoinsiemi ... devo dire che sembra che {⍵operator itsArguments} ¨ (per ogni sinistra) e ¨ (per ogni destra) possano imitare il ciclo con un numero fisso di cicli e ¨¨ va bene in per vedere sottoinsiemi di un set ... questo modo di vedere sembra ridurre i simboli nel descrivere i loop ...; test

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

Una piccola analisi:

π¨⍵  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 byte

®k â ã mx
rf Ê

Salvato 3 byte grazie a @Shaggy

Provalo

Gelatina , 18 9 byte

ÆfŒPḊ§)f/

Provalo online!

Grazie a @Jonathan Allan per -9 e lo straordinario aiuto :).

Accetta input come una matrice di due elementi. Spiegazione del codice:

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

ḍzΣ¦
↑@↑&ỵ!

Provalo online!

La funzione superiore (prima riga) calcola le somme del powerset dei fattori primi e la seconda funzione rileva se uno qualsiasi degli elementi dell'intersezione è diverso da zero.