Суми простих факторів


27

2013 рік є основним фактором 3*11*61. 2014 рік має основну факторизацію 2*19*53. Цікава властивість щодо цих факторизацию є те , що існує різні прості числа в факторизацию 2013 і 2014 , що сума до того ж номеру: 11+61=19+53=72.

Напишіть програму або функцію, яка приймає за свій вхід два додатні цілі числа, що перевищують 1, і повертає тривале значення, якщо існує сума вибраних простих коефіцієнтів одного числа, що дорівнює сумі вибраних простих факторів у другому числі, і a значення фальси інакше.


Роз'яснення

  • Можна використовувати більше двох основних факторів. Не всі прості множники числа повинні використовуватися в сумі. Не обов’язково, щоб кількість простих чисел, використаних з двох чисел, було рівним.
  • Навіть якщо прайм підвищений на деяку потужність, що перевищує 1, при факторизації числа, його можна використовувати лише один раз у сумі простих чисел.
  • 1 не є простим.
  • Обидва вхідні числа будуть меншими за 2^32-1.

Тестові справи

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

Це код гольфу. Діють стандартні правила. Найкоротший код у байтах виграє.


6
Мені подобаються такі виклики, але для мов, що займаються гольфом, це буде ланцюжок вбудованих елементів: фактор, уніфікація, підмножини, суми, перекриття.
xnor

Чи можемо ми взяти дані як масив з двома елементами?
ETHproductions

@ETHproductions За замовчуванням, так.
lirtosiast

Як щодо 14 (2 * 7) та 21 (3 * 7), це так true, як вони поділяють коефіцієнт 7?
Саймон Форсберг

@SimonForsbergMcFeely Так
Арктур

Відповіді:


10

Джулія, 95 93 байт

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

Основна функція - це fі називає функцію помічника g.

Безголівки:

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

Збережено 2 байти завдяки Дарту Алефальфі


3
Я помітив, що це було знято. Чи є щось, що я не помітив? Якщо це неправильно, я би радий це виправити, але, як він стоїть, він працює добре для мене і проходить всі тестові справи.
Алекс А.

