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 বিট পূর্ণসংখ্যায় সংরক্ষণ করা যেতে পারে কোডটি কাজ করা উচিত।
যে কোনও ওভারফ্লো আচরণ আপনার উপর নির্ভর করে।

আমি আশা করি এটি যথেষ্ট পরিষ্কার, এটি আমার প্রথম কোড গল্ফ চ্যালেঞ্জ পরামর্শ sugges

code-golf math arithmetic

— CNicolas
সূত্র

আপনার উদাহরণগুলির মধ্যে একটি এমন ক্রিয়াকলাপ ব্যবহার করছে যা অনুমোদিত নয়: যদি অকার্যকর অবহেলা যদি আপনার শ্বেত তালিকাতে থাকে তবে বিয়োগফলটি সত্যিই প্রয়োজনীয় নয়।

— পিটার টেলর

সম্পাদিত এবং অযৌক্তিক অবহেলা যোগ করা হয়েছে। বিয়োগ শ্বেত তালিকাতে রাখা হয়।

— CNicolas

1

এটি একটি সম্পূর্ণ প্রোগ্রাম হতে হবে বা একটি কার্যকারিতা যথেষ্ট?

— থ্রিএফএক্স

পুরো প্রোগ্রাম। এটি অনলাইনে চালানো যেতে পারে তবে আরও ভাল, তবে অবশ্যই বাধ্যতামূলক নয়

— সিএনকোলাস

@ আইএনএসইডে কি অনলাইনে চালানোর কোনও উপায় যুক্ত করা উচিত?

— অভিমানী হাসেল্লার

9

সি - 224 বাইট - চলমান সময় হে (এন)

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);}

রৈখিক-সময় সমস্যার জন্য এটি কেবলমাত্র ক্ষতিকারক-সময় সমাধানগুলি দেখার জন্য মজাদার ছিল, তবে আমি মনে করি যে এটি অ্যালগরিদম থাকার কোনও বোনাস পয়েন্ট ছিল না বলেই এগিয়ে যাওয়ার যুক্তিযুক্ত উপায়, যা লোগারিদমের একটি এনালগ্রাম।

নেতিবাচক সংখ্যাগুলিকে ধনাত্মক করে ও জিরোগুলিকে ত্যাগ করার পরে, স্পষ্টত আমরা বেশিরভাগই গুণিত করতে আগ্রহী। আমরা চূড়ান্ত সংখ্যার লগারিদম সর্বোচ্চ করতে চাই।

লগ (এ + বি) <লগ (ক) + লগ (খ) ব্যতীত যখন একটি = 1 বা বি = 1 হয়, সুতরাং কেবলমাত্র একমাত্র ক্ষেত্রে আমরা একসাথে কিছু যুক্ত করতে আগ্রহী। সাধারণভাবে এটি একটি ছোট সংখ্যায় 1 যুক্ত করা আরও ভাল, কারণ এটি বড় সংখ্যায় 1 যুক্ত করার চেয়ে লগারিদমে বড় অর্থাত্ একটি বৃহত্তর শতাংশ বৃদ্ধি ঘটায়। চারটি সম্ভাব্য পরিস্থিতি রয়েছে যা ব্যবহার করার জন্য সর্বাধিক কমপক্ষে পছন্দনীয় অর্ডার:

একটি 2 এ যোগ করা + লগ দেয় 4040 [লগ (3) - লগ (2)]
একটিকে ত্রিশের সাথে একত্রিত করা প্রতি এক + লগ .366 দেয় [লগ (3) / 3]
2 জনের মধ্যে 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

