Cho một mảng các số nguyên dương, xuất ra một mảng ổn định các thừa số nguyên tố riêng biệt của các số nguyên này. Nói cách khác, đối với mỗi số nguyên trong đầu vào theo thứ tự, hãy lấy các thừa số nguyên tố của nó, sắp xếp chúng và nối thêm bất kỳ số nguyên tố nào chưa có trong đầu ra vào đầu ra.

Các trường hợp thử nghiệm

[1,2,3,4,5,6,7,8,9,10] -> [2,3,5,7]
[10,9,8,7,6,5,4,3,2,1] -> [2,5,3,7]
[100,99,98,1,2,3,4,5] -> [2,5,3,11,7]
[541,60,19,17,22] -> [541,2,3,5,19,17,11]
[1,1,2,3,5,8,13,21,34,45] -> [2,3,5,13,7,17]
[6,7,6,7,6,7,6,5] -> [2,3,7,5]
[1] -> []
[8] -> [2]
[] -> []

Đầu ra có thể là một mảng hoặc danh sách các số nguyên hoặc chuỗi, đầu ra được phân tách hoặc bất kỳ phương tiện tiêu chuẩn nào khác để đưa ra một danh sách các số theo thứ tự.

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.

05AB1E , 3 byte

Đầu ra dưới dạng một danh sách các Chuỗi.

f˜Ù

Hãy thử trực tuyến!

2sable , 3 byte

Vâng, điều này cũng hoạt động trong 2sable. Cũng trả về một danh sách các Chuỗi.

f˜Ù

Hãy thử trực tuyến!

Husk , 3 byte

Lưu 1 byte nhờ @Zgarb .

uṁp

Hãy thử trực tuyến!

Giải trình

Chương trình đầy đủ.

  p Các yếu tố chính của mỗi.
 Chức năng ánh xạ qua danh sách và nối kết quả.
u độc đáo 

Tiện ích Bash + GNU, 37

• 21 byte được lưu nhờ @muru (wow!)

factor|tr \  \\n|awk '!/:/&&!a[$0]++'

Hãy thử trực tuyến .

MATL , 6 byte

"@Yfvu

Hãy thử trực tuyến!

Giải trình:

"      % Loop over input
 @     % Push the array element
  Yf   % Prime factors
    v  % Concatenate entire stack vertically (does nothing the first iteration)
     u % Stably get distinct (unique, in MATLAB terminology) elements. Does so every loop but this is code golf, not fastest code.

Các mẩu tin MATL thú vị: nói chung, tất cả các hàm áp dụng cho các vectơ (mảng) đều dễ dàng như vậy. Nhưng trong trường hợp này, số lượng các yếu tố là thay đổi cho mỗi đầu vào, và Matlab và bởi MATL mở rộng thường chỉ xử lý các ma trận vuông, vì vậy tôi phải sử dụng một vòng lặp for ".

Hơn nữa, MATL có hai toán tử ghép nối chính: hvà v, ghép ngang và dọc. Hành vi của họ khác nhau đáng kể: vnối toàn bộ ngăn xếp, ngay cả khi nó chỉ có một yếu tố như trong lần lặp đầu tiên của chúng tôi. hmất chính xác hai yếu tố và sẽ thất bại nếu chỉ có một yếu tố, làm cho nó không phù hợp với ứng dụng này.

Brachylog , 6 byte

ḋᵐ↔ᵐcd

Hãy thử trực tuyến!

Brachylog , 6 byte

ḋᵐoᵐcd

Hãy thử trực tuyến!

Giải trình

Bản đồ với phân rã nguyên tố (trả về các yếu tố theo thứ tự ngược lại).
  Đảo ngược từng (hoặc oᵐ - thứ tự mỗi).
    c Ghép (làm phẳng).
     d Khử trùng lặp.

Bình thường , 5 4 byte