Я думаю map(p->map, що коротше, ніж (m=map)(p->m.
алефальфа

@DarthAlephalpha Гарний дзвінок, дякую.
Олексій А.

7

Pyth, 11 байт

t@FmsMy{PdQ

Введіть у форму 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.

1
Це тепер ідентично іншій відповіді Pyth, за винятком однієї перенесеної літери;)
ETHproductions

@ETHproductions я відповів, перш ніж Малтісен виправив їх; тому я буду його тримати.
lirtosiast

7

Pyth - 17 12 11 байт

Дякуємо @FryAmTheEggman за виправлення моєї відповіді та збереження байта.

@FmsMty{PdQ

Тестовий сюїт .


Я думаю, що використання tyтворів і економить побачення?
FryAmTheEggman

@FryAmTheEggman дякую!
Мальтісен

17
@Maltysen ви пропустили золоту нагоду сказати "ty"
undergroundmonorail

4

Haskell, 115 106 байт

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

Приклад використання: 2013 # 2014-> True.

pскладає список усіх простих факторів свого аргументу, видаляє дублікати, складає список усіх підпослідовностей, скидає перший (який завжди є порожнім списком) і, нарешті, підсумовує підпослідовності. #перевіряє, чи p aне дорівнює різниця p a \\ p b. Якщо вони не рівні, вони мають принаймні один загальний елемент.


3

Japt, 25 байт

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

Виходи trueабо false. Спробуйте в Інтернеті!

Необурені і пояснення

[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

Для отримання додаткового байту ви можете розділити код унікальної сукупності-сукупність суми між обома входами з додатковою перевагою у часовій складності O(O(25-byte version)^2):

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

3

CJam, 23 байти

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

Перевірте це тут.

Значенням "truthy" будуть всі об'єднані суми, помилковим значенням є порожній рядок.

Пояснення

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.

3

Брахілог , 10 9 байт

{ḋd⊇+ℕ₁}ᵛ

Спробуйте в Інтернеті!

Присудок успішно повертається, [the sum, the sum]якщо він існує, і провалюється, якщо сума не існує.

{            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 байт завдяки Fatalize (творець Brachylog), який нагадує мені, що мета-предикат verify існує.


1
Ви можете використовувати ᵛ - verifyзамість того, ˢ=щоб зберегти один байт.
Фаталізувати

2

MATL , 23 байти

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

Використовується поточний випуск 2.0.2 , який є попереднім, ніж цей виклик.

Номери подаються у вигляді двох окремих входів. Вихід 0або 1.

Приклад

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

Пояснення

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

2

Математика, 58 байт

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

Пояснення:

Це анонімна функція.

Спочатку IntersectingQперевіряють, чи перетинаються два списки. Але вхідні дані - це цифри замість списків, тому вони залишаються неоціненими. Наприклад, якщо входи є 2013і 2014, тоді IntersectingQ@##&повертається IntersectingQ[2013, 2014].

Tr/@Rest@Subsets[#&@@@FactorInteger@#]&- це ще одна анонімна функція, яка приймає ціле число, отримує список своїх простих факторів без повторів, приймає набір потужності, видаляє порожній набір, а потім бере суму кожного набору. Так Tr/@Rest@Subsets[#&@@@FactorInteger@#]&[2013]повертається {3, 11, 61, 14, 64, 72, 75}.

Потім наведіть Tr/@Rest@Subsets[#&@@@FactorInteger@#]&на карту вираз IntersectingQ[2013, 2014]. Tr/@Rest@Subsets[#&@@@FactorInteger@#]&[2013]і Tr/@Rest@Subsets[#&@@@FactorInteger@#]&[2014]]є списками, тому ми можемо отримати результат збирання цього разу.


Викликати IntersectingQспочатку дивовижно! :)
Мартін Ендер

Чи можете ви додати пояснення?
Лінн

2

PARI / GP , 98 байт

Фактор, захопіть primes ( [,1]), переведіть цикл на непорожні підмножини, sum та uniq, а потім переріжте результат цього для двох чисел. Повернене значення - це кількість перетинів, яка є правдою, якщо вони не дорівнюють 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))

2

APL (Dyalog Extended) , 23 17 байт SBCS

-5 завдяки ngn

Функція анонімного мовчазного виправлення.

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

Спробуйте в Інтернеті!

⍥{} Застосувати наступну анонімну функцію до обох аргументів:

 основні фактори

 потім

 унікальні з них

0+⍀., додавання таблиці зменшення нуля, зв'язаного з кожним фактором

ϵ список (згладити)

 перехрестя

 потім

 підрахунок цих

1< чи є більше одного? (один, бо суми відсутність факторів)


використовуючи лише функції з власного dyalog: p+.×⊤1↓⍳2*≢p←->1↓∊(⊢,+)/0,⍨
ngn

ще коротше:1↓∊∘.+/0,¨
пн.

що є 1↓∊0∘.+.,inouter продуктом - як часто ви це бачите :)
ngn

якщо я розумію правильно, то це повинно працювати теж:1<∘≢∩⍥{∊0∘.+.,∪⍭⍵}
СПП

@ngn Дякую Зроблено.
Адам

2

05AB1E , 10 8 байт

f€æO`å¦à

-2 байти завдяки @Emigna .

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

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

1
f€æO`å¦àмає працювати для 8.
Емінья


1

Python 3 , 206 байт

Це лямбда-функція (m), яка бере 2 числа і повертає набір, що містить будь-які суми простих факторів, які мають спільне. У Python це значення "truthy", коли воно не порожнє, і значення "falsey", коли порожнє.

Редагувати: виявляється, що моя оригінальна відповідь не спрацювала з основним введенням, як вказував @JoKing. Це було виправлено (разом із деякими іншими помилками) трагічною вартістю 40 байт.

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

Швидке пояснення за допомогою коментарів:

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

Спробуйте в Інтернеті!


Це не працює для першого тестового випадку 5,6, оскільки він не обробляє основні входи
Jo King

@JoKing Дякую, що це зробив. Відповідь оновлено.
senox13

1

APL (NARS), 50 знаків, 100 байт

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

тут π знайде масив факторів на його аргументі;

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

була б функцією, яка знаходила всі підмножини ... я мушу сказати, що, здається, {⍵operator itsArguments} ¨ (для кожного зліва) та ¨ (для кожного правого) може імітувати цикл із фіксованою кількістю циклів, і ¨¨ в порядку бачити підмножини одного набору ... таким способом бачення здається зменшення символів в циклах опису ...; тест

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

Один невеликий аналіз:

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


1

Желе , 18 9 байт

ÆfŒPḊ§)f/

Спробуйте в Інтернеті!

Завдяки @Jonathan Allan за -9 та чудова допомога :).

Приймає вхід як масив з двох елементів. Пояснення коду:

      )    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

¹


Візьміть дані як список двох значень і уникайте ,. Це ẒƇнадлишок, немає основних факторів, що не є простими. Тоді ÆFḢ€ якраз Æf, за винятком того, що останнє дає нам повторення, які, можливо, нам справді потрібні, наприклад, 26=2*13і 125=5*5*5поки 2+13=5+5+5. Однак, навіть з цим, це недостатньо добре, наприклад, замість 26використання, 182=2*7*13яке також слід знайти, 2+13=5+5+5але це не так - натомість ми хочемо, щоб power-set ( ŒP) без провідного, порожнього, елемента (ми можемо використовувати ). S€тут може бути замінено на §. - Ви, ймовірно, можете зберегти байти за допомогою $і Ɗ-.
Джонатан Аллан

Немає необхідності в тих хитах, про які я згадував наприкінці, які ми можемо використовувати, )і за допомогою моїх виправлень, щоб він працював правильно (плюс замінив œ&на нього f) код становить 9 байт: ÆfŒPḊ§)f/ спробуйте
Джонатан Аллан

Оновлено поясненням. Ще раз дякую вам :)!
Вран

1
Я трохи оновив ваше пояснення.
Джонатан Аллан

0

Гая , 16 11 байт

ḍzΣ¦
↑@↑&ỵ!

Спробуйте в Інтернеті!

Верхня функція (перший рядок) обчислює суми набору потужностей простих коефіцієнтів, а друга функція виявляє, чи будь-який з елементів перетину є ненульовим.

Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.