Un gioco di fattorizzazione

13

Ingresso

Un singolo intero 1≤x≤1015 .

Produzione

Il numero massimo di interi positivi distinti che hanno il prodotto x .

Esempi

Input: 1099511627776. Output: 9. Un possibile elenco ottimale di fattori è: (1, 2, 4, 8, 16, 32, 64, 128, 4096).

Input: 127381. Output 4. Un possibile elenco ottimale di fattori è: (1, 17, 59, 127).

Relativo a questa vecchia domanda .

code-golf  math 
— Anush
fonte
9
Potresti aggiungere qualche altro test case? (Preferibilmente di dimensioni ragionevoli.)
— Arnauld
8
Dati i tuoi commenti sulla maggior parte delle risposte: se stai cercando un codice efficiente, questo non dovrebbe essere etichettato come code-golf. Puoi prendere in considerazione una fastest-codeo fastest-algorithmper una sfida imminente. Se volevi davvero che tutte le risposte funzionassero in un tempo limitato entro l'intervallo specificato, avrebbe dovuto essere esplicitamente menzionato. (E avrei raccomandato un intervallo più piccolo in modo che non sia completamente in conflitto code-golf.)
— Arnauld
@Arnauld No, sto attento a farlo code-golf e nessuno è giudicato per questo. Sarebbe bello se il codice potesse essere eseguito per gli intervalli di input specificati.
— Anush,
5
— Arnauld
1
Perché x=1, 2, ...ottengo f(x)=1, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 3, 3, 2, 3, 2, 3, 3, 3, 2, 4, 2, 3, 3, 3, 2, 4, 2, 3, 3, 3, 3, 4, 2, 3ciò che non trovo in OEIS. È abbastanza chiaro che verranno visualizzati i record per i numeri fattoriali x. Ad esempio il più piccolo xtale f(x)=13sarà 13!. Immagino che fdipenda solo dagli esponenti della scomposizione in fattori primi. Quindi, per scoprire f(13^4*19^7*29^2), potremmo semplificare f(2^7*3^4*5^2).
— Jeppe Stig Nielsen

Risposte:

5

Wolfram Language (Mathematica) , 52 byte