{smP

Hãy thử nó ở đây! hoặc Xác minh tất cả các trường hợp thử nghiệm.

Thay thế: {sPM

Giải trình

{smP Chương trình đầy đủ với đầu vào ẩn (Q).
  m Bản đồ qua đầu vào.
   P Các yếu tố chính.
 Làm phẳng.
{Khử trùng lặp.

PowerShell , 102 byte

param($x)$a=@();$x|%{$a+=(2..($z=$_)|?{!($z%$_)-and'1'*$_-match'^(?!(..+)\1+$)..'}|sort)};$a|select -u

Hãy thử trực tuyến!

(Mượn ý tưởng nhân cách hóa từ câu trả lời của TessellatingHeckler về "Hãy lấy ngươi sau lưng Satan-Prime!")

Đưa đầu vào như một mảng theo nghĩa đen $x. Tạo một mảng trống mới $a. Vòng lặp qua $x. Mỗi lần lặp chúng ta lặp từ 2tối đa đến số hiện tại, kiểm tra xem đó có phải là một thừa -andsố hay không, sau đó |sortlà đầu ra của số đó và nối nó vào $a. Khi chúng ta thực hiện xong $x, chúng ta sẽ xuất ra $anhưng |selectchỉ các -usố nique của chúng. Điều này khai thác thực tế là duy nhất đi từ trái sang phải, giữ lần xuất hiện đầu tiên, phù hợp với mô tả vấn đề. Những con số này được để lại trên đường ống và đầu ra là ẩn.

CJam, 11 byte

{:mfe__&1-}

Hàm lấy mảng int và đầu ra mảng ints.

Phiên bản thử nghiệm

Gaia , 4 byte

ḍ¦_u

Hãy thử trực tuyến!

Giải trình

Các yếu tố chính của mỗi.
  _ Làm phẳng danh sách.
   u Loại bỏ các yếu tố trùng lặp.

Thạch , 5 4 byte

1 byte nhờ vỗ tay.

ÆfFQ

Hãy thử trực tuyến!

Pyke , 4 byte

MPs}

Hãy thử nó ở đây!

Giải trình

MP       Prime factors of each.
  s      Flatten.
   }     Deduplicate.

Toán học, 64 byte

Select[DeleteDuplicates[First/@FactorInteger@#~Flatten~1],#>1&]&

đầu vào

[{100, 99, 98, 1, 2, 3, 4, 5}]

Haskell, 77 byte

import Data.List
x!y|y>x=[]|x`mod`y<1=y:(x`div`y)!y|1<2=x!(y+1)
nub.((!2)=<<)

Giải trình:

• các x!ylợi nhuận điều hành một danh sách của tất cả các yếu tố chính của xmà là lớn hơn hoặc bằngy
• các (!2)hàm trả về một danh sách của tất cả các thừa số nguyên tố của đối số của nó
• chức năng trên dòng cuối cùng thực hiện các chức năng cần thiết

Hãy thử trực tuyến.

Brachylog , 6 byte

ḋᵐoᵐcd

Hãy thử trực tuyến!

Giải trình

ḋᵐ         Map prime decomposition
  oᵐ       Map order
    c      Concatenate
     d     Remove duplicates

Ohm v2 , 3 byte

Còn 3-byter nữa (nhờ các ngôn ngữ có tính năng vector hóa tự động).

m{U

Hãy thử trực tuyến!

Giải trình

m Các yếu tố chính. Tự động vector hóa trên đầu vào.
 {Làm phẳng.
  U duy nhất.

Japt , 6 byte

mk c â

Kiểm tra nó

Giải trình

Đầu vào ngầm định của mảng U. Ánh xạ ( m) qua nó, lấy các yếu tố ( k) của từng yếu tố. Flatten ( c), lấy các phần tử duy nhất ( â) và đầu ra ngầm.

Python 3 , 128 125 116 byte

Đây là một giải pháp Python thuần túy. Không có gói. Cảm ơn Halvard đã lưu 9 byte.

def f(l):y=[k for i in l for k in range(2,i+1)if i%k<1*all(k%x for x in range(2,k))];print(sorted({*y},key=y.index))

Hãy thử trực tuyến!

Python 2 , 133 127 126 byte

def f(l):y=sum([[k for k in range(2,i+1)if i%k<1*all(k%x for x in range(2,k))]for i in l],[]);print sorted(set(y),key=y.index)

Hãy thử trực tuyến!

Python 2 , 142 138 134 byte

l=input();r=[]
for i in sum([[k for k in range(2,i+1)if i%k<1*all(k%x for x in range(2,k))]for i in l],[]):r+=[i]*(i not in r)
print r

Hãy thử trực tuyến!

Rất ngạc nhiên không có câu trả lời Python nào. Làm việc trên sân golf.

Deorst , 16 byte

EDkE]l1FeFPkEQE_

Hãy thử trực tuyến!

Thực hiện với sự trợ giúp từ @cairdcoinheringaahing trong phòng chat Deorst (lưu ý rằng các giải pháp là khác nhau).

Giải trình

EDkE] l1FeFPkEQE_ Chương trình đầy đủ.

ED Đẩy danh sách các ước của từng phần tử.
  k Ngăn chặn ngăn xếp sắp xếp lại.
   E] Làm phẳng ngăn xếp.
     l1Fe Xóa 1s khỏi ngăn xếp (vì caird đã vội vã và tạo 1 số nguyên tố!) - Nên được loại bỏ trong các bản phát hành ngôn ngữ trong tương lai.
         FP Giữ nguyên số.
           k Ngăn chặn ngăn xếp sắp xếp lại.
            EQ Ded repeatate.
              E_ Xuất kết quả.

Deorst , 16 byte

EDkE]EQFPkl1FeE_

Hãy thử trực tuyến!

Thực hiện với sự giúp đỡ từ @ Mr.Xcoder. Đây là cách quá dài cho một ngôn ngữ giả.

Làm thế nào nó hoạt động

EDkE]EQFPkl1FeE_ - Full program, implicit input: [1,2,3,4,5]

ED               - Get divisors. Vectorizes. STACK = [[1], [1,2], [1,3], [1,2,4], [1,5]]
  k              - Turn off sorting for the next command
   E]            - Flatten the stack. STACK = [1, 1, 2, 1, 3, 1, 2, 4, 1, 5]
     EQ          - Deduplicate stack in place. STACK = [1, 2, 3, 4, 5]
       FP        - Filter by primality 1 is considered prime. STACK = [1, 2, 3, 5]
         k       - Turn off sorting for the next command
          l1     - Push 1. STACK = [1, 2, 3, 5, 1]
            Fe   - Filter elements that are equal to the last element. STACK = [2, 3, 5]
              E_ - Output the whole stack

