Factorización de matrices

13

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.

code-golf  array-manipulation  primes 
— Stephen
fuente
— Stephen el
55
Este es uno de esos desafíos que creo que es "demasiado simple". Casi todas las respuestas se verán como una de estas: (a) un bucle sobre la entrada, y el código de factorización de Ye Olde Prime con un anexo condicional; (b) una cadena de cuatro elementos integrados. Simplemente no hay mucho espacio para la creatividad. Tal vez las respuestas demuestren que estoy equivocado, pero lo dudo. Aquí el golf es muy poco más que la factorización principal aquí, y eso se ha hecho hasta la muerte.
— Lynn
1
@ Lynn es trivial para jugar al golf, pero no es trivial para casi todo lo demás. No estoy seguro si eso es motivo de trivialidad aquí: /
— Stephen
¿Me puede decir cuáles son "los factores primos distintos" de 1?
— J42161217
1
@ DigitalTrauma Sí. De lo contrario, solo sería "generar el conjunto de todos los factores primos de la entrada"
— Stephen

Respuestas:

5

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.
— Sr. Xcoder
fuente
3
Σ†puede ser ṁ.
— Zgarb
@ Zgarb Muchas gracias. Como pueden ver, es mi primera respuesta de Husk :)
— Sr. Xcoder
Es agradable ver gente nueva usando Husk. :)
— Zgarb
1
@ Zgarb Parece muy agradable (especialmente cuando supera a Jelly: P)
— Sr. Xcoder
5

Bash + GNU utilidades, 37

  • 21 bytes guardados gracias a @muru (¡guau!)
factor|tr \  \\n|awk '!/:/&&!a[$0]++'

Pruébalo en línea .

— Trauma digital
fuente
1
I think the nl|sort|... can be done using awk: awk '!a[$0]++' (print if not seen before; so order is never lost), saving 15 bytes. Then the sed command can be eliminated using a slightly longer awk one: factor|awk '!/:/&&!a[$0]++' RS='[ \n]+' (split records on spaces and newlines, skip records with :), saving another 4 bytes.
— muru
1
I just realised I can save another two bytes on the previous comment by using tr: factor|tr \ \\n|awk '!/:/&&!a[$0]++' (that's two spaces after the first backslash)
— muru
@muru awesome - thanks! (I wouldn't have been upset if you'd posted this as your own answer, that significantly out-golfed my original)
— Digital Trauma
4

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.

— Sanchises
fuente
3

PowerShell , 102 bytes

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

Pruébalo en línea!

(Toma prestada la idea de factorización de la respuesta de TessellatingHeckler sobre "¡Apártate de mí, Satan-Prime!")

Takes input as a literal array $x. Creates a new empty array $a. Loops over $x. Each iteration we loop from 2 up to the current number, checking whether that is a factor -and is prime, then |sort the output of that, and append it to $a. When we're done going through $x, we then output $a but |select only the -unique numbers thereof. This exploits the fact that the uniqueify goes left-to-right, keeping the first occurrence, which matches the problem description. Those numbers are left on the pipeline and output is implicit.

— AdmBorkBork
fuente
3

CJam, 11 bytes

{:mfe__&1-}

Función que toma una matriz de entradas y produce una matriz de entradas.

Versión de prueba

— geokavel
fuente
¿Cómo diferenciaría la salida con varios caracteres? Al menos para mi prueba (en línea) genera una cadena, no una matriz de entradas.
— Stephen
Como función, su tipo de datos de salida es una matriz de entradas. CJam imprime automáticamente esta pila e imprime matrices sin delimitadores. No sé si eso es lo suficientemente bueno para tus propósitos. Si desea delimitadores agregue S*dentro del corchete cerrado.
— geokavel
Creo que, de todos modos, los langs basados ​​en pila pueden generar resultados por ToS, así que está bien, me preguntaba. Gracias.
— Stephen
2

Mathematica, 64 bytes

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

entrada

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

— J42161217
fuente
Select[#&@@@Gather[#&@@@Join@@FactorInteger@#],#>1&]&
— matrix89
2

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.

— Cristian Lupascu
fuente
2

Brachylog , 6 bytes

ḋᵐoᵐcd

Pruébalo en línea!

Explicación

ḋᵐ         Map prime decomposition
  oᵐ       Map order
    c      Concatenate
     d     Remove duplicates
— Fatalizar
fuente
Fais para [10,9,8,7,6,5,4,3,2,1]. Debería ser [2, 5, 3, 7], no[2, 3, 5, 7]
— Sr. Xcoder
Puede arreglar eso para +1 byte:ḋᵐoᵐcd
— Sr. Xcoder
@ Mr.Xcoder Gracias, arreglado. Sin embargo, requisitos imo bastante no sensuales.
— Fatalize
No es realmente no sensitivo, ya que es un poco , un poquito menos trivial. Publiqué mi propia respuesta también, pero usé invertido primero en lugar de orden. ¿No está seguro de por qué los factores primos se generan en orden inverso?
— Sr. Xcoder
@Fatalice bien: el desafío no es "ordenar los factores primos distintos de la lista", es "iterar a través de la lista y agregar factores primos distintos".
— Stephen
2

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.
— Sr. Xcoder
fuente
2

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.

— Lanudo
fuente
2

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.

— Sr. Xcoder
fuente
— Halvard Hummel
@HalvardHummel Gracias
— Sr. Xcoder
2

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.
— Sr. Xcoder
fuente
2

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
— caird coinheringaahing
fuente
1

Pyke , 4 bytes

mPs}

Pruébalo aquí!

mP   -   map(factorise, input)
  s  -  sum(^)
   } - uniquify(^)
— Azul
fuente
Ouch, te ninja mal - Bueno, tenemos diferentes enfoques :)
— Sr. Xcoder
: P Diferencia de un byte. Sin embargo, creo que está permitido, o al menos según el último consenso que leí
— el
Sí, se permiten respuestas duplicadas, incluso byte a byte
— Sr. Xcoder
1

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
— Zacharý
fuente
1

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.

— hvd
fuente
1

J, 10 bytes

~.(#~*),q:

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

— Gregory Higley
fuente
1

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!

Editar:

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)
— Simón
fuente
Esto no parece ser correcto. El segundo caso de prueba debería salir [2, 5, 3, 7]. El orden de las salidas es importante.
— Mego
sorted(set().union(*map(primefac,l)))
— Alex Hall
El orden de las salidas es importante. Vuelva a leer la explicación o mire otras respuestas. Realmente no sé cómo explicarla.
— Stephen
@Stephen. Rutina actualizada, con salida correcta. Me tomó un tiempo hasta que noté las diferencias en cada línea. Centrarse mientras lee ayuda mucho.
— Simon
@Simon ahorra tres bytes al deshacerse de los espacios después de los parens - s.append(x) for-> s.append(x)for, primefac(i)) for-> primefac(i))for, []) if->[])if
— Stephen
1

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
— Skidsdev
fuente
Falla por [10,9,8,7,6,5,4,3,2,1]. - El orden es importante: debe regresar en [2, 5, 3, 7]lugar de [2, 3, 5, 7].
— Sr. Xcoder
Sin embargo, puedes arreglar eso para -1 byte . Ya que Ksolo hace daño aquí.
— Sr. Xcoder
@ Mr.Xcoder oh, sí, no me di cuenta de que se suponía que debían estar en orden de ocurrencia, no en orden ascendente. Corregido
— Skidsdev
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.