12

चुनौती यह है कि आप मूल अंकगणितीय संचालकों (इसके अलावा, घटाव, गुणा, असमान नकार) का उपयोग करके पूर्णांक की एक सूची से अधिकतम संख्या प्राप्त कर सकते हैं।

इनपुट

पूर्णांकों की एक सूची

उत्पादन

इंटप्यूट में प्रत्येक पूर्णांक का उपयोग करते हुए अधिकतम परिणाम ।

इनपुट ऑर्डर मायने नहीं रखता, परिणाम समान होना चाहिए।

आपको पूर्ण ऑपरेशन को आउटपुट करने की आवश्यकता नहीं है, बस परिणाम।

उदाहरण

Input : 3 0 1
Output : 4 (3 + 1 + 0)

Input : 3 1 1 2 2
Output : 27 ((2+1)*(2+1)*3))

Input : -1 5 0 6
Output : 36 (6 * (5 - (-1)) +0)

Input : -10 -10 -10
Output : 1000 -((-10) * (-10) * (-10))

Input : 1 1 1 1 1
Output : 6 ((1+1+1)*(1+1))

नियम

सबसे छोटा कोड जीतता है
मानक "कमियां" लागू होती हैं
आप केवल + * का उपयोग कर सकते हैं - ऑपरेटर (इसके अलावा, गुणन, घटाव, एकाकी नकार)
कोड को तब तक काम करना चाहिए जब तक परिणाम 32 बिट इंटेगर पर संग्रहीत किया जा सकता है।
कोई भी अतिप्रवाह व्यवहार आपके ऊपर है।

मुझे उम्मीद है कि यह पर्याप्त स्पष्ट है, यह मेरा पहला कोड गोल्फ चुनौती सुझाव है।

code-golf math arithmetic

— CNicolas
स्रोत

आपका एक उदाहरण एक ऐसे ऑपरेशन का उपयोग कर रहा है जिसकी अनुमति नहीं है: यदि एकतरफा नकारात्मकता आपके श्वेतसूची में होने का इरादा है तो घटाव वास्तव में आवश्यक नहीं है।

— पीटर टेलर

संपादित किया गया और एकात्मक निषेध जोड़ा गया। श्वेतसूची में पदार्थ को रखा जाता है।

— CNicolas

1

क्या यह एक पूर्ण कार्यक्रम होना चाहिए या एक कार्य पर्याप्त है?

— थ्रीएफएक्स

पूरा कार्यक्रम। इससे भी बेहतर अगर इसे ऑनलाइन चलाया जा सकता है, लेकिन जाहिर है अनिवार्य नहीं है

— CNicolas

@INSeed क्या मुझे ऑनलाइन चलाने का तरीका जोड़ना चाहिए?

— गर्वित हैकेलर

9

C - 224 बाइट्स - रनिंग टाइम O (n)

o=0,w=0,n[55],t,*m=n,*p=n;main(r){for(;scanf("%d",++p);t<3?--p,w+=t/2,o+=t&1:t<*m|m==n?m=p:9)t=*p=abs(*p);t=o<w?o:w;o-=t;w-=t;t+=o/3;for(o%3?o%3-2?t?t--,w+=2:++*m:w++:9;t--;)r*=3;for(r<<=w;--p>n;)r*=*p;printf("%d",r>1?r:o);}

यह रैखिक-समय की समस्या के लिए केवल घातीय-समय के समाधान को देखने के लिए मनोरंजक था, लेकिन मुझे लगता है कि यह आगे बढ़ने का तार्किक तरीका था क्योंकि वास्तव में एक एल्गोरिथ्म होने के लिए कोई बोनस अंक नहीं थे, जो कि लघुगणक का एक विपर्यय है।

नकारात्मक संख्याओं को सकारात्मक और शून्य छोड़ने में परिवर्तित करने के बाद, स्पष्ट रूप से हम गुणा करने में रुचि रखते हैं। हम अंतिम संख्या के लघुगणक को अधिकतम करना चाहते हैं।

log (a + b) <log (a) + log (b) को छोड़कर जब a = 1 या b = 1 होता है, तो वही एकमात्र ऐसा मामला होता है, जिसमें हम कुछ भी एक साथ जोड़ने में रुचि रखते हैं। सामान्य तौर पर 1 को छोटी संख्या में जोड़ना बेहतर होता है, क्योंकि इससे लॉगरिदम में बड़ी वृद्धि होती है, यानी 1 प्रतिशत से बड़ी संख्या में वृद्धि होती है। चार संभावित परिदृश्य हैं, जिन्हें कम से कम बेहतर उपयोग करने का आदेश दिया गया है:

2 में से एक देता है + लॉग .405 [लॉग (3) - लॉग (2)]
लोगों को जोड़कर + लॉग .366 प्रति एक [लॉग (3) / 3] देता है
लोगों में से 2 को बनाना + लॉग .347 प्रति एक [लॉग (2) / 2] देता है
3 या उच्चतर संख्या में एक जोड़ने पर + लॉग .288 या उससे कम [लॉग (4) - लॉग (3)]

