Dada una matriz de enteros positivos, genera una matriz estable de los distintos factores primos de estos enteros. En otras palabras, para cada entero en la entrada en orden, obtenga sus factores primos, ordénelos y agregue cualquier primo que aún no esté en la salida a la salida.

Casos de prueba

[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]
[] -> []

La salida puede ser como una matriz o lista de enteros o cadenas, salida delimitada o cualquier otro medio estándar de salida de una lista ordenada de números.

Este es el código de golf , por lo que la respuesta más corta en bytes gana.

05AB1E , 3 bytes

Salidas como una lista de cadenas.

f˜Ù

Pruébalo en línea!

2sable , 3 bytes

Sí, esto también funciona en 2sable. También devuelve una lista de cadenas.

f˜Ù

Pruébalo en línea!

Casco , 3 bytes

1 byte guardado gracias a @Zgarb .

uṁp

Pruébalo en línea!

Explicación

u Fullp Programa completo.

  p Factores primos de cada uno.
 ṁ Mapear la función sobre la lista y concatenar el resultado.
U único. 

Bash + GNU utilidades, 37

• 21 bytes guardados gracias a @muru (¡guau!)

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

Pruébalo en línea .

MATL, 6 bytes

"@Yfvu

Try it online!

Explanation:

"      % 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.

Interesting MATL tidbits: generally, all functions apply to vectors (arrays) just as easily. But in this case, the number of factors is variable for each input, and Matlab and by extension MATL generally only deal in square matrices, so I had to use a for loop ".

Además, MATL tiene dos operadores principales de concatenación: hy v, concatenación horizontal y vertical. Su comportamiento difiere significativamente: vconcatena toda la pila, incluso si solo tiene un elemento como en nuestra primera iteración. htoma exactamente dos elementos y fallará si solo hay uno presente, lo que lo hace inadecuado para esta aplicación.

Brachylog , 6 bytes

ḋᵐ↔ᵐcd

Pruébalo en línea!

Brachylog , 6 bytes

ḋᵐoᵐcd

Pruébalo en línea!

Explicación

ḋᵐ       Map  with prime decomposition (which returns the factors in reverse order).
  ↔ᵐ Invierta cada uno (u oᵐ - ordene cada uno).
    c Concatenar (aplanar).
     d Deduplicar.

Pyth , 5 4 bytes

{smP

Pruébalo aquí! o Verificar todos los casos de prueba.

Alternativa: {sPM

Explicación

{Programa completo smP con entrada implícita (Q).
  m Mapa sobre la entrada.
   P Factores primos.
 s Aplanar.
{Deduplicar.

Haskell, 77 bytes

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

Explicación:

• el x!yoperador devuelve una lista de todos los factores primos xque son mayores o iguales quey
• la (!2)función devuelve una lista de todos los factores primos de su argumento
• la función en la última línea implementa la funcionalidad requerida

Pruébalo en línea.

Brachylog , 6 bytes

ḋᵐoᵐcd

Pruébalo en línea!

Explicación

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

Ohm v2 , 3 bytes

Sin embargo, otro 3 byter (gracias a los idiomas con auto-vectorización).

m{U

Pruébalo en línea!

Explicación

m Factores primos. Auto-vectoriza sobre la entrada.
 {Aplanar.
  U Uniquify.

Japt , 6 bytes

mk c â

Pruébalo

Explicación

Entrada implícita de matriz U. Map ( m) sobre él, obteniendo los factores ( k) de cada elemento. Flatten ( c), obtiene los elementos únicos ( â) y la salida implícita.

Python 3 , 128 125 116 bytes

Esta es una solución pura de Python. No paquetes Gracias a Halvard por guardar 9 bytes.

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

Pruébalo en línea!

Python 2 , 133 127 126 bytes

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)

Pruébalo en línea!

Python 2 , 142138134 bytes

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

Pruébalo en línea!

Muy sorprendido de que aún no haya una respuesta de Python. Trabajando en golf.

Deorst , 16 bytes

EDkE]l1FeFPkEQE_

Pruébalo en línea!

Hecho con la ayuda de @cairdcoinheringaahing en la sala de chat Deorst (tenga en cuenta que las soluciones son diferentes).

Explicación

EDkE] l1FeFPkEQE_ Programa completo.

ED Empuje la lista de divisores de cada elemento.
  k Evita que la pila se reordene.
   E] Acoplar la pila.
     l1Fe Eliminar 1s de la pila (¡porque caird se apresuró y se convirtió en 1 prime!) - Debería eliminarse en futuras versiones de idiomas.
         FP Mantener los primos.
           k Evita que la pila se reordene.
            EQ Deduplicar.
              E_ Salida del resultado.

Deorst , 16 bytes

EDkE]EQFPkl1FeE_

Pruébalo en línea!

Hecho con la ayuda de @ Mr.Xcoder. Esto es demasiado tiempo para un lenguaje pseudogolfing.

Cómo funciona

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 bytes

mPs}

Pruébalo aquí!

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

Octava, 61 bytes

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

Pruébalo en línea!

MI, 17 bytes

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

Pruébalo en línea!

¿Cómo?

• ⎕ entrada evaluada
• Ḋ divisores (vectoriza / vecifica)
• ḟ aplanar
• ’⊢f(‘decremento, filtro, incremento (elimina 1)
• 53ǵ'la cadena 'P'en la página de códigos de MY, que es la prueba de primalidad. Lamentablemente 0x35=53es el número 16 primo, y no hay un comando para empujar 16a la pila> _ <.
• ƒ como una función
• f( filtrar por eso
• ū uniquify
• ← salida

C ++, 118 bytes

[](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;}

Necesita pasar la entrada en a std::vector<int>, devuelve otro std::vector<int>para la salida.

J, 10 bytes

~.(#~*),q:

Estoy seguro de que algún J-er inteligente podría acortar esto.

En realidad , 5 bytes

♂y♂i╔

Pruébalo en línea!

Explicación:

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

Python 2, 88 119 103 bytes

Aquí vamos. Con la clasificación correcta.

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*

Aparentemente no puedo hacer que funcione en TIO, porque el paquete no es compatible. Se ejecuta en mi máquina aunque. Aquí están mis resultados de prueba:

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([],[])                         #[]

De alguna manera no pude hacer la función como una función lambda. Cada vez que intento devolver la comprensión de la lista, devuelve [Ninguno, Ninguno, ...]. Si solo estoy pasando por alto algo, ¿alguien podría señalar ese error? ¡Gracias por la respuesta!

Usando el algoritmo de ordenación del Sr. Xcoders, podría reducir el código en 16 bytes. Gracias por esa parte

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

Braingolf , 7 bytes

&(p)u=;

Pruébalo en línea!

Oh mira, es básicamente una cadena de 4 integradas

Explicación

&(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) , ^{SBCS de} 4 bytes

∪∘∊⍭

Pruébalo en línea!