Abbiamo avuto una sfida di fattorizzazione primaria qualche tempo fa, ma quella sfida ha quasi sei anni e soddisfa a malapena le nostre attuali esigenze, quindi credo che sia tempo per una nuova.

Sfida

Scrivi un programma o una funzione che accetta come input un numero intero maggiore di 1 e genera o restituisce un elenco dei suoi fattori primi.

Regole

L'input e l'output possono essere forniti con qualsiasi metodo standard e in qualsiasi formato standard.
I fattori duplicati devono essere inclusi nell'output.
L'output può essere in qualsiasi ordine.
L'ingresso non sarà inferiore a 2 o superiore a 2 ³¹ - 1.
Gli incorporati sono consentiti, ma è incoraggiata l'inclusione di una soluzione non incorporata.

Casi 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

punteggio

Questo è code-golf , quindi vince il codice più breve in byte.

code-golf primes factoring

— ETHproductions
fonte

2

Sarebbe molto meglio se non si consentissero i built-in.

— Buffer over letto il

2

@TheBitByte Le sfide che non consentono gli incorporamenti sono generalmente considerate sfide Do X senza Y , soprattutto perché a volte è difficile stabilire se una soluzione sia tecnicamente integrata.

— Produzioni ETH il

1

Bene, goditi l'afflusso di soluzioni <5 byte! Mentre scrivo, Pyth lo fa già in 1 byte.

— Buffer over letto il

2

@TheBitByte Pensalo principalmente come una sfida lingua per lingua. Prova a battere la soluzione di Python o qualche altra lingua senza un built-in.

— isaacg,

1

@isaacg Beh, lingua per lingua è un modo migliore di vederlo, sono d'accordo.

— Buffer over letto il

15

Pyth , 1 byte

Mi piacciono le possibilità di Pyth in questa sfida.

— isaacg
fonte

16

Fino a quando la lingua "P" arriva e lo fa in 0 byte

— downrep_nation

13

Python 2 , 55 byte

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

Provalo online!

— Dennis
fonte

1

Scommetto che hai aspettato questa cosa per quasi un'ora ...

— ETHproductions il

10

Python 2, 53 byte

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

Prova ia turno ogni potenziale divisore . Se iè un divisore, lo antepone e si riavvia n/i. Altrimenti, prova il divisore successivo più alto. Poiché i divisori vengono controllati in ordine crescente, vengono rilevati solo i primi.

Come programma, per 55 byte:

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

— XNOR
fonte

8

Mathematica, 38 30 byte

Grazie @MartinEnder per 8 byte!

Join@@Table@@@FactorInteger@#&

— JungHwan Min
fonte

Che ne dici FactorInteger[#][[All, 1]]&? 26 byte

— David G. Stork

@ DavidG.Stork che non funzionerebbe perché non ripeterebbe i fattori primi se la potenza fosse maggiore di 1.

— JungHwan Min

5

Gelatina , 2 byte

Æf

Provalo online!

— Dennis
fonte

5

Haskell , 48 byte

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

Provalo online! Esempio di utilizzo: (2%) 1001rese [7,11,13].

— Laikoni
fonte

4

JavaScript (ES6), 44 byte

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

Orribilmente inefficiente a causa del fatto che scorre da 2 a ogni fattore primo, incluso l'ultimo. Puoi ridurre drasticamente la complessità temporale al costo di 5 byte:

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

— ETHproductions
fonte

4

Cubix , 37 32 byte

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

Provalo online! o guardalo in azione .

— ETHproductions
fonte

3

In realtà , 6 byte

w`in`M

Provalo online!

Spiegazione:

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

— Mego
fonte

Probabilmente puoi semplicemente usare oora, giusto?

— Oliver,

@Oliver Sì, ma di solito non aggiorno le vecchie risposte con i builtin.

— Mego,

3

J, 2 byte

q:

~~Il corpo deve contenere almeno 30 caratteri.~~

— alephalpha
fonte

3

MATL , 2 byte

Yf

Provalo online!

"Risposta incorporata noiosa" obbligatoria.

— DJMcMayhem
fonte

3

Japt, 2 byte

Uk

Un built-in kutilizzato sull'input U. Si riferisce anche a un paese.

Provalo online!

— ETHproductions
fonte

2

non udente , 3 byte

Questo linguaggio è piuttosto giovane e non è ancora pronto per qualcosa di importante, ma può fare la scomposizione in fattori primi:

A/D

Questo attenderà l'input dell'utente e quindi visualizzerà l'elenco dei fattori primi.

— Kade
fonte

2

MATLAB, 6 byte

Penso che questo non richieda alcuna spiegazione.

factor

— flawr
fonte

1

Bash + coreutils, 19 byte

factor|sed s/.*:.//

Provalo online!

— Dennis
fonte

È possibile radere via un byte se lo spazio bianco non ha importanza nell'output usando factor|sed s/.*://. Inoltre factor|cut -d: -f2(o factor|cut -d\ -f2per corrispondere all'output corrente) ha la stessa lunghezza di byte ma funzionerà più velocemente e utilizzerà meno sovraccarico di memoria.