Max[Length/@Cases[Subsets@Divisors@#,{a__}/;1a==#]]&

Provalo online!

4 byte salvati grazie a @attinat

Ecco anche una versione di 153 byte che calcola 1099511627776e10^15 

Max[Length/@Table[s=RandomSample@Flatten[Table@@@FactorInteger[#]];Last@Select[Times@@@TakeList[s,#]&/@IntegerPartitions@Length@s,DuplicateFreeQ],5!]]+1&

Provalo online!

Il risultato per 10^15è 12

{1, 2, 4, 5, 10, 16, 25, 40, 50, 100, 125, 250}

— J42161217
fonte
Si blocca con 1099511627776
— Anush,
7
@Anush Non si blocca. Ha solo bisogno di memoria. Non hai detto nulla sulle limitazioni della memoria. Questo è il codice golf
— J42161217
Sì, mi rendo conto. Sarebbe bello se si potesse effettivamente eseguire il codice negli intervalli di input specificati nella domanda.
— Anush,
6
@Anush Questo è code-golf. Non belle risposte. Si prega di specificare i criteri. Una risposta è valida o no. Penso che il problema qui sia la domanda ... Forse dovresti cambiarlo in "algoritmo più sufficiente"
— J42161217
3
@Anush ho fatto una modifica nella mia risposta e ho aggiunto un'altra versione che è davvero veloce ed efficiente nel caso in cui tu voglia controllarla
— J42161217
3

05AB1E , 9 byte

Molto inefficiente. Timeout su TIO per i numeri con una grande quantità di divisori.

ÑæʒPQ}€gZ

Provalo online!

Spiegazione

Ñ          # push a list of divisors of the input
 æ         # push the powerset of that list
  ʒPQ}     # filter, keep only the lists whose product is the input
      €g   # get the length of each
        Z  # take the maximum
— Emigna
fonte
Il tuo codice TIO sembra produrre 3 invece di 9.
— Anush,
@Anush: è un numero diverso rispetto al tuo esempio (dal momento che uno va in timeout a causa di molti fattori). Probabilmente dovrei usare un esempio più distinto.
— Emigna,
€gZè un po 'più efficiente rispetto éθgallo stesso conteggio parziale.
— Grimmy,
@Grimy: True. Non farà molta differenza in quanto è il filtro che è il grande cattivo qui, ma non fa male essere un po 'più efficiente :)
— Emigna,
2

Perl 6 , 38 byte

{$!=$_;+grep {$!%%$_&&($!/=$_)},1..$_}

Provalo online!

Adotta l'approccio avido per selezionare i divisori.

— Jo King
fonte
Non termina con 1099511627776
— Anush,
6
@Anush Bene, alla fine termina . Generalmente, la risposta è valida se l'algoritmo del programma funzionasse con qualsiasi input, se gli fosse data tutta la memoria e il tempo che voleva. Dato che si tratta di code-golf , l'ho ottimizzato per la lunghezza del codice, non per la complessità algoritmica
— Jo King,
2

Javascript (ES6), 39 byte

f=(n,i=0)=>n%++i?n>i&&f(n,i):1+f(n/i,i)

Probabilmente ci sono alcuni byte che possono essere salvati qua e là. Utilizza solo l'algoritmo goloso per i fattori.

— vrugtehagel
fonte
2

Gelatina , 9 byte

ŒPP=³ƊƇẈṀ

Provalo online!

-1 byte grazie a qualcuno

-2 byte grazie a ErikTheOutgolfer

— HyperNeutrino
fonte
Mentre si prepara un ingresso per il SuperSeeker OEIS, ho creato un 11-byte di programma che possa golfable Jelly (che utilizza un approccio diverso), e sono difficilmente inviare una risposta Jelly così farò finta golfed un byte dalla soluzione: ÆE×8‘½’:2S‘(it funziona con la potenza della sezione "formula" di OEIS per A003056). Disclaimer: potrebbe essere sbagliato, ma funziona sui casi di test.
— mio pronome è monicareinstate
Non sembra terminare con 1099511627776
— Anush,
@someone non funziona per 36 ma grazie
— HyperNeutrino
@Anush sì, è molto lento perché l'ho codificato, non ottimizzato per l'efficienza
— HyperNeutrino,
1
Puoi rimuoverlo ÆD, non è che ci siano più partizioni che verranno create in questo modo, ci vorrà molto più tempo (timeout perX≥21).
— Erik the Outgolfer,
2

Brachylog , 8 byte

f;?⟨⊇×⟩l

Provalo online!

(L'approccio ingenuo {~×≠l}ᶠ⌉, genera un numero infinito di soluzioni con 1 in più prima di eliminarle con ≠, e quindi non riesce a terminare effettivamente. Non è un problema, però, poiché è per lo stesso conteggio di byte!)

Accetta l'input tramite la variabile di input e l'output tramite la variabile di output. L'intestazione su TIO contiene una copia della maggior parte del codice per mostrarti quale sia la lista dei fattori, ma questo funziona perfettamente senza di essa. Dal momento che ⊇fornisce prima liste più grandi, questo predicato fa essenzialmente la stessa cosa della maggior parte delle altre risposte, ma senza generare e filtrare esplicitamente il set completo di fattori, grazie al backtracking.

            The output
       l    is the length of
    ⊇       a sublist (the largest satisfying these constraints)
f           of the factors of
            the input
 ; ⟨  ⟩     which
     ×      with its elements multiplied together
  ?         is the input.
— Stringa non correlata
fonte
1

Gaia , 10 9 byte

Π=
dz↑⁇(l

Provalo online!

Segue lo stesso "algoritmo" visto altrove: filtra il powerset divisore per il più lungo con un prodotto uguale al numero e restituisce la sua lunghezza.

	| helper function
Π=	| is prod(list)==n (implicit)?
	|
	| main function; implicitly takes n
dz	| divisor powerset (in decreasing order of size)
  ↑⁇	| filter by helper function
    (l	| take the first element and take the length (implicitly output)
— Giuseppe
fonte
0

Clam , 15 byte

p}_`nq#:;qQ@s~Q

Collegamento TIO in arrivo (quando dennis tira)

Fondamentalmente un port della soluzione 05AB1E di @ Emigna.

Spiegazione

                - Implicit Q = first input
p               - Print...
 }              - The last element of...
  _             - Sorted...
   `nq          - Lengths of... (map q => q.len)
           @s   - Items in powerset of
             ~Q - Proper divisors of Q
      #         - Where... (filter)
        ;q      - Product of subset
       :        - Equals...
          Q     - Q
— Skidsdev
fonte
0

C # (compilatore interattivo Visual C #) , 54 byte

int f(int n,int i=0)=>n%++i<1?1+f(n/i,i):n>i?f(n,i):0;

Utilizza lo stesso approccio delle risposte di @ vrugtehagel e @ JoKing.

Provalo online!

— Incarnazione dell'ignoranza
fonte
Supponendo di aver implementato correttamente la tua logica, una soluzione a 53 byte (che non riuscivo a liberare della parola chiave "return"): provala online!
— mio pronome è monicareinstate
1
@someone Grazie, ma secondo meta, le funzioni devono essere riutilizzabili . Inoltre, non so se è accettabile che dichiarazioni al di fuori della funzione tralascino un punto e virgola finale, possono fare un meta post su quello.
— Incarnazione dell'ignoranza
0

Rubino , 34 byte

Ovviamente va in timeout su quel numero enorme, ma alla fine scadrà se viene concesso abbastanza tempo su un'altra macchina.

->n{(1..n).count{|e|n%e<1?n/=e:p}}

Provalo online!

— Value Ink
fonte
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.