अधिकतम कॉन्टैनेटेड उत्पाद

Question

हमें पूर्णांक p1, ..., pk (जरूरी नहीं कि विशिष्ट) की एक सूची दी जाए, जहां प्रत्येक में 1 और 9 के बीच का मान हो, समावेशी। पी 1, ..., पीके में से प्रत्येक का उपयोग करते हुए, हम अंकों की एक नई सूची प्राप्त करने के लिए, अंकों के संघटन बना सकते हैं; हम फिर इस नई सूची के उत्पाद का उत्पादन करते हैं। लक्ष्य इस उत्पाद को अधिकतम अंकों का सर्वश्रेष्ठ संयोजन चुनकर अधिकतम करना है।

उदाहरण के लिए, हमें सूची दी गई है: 2 3 2 (रिक्त स्थान से अलग)। हम निम्नलिखित निष्कर्ष तैयार कर सकते हैं:

• 2 3 2(इन संघों का उत्पाद है 12)
• 23 2(उत्पाद है 46)
• 32 2(उत्पाद है 64)
• 22 3(उत्पाद है 66)

चूँकि हम सबसे बड़े उत्पाद का निर्माण कर सकते हैं, इसलिए हम इसका उत्पादन करते हैं।

नियम:

• कम से कम एक गुणा होना चाहिए (यानी, आप सभी अंकों और आउटपुट को पूरा नहीं कर सकते)।
• आप गुणा के अलावा किसी भी अन्य ऑपरेटर का उपयोग नहीं कर सकते हैं, या कोष्ठक सम्मिलित कर सकते हैं, आदि।
• मान लें कि दिए गए पूर्णांकों की सूची को रिक्त स्थान द्वारा अलग किया गया है, और सभी पूर्णांकों में 1 और 9 के बीच मान हैं।

सबसे छोटा कोड (बाइट्स में) जीतता है!

परीक्षण के मामलों:

इनपुट 1 2 3:; आउटपुट: 63(यानी, 21*3)

इनपुट 2 5 9:; आउटपुट: 468( 52*9)

इनपुट 1 2 3 4:; आउटपुट: 1312( 41*32)

Comments

क्या हमें एक पूरा कार्यक्रम लिखना चाहिए या इनपुट मापदंडों को लेने वाला कोई फ़ंक्शन और परिणाम वापस करना भी ठीक है?

— यादृच्छिक

@randomra हां, यह ठीक है।

— रेयान

संख्याओं की प्रत्येक जोड़ी के लिए a, b, उत्पाद एक * b.is सरल समापक ab (= a * 10 ^ (b के अंक) + b) से कम है। तो बस 1 उत्पाद (जैसा कि यह अनिवार्य है)। इसे जोड़ें: codegolf.stackexchange.com/q/49854/21348

— edc65

Answer 1

CJam, 32 28 23 12 बाइट्स

0le!f{~*}:e>

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

16 पूरे बाइट्स बचाने में मेरी मदद करने के लिए @ user23013 को धन्यवाद!

विचार

इनपुट स्ट्रिंग में वर्णों की अनुमति देकर इसे रिक्त स्थान द्वारा अलग किए गए पूर्णांक (लगातार अंकों के समूह) में विभाजित करता है। शून्य को धक्का देकर और फिर अनुमत इनपुट स्ट्रिंग का मूल्यांकन करके, हम दो या दो से अधिक पूर्णांकों को धक्का देते हैं। सबसे ऊपर के दो को गुणा करने पर या तो दो पूर्णांक या कुछ उप-मान मान में विभाजित इनपुट के उत्पाद का परिणाम होगा।

कोड

 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.

Comments

l2%_,,1>\e!m*{~S+m<~*}%$W=।

— jimmy23013

l2%S+e!{0\~*}%$W=।

— jimmy23013

Answer 2

CJam, 36 35 बाइट्स

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

बहुत सीधा। सभी संभव संयोजनों पर Iterates और उन्हें उत्पाद द्वारा सॉर्ट करें। फिर सबसे बड़ा आउटपुट। यह सब, यह ध्यान में रखते हुए कि कम से कम 1 गुणा मौजूद होना चाहिए।

जल्द ही स्पष्टीकरण जोड़ देंगे।

