Factorisation des tableaux

13

Étant donné un tableau d'entiers positifs, affichez un tableau stable des facteurs premiers distincts de ces entiers. En d'autres termes, pour chaque entier de l'entrée dans l'ordre, obtenez ses facteurs premiers, triez-les et ajoutez à la sortie tous les nombres premiers qui ne sont pas déjà dans la sortie.

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

La sortie peut être un tableau ou une liste d'entiers ou de chaînes, une sortie délimitée ou tout autre moyen standard de sortie d'une liste ordonnée de nombres.

C'est le code-golf , donc la réponse la plus courte en octets l'emporte.

code-golf  array-manipulation  primes 
— Stephen
source
— Stephen
5
C'est l'un de ces défis qui, à mon avis, est «trop simple». Presque toutes les réponses vont ressembler à l'une d'entre elles: (a) une boucle sur l'entrée, et le code de factorisation Ye Olde Prime avec un ajout conditionnel; (b) une chaîne de quatre éléments intégrés. Il n'y a tout simplement pas beaucoup de place pour la créativité. Peut-être que les réponses me prouveront le contraire, mais j'en doute. Il n'y a pas grand-chose de plus dans le golf que la factorisation principale ici, et cela a été fait à mort.
— Lynn
1
@Lynn, c'est trivial pour les langues de golf, mais non trivial pour presque tout le reste. Je ne sais pas si c'est un motif de trivialité ici: /
— Stephen
Pouvez-vous me dire quels sont les "facteurs premiers distincts" de 1?
— J42161217
1
@DigitalTrauma Oui. Sinon, ce serait juste "sortir l'ensemble de tous les facteurs premiers de l'entrée"
— Stephen

Réponses:

5

Husk , 3 octets

1 octet enregistré grâce à @Zgarb .

uṁp

Essayez-le en ligne!

Explication

uṁp Programme complet.

  p Facteurs premiers de chacun.
 ṁ Mapper la fonction sur la liste et concaténer le résultat.
u Unique.
— M. Xcoder
source
3
Σ†peut être ṁ.
— Zgarb
@Zgarb Merci beaucoup. Comme vous pouvez le voir, c'est ma première réponse Husk jamais :)
— M. Xcoder
C'est agréable de voir de nouvelles personnes utiliser Husk. :)
— Zgarb
1
@Zgarb Cela semble très agréable (surtout quand il surpasse Jelly: P)
— M. Xcoder
5

Utilitaires Bash + GNU, 37

  • 21 octets enregistrés grâce à @muru (wow!)
factor|tr \  \\n|awk '!/:/&&!a[$0]++'

Essayez-le en ligne .