(কোনও বিশিষ্ট কারণ ছাড়াই, আমি এটি দুর্দান্ত দেখতে পেয়েছি যে আমার গল্ফড ক্রিয়াকলাপের নামগুলি "টমেটো পাত্র" "বানান করে)

অবরুদ্ধ সংস্করণ:

% 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.

ব্যাখ্যা:

আর্গুমেন্ট হিসাবে অ্যারে নিন।
অ্যারের সমস্ত অনুমোদন পান।
অ্যারে যুক্ত করতে অপারেটরদের কিছু ব্যবস্থা সন্ধান করুন। (এটি গতিশীল প্রোগ্রামিংয়ের মাধ্যমে সম্পন্ন করা হয়েছে, এটি দেখার জন্য যে আমরা প্রথম দুটি উপাদান একত্রিত করি কিনা তা ভাল whether
এটি আমাদের বর্তমান সর্বাধিক মানের বিপরীতে দেখুন। যদি এটি আরও ভাল হয় তবে এটি প্রতিস্থাপন করুন।
প্রোগ্রামটি বলুন আমরা ব্যর্থ হয়েছি যাতে এটি চেক করে চলে, তবে তারপরে অগ্রাহ্য সামগ্রিক প্রত্যাবর্তন করতে এবং চালিয়ে যাওয়ার জন্য এটি (ব্যবহার করে ) 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
)

সবচেয়ে বড় উত্তরটি সর্বদা অঙ্কের পণ্য হিসাবে প্রকাশ করা যেতে পারে তা বুঝতে পেরে কিছুটা ভিন্ন দৃষ্টিভঙ্গি।

এত কাছে, তবে লাইব্রেরির বোকামির একগুচ্ছ (ক্রমবিন্যাসগুলি একটি সেকের পরিবর্তে একটি আইট্রেটারকে ফেরত দেয়, খালি সিকোয়েন্সগুলিতে ভয়ঙ্কর ধরণের অনুক্রম, অ্যারে.আপডেট রিটার্নিং ইউনিট) আমাকে করেছিল।

— 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

ব্যাখ্যা

সমস্ত নেতিবাচক সংখ্যাকে ধনাত্মক রূপান্তর করতে ইউনারি নেগেটটি ন্যায়বিচারের সাথে ব্যবহার করা উচিত
সংখ্যাগুলির সমস্ত সম্ভাব্য ক্রম নির্ধারণ করুন
প্রদত্ত ক্রমান্বয়ে সমস্ত পাওয়ার সেট সেট করতে পূর্ণসংখ্যা বিভাজন ব্যবহার করে
অঙ্কের পণ্যটি সন্ধান করুন
অঙ্কের পণ্যের সর্বাধিক ফিরিয়ে দিন

— অভিজিৎ
সূত্র

3

হাস্কেল - 295 290 265 246 203 189 182 বাইট

শেষ পর্যন্ত কাজ! এছাড়াও এখন এটি একটি গতিশীল সমাধানের পরিবর্তে একটি নিষ্ঠুর শক্তি।

কিছু গল্ফিং টিপসের জন্য গর্বিতসেলারকে ধন্যবাদ।

এটি সম্ভবত হয় না একটি সম্পূর্ণরূপে golfed সমাধান কারণ আমি আসলে golfing এ স্তন্যপান, কিন্তু এটা ভাল আমি সঙ্গে আসা পর্যন্ত করতে পারেন (এবং জটিল দেখায়, তাই আমি পেয়েছিলাম আমার জন্য যাচ্ছে যে):

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
সূত্র

এটি বেশ একটি পারফরম্যান্স-চালিত সমাধানের মতো বলে মনে হচ্ছে।

— গর্বিত হাসকলার

আপনি ;যখন সম্ভব সম্ভব পরিবর্তে নতুন লাইন লিখতে পারেন ? এটি বাইট গণনা পরিবর্তন করে না তবে পঠনযোগ্যতাটিকে সাময়িকভাবে সহায়তা করে

— গর্বিত হাসেলেলার

@ প্রফেসহেস্কেলর আমাকে কীভাবে জোর করা উচিত তা সম্পর্কে আমার কোনও ধারণা ছিল না তাই আমাকে আরও কিছু নিয়ে আসতে হবে: ডি

— থ্রিএফএক্স

এটিকে গল্ফ করার জন্য আমার পরামর্শ - 1) প্রতিটি ফাংশন ইনলাইন করুন যা কেবল একবার ব্যবহৃত হয় (যদি না এটি প্যাটার্ন মেলানো বা রক্ষীদের ব্যবহার করে)। 2) আপনি d হিসাবে d n=[0,2,1]!!nবা প্রয়োগ করতে পারেন d n=mod(3-n)3। 3) করা oএবং gপরিবর্তে তালিকার দৈর্ঘ্য নেওয়া তালিকা নিজেই গ্রহণের, তারা শুধুমাত্র দৈর্ঘ্যের উপর নির্ভর করে (সম্ভবত এই দাঁড়িয়েছে শুধুমাত্র যতদিন তারা inlined হয় না)। 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)।

— Brilliand

1

গল্ফস্ক্রিপ্ট (৫২ টি অক্ষর)

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

অনলাইন ডেমো

ফেয়ারসামের বিশ্লেষণ বেশ ভাল তবে লক্ষ্যটি যদি দক্ষতার চেয়ে গল্ফ হয় তবে তা আরও নেওয়া যেতে পারে। সিউডো কোডে:

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

— পিটার টেলর
সূত্র

সর্বাধিক অপারেশন সন্ধান করুন