Fattorizzazione dell'array

13

Dato un array di numeri interi positivi, genera un array stabile dei distinti fattori primi di questi numeri interi. In altre parole, per ogni numero intero nell'input in ordine, ottieni i suoi fattori primi, ordinali e aggiungi tutti i numeri primi non già nell'output all'output.

Casi test

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

L'output può essere un array o un elenco di numeri interi o stringhe, output delimitato o qualsiasi altro mezzo standard per produrre un elenco ordinato di numeri.

Questo è code-golf , quindi vince la risposta più breve in byte.

code-golf  array-manipulation  primes 
— Stefano
fonte
— Stephen,
5
Questa è una di quelle sfide che ritengo "troppo semplici". Quasi ogni risposta assomiglierà a una di queste: (a) un loop sull'input e il codice di fattorizzazione Ye Olde Prime con un'appendice condizionale; (b) una catena di quattro built-in. Non c'è molto spazio per la creatività. Forse le risposte mi dimostreranno sbagliate, ma ne dubito. Qui c'è molto poco di più del golf oltre alla fattorizzazione primaria, e questo è stato fatto a morte.
— Lynn,
1
@Lynn è banale per i golfisti, ma non banale per quasi tutto il resto. Non sono sicuro se questo è motivo di banalità qui: /
— Stephen
Puoi dirmi quali sono i "fattori primi distinti" di 1?
— J42161217,
1
@DigitalTrauma Sì. Altrimenti sarebbe solo "uscita l'insieme di tutti i fattori primi dell'input"
— Stephen

Risposte:

5

Buccia , 3 byte

1 byte salvato grazie a @Zgarb .

uṁp

Provalo online!

Spiegazione

u programp Programma completo.

  p Fattori primi di ciascuno.
 ṁ Mappa la funzione sull'elenco e concatena il risultato.
unico.
— Mr. Xcoder
fonte
3
Σ†può essere ṁ.
— Zgarb,
@Zgarb Grazie mille. Come puoi dire, è la mia prima risposta Husk in assoluto :)
— Mr. Xcoder,
È bello vedere nuove persone che usano Husk. :)
— Zgarb,
1
@Zgarb Sembra molto bello (soprattutto quando supera la gelatina: P)
— Mr. Xcoder
5

Utilità Bash + GNU, 37

  • 21 byte salvati grazie a @muru (wow!)
factor|tr \  \\n|awk '!/:/&&!a[$0]++'

Provalo online .