— Traumatisme numérique
source
1
Je pense que cela nl|sort|...peut être fait en utilisant awk: awk '!a[$0]++'(imprimer s'il n'est pas vu auparavant, donc l'ordre n'est jamais perdu), en économisant 15 octets. Ensuite, la sedcommande peut être éliminée en utilisant une commande légèrement plus longue awk: factor|awk '!/:/&&!a[$0]++' RS='[ \n]+'(fractionner les enregistrements sur les espaces et les sauts de ligne, sauter les enregistrements avec :), en économisant encore 4 octets.
— muru
1
Je viens de réaliser que je peux économiser encore deux octets sur le commentaire précédent en utilisant tr: factor|tr \ \\n|awk '!/:/&&!a[$0]++'(c'est deux espaces après la première barre oblique inverse)
— muru
@muru génial - merci! (Je n'aurais pas été contrarié si vous aviez posté cela comme votre propre réponse, qui a largement dépassé mon original)
— Digital Trauma
4

MATL , 6 octets

"@Yfvu

Essayez-le en ligne!

Explication:

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

Quelques informations MATL intéressantes: généralement, toutes les fonctions s'appliquent aux vecteurs (tableaux) tout aussi facilement. Mais dans ce cas, le nombre de facteurs est variable pour chaque entrée, et Matlab et par extension MATL ne traitent généralement que des matrices carrées, j'ai donc dû utiliser une boucle for ".

De plus, MATL a deux principaux opérateurs de concaténation: het v, la concaténation horizontale et verticale. Leur comportement diffère considérablement: vconcatène toute la pile, même si elle n'a qu'un seul élément comme lors de notre première itération. hprend exactement deux éléments et échouera si un seul est présent, le rendant inapproprié pour cette application.

— Sanchises
source
3

PowerShell , 102 octets

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

Essayez-le en ligne!

(Idée de factorisation des emprunts issue de la réponse de TessellatingHeckler sur "Mettez-vous derrière moi Satan-Prime!")

Prend l'entrée comme un tableau littéral $x. Crée un nouveau tableau vide $a. Boucles $x. À chaque itération, nous bouclons 2jusqu'au nombre actuel, vérifiant si c'est un facteur -andpremier, puis |sortla sortie de celui-ci, et ajoutons-le à $a. Lorsque nous aurons terminé en passant par $x, nous avons alors sortie , $amais |selectseulement-u numéros de ceux - ci nique. Cela exploite le fait que l'unicité va de gauche à droite, en conservant la première occurrence, qui correspond à la description du problème. Ces chiffres sont laissés sur le pipeline et la sortie est implicite.

— AdmBorkBork
source
3

CJam, 11 octets

{:mfe__&1-}

Fonction qui prend un tableau d'ints et génère un tableau d'ints.

Version de test

— geokavel
source
Comment différencier la sortie avec plusieurs caractères? Au moins pour mes tests (en ligne), il génère une chaîne, pas un tableau d'entiers.
— Stephen
En tant que fonction, son type de données de sortie est un tableau d'ints. CJam imprime automatiquement cette pile et imprime des tableaux sans délimiteurs. Je ne sais pas si c'est assez bon pour vos besoins. Si vous souhaitez ajouter des délimètres S*à l'intérieur du crochet de fermeture.
— geokavel
Je crois que les langages basés sur la pile peuvent sortir par ToS de toute façon, donc ça va, je me demandais juste. Merci.
— Stephen
2

Mathematica, 64 octets

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

contribution

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

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

Haskell, 77 octets

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

Explication:

  • l' x!yopérateur renvoie une liste de tous les facteurs premiers xqui sont supérieurs ou égaux ày
  • la (!2)fonction renvoie une liste de tous les facteurs premiers de son argument
  • la fonction sur la dernière ligne implémente la fonctionnalité requise

Essayez-le en ligne.

— Cristian Lupascu
source
2

Brachylog , 6 octets

ḋᵐoᵐcd

Essayez-le en ligne!

Explication

ḋᵐ         Map prime decomposition
  oᵐ       Map order
    c      Concatenate
     d     Remove duplicates
— Fatalize
source
Fais pour [10,9,8,7,6,5,4,3,2,1]. Ce devrait être [2, 5, 3, 7], non[2, 3, 5, 7]
— M. Xcoder
Vous pouvez corriger cela pour +1 octet:ḋᵐoᵐcd
— M. Xcoder
@ Mr.Xcoder Merci, fixe. Une exigence assez non sensuelle imo cependant.
— Fatalize
Ce n'est pas vraiment insensé, car c'est un tout petit peu moins trivial. J'ai également publié ma propre réponse, mais j'ai utilisé inversé en premier au lieu de l'ordre. Vous ne savez pas pourquoi les facteurs premiers sont générés dans l'ordre inverse?
— M. Xcoder
@Fatalize well - le défi n'est pas de "trier les facteurs premiers distincts de la liste", mais de "parcourir la liste et d'ajouter des facteurs premiers distincts".
— Stephen
2

Ohm v2 , 3 octets

Encore un 3 octets (grâce aux langages avec auto-vectorisation).

m{U

Essayez-le en ligne!

Explication

m Facteurs premiers. Auto-vectorise sur l'entrée.
 {Aplatir.
  U Uniquify.
— M. Xcoder
source
2

Japt , 6 octets

mk c â

Essaye-le

Explication

Entrée implicite du tableau U. Map ( m) dessus, obtenant les facteurs ( k) de chaque élément. Aplatir ( c), obtenir les éléments uniques ( â) et les afficher implicitement.

— Hirsute
source
2

Python 3 , 128 125 116 octets

Il s'agit d'une pure solution Python. Pas de colis. Merci à Halvard d'avoir économisé 9 octets.

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

Essayez-le en ligne!

Python 2 , 133 127 126 octets

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)

Essayez-le en ligne!

Python 2 , 142 138 134 134 octets

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

Essayez-le en ligne!

Très surpris qu'il n'y ait pas encore de réponse Python. Travailler sur le golf.

— M. Xcoder
source
— Halvard Hummel
@HalvardHummel Merci
— M. Xcoder
2

Deorst , 16 octets

EDkE]l1FeFPkEQE_

Essayez-le en ligne!

Fait avec l'aide de @cairdcoinheringaahing dans le salon de discussion Deorst (notez que les solutions sont différentes).

Explication

EDkE] l1FeFPkEQE_ Programme complet.

ED Poussez la liste des diviseurs de chaque élément.
  k Empêchez la pile de se réorganiser.
   E] Aplatissez la pile.
     l1Fe Supprimer 1s de la pile (parce que caird s'est précipité et a fait 1 prime!) - Doit être supprimé dans les futures versions linguistiques.
         FP Gardez les nombres premiers.
           k Empêchez la pile de se réorganiser.
            EQ Deduplicate.
              E_ Sortie du résultat.
— M. Xcoder
source
2

Deorst , 16 octets

EDkE]EQFPkl1FeE_