Pyke , 4 byte

mPs}

Hãy thử nó ở đây!

mP   -   map(factorise, input)
  s  -  sum(^)
   } - uniquify(^)

Octave, 61 byte

a=input('');b=[];for c=a(a>1)b=[b setdiff(factor(c),b)];end;b

Hãy thử trực tuyến!

TÔI, 17 byte

⎕Ḋḟ’⊢f(‘53ǵ'ƒf(ū←

Hãy thử trực tuyến!

Làm sao?

• ⎕ đánh giá đầu vào
• Ḋ ước số (vectorizes / vecizes)
• ḟ làm phẳng
• ’⊢f(‘giảm, lọc, tăng (loại bỏ 1)
• 53ǵ'chuỗi 'P'trong codepage của MY, đó là thử nghiệm nguyên thủy. Đáng buồn 0x35=53là số nguyên tố thứ 16 và không có lệnh đẩy 16vào ngăn xếp> _ <.
• ƒ như một chức năng
• f( lọc theo đó
• ū xác định
• ← đầu ra

C ++, 118 byte

[](auto n){decltype(n)r;for(int m:n)for(int i=1,j;i++<m;){j=m%i;for(int x:r)j|=!(i%x);if(!j)r.push_back(i);}return r;}

Cần phải được thông qua đầu vào trong một std::vector<int>, trả về một std::vector<int>đầu ra khác.

J, 10 byte

~.(#~*),q:

Tôi chắc rằng một số J-er thông minh có thể làm cho điều này ngắn hơn.

Trên thực tế , 5 byte

♂y♂i╔

Hãy thử trực tuyến!

Giải trình:

♂y♂i╔
♂y     prime factors of each element
  ♂i   flatten
    ╔  deduplicate (stable)

Con trăn 2, 88 119 103 byte

Chúng ta đi đây. Với sự sắp xếp chính xác.

def f(l,s=[]):[s.append(x) for x in sum([list(primefac(i)) for i in l],[]) if x not in s];print s
from primefac import*

Dường như tôi không thể làm cho nó hoạt động trên TIO, vì gói không được hỗ trợ. Nó không chạy trên máy của tôi tho. Dưới đây là kết quả thử nghiệm của tôi:

f([1,2,3,4,5,6,7,8,9,10],[])     #[2, 3, 5, 7]
f([10,9,8,7,6,5,4,3,2,1],[])     #[2, 5, 3, 7]
f([100,99,98,1,2,3,4,5],[])      #[2, 5, 3, 11, 7]
f([541,60,19,17,22],[])          #[541, 2, 3, 5, 19, 17, 11]
f([1,1,2,3,5,8,13,21,34,45],[])  #[2, 3, 5, 13, 7, 17]
f([6,7,6,7,6,7,6,5],[])          #[2, 3, 7, 5]
f([1],[])                        #[]
f([8],[])                        #[2]
f([],[])                         #[]

Bằng cách nào đó tôi đã không thể thực hiện chức năng như một chức năng lambda. Bất cứ khi nào tôi cố gắng trả lại sự hiểu biết danh sách, nó sẽ trả về [Không, Không, ...]. Nếu tôi chỉ nhìn vào một cái gì đó, ai đó có thể chỉ ra sai lầm đó? Cảm ơn vì bạn đã phản hồi!

Sử dụng thuật toán sắp xếp Mr. Xcoders tôi có thể cắt mã xuống 16 byte. Cảm ơn bạn cho phần đó.

from primefac import*
def f(l):a=sum([list(primefac(i))for i in l],[]);print sorted(set(a),key=a.index)

Braingolf , 7 byte

&(p)u=;

Hãy thử trực tuyến!

Ôi, cơ bản là một chuỗi gồm 4

Giải trình

&(p)u=;  Implicit input from commandline args
 (.)     Sandbox loop, sandboxes each item in a separate stack and runs the
         code within the loop.
&        Append the entire sandboxed stack when loop ends, rather than only the
         top of stack after each iteration
  p      Prime factors
    u    Unique
     =   Print stack
      ;  Suppress implicit output

APL (Dyalog Extended) , 4 byte ^SBCS

∪∘∊⍭

Hãy thử trực tuyến!