— Trauma digitale
fonte
1
Penso che si nl|sort|...possa fare usando awk: awk '!a[$0]++'(stampa se non visto prima; quindi l'ordine non viene mai perso), risparmiando 15 byte. Quindi il sedcomando può essere eliminato usando uno leggermente più lungo awk: factor|awk '!/:/&&!a[$0]++' RS='[ \n]+'(dividi i record su spazi e newline, salta i record con :), salvando altri 4 byte.
— muru,
1
Mi sono appena reso conto di poter salvare altri due byte nel commento precedente usando tr: factor|tr \ \\n|awk '!/:/&&!a[$0]++'(sono due spazi dopo la prima barra rovesciata)
— muru,
@muru fantastico - grazie! (Non sarei stato sconvolto se avessi pubblicato questo come risposta personale, che ha notevolmente superato il mio originale)
— Digital Trauma
4

MATL , 6 byte

"@Yfvu

Provalo online!

Spiegazione:

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

Idee interessanti MATL: in generale, tutte le funzioni si applicano ai vettori (array) altrettanto facilmente. Ma in questo caso, il numero di fattori è variabile per ogni input, e Matlab e per estensione MATL generalmente si occupano solo di matrici quadrate, quindi ho dovuto usare un ciclo for ".

Inoltre, MATL ha due principali operatori di concatenazione: he v, concatenazione orizzontale e verticale. Il loro comportamento differisce in modo significativo: vconcatena l'intero stack, anche se ha solo un elemento come nella nostra prima iterazione. haccetta esattamente due elementi e fallirà se ne è presente solo uno, rendendolo inadatto per questa applicazione.

— Sanchises
fonte
3

PowerShell , 102 byte

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

Provalo online!

(Prende in prestito l'idea di fattorizzazione dalla risposta di TessellatingHeckler su "Fatti alle spalle Satan-Prime!")

Accetta input come un array letterale $x. Crea un nuovo array vuoto $a. Si avvolge $x. Ogni iterazione viene ripetuta 2fino al numero corrente, verificando se si tratta di un fattore -andprimo, quindi |sortl'output di quello e lo accoda $a. Quando abbiamo finito $x, abbiamo quindi prodotto $ama |selectsolo i -uloro numeri di nicchia. Questo sfrutta il fatto che uniqueify va da sinistra a destra, mantenendo la prima occorrenza, che corrisponde alla descrizione del problema. Quei numeri vengono lasciati in cantiere e l'output è implicito.

— AdmBorkBork
fonte
3

CJam, 11 byte

{:mfe__&1-}

Funzione che accetta array di ints e genera array di ints.

Versione di prova

— geokavel
fonte
Come differenzerei l'output con più caratteri? Almeno per il mio test (online) genera una stringa, non una matrice di ints.
— Stephen,
Come funzione, il suo tipo di dati di output è un array di ints. CJam stampa automaticamente questo stack e stampa array senza delimitatori. Non so se sia abbastanza buono per i tuoi scopi. Se si desidera aggiungere delimitatori S*all'interno della parentesi chiusa.
— geokavel,
Credo che i lang basati su stack possano essere emessi da ToS comunque, quindi va bene, mi stavo solo chiedendo. Grazie.
— Stephen,
2

Mathematica, 64 byte

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

ingresso

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

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

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

Spiegazione:

  • l' x!yoperatore restituisce un elenco di tutti i fattori primi xche sono maggiori o uguali ay
  • la (!2)funzione restituisce un elenco di tutti i fattori primi del suo argomento
  • la funzione sull'ultima riga implementa la funzionalità richiesta

Provalo online.

— Cristian Lupascu
fonte
2

Brachylog , 6 byte

ḋᵐoᵐcd

Provalo online!

Spiegazione

ḋᵐ         Map prime decomposition
  oᵐ       Map order
    c      Concatenate
     d     Remove duplicates
— Fatalize
fonte
Fais per [10,9,8,7,6,5,4,3,2,1]. Dovrebbe essere [2, 5, 3, 7], non[2, 3, 5, 7]
— il signor Xcoder
Puoi aggiustarlo per +1 byte:ḋᵐoᵐcd
— Mr. Xcoder
@ Mr.Xcoder Grazie, risolto. Requisito piuttosto non sensato, comunque.
— Fatalizza il
Non è proprio non chiacchiere, in quanto è un piccolo, minuscolo po 'meno banale. Ho pubblicato anche la mia risposta, ma ho usato prima il contrario invece che l'ordine. Non sai perché i fattori primi sono generati in ordine inverso?
— Mr. Xcoder,
@Fatalizza bene - la sfida non è "ordinare i fattori primi distinti dell'elenco", è "scorrere l'elenco e aggiungere fattori primi distinti".
— Stephen,
2

Ohm v2 , 3 byte

Ancora un altro 3-byter (grazie alle lingue con auto-vettorializzazione).

m{U

Provalo online!

Spiegazione

m Fattori primi. Vettorializza automaticamente sull'input.
 {Appiattisci.
  U Uniquify.
— Mr. Xcoder
fonte
2

Japt , 6 byte

mk c â

Provalo

Spiegazione

Input implicito di array U. Mappa ( m) su di esso, ottenendo i fattori ( k) di ciascun elemento. Appiattire ( c), ottenere gli elementi univoci ( â) e implicitamente l'output.

— ispido
fonte
2

Python 3 , 128 125 116 byte

Questa è una soluzione Python pura. Nessun pacco Grazie a Halvard per aver salvato 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))

Provalo online!

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)

Provalo online!

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

Provalo online!

Molto sorpreso non c'era ancora risposta Python. Lavorando sul golf.

— Mr. Xcoder
fonte
— Halvard Hummel,
@HalvardHummel Grazie
— Mr. Xcoder
2

Deorst , 16 byte

EDkE]l1FeFPkEQE_

Provalo online!

Fatto con l'aiuto di @cairdcoinheringaahing nella chat di Deorst (nota che le soluzioni sono diverse).

Spiegazione

EDkE] l1FeFPkEQE_ Programma completo.

