Tivemos um grande desafio de fatoração há um tempo atrás, mas esse desafio tem quase seis anos e mal atende aos nossos requisitos atuais, então acredito que está na hora de um novo.

Desafio

Escreva um programa ou função que tome como entrada um número inteiro maior que 1 e produza ou retorne uma lista de seus fatores primos.

Regras

• A entrada e a saída podem ser fornecidas por qualquer método padrão e em qualquer formato padrão.
• Fatores duplicados devem ser incluídos na saída.
• A saída pode estar em qualquer ordem.
• A entrada não será menor que 2 ou maior que 2 ³¹ - 1.
• Os internos são permitidos, mas é recomendável incluir uma solução não interna.

Casos de teste

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

Pontuação

Isso é código-golfe , então o código mais curto em bytes vence.

Pitão , 1 byte

P

Gosto das chances de Pyth nesse desafio.

Python 2 , 55 bytes

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

Experimente online!

Python 2, 53 bytes

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

Tenta cada divisor iem potencial por vez. Se ié um divisor, o anexa e reinicia com n/i. Senão, tenta o próximo divisor mais alto. Como os divisores são verificados em ordem crescente, apenas os primos são encontrados.

Como um programa, para 55 bytes:

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

Mathematica, 38 30 bytes

Obrigado @MartinEnder por 8 bytes!

Join@@Table@@@FactorInteger@#&

Geléia , 2 bytes

Æf

Experimente online!

Haskell , 48 bytes

(2%)
n%1=[]
n%m|mod m n<1=n:n%div m n|k<-n+1=k%m

Experimente online! Exemplo de uso: (2%) 1001rendimentos [7,11,13].

JavaScript (ES6), 44 bytes

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

Horrivelmente ineficiente devido ao fato de iterar de 2 a todos os fatores primos, incluindo o último. Você pode reduzir drasticamente a complexidade do tempo ao custo de 5 bytes:

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

Cubix , 37 32 bytes

vs(...<..1I>(!@)s)%?w;O,s(No;^;<

Experimente online! ou Assista em ação .

Na verdade , 6 bytes

w`in`M

Experimente online!

Explicação:

w`in`M
w       factor into primes and exponents
 `in`M  repeat each prime # of times equal to exponent

J, 2 bytes

q:

O corpo deve ter pelo menos 30 caracteres.

MATL , 2 bytes

Yf

Experimente online!

Obrigatória "resposta interna chata".

Japonês, 2 bytes

Uk

Um interno kusado na entrada U. Também se refere a um país.

Teste online!

surdo , 3 bytes

Essa linguagem é bastante jovem e ainda não está pronta para qualquer coisa importante, mas pode ser fatorada como primordial:

A/D

Isso aguardará a entrada do usuário e emitirá a lista de fatores primos.

MATLAB, 6 bytes

Eu acho que isso não requer nenhuma explicação.

factor

Bash + coreutils, 19 bytes

factor|sed s/.*:.//

Experimente online!

Lote, 96 bytes

@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

Pyke, 1 byte

P

Experimente aqui!

Fatores principais incorporados.

Hexagonia , 58 bytes

Ainda não terminou o golfe, mas o @MartinEnder deve ser capaz de destruir isso de qualquer maneira

Imprime fatores separados por espaço, com um espaço à direita

Golfe:

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

Estabelecido:

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

Explicação em breve.

05AB1E , 1 byte

Ò

Experimente online!

CJam, 2 bytes

mf

cjam.aditsu.net / ...

Esta é uma função. Martin, parece que eu estava com sono.

C, 92 bytes

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

Versão não destruída:

#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]));
}

Japt , 1 byte (não concorrente)

k

Experimente online!

PHP , 51 bytes

for($i=2;1<$a=&$argn;)$a%$i?$i++:$a/=$i*print"$i ";

Experimente online!

C (gcc) , 51 bytes

i;f(n){for(i=2;i<=n;)n%i?i++:printf("%d ",i,n/=i);}

Experimente online!

Perl 6 , 77 64 bytes  

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

Tente

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

Experimente (Nota: não tem tempo suficiente para terminar)

Uma versão com muito mais desempenho é um pouco mais longa, com 100 bytes.

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

Tente

Expandido: ^{_{(versão de 64 bytes)}}

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

VB.NET, 86 bytes

Teve isso em torno de alguns programas do Project Euler. Removidas as otimizações no interesse da falta, e este é o resultado. Naturalmente, o VB é muito detalhado, por isso é bastante longo. Não estou contando os principais espaços em branco. Pode ser omitido, mas é mais fácil ler com ele.

Isso leva um número inteiro como parâmetro e imprime os fatores primos com uma vírgula depois. Há uma vírgula no final.

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

Perl 6 , 51 bytes

Uma solução recursiva:

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

Java (OpenJDK) , 259 bytes

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?", ":""));}}

Experimente online!

Ruby, 61 bytes

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

Versão mais curta que eu consegui pensar.

Ruby , 48 bytes

->x{r,*c=2;0while(x%r<1?(x/=r)&&c<<r:x>=r+=1);c}

Experimente online!

Um pouco atrasado para a festa, mas ... por que não?