कार्यक्रम लोगों की संख्या, दो की संख्या और न्यूनतम संख्या 2 से अधिक का ट्रैक रखता है, और लोगों के उपयोग के सबसे कम से कम बेहतर तरीकों की सूची को नीचे जाता है। अंत में, यह सभी शेष संख्याओं को गुणा करता है।

— feersum
स्रोत

6

हास्केल, 126 वर्ण

यह केवल ब्रूट-फोर्सिंग है, इनपुट के संकेत की अनदेखी और घटाव और एकात्मक नकार की अनदेखी के साथ।

import Data.List
f[x]=abs x::Int
f l=maximum$subsequences l\\[[],l]>>= \p->[f p+f(l\\p),f p*f(l\\p)]
main=interact$show.f.read

यह कोड बेहद धीमा है। कोड चार बार इनपुट के प्रत्येक बाद पर एफ की गणना करता है _{([] और इनपुट के अलावा)} । लेकिन हे, यह कोड गोल्फ है।

— गर्वित हेकलर
स्रोत

5

एसडब्ल्यूआई-प्रोलॉग - 250

ओह बॉय, मैंने इस पर बहुत लंबा रास्ता तय किया।

o(A,B,A+B).
o(A,B,A-B).
o(A,B,A*B).
t([],0).
t([A,B|T],D):-t(T,Q),o(A,B,C),o(C,Q,D).
t([A|T],C):-t(T,Q),o(A,Q,C).
a(A):-t(A,B),n(C),B>C,retract(n(C)),assert(n(B)).
m(A):-assert(n(0)),\+p(A),n(R),R2 is R,write(R2).
p(A):-permutation([0|A],B),a(B),0=1.

कमांड लाइन से कॉल किया जाता है (जैसे):

> swipl -s filename.pl -g "m([1, 1, 1, 1, 1])" -t halt
6