— Caleb,

Chiederò all'OP dello spazio bianco. Purtroppo, avrei bisogno factor|cut -d\ -f2-di eliminare lo spazio iniziale, che è più lungo di un byte.

— Dennis,

1

Lotto, 96 byte

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

1

Pyke, 1 byte

Provalo qui!

Fattori primi integrati.

— Blu
fonte

1

Esagonia , 58 byte

Non ho ancora giocato a golf, ma @MartinEnder dovrebbe essere in grado di distruggerlo comunque

Stampa i fattori separati da spazio, con uno spazio finale

golfed:

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

Disposte:

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

Spiegazione in arrivo.

— Blu
fonte

1

05AB1E , 1 byte

Ò

Provalo online!

— Erik the Outgolfer
fonte

1

Mi chiedo quante persone supereranno Dennis ...

— Erik the Outgolfer il

1

CJam, 2 byte

mf

cjam.aditsu.net / ...

Questa è una funzione Martin, sembra che io abbia sonno.

— Erik the Outgolfer
fonte

1

C, 92 byte

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

Versione non golfata:

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

1

Japt , 1 byte (non concorrenziale)

Provalo online!

— Oliver
fonte

1

PHP , 51 byte

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

Provalo online!

— Jörg Hülsermann
fonte

1

C (gcc) , 51 byte

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

Provalo online!

— gastropner
fonte

0

Perl 6 , 77 64 byte

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

Provalo

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

Provalo (Nota: non ha abbastanza tempo assegnato per terminare)

Una versione molto più performante è leggermente più lunga a 100 byte.

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

Provalo

Espanso: ^{_{(versione 64 byte)}}

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

0

VB.NET, 86 byte

Ci siamo seduti attorno ad alcuni programmi di Project Euler. Rimosse le ottimizzazioni nell'interesse della mancanza, e questo è il risultato. Naturalmente, VB è molto dettagliato, quindi è abbastanza lungo. Non sto contando lo spazio bianco principale. Può essere omesso, ma è più facile da leggere con esso.

Questo accetta un numero intero come parametro e stampa i fattori primi con una virgola dopo. C'è una virgola finale alla fine.

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
fonte

0

Perl 6 , 51 byte

Una soluzione ricorsiva:

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

— Sean
fonte

0

Java (OpenJDK) , 259 byte

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

Provalo online!

— Pavel
fonte

Fare riferimento a questa sintesi per vedere come è possibile approfondire ulteriormente questa presentazione: gist.github.com/kritixilithos/fde37dc5a8ae54852aa134a6e70ea495 . Se hai bisogno di chiarire qualcosa, sentiti libero di chiamarmi al 19 byte :)

— Kritixi Lithos

0

Rubino, 61 byte

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

La versione integrata più corta che mi sia venuta in mente.

— Seims
fonte

0

Rubino , 48 byte

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

Provalo online!

Un po 'tardi alla festa, ma ... perché no?

— GB
fonte

Calcola i fattori primi

Sfida

Regole

Casi test

punteggio

Pyth , 1 byte

Python 2 , 55 byte

Python 2, 53 byte

Mathematica, 38 30 byte

Gelatina , 2 byte

Haskell , 48 byte

JavaScript (ES6), 44 byte

Cubix , 37 32 byte

In realtà , 6 byte

J, 2 byte

MATL , 2 byte

Japt, 2 byte

non udente , 3 byte

MATLAB, 6 byte

Bash + coreutils, 19 byte

Lotto, 96 byte

Pyke, 1 byte

Esagonia , 58 byte

05AB1E , 1 byte

CJam, 2 byte

C, 92 byte

Japt , 1 byte (non concorrenziale)

PHP , 51 byte

C (gcc) , 51 byte

Perl 6 , 77 64 byte

Espanso: (versione 64 byte)

VB.NET, 86 byte

Perl 6 , 51 byte

Java (OpenJDK) , 259 byte

Rubino, 61 byte

Rubino , 48 byte

Espanso: ^{_{(versione 64 byte)}}