Ci viene fornito un elenco di numeri interi p1, ..., pk (non necessariamente distinti) in cui ognuno ha un valore compreso tra 1 e 9, inclusi. Usando ciascuno dei p1, ..., pk esattamente una volta, possiamo formare concatenazioni di cifre, per ottenere un nuovo elenco di numeri; abbiamo quindi prodotto il prodotto di questo nuovo elenco. L'obiettivo è massimizzare questo prodotto scegliendo le migliori concatenazioni di cifre.

Ad esempio, ci viene fornito l'elenco: 2 3 2 (separati da spazi). Possiamo formare le seguenti concatenazioni:

• 2 3 2(il prodotto di queste concatenazioni è 12)
• 23 2(il prodotto è 46)
• 32 2(il prodotto è 64)
• 22 3(il prodotto è 66)

Poiché il più grande prodotto che possiamo formare di concatenazioni è 66, lo produciamo.

Regole:

• Deve esserci almeno una moltiplicazione (cioè non è possibile concatenare tutte le cifre e produrle).
• Non è possibile utilizzare altri operatori diversi dalla moltiplicazione, né inserire parentesi, ecc.
• Supponiamo che l'elenco degli interi indicati sia separato da spazi e che tutti gli interi abbiano valori compresi tra 1 e 9.

Il codice più corto (in byte) vince!

Casi test:

Ingresso: 1 2 3; Uscita: 63(cioè, 21*3)

Ingresso: 2 5 9; Uscita: 468( 52*9)

Ingresso: 1 2 3 4; Uscita: 1312( 41*32)

CJam, 32 28 23 12 byte

0le!f{~*}:e>

Provalo online nell'interprete CJam .

Grazie a @ user23013 per avermi aiutato a salvare 16 byte interi!

Idea

Permettere i caratteri nella stringa di input la divide in numeri interi (gruppi di cifre consecutive) separati da spazi. Spingendo uno zero e quindi valutando la stringa di input consentita, spingiamo due o più numeri interi. Moltiplicando i primi due si otterrà il prodotto dell'input diviso esattamente in due numeri interi o un valore non ottimale.

Codice

 le!         e# Push all possible character permutations of the input.
0   f{  }    e# For each permutation:
             e#   Push 0, then the permuted string.
      ~      e#   Evaluate the string. Pushes one or more integers.
       *     e#   Multiply the two topmost integers.
         :e> e# Retrieve the greatest integer in the array.

CJam, 36 35 byte

