Calculer les facteurs premiers

27

Nous avons eu un défi de factorisation de premier ordre il y a quelque temps, mais ce défi remonte à près de six ans et répond à peine à nos exigences actuelles, donc je crois qu'il est temps d'en relever un nouveau.

Défi

Écrivez un programme ou une fonction qui prend en entrée un entier supérieur à 1 et génère ou renvoie une liste de ses facteurs premiers.

Règles

  • L'entrée et la sortie peuvent être fournies par n'importe quelle méthode standard et dans n'importe quel format standard.
  • Les facteurs en double doivent être inclus dans la sortie.
  • La sortie peut être dans n'importe quel ordre.
  • L'entrée ne sera pas inférieure à 2 ni supérieure à 2 31 - 1.
  • Les fonctions intégrées sont autorisées, mais l'inclusion d'une solution non intégrée est encouragée.

Cas de test

2 -> 2
3 -> 3
4 -> 2, 2
6 -> 2, 3
8 -> 2, 2, 2
12 -> 2, 2, 3
255 -> 3, 5, 17
256 -> 2, 2, 2, 2, 2, 2, 2, 2
1001 -> 7, 11, 13
223092870 -> 2, 3, 5, 7, 11, 13, 17, 19, 23
2147483646 -> 2, 3, 3, 7, 11, 31, 151, 331
2147483647 -> 2147483647

Notation

Il s'agit de code-golf , donc le code le plus court en octets l'emporte.

code-golf  primes  factoring 
— ETHproductions
source
2
Cela aurait été beaucoup mieux si vous aviez interdit les fonctions intégrées.
— Mémoire tampon
2
@TheBitByte Les défis qui interdisent les fonctionnalités intégrées sont généralement considérés comme des défis Do X sans Y , d'autant plus qu'il est parfois difficile de dire si une solution est techniquement intégrée.
— ETHproductions
1
Eh bien, profitez de l'afflux de solutions <5 octets! Au moment où j'écris ceci, Pyth le fait déjà en 1 octet.
— Mémoire tampon
2
@TheBitByte Considérez-le comme un défi langue par langue, principalement. Essayez de battre la solution de Python, ou un autre langage sans intégré.
— isaacg
1
@isaacg Eh bien, langue par langue est une meilleure façon de voir les choses, je suis d'accord.
— Mémoire tampon

Réponses:

10

Python 2, 53 octets

f=lambda n,i=2:n/i*[f]and[f(n,i+1),[i]+f(n/i)][n%i<1]

Essaie itour à tour chaque diviseur potentiel . Si iest un diviseur, l'ajoute et redémarre avec n/i. Sinon, essaie le diviseur suivant. Les diviseurs étant vérifiés dans l'ordre croissant, seuls les premiers sont trouvés.

En tant que programme, pour 55 octets:

n=input();i=2
while~-n:
 if n%i:i+=1
 else:n/=i;print i
— xnor
source
8

Mathematica, 38 30 octets

Merci @MartinEnder pour 8 octets!

Join@@Table@@@FactorInteger@#&
— JungHwan Min
source
Et alors FactorInteger[#][[All, 1]]&? 26 octets
— David G.Stork
@ DavidG.Stork qui ne fonctionnerait pas car il ne répéterait pas les facteurs premiers si la puissance est supérieure à 1.
— JungHwan Min
4

JavaScript (ES6), 44 octets

f=(n,x=2)=>n-1?n%x?f(n,x+1):[x,...f(n/x)]:[]

Horriblement inefficace en raison du fait qu'il itère de 2 jusqu'à chaque facteur premier, y compris le dernier. Vous pouvez réduire considérablement la complexité temporelle au prix de 5 octets:

f=(n,x=2)=>x*x>n?[n]:n%x?f(n,x+1):[x,...f(n/x,x)]
— ETHproductions
source
3

En fait , 6 octets

w`in`M

Essayez-le en ligne!

Explication:

w`in`M
w       factor into primes and exponents
 `in`M  repeat each prime # of times equal to exponent
— Mego
source
Vous pouvez probablement simplement utiliser omaintenant, non?
— Oliver
@Oliver Oui, mais je ne mets généralement pas à jour les anciennes réponses avec les fonctions intégrées.
— Mego
2

sourd , 3 octets

Ce langage est assez jeune et n'est pas encore vraiment prêt pour quelque chose de majeur, mais il peut faire une factorisation principale:

A/D

Cela attendra l'entrée de l'utilisateur, puis affichera la liste des facteurs premiers.

— Kade
source
2

MATLAB, 6 octets

Je pense que cela ne nécessite aucune explication.

factor
— flawr
source
1

Bash + coreutils, 19 octets

factor|sed s/.*:.//

Essayez-le en ligne!

— Dennis
source
Vous pouvez raser un octet si les espaces n'ont pas d'importance dans la sortie à l'aide de factor|sed s/.*://. Aussi factor|cut -d: -f2(ou factor|cut -d\ -f2pour correspondre à votre sortie actuelle) a la même longueur d'octet mais va s'exécuter plus rapidement et utiliser moins de surcharge de mémoire.
— Caleb
Je vais demander au PO sur les espaces blancs. Malheureusement, je devrais factor|cut -d\ -f2-éliminer l'espace de tête, qui est un octet de plus.
— Dennis
1

Lot, 96 octets

@set/an=%1,f=2,r=0
:l
@set/af+=!!r,r=n%%f
@if %r%==0 echo %f%&set/an/=f
@if %n% gtr 1 goto l
— Neil
source
1

Hexagonie , 58 octets

Pas encore joué au golf, mais @MartinEnder devrait quand même être capable de le détruire

Imprime les facteurs séparés par des espaces, avec un espace de fin

Golfé:

2}\..}$?i6;>(<...=.\'/})."@...>%<..'':\}$"!>~\{=\)=\}&<.\\

Disposition:

     2 } \ . .
    } $ ? i 6 ;
   > ( < . . . =
  . \ ' / } ) . "
 @ . . . > % < . .
  ' ' : \ } $ " !
   > ~ \ { = \ )
    = \ } & < .
     \ \ . . .