ED Spingere l'elenco dei divisori di ciascun elemento.
  k Impedire il riordino dello stack.
   E] Appiattire la pila.
     l1Fe Rimuovi 1s dallo stack (perché caird si è precipitato e ha fatto 1 numero primo!) - Dovrebbe essere rimosso nelle versioni future della lingua.
         FP Mantieni i numeri primi.
           k Impedire il riordino dello stack.
            Deduplicazione EQ.
              E_ Emette il risultato.
— Mr. Xcoder
fonte
2

Deorst , 16 byte

EDkE]EQFPkl1FeE_

Provalo online!

Fatto con l'aiuto di @ Mr.Xcoder. È troppo lungo per un linguaggio pseudogolfing.

Come funziona

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
fonte
1

Pyke , 4 byte

mPs}

Provalo qui!

mP   -   map(factorise, input)
  s  -  sum(^)
   } - uniquify(^)
— Blu
fonte
Ahi, ti ho fatto male - Bene, abbiamo approcci diversi :)
— Mr. Xcoder,
: P Differenza di un byte. Penso che sia permesso comunque o almeno secondo l'ultimo consenso che ho letto
— Blue
Sì, sono consentite risposte duplicate, anche byte-to-byte
— Mr. Xcoder,
1

MY, 17 byte

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

Provalo online!

Come?

  • ⎕ input valutato
  • Ḋ divisori (vettorializza / vecifica)
  • ḟ appiattire
  • ’⊢f(‘ decrementa, filtra, incrementa (rimuove 1 )
  • 53ǵ'la stringa 'P'nella tabella codici di MY, che è il test di primalità. Purtroppo 0x35=53è il sedicesimo numero primo e non c'è un comando per spingere16 in pila> _ <.
  • ƒ come una funzione
  • f( filtra per quello
  • ū uniquify
  • ← produzione
— Zaccaria
fonte
1

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;}

Deve essere passato l'ingresso in a std::vector<int>, ne restituisce un altro std::vector<int>per l'output.

— HVD
fonte
1

J, 10 byte

~.(#~*),q:

Sono sicuro che qualche J-er intelligente potrebbe renderlo più breve.

— Gregory Higley
fonte
1

Python 2, 88 119 103 byte

Eccoci qui. Con l'ordinamento corretto.

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*

Apparentemente non riesco a farlo funzionare su TIO, perché il pacchetto non è supportato. Funziona sulla mia macchina però. Ecco i miei risultati del test:

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

In qualche modo non sono stato in grado di eseguire la funzione come funzione lambda. Ogni volta che provo a restituire la comprensione dell'elenco, restituisce [Nessuno, Nessuno, ...]. Se sto solo trascurando qualcosa, qualcuno potrebbe segnalare quell'errore? Grazie per il feedback!

Modificare:

Usando l'algoritmo di ordinamento di Mr. Xcoders ho potuto ridurre il codice di 16 byte. Grazie per quella parte.

from primefac import*
def f(l):a=sum([list(primefac(i))for i in l],[]);print sorted(set(a),key=a.index)
— Simon
fonte
Questo non sembra essere corretto. Il secondo caso di test dovrebbe essere prodotto [2, 5, 3, 7]. L'ordine delle uscite è importante.
— Mego
sorted(set().union(*map(primefac,l)))
— Alex Hall,
L'ordine delle uscite è importante. Rileggi la spiegazione o guarda le altre risposte: non so davvero come spiegarla diversamente.
— Stephen,
@Stefano. Routine aggiornata, con output corretto. Mi ci è voluto un po 'prima di notare le differenze in ogni riga. Concentrarsi durante la lettura aiuta molto.
— Simon,
@Simon salva tre byte eliminando gli spazi dopo le parentesi - s.append(x) for-> s.append(x)for, primefac(i)) for-> primefac(i))for, []) if->[])if
— Stephen
1

Braingolf , 7 byte

&(p)u=;

Provalo online!

Oh guarda, è fondamentalmente una catena di 4 built-in

Spiegazione

&(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
fonte
Non funziona per [10,9,8,7,6,5,4,3,2,1]. - L'ordine conta: dovresti restituire [2, 5, 3, 7]invece di [2, 3, 5, 7].
— Mr. Xcoder,
Puoi risolverlo per -1 byte però . Dal momento Kche fa solo male qui.
— Mr. Xcoder,
@ Mr.Xcoder oh sì sì, non avevo capito che dovevano essere in ordine di occorrenza, non in ordine crescente. Risolto
— Skidsdev
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.