q~]_,([SL]m*{s},\e!\m*{z[s~]:*}%$W=

Abbastanza diretto. Esamina tutte le combinazioni possibili e le ordina per prodotto. Quindi genera il più grande. Tutto ciò, tenendo presente che dovrebbe essere presente almeno 1 moltiplicazione.

Aggiungerà presto una spiegazione.

Provalo online qui

JavaScript (ES6) 125

Modifica Penso che @oberon abbia capito bene: "ogni nuova cifra deve essere concatenata al numero più piccolo"

Non cambierò questa risposta rubando la sua idea. L'implementazione in ES6 sarebbe di 70 byte (segno cambiato in confronto per confrontare come numero e non stringhe)

f=l=>l.split(' ').sort().reverse().map(d=>-a>-b?a+=d:b+=d,a=b='')||a*b

La mia soluzione

f=l=>(i=>{for(r=0;a=b='',k=--i;r<a*b?r=a*b:0)for(v of l)k&1?a+=v:b+=v,k/=2})(1<<~-(l=l.split(' ').sort().reverse()).length)|r

Come ho detto nei commenti, per ogni coppia di numeri a, b, il prodotto a * b è inferiore alla semplice concatenazione ab (= a * 10 ^ (cifre di b) + b). Quindi è meglio evitare i prodotti e preferire la concatenazione, ma poiché è richiesto almeno 1 prodotto, dobbiamo costruire 2 numeri e moltiplicarli.

Provo tutti i possibili raggruppamenti di cifre, costruendo una coppia di numeri da moltiplicare. Ogni numero è costruito in modo ovvio prendendo le cifre in ordine decrescente.

Ad esempio, con un elenco di 4 numeri, [1 2 3 4] - prova:

• 4 * 321
• 43 * 21
• 42 * 31
• 41 * 32
• 432 * 1
• 431 * 2
• 421 * 3

Il massimo di questi valori è il risultato di cui abbiamo bisogno.

I raggruppamenti possono essere enumerati in loop su una bitmap di 4 bit, con valore minimo 0001 e valore massimo 0111 (ovvero 1 << (4 -1) - 1)

Non così da golf

f=l=>{
  l = l.split(' '); // string to array
  l.sort().reverse(); // decreasing order 
  m = 1 << (l.length-1); starting value fro loop
  r = 0 
  // loop from m-1 down to 1
  for(i=m; --i; )
  {
    a = b = '';
    k = i;
    for(v of l) // divide the digits base on bits of i
    {
      k & 1 ? a+=v : b+=v;
      k /= 2;
    }
    if (r < a*b) r = a*b; // remember max value in r
  }
  return r
}

Prova utilizzando lo snippet di seguito in Firefox.

f=l=>(i=>{for(r=0;a=b='',k=--i;r<a*b?r=a*b:0)for(v of l)k&1?a+=v:b+=v,k/=2})(1<<~-(l=l.split(' ').sort().reverse()).length)|r

t=l=>(i=>{for(x=r='';a=b='',k=--i;r<a*b?(r=a*b,x=' = '+a+'x'+b):0)for(v of l)k&1?a+=v:b+=v,k/=2})
(1<<~-(l=l.split(' ').sort().reverse()).length)|| x

function go()
{
  R.value = f(I.value) // TEST AS IS
   + t(I.value) // Some more info
}

test=['1 2 3 4','1 2 3','2 5 9','8 9 8']

test.forEach(t => O.innerHTML = O.innerHTML + (t + ' -> ' + f(t)) + '\n')

Type your list: <input id=I><button onclick='go()'>-></button><input readonly id=R><br>
<pre id=O></pre>

Python 3, 111 byte

Probabilmente è molto più golfabile. Mi piace il suo tempo di esecuzione, però (O ( n log n ), vero?).

l=sorted(map(int,input().split()),reverse=1);m=[0,0]
for x in l:i=m[0]>m[1];m[i]=m[i]*10+x
print(m[0]*m[1])

Ungolfed con spiegazione.

# edc65 has already explained that the optimal solution can be found applying a single
# multiplication. thus, given that
#     (10x + d)y > (10y + d)x
# where x, y are the two numbers and d is the next digit to insert, it follows that
#     y > x
# and thus each new digit must be concatenated to the smallest number. obviously, digits
# should be added in descending order.
l = sorted(map(int, input().split()), reverse=1)
m = [0,0]
for x in l:
    i = m[0] > m[1]
    m[i] = m[i]*10 + x
print(m[0] * m[1])

Pyth, 25 byte

eSsmm*ss<dkss>dkr1ld.pcz)

Ciclo su ogni permutazione dell'ingresso. Quindi, poiché ogni combinazione ottimale è composta da due numeri interi, la divido semplicemente in ogni posizione possibile e moltiplico le divisioni concatenate. Ordino e ottengo l'ultimo elemento.

R, 164

function(n){l=length(n);a=sort(n,T);i=1;while(a[i]==a[i+1]&&i<l-2)i=i+2;a[c(i,i+1)]=a[c(i+1,i)];eval(parse(t=paste0(c(a[1:l%%2==1],"*",a[1:l%%2==0]),collapse='')))}

Come metodo non sono sicuro che sia robusto. Con i casi che ho testato sembra funzionare ogni volta. Ho provato a testarlo con la soluzione di ottimizzatori e sembra anche a posto. Sono più che preparato per essere smentito :) C'è spazio per il golf, ma speravo di ottenere prima un feedback sul metodo.

Il processo generale è:

• Ordina l'elenco in ordine decrescente
• Scambia la prima coppia pari / dispari che differisce
• Concatena gli elementi pari e dispari dell'elenco
• Valuta il prodotto dei due risultati

Espanso con alcuni commenti

function(n){
    l=length(n);
    a=sort(n,T);    # sort descending order
    # Determine which pair to swap
    i=1;
    while(a[i]==a[i+1]&&i<l-2)i=i+2;
    a[c(i,i+1)]=a[c(i+1,i)];  # swap pair   
    # concatenate the even and odd indices items around a * and evaluate    
    eval(parse(t=paste0(c(a[1:l%%2==1],"*",a[1:l%%2==0]),collapse=''))) 
}

E alcuni test eseguiti (implementati come una funzione chiamata g)

> g(c(1,2,3))
[1] 63
> g(c(2,5,9))
[1] 468
> g(c(1,2,3,4))
[1] 1312
> g(c(1,2,3,5,5,5))
[1] 293132
> g(c(1,5,7,7,9,9))
[1] 946725
> g(c(1,7,8,9,9,9))
[1] 978117
> g(c(7,8,9,9,9))  #Test case provided edc65 to randomra
[1] 97713