Explication à venir plus tard.

— Bleu
source
1

C, 92 octets

int p(int n){for(int i=2;i<n;i++)if(n%i==0)return printf("%d, ",i)+p(n/i);printf("%d\n",n);}

Version non golfée:

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int prime(int number) {
    for (int i = 2; i < number; i++) {
        if (number % i == 0) {
            printf("%d, ", i);
            return prime(number / i); //you can golf away a few bytes by returning the sum of your recursive function and the return of printf, which is an int
        }                             //this allow you to golf a few more bytes thanks to inline calls
    }
    printf("%d\n", number);
}

int main(int argc, char **argv) {
    prime(atoi(argv[1]));
}
— Valentin Mariette
source
0

Perl 6 , 77 64 octets   

{my$a=$_;.is-prime??$_!!map ->\f{|({$a%f||($a/=f)&&f}...^*!= f)},(2... *>$a)}

Essayez-le

{my$a=$_;map ->\f{|({$a%f||($a div=f)&&f}...^ f>*)},(2... *>$a)}

Essayez-le (Remarque: il ne dispose pas de suffisamment de temps pour terminer)

Une version beaucoup plus performante est légèrement plus longue à 100 octets.

{my$a=$_;map ->\f{|({$a.is-prime??($/=$a)&&($a=0)||$/!!($a%f||($a div=f)&&f)}...^ f>*)},(2... *>$a)}

Essayez-le

Développé: (version 64 octets)

{
  my $a = $_;  # the input ｢$_｣ is read-only by default
  map
    -> \f {
      |(              # slip ( flattens into outer list )

        # generate sequence of 0 or more ｢f｣s
        {
          $a % f      # is it not evenly divisible

          ||          # if it is evenly divisible
          ($a div=f)  # divide it
          &&          # and
          f           # return ｢f｣
        }
        ...^   # keep doing that until
        f > *  # ｢f｣ is bigger
      )

    },

    # do that over the following list

    (2 ... * > $a) # generate a sequence from 2
                   # up to whatever the value of $a
                   # is at the time of the check
}
— Brad Gilbert b2gills
source
0

VB.NET, 86 octets

Avait cela assis autour de certains programmes Project Euler. Suppression des optimisations dans l'intérêt de la brièveté, et c'est le résultat. Naturellement, VB est très verbeux, il est donc assez long. Je ne compte pas le premier espace blanc. Il peut être omis, mais il est plus facile à lire avec.

Cela prend un entier comme paramètre et affiche les facteurs premiers avec une virgule après. Il y a une virgule de fin à la fin.

Sub A(a)
    For i=2To a ' VB re-evaluates a each time, so the /= at the end of the loop shortens this
        While a Mod i=0 ' this is a factor. We've grabbed primes before this, so this must be a prime factor
            Console.Write(i &",") ' output
            a/=i ' "mark" the prime as "used"
        End While
    Next
End Sub
— Brian J
source
0

Perl 6 , 51 octets

Une solution récursive:

sub f(\n,\d=2){n-1??n%d??f n,d+1!!(d,|f n/d,d)!!()}
— Sean
source
0

Java (OpenJDK) , 259 octets

import java.util.*;interface g{static void main(String[]z){int a=new Scanner(System.in).nextInt();int b=0;int[]l={};for(int i=2;i<=a;i++){for(;a%i<1;l[b-1]=i){l=Arrays.copyOf(l,b=l.length+1);a/=i;}}for(int i=0;i<b;i++)System.out.print(l[i]+(i<b-1?", ":""));}}

Essayez-le en ligne!

— Pavel
source
Reportez-vous à cet essentiel pour voir comment cette soumission peut être approfondie: gist.github.com/kritixilithos/fde37dc5a8ae54852aa134a6e70ea495 . Si vous avez besoin de clarifier quelque chose, n'hésitez pas à me cingler au 19ème octet :)
— Kritixi Lithos
0

Rubis, 61 octets

require'prime';->x{x.prime_division.flat_map{|x|[x[0]]*x[1]}}

La version intégrée la plus courte à laquelle je pouvais penser.

— Seims
source
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.