Essayez-le en ligne!

Fait avec l'aide de @ Mr.Xcoder. C'est beaucoup trop long pour un langage de pseudogolf.

Comment ça fonctionne

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

Pyke , 4 octets

mPs}

Essayez-le ici!

mP   -   map(factorise, input)
  s  -  sum(^)
   } - uniquify(^)
— Bleu
source
Aïe, je vous ai mal ninja - Bon nous avons des approches différentes :)
— M. Xcoder
: P Différence d'un octet. Je pense que c'est autorisé ou du moins selon le dernier consensus que j'ai lu
— Blue
Oui, les réponses en double, même octet par octet sont autorisées
— M. Xcoder
1

MY, 17 octets

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

Essayez-le en ligne!

Comment?

  • ⎕ entrée évaluée
  • Ḋ diviseurs (vectorise / précise)
  • ḟ aplatir
  • ’⊢f(‘décrémenter, filtrer, incrémenter (supprime 1)
  • 53ǵ'la chaîne 'P'dans la page de codes de MY, qui est un test de primalité. C'est malheureusement 0x35=53le 16e nombre premier, et il n'y a pas de commande pour pousser 16vers la pile> _ <.
  • ƒ en tant que fonction
  • f( filtrer par ça
  • ū unifier
  • ← production
— Zacharý
source
1

C ++, 118 octets

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

Doit être passé l'entrée dans un std::vector<int>, renvoie un autre std::vector<int>pour la sortie.

— hvd
source
1

J, 10 octets

~.(#~*),q:

Je suis sûr qu'un J-er intelligent pourrait raccourcir la durée.

— Gregory Higley
source
1

Python 2, 88 119 103 103 octets

Et c'est parti. Avec le bon tri.

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*

Apparemment, je ne peux pas le faire fonctionner sur TIO, car le package n'est pas pris en charge. Il fonctionne sur ma machine. Voici mes sorties de 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([],[])                         #[]

D'une certaine manière, je n'ai pas pu faire de la fonction une fonction lambda. Chaque fois que j'essaie de renvoyer la liste, elle renvoie [Aucun, Aucun, ...]. Si je néglige quelque chose, quelqu'un pourrait-il signaler cette erreur? Merci pour les commentaires!

Éditer:

En utilisant l'algorithme de tri de M. Xcoders, j'ai pu réduire le code de 16 octets. Merci pour cette partie.

from primefac import*
def f(l):a=sum([list(primefac(i))for i in l],[]);print sorted(set(a),key=a.index)
— Simon
source
Cela ne semble pas être correct. Le deuxième cas de test devrait sortir [2, 5, 3, 7]. L'ordre des sorties est important.
— Mego
sorted(set().union(*map(primefac,l)))
— Alex Hall
L'ordre des sorties est important. Relisez l'explication ou regardez d'autres réponses - je ne sais pas vraiment comment l'expliquer autrement.
— Stephen
@Stephen. Updated routine, with correct output. It took me a while until i noticed the differences in each line. Focus while reading helps a lot.
— Simon
@Simon save three bytes by getting rid of spaces after parens - s.append(x) for -> s.append(x)for, primefac(i)) for -> primefac(i))for, []) if-> [])if
— Stephen
1

Braingolf, 7 bytes

&(p)u=;

Try it online!

Oh look, it's basically a chain of 4 built-ins

Explanation

&(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
source
Fails for [10,9,8,7,6,5,4,3,2,1]. - The order matters: you should return [2, 5, 3, 7] instead of [2, 3, 5, 7].
— Mr. Xcoder
You can fix that for -1 byte though. Since K only makes harm here.
— Mr. Xcoder
@Mr.Xcoder oh right yeah, didn't realise they were supposed to be in order of occurrence, not ascending order. Fixed
— Skidsdev
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.