(बिना किसी कारण के, मुझे यह बहुत अच्छा लगा कि मेरे गोल्फ के फंक्शन का नाम "टोमेटो पॉट" है।

Ungolfed संस्करण:

% Possible operations
operation(Left, Right, Left + Right).
operation(Left, Right, Left - Right).
operation(Left, Right, Left * Right).

% Possible ways to transform
transform([], 0).
transform([A, B|T], D) :- transform(T, Q), operation(A, B, C), operation(C, Q, D).
transform([A|T], C) :- transform(T, Q), operation(A, Q, C).

% Throw the given array through every possible transformation and update the max
all_transforms(A) :- transform(A, B), n(C), B>C, retract(n(C)), assert(n(B)).

% Find all the permutations and transformations, then fail and continue execution.
prog(A) :- assert(n(0)), !, permutation([0|A], B), all_transforms(B), fail.

% End the program
finished :- n(R), write(R), nl, R2 is R, write(R2), nl.

% Run the program
main(A) :- ignore(prog(A)), finished.

स्पष्टीकरण:

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

— एरिक
स्रोत

4

स्केला, 134

print(args.map(Math abs _.toInt)./:(Seq(Array(0)))((l,a)=>l.map(a+:_)++l.flatMap(_.permutations.map{r=>r(0)+=a;r}))map(_.product)max)

अपुष्ट और टिप्पणी की गई:

print(
  args
    .map(Math abs _.toInt)                     // to int, ignoring -
    .foldLeft(Seq(Array(0))){ (list,num) =>    // build up a list of sums of numbers
      list.map(num+:_) ++                      // either add the new number to the list
      list.flatMap(_.permutations.map{ copy =>
        copy(0)+=num                           // or add it to one of the elements
        copy
      })
    }
    .map(_.product) // take the maximum of the the products-of-sums
    .max
)

थोड़ा अलग दृष्टिकोण, यह महसूस करने से कि सबसे बड़ा जवाब हमेशा रकम के उत्पाद के रूप में व्यक्त किया जा सकता है।

इतना करीब है, लेकिन लाइब्रेरी की मूर्खता का एक गुच्छा (क्रमचय एक Seq के बजाय एक Iterator लौटाता है, खाली अनुक्रमों पर भयानक प्रकार का निष्कर्ष, Array.update रिटर्निंग यूनिट) ने मुझे अंदर किया।

— paradigmsort
स्रोत

3

पायथन 278 (ओ (एन!))

from itertools import*
def f(n):
 f,n,m=lambda n:[(n,)]+[(x,)+y for x in range(1,n)for y in f(n-x)],map(abs,map(int,n.split())),0
 for p,j in product(permutations(n),f(len(n))):
  i=iter(p)
  m=max(m,reduce(lambda e,p:e*p,(sum(zip(*zip([0]*e,i))[1])for e in j)))
 return m

व्याख्या

सभी नकारात्मक संख्याओं को सकारात्मक में बदलने के लिए Unary Negate का विवेकपूर्ण उपयोग किया जाना चाहिए
संख्याओं के सभी संभावित क्रमों का पता लगाएं
किसी दिए गए क्रमचय के सभी बिजली-सेटों को खोजने के लिए इंटीजर विभाजन का उपयोग करना
रकम का उत्पाद ज्ञात कीजिए
रकम का अधिकतम उत्पाद लौटाएं

— अभिजीत
स्रोत

3

हास्केल - 295 290 265 246 203 189 182 बाइट्स

अंत में काम करता है! इसके अलावा अब यह एक गतिशील समाधान के बजाय एक क्रूर बल है।

गर्व करने के लिए कुछ गोल्फ युक्तियाँ के लिए धन्यवाद।

यह शायद है नहीं एक पूरी तरह से golfed समाधान क्योंकि मैं वास्तव में गोल्फ में चूसना, लेकिन यह सबसे अच्छा मैं के साथ आ सकता है (और यह जटिल लगता है, इसलिए मुझे मिल गया मेरे लिए जा रहा है कि):

import Data.List
main=interact$show.g.read
g x=maximum[product$a#b|a<-sequence$replicate(length x-1)[0,1],b<-permutations x]
(a:b)#(c:d:e)|a>0=b#(c+d:e)|0<1=c:b#(d:e)
_#x=x

नए परीक्षण के मामले:

[1,1,1,2,2]
12

[1,1,3,3,3]
54

[1,1,1,1,1,1,1,1,5,3]
270

समाधान स्पष्टीकरण:

mainसमारोह सिर्फ एक इनपुट हो जाता है और चलाता है gइसके साथ।

g इनपुट लेता है और रकम और सूची क्रम के सभी संभावित संयोजनों का अधिकतम लाभ देता है।

# वह कार्य है जो इस तरह से एक सूची में रकम की गणना करता है:

a = [1,0,0,1]
b = [1,1,1,2,2]
a#b = [2,1,4]

— ThreeFx
स्रोत

यह काफी प्रदर्शन-संचालित समाधान जैसा लगता है।

— गर्वित हैकेलर

क्या आप ;जब संभव हो तो इसके बजाय कृपया नई जानकारी लिख सकते हैं ? यह बाइट काउंट को नहीं बदलता है, लेकिन पठनीयता को परेशान करने में मदद करता है

— गर्व हैकेलर

@proudhaskeller मुझे कोई अंदाजा नहीं था कि इसको कैसे बल देना है, इसलिए मुझे कुछ और करना होगा: D

— थ्रीफैक्स

यह सलाह देने के लिए मेरी सलाह - 1) हर फ़ंक्शन को इनलाइन करें जो केवल एक बार उपयोग किया जाता है (जब तक कि यह पैटर्न मिलान या गार्ड का उपयोग नहीं करता है)। 2) आप d d n=[0,2,1]!!nया के रूप में लागू कर सकते हैं d n=mod(3-n)3। 3) सूची को खुद लेने के बजाय सूची की लंबाई बनाएं oऔर gलें, क्योंकि वे केवल लंबाई पर निर्भर करते हैं (जाहिर है कि यह केवल तब तक ही खड़ा होता है जब तक वे इनलेट नहीं होते)। 4) के otherwiseसाथ बदलें 0<1। 5) r की अंतिम परिभाषा बनाओ r$o x:y। 6) को हटा दें a@और एक के साथ बदलें x:y। अपने गोल्फ के साथ शुभकामनाएँ!

— गर्वित हैकेलर

आपका एल्गोरिथ्म [3,3,3,2,2,2,1,1,1] के लिए गलत उत्तर देता है। मैंने आपका कोड चलाया, और यह 216 रिटर्न (सबसे बड़ा परिणाम जो मैं 729 के साथ आने में सक्षम था)।

— ब्रिलियनड

1

गोल्फस्क्रिप्ट (52 वर्ण)

~]0-{abs}%.1-.1,or@,@,-,-1%{!\$.0=3<@+{()}1if+}/{*}*

ऑनलाइन डेमो

feersum का विश्लेषण बहुत अच्छा है, लेकिन इसे आगे ले जाया जा सकता है अगर लक्ष्य दक्षता के बजाय गोल्फिंग है। छद्म कोड में:

filter zeros from input and replace negatives with their absolute value
filter ones to get A[]
count the ones removed to get C
while (C > 0) {
    sort A
    if (A[0] < 3 || C == 1) A[0]++
    else A.append(1)
    C--
}
fold a multiply over A

— पीटर टेलर
स्रोत

अधिकतम संचालन खोजें

C - 224 बाइट्स - रनिंग टाइम O (n)

हास्केल, 126 वर्ण

एसडब्ल्यूआई-प्रोलॉग - 250

स्केला, 134

पायथन 278 (ओ (एन!))

व्याख्या

हास्केल - 295 290 265 246 203 189 182 बाइट्स

गोल्फस्क्रिप्ट (52 वर्ण)