इसे यहाँ ऑनलाइन आज़माएँ

Answer 3

जावास्क्रिप्ट (ईएस 6) 125

मुझे लगता है कि संपादित करें @ रॉबर्टन ने इसे सही पाया: "प्रत्येक नए अंक को सबसे छोटी संख्या तक पहुंचना चाहिए"

मैं इस उत्तर को उनके विचार को चुराकर नहीं बदलूंगा। ईएस 6 में कार्यान्वयन 70 बाइट्स होगा (संख्या के रूप में तुलना करने के लिए संकेत बदल गया और तार नहीं)

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

मेरा समाधान

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

जैसा कि मैंने टिप्पणियों में कहा, संख्याओं की प्रत्येक जोड़ी के लिए a, b, उत्पाद a * b सरल संघनन ab (= a * 10 ^ (b के अंक) + b) से कम है। इसलिए उत्पादों से बचना और संगति को प्राथमिकता देना बेहतर है, लेकिन जैसा कि कम से कम 1 उत्पाद का अनुरोध किया जाता है, हमें 2 नंबर बनाने होंगे और उन्हें गुणा करना होगा।

मैं अंकों की एक जोड़ी का निर्माण करने के लिए अंकों के सभी संभव समूहीकरण की कोशिश करता हूं। प्रत्येक संख्या घटते क्रम में अंकों को लेते हुए बनाया गया है।

उदाहरण के लिए, 4 संख्याओं की सूची के साथ, [1 2 3 4] - कोशिश करें:

• 4 * 321
• ४३ * २१
• ४२ * ३१
• ४१ * ३२
• ४३२ * १
• ४३१ * २
• ४२१ * ३

इन वैल्यू का अधिकतम परिणाम हमें चाहिए होता है।

समूह में 4 बिट्स के बिटमैप पर लूपिंग की गणना की जा सकती है, जिसमें न्यूनतम मान 0001 और अधिकतम मान 0111 (जो कि 1 << (4 -1) - 1) है।

इतना गोल्फ नहीं है

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
}

फ़ायरफ़ॉक्स में नीचे स्निपेट का उपयोग करके परीक्षण करें।

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>

Answer 4

पायथन 3, 111 बाइट्स

यह शायद बहुत अधिक गोल्फ है। मुझे इसका रनिंग टाइम अच्छा लगता है, हालाँकि (O ( n log n ), क्या यह है?)।

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])

स्पष्टीकरण के साथ असंगठित।

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

Answer 5

पायथ, 25 बाइट्स

eSsmm*ss<dkss>dkr1ld.pcz)

मैं इनपुट के हर क्रमपरिवर्तन पर लूप करता हूं। तब क्योंकि प्रत्येक इष्टतम संयोजन में दो पूर्णांक होते हैं, मैं इसे हर संभव स्थिति में विभाजित करता हूं, और संक्षिप्त विभाजन को गुणा करता हूं। मैं तब छांटता हूं और अंतिम तत्व प्राप्त करता हूं।

Answer 6

आर, 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='')))}

एक विधि के रूप में मैं अनिश्चित हूँ अगर यह मजबूत है। उन मामलों के साथ जिनका मैंने परीक्षण किया है, यह हर बार काम करता प्रतीत होता है। मैंने इसे ऑप्टिमाइज़र समाधान के खिलाफ परीक्षण करने की कोशिश की और यह इसके साथ ही ठीक भी प्रतीत होता है। मैं गलत साबित होने के लिए तैयार से अधिक हूं :) गोल्फिंग के लिए जगह है, लेकिन मैं पहले विधि पर कुछ प्रतिक्रिया प्राप्त करने की उम्मीद कर रहा था।

सामान्य प्रक्रिया है:

• सूची को अवरोही क्रम में क्रमबद्ध करें
• पहली विषम / यहां तक ​​कि जोड़ी को अलग करें
• सूची की सम और विषम वस्तुओं को समेटें
• दो परिणामों के उत्पाद का मूल्यांकन करें

कुछ टिप्पणियों के साथ विस्तार किया

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=''))) 
}

और कुछ टेस्ट रन (जी नामक एक समारोह के रूप में लागू)

> 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