Oggi nella mia lezione di statistica, ho scoperto che alcuni fattoriali possono essere semplificati se moltiplicati insieme! Per esempio:5! * 3! = 5! *3*2 = 5! *6 = 6!

Il tuo lavoro:

Data una stringa contenente solo numeri arabi e punti esclamativi, semplifica il mio fattoriale alla sua stringa più breve possibile, nel minor numero di byte per la tua lingua, in stile codice golf.

Ingresso

Una stringa contenente solo numeri arabi e punti esclamativi. I fattoriali per l'input non saranno più grandi di 200 !. I fattoriali non avranno più di un fattoriale per numero. L'input può essere considerato come un elenco di numeri interi.

Produzione

Una stringa possibilmente abbreviata, che ha il valore equivalente sull'input. L'ordine non è importante. La notazione fattoriale è un must, ma non è necessario utilizzare più di un simbolo fattoriale per numero.

Casi test

In: 3!2!2!  
Out: 4! 

In 2!3!2!0! 
Out: 4! 

In: 7!2!2!7!2!2!2!2! 
Out: 8!8! 

In: 23!3!2!2! 
Out: 24!  
Also: 4!!

In: 23!3!2!2!2! 
Out: 24!2!

In: 127!2!2!2!2!2!2!2! 
Out: 128!

In: 32!56!29!128!  
Out: 29!32!56!128!

Buona fortuna

Gelatina ,  17  18 byte

!P
ÇṗLÇ⁼¥ÐfÇḢḟ1ȯ0F

Un collegamento monadico che prende e restituisce un elenco di numeri (si attacca all'unica opzione fattoriale per numero)

Provalo online!

Come?

Una versione giocata a golf (anche se scritta in modo indipendente) della soluzione di Pietu1998.

!P - Link 1, product of factorials: list
!  - factorial (vectorises)
 P - product

ÇṗLÇ⁼¥ÐfÇḢḟ1ȯ0F - Main link: list                       e.g. [3,2,2]
Ç               - call the last link (1) as a monad           24
  L             - length                                      3
 ṗ              - Cartesian power      [[1,1,1],[1,1,2],...,[1,1,24],...,[24,24,24]]
        Ç       - call the last link (1) as a monad           24
      Ðf        - filter keep if:
     ¥          -   last two links as a dyad:
   Ç            -     call the last link (1) as a monad     [1,2,...,24!,...,24!^3]
    ⁼           -     equal?
         Ḣ      - head
          ḟ1    - filter out any ones
            ȯ0  - or with zero (for the empty list case)
              F - flatten (to cater for the fact that zero is not yet a list)

Gelatina , 19 byte

,!P€E
SṗLçÐfµḢḟ1ȯ1F

Provalo online!

Veloce e sporco. Molto lento, anche il 23!2!3!2!test case è un allungamento. I / O come elenchi di numeri interi.

Spiegazione

,!P€E    Helper link. Arguments: attempt, original
,        Make the array [attempt, original].
         Example: [[1,1,1,4], [2,3,2,0]]
 !       Take the factorial of each item.
         Example: [[1,1,1,24], [2,6,2,1]]
  P€     Take the product of each sublist.
         Example: [24, 24]
    E    Check if the values are equal.

SṗLçÐfµḢḟ1ȯ1F   Main link. Arguments: original
S               Find the sum S of the integers in the input.
  L             Find the number N of integers in the input.
 ṗ              Generate all lists containing N integers from 1 to S.
   çÐf          Take the lists whose factorial-product is the same as the original.
       Ḣ        Take the first match. This is the one with the most ones.
        ḟ1      Remove any ones.
          ȯ1    If there were only ones, return a one instead.
            F   Turn into a list if needed.

Pulito , 397 ... 317 byte

import StdEnv,StdLib
c=length
f c m=sortBy c o flatten o map m
%n=f(>)@[2..n]
@1=[]
@n#f=[i\\i<-[2..n]|n/i*i==n&&and[i/j*j<i\\j<-[2..i-1]]]
=f++ @(n/prod f)
?l=group(f(>)%l)
$l=hd(f(\a b=c a<c b)(~(?l))[0..sum l])
~[]_=[[]]
~i n=[[m:k]\\m<-take n[hd(i!!0++[0])..],k<- ~[drop(c a)b\\a<-group(%m)&b<-i|b>a]n|i== ?[m:k]]

Provalo online!

Questo richiede un [Int], determina i fattori primi del risultato e si riduce rispetto ai fattori per trovare la rappresentazione più piccola, usando il fattore più grande in qualsiasi fase come valore di base per il termine fattoriale successivo. Non completerà alcuni casi di test su TIO, ma è abbastanza * veloce e può eseguirli tutti in meno di 3 minuti su un laptop di fascia media.

* per un O((prod(N)!)^sum(N))algoritmo di complessità

> <> , 66 byte

1}:?\~l1=?v{!
-:?!\:{*}1
v?( 4:{/}1<o"!"n-1
{:,} :{/?%}:+1
\:1-?n;

Provalo online!

Non efficiente, non trova la stringa più piccola e l'interprete non si occupa molto bene di numeri estremamente grandi. Ma almeno ci ho provato? Accetta input come un elenco di numeri attraverso la -vbandiera.

Innanzitutto calcola il valore dell'ingresso fattorizzando ogni numero e moltiplicandolo insieme. Quindi trova il fattoriale più grande che si divide nettamente nel totale e lo genera. Ripeti fino a quando non ottiene un numero primo (che emette) o un 1 ed esce dal programma. Per questo motivo , a volte non trova la rappresentazione più breve del numero, ad esempio il caso di test 7!2!2!7!2!2!2!2!ritorna 10!224invece che 8!8!perché trova che il totale è divisibile per 10! primo.

Rubino , 240 237 233 byte

Questo è incredibilmente inefficiente

Accetta una matrice di ints come input

Restituisce una stringa e sceglie l'opzione più breve tra, diciamo '720!', '6!!'e'3!!!'

->i{f=->n{n>0?n*f[n-1]:1}
s=->a{eval a.map{|i|f[i]}*?*}
r=->e,a=[2]{e==s[a]?a:s[a]<=e&&(r[e,a[0..-2]+[a[-1]+1]]||r[e,a+[2]])}
j=->v{v.join(?!)+?!}
u=r[s[i]]
while j[g=u.map{|i|i&&r[i]?[r[i],p]:i}.flatten].size<j[u].size;u=g;end
j[u]}

Provalo online!