রুনডাউন

এমন একটি প্রোগ্রাম তৈরি করুন যা এলোমেলো সংখ্যার সাথে এলোমেলো দৈর্ঘ্যের একটি অ্যারে তৈরি করে, তারপরে অ্যারে পরিবর্তন করে এমন একটি বিধিবিধানের একটি সিরিজ প্রয়োগ করুন। নিয়ম প্রয়োগ হওয়ার পরে অ্যারের যোগফল মুদ্রণ করুন অন্যথায় নির্দিষ্ট না করে

অ্যারে সেটআপ

অ্যারে অবশ্যই 5 থেকে 10 সমেতের মধ্যে একটি এলোমেলো দৈর্ঘ্য হতে হবে, 1 থেকে 20 এর মধ্যে এলোমেলো পূর্ণসংখ্যা সহ। প্রতিটি অ্যারের দৈর্ঘ্যের ঘটনার সমান সম্ভাবনা থাকা উচিত এবং প্রতিটি পূর্ণসংখ্যার উপাদান অনুসারে বাছাইয়ের সমান সম্ভাবনা থাকা উচিত।

7 বিধি

নিয়মগুলি এমনভাবে আচরণ করবে যেন সেগুলি ধারাবাহিকভাবে প্রয়োগ করা হয়েছিল (উদাহরণস্বরূপ: বিধি 2 বিধি আগে 1 টি নিয়ম) এবং কেবল একবার প্রয়োগ করা হয়। বিধি প্রয়োগের প্রমাণের জন্য, প্রতিটি বিধি প্রয়োগের পরে এবং কোনও বিধি প্রয়োগ করার আগে একবার কনসোল করার জন্য অ্যারেটি মুদ্রণ করতে হবে।

অ্যারেতে যদি 7 থাকে তবে প্রতিটি উপাদান থেকে 1 টি বিয়োগ করুন
যদি নিয়ম 1 প্রয়োগ করা হয় এবং অ্যারেতে এখন 0 থাকে, প্রতিটি উপাদানকে 1 যুক্ত করুন
যদি অ্যারেটিতে একটি 13 থাকে তবে অ্যারে থেকে 13 এবং সমস্ত উপাদান অনুসরণ করে বাদ দিন
অ্যারেটিতে যদি 2 থাকে তবে সমস্ত বিজোড় সংখ্যা বাদ দিন
যদি অ্যারেতে 20 টি থাকে এবং তৃতীয় উপাদানটি সমান হয় তবে যোগফল 20 হিসাবে ফেরত তারপর সমাপ্ত হবে। যদি একটি 20 উপস্থিত থাকে এবং তৃতীয় উপাদানটি বিজোড় হয় তবে অ্যারের দৈর্ঘ্যের 20 গুণ আবার সমাপ্ত হবে return
যোগফল 50 এর চেয়ে বেশি হলে শেষের উপাদানটি 50 এর চেয়ে কম বা সমান না হওয়া পর্যন্ত বার বার সরিয়ে দিন
যদি অ্যারেটিতে একটি 16 থাকে, তবে দশমিক এবং হেক্সাডেসিমাল উভয়টিতে যোগফলটি মুদ্রণ করুন।

উদাহরণ

এখানে একটি প্রাথমিক অ্যারে,

[20, 2, 5, 7, 14, 8]

বিধি 1 প্রয়োগ করা যেতে পারে:

[19, 1, 4, 6, 13, 7]

বিধি 3 পরবর্তী প্রয়োগ করা হয়:

[19, 1, 4, 6]

অন্য কোনও নিয়মের প্রয়োজন নেই, সুতরাং প্রোগ্রামটি যোগফল হিসাবে 30 ফেরত দেয়।

আমি অভিজ্ঞ কোড গল্ফার নই, যদিও আমি বলতে পারি যে আমার ব্যক্তিগত রেকর্ডটি পাইথন 3 এ 369 বাইট রয়েছে ।
নিয়মগুলি আসলে প্রয়োগ করতে হবে না, তবে তারা যেমন করেছে তেমন আচরণ করতে হবে।

code-golf array-manipulation

— Graviton
সূত্র

1

"এলোমেলো" কতটা এলোমেলো হতে হবে?

— হাইপারনিউটারিনো

1

@ হাইপারনিউট্রিনো এটি যতটা ইচ্ছা সুডো-এলোমেলো হতে পারে তবে ছুঁড়ে দেওয়া চ্যালেঞ্জ নয়। পুনরাবৃত্তি অনুমোদিত।

— গ্র্যাভিটন

আমরা কীভাবে নিয়ম প্রয়োগ করেছি তা আপনি কীভাবে যাচ্ছেন? আমি 50 এর নিচে কেবল একটি এলোমেলো সংখ্যা তৈরি করতে পারি এবং এটি এখনও প্রযুক্তিগতভাবে কোনও নিয়ম ভাঙবে না, এবং আমি এটি নিয়ম "অনুসরণ করা" বলতে পারি। সম্পাদনা: আমি এখন বুঝতে পারি যে এটি কার্যকর হবে না, তবে লোকেরা এলোমেলো নিয়মগুলি রোধ করার উপায় খুঁজে বের করবে। আপনি কি তা প্রতিরোধ করতে যাচ্ছেন?

— ক্লিমেমিক

1

এই মুহুর্তে, দুটি অ্যারের মধ্যে একটি বেছে নেওয়া [3 3 3 3 4 3]এবং [4 4 3 4 4]সম্ভাব্যতা 50% সহ প্রতিটি "অ্যারে সেটআপ" এর অধীনে যা লেখা আছে তার সাথে সম্মতিযুক্ত। সুতরাং আমি কি 19প্রতিবার আউটপুট করতে পারি ? (অবশ্যই, আমি সত্যিই যা মনে করি তা হ'ল "এলোমেলো" এর সংজ্ঞাটি স্পষ্ট করা দরকার।)

— গ্রেগ মার্টিন

2

If the array contains a 20, and the third element is even/odd, যদি এই পদক্ষেপে অ্যারের 3 টিরও কম উপাদান থাকে?

— Emigna

8

পাইথন 3, 294 301 287 356 বাইট

import random as r
r=r.randint
k=[r(i)+1for i in[20]*r(5,11)]
p=print
if 7in k:k=[i-1for i in k]
p(k)
if 0in k:k=[i+1for i in k]
p(k)
i=k.find(13)
if not~i:k=k[:i]
p(k)
if 2in k:k=[i for i in k if~i%2]
p(k)
a=0
z=len(k)>2and k[2]%2
if 20in k:a=20*len(k)**z
if~z:p(k)
while sum(k)>50:k=k[:-1]
if~z:p(k)
if a:p(a)
else:a=sum(k);p(a,hex(a)*(16in k))
if~z:p(k)

আমি জানি না আপনি কীভাবে লোকদের নিয়ম লঙ্ঘন করা থেকে বিরত রাখছেন, তবে এটি একটি নির্দিষ্ট পদ্ধতি ব্যবহার করে।

+7 বাইট; কয়েকটা বাইট সংরক্ষণের জন্য @ ইয়ামবিকে ধন্যবাদ; পূর্ববর্তী ত্রুটিটি ঠিক করতে আরও অনেক কিছু যুক্ত করা হয়েছে।
-১৪ বাইটস @ রুটটউ এবং আমার নিজের ধন্যবাদ এবং ত্রুটিটিও সংশোধন করেছেন।
+83 বাইট; এটি মারাত্মকভাবে দীর্ঘ হচ্ছে কারণ ওপি নিয়মগুলি পরিবর্তন করে চলেছে। -জ্যাচারিটি কে ধন্যবাদ কয়েক সংখ্যক বাইটস

— HyperNeutrino
সূত্র

সমস্ত চেক আউট, সৎ থাকার জন্য ধন্যবাদ।

— গ্র্যাভিটন

আপনি 7in কে: কে = [আই -1 ... 'থেকে' যদি 7 ইন কে: কে = [আমি + 1-ইন (1 ই কে ) ... '

— গ্রাভিটন

কে শুরু করার সময়, আপনার i এর মান প্রয়োজন হয় না, তাই আপনি 6 বাইটের সাহায্যে সঞ্চয় করতে পারেন k=[r(1,20)for _ in'-'*r(5,11)]। আপনি k=[i+~-(1in k)*(7in k)for i in k]নিয়ম 1 এবং 2 ব্যবহার করে আরেকটি বাইট সংরক্ষণ করতে পারেন

— রুটটউ

1

@ নোটস 90 আমি এই চ্যালেঞ্জটি লেখার পরে নিয়মগুলি পরিবর্তন করা হয়েছিল। আমি কোনও কম্পিউটারে উঠলে আমি এটি ঠিক করব। ধন্যবাদ।

— হাইপারনিউটারিনো

পাঁচ এবং সাত লাইনে, আপনার পরে একটি অপ্রয়োজনীয় স্থান রয়েছে 1এবং আপনি printদ্বিতীয় এবং তৃতীয়টি শেষ লাইনে পরিবর্তন করতে পারেন p। এবং আপনি ... আপনার বাইকোয়ান্ট আপডেট করেন নি।

— জাচারা

6

05 এ বি 1 ই , 91 বাইট

5TŸ.RF20©L.R})=D7åi<=D0åi>=}}D13åiD13k£=}D2åiDÈÏ=}D®åiDgs2èÉ®si*},q}[DO50›_#¨=]D16åiDOH,}O,

এটি অনলাইন চেষ্টা করুন! অথবা ইনপুট সহ

— Emigna
সূত্র

84 বাইট, এবং সম্ভাব্য সঠিক? ভিন্ন? কোন ধারণা নেই. tio.run/nexus/…

— ম্যাজিক অক্টোপাস উরান

@ কারাসোকম্পুটিং: আমি এটিকে ভালভাবে দেখিনি, তবে এটি শুরুতে এলোমেলো অ্যারে তৈরি করে না বা মধ্যবর্তী ফলাফলগুলিও মুদ্রণ করে না। এই অংশগুলি যুক্ত করার সময় কিছুটা দীর্ঘ হবে।

— এমিগানা

6

জাভাস্ক্রিপ্ট (ES6), 344 342 340 342 335 331 333 313 311 305 298 297 290 289 283 279 বাইট

Huzzah! অবশেষে ~~দিয়ে বাঁধা~~ বীট Arnauld !

চ্যালেঞ্জের মন্তব্যে এই এক্সচেঞ্জ * অনুসরণ করা এবং অনেক আলোচনার পরে আমি new Dateএলোমেলো নম্বর জেনারেটরের পরিবর্তে বীজ হিসাবে ব্যবহার করার সিদ্ধান্ত নিয়েছি Math.random()। এটি করার অর্থ হ'ল অ্যারেতে থাকা সমস্ত সংখ্যার মান একই হবে।

_=>(l=alert,r=new Date,l(a=[...Array(r%6+5)].map(x=>r%20+1)),i=v=>~a.indexOf(v),i(7)&&l(a=a.map(x=>--x)),i(0)&&l(a=a.map(x=>++x)),i(13)&&l(a=a.slice(0,~i(13))),i(2)&&l(a=a.filter(x=>x%2)),i(t=20)?a[2]%2?t*a.length:t:l(a=a.filter(x=>s+x<51?s+=x:0,s=0))|i(16)?[s,s.toString(16)]:s)

চেষ্টা করে দেখুন

f=
_=>(l=alert,r=new Date,l(a=[...Array(r%6+5)].map(x=>r%20+1)),i=v=>~a.indexOf(v),i(7)&&l(a=a.map(x=>--x)),i(0)&&l(a=a.map(x=>++x)),i(13)&&l(a=a.slice(0,~i(13))),i(2)&&l(a=a.filter(x=>x%2)),i(t=20)?a[2]%2?t*a.length:t:l(a=a.filter(x=>s+x<51?s+=x:0,s=0))|i(16)?[s,s.toString(16)]:s)
alert(f())

স্নিপেট প্রসারিত করুন

নিয়ম 6-এ কেবল পপড উপাদানগুলিতে লগইন করে 2 বাইট সংরক্ষণ করা হয়েছে।
প্রতিস্থাপন 2 বাইট সংরক্ষিত Array(x).fill()সঙ্গে [...Array(x)]।
2 বাইট যুক্ত করলাম আমি নিয়ম 5 এ গণ্ডগোল করেছি!
আমি আগের জগাখিচুড়ি ঠিক করার চেষ্টা করে মেস ফিক্সিং করে 7 বাইট সংরক্ষণ করেছি!
সংরক্ষিত 3 ধন্যবাদ বাইট Arnauld আমাকে শাসন 2 একটি brainfart নিরাময় এবং একটি প্রতিস্থাপন একটি অতিরিক্ত বাইট সংরক্ষিত সাহায্য +1একটি সঙ্গে ~।
যোগ করা 2 বাইট নিশ্চিত করে 0খালি অ্যারে প্রদান করা হয়।
কীভাবে সেই ফেকিং whileলুপটি খনন করা যায় তা অবশেষে নির্ধারণ করে 20 বাইট সংরক্ষণ করা হয়েছে ।
প্রতিস্থাপন 2 বাইট সংরক্ষিত ,একটি গত 2 বিবৃতি মধ্যে |এবং এনক্লোজিং সরানোর ()।
প্রতিস্থাপন 6 বাইট সংরক্ষিত console.logসঙ্গে alert।
এর শর্টকাট উন্নত করে 7 বাইট সংরক্ষণ করা হয়েছে a.includes()।
নিয়ম 3 প্রয়োগের সম্পাদনা করে 1 বাইট সংরক্ষণ করা হয়েছে।
ডাচ করে includes()এবং কেবল indexOf()জুড়ে ব্যবহার করে 7 বাইট সংরক্ষণ করা হয়েছে।
sভেরিয়েবলের প্রাথমিক ঘোষণাকে কোথাও সরিয়ে নিয়ে 1 বাইট সংরক্ষণ করা হয়েছে এর জন্য কমা দরকার নেই need
প্রতিস্থাপন 6 বাইট সংরক্ষিত Math.random()সঙ্গে new Date।
এলোমেলো সংখ্যার (বর্তমানে রিডানড্যান্ট) রাউন্ডিং সরিয়ে 4 বাইট সংরক্ষণ করা হয়েছে।

পঠনযোগ্য ও পরীক্ষামূলক সংস্করণ

কোডে লাইন ব্রেক এবং মন্তব্য যুক্ত করা হয়েছে
console.logপরিবর্তে alertআপনার বিড়ম্বনার জন্য ব্যবহৃত ! (আপনার ব্রাউজারের কনসোলে সেরা দেখা)
আউটপুটে বর্তমান নিয়ম সংখ্যা যুক্ত করেছে।
কমা দ্বারা পৃথক করা সংখ্যার তালিকার ইনপুট দ্বারা পরীক্ষার অনুমতি দেওয়ার জন্য এলোমেলোভাবে অ্যারে প্রজন্মকে মন্তব্য করেছে।

কোড স্নিপেট দেখান

f=a=>(
    // Alias alert as l
    // (console.log used for this demo)
    l=(s,a)=>console.log(s+JSON.stringify(a))/*alert*/,
    // Alias new Date as r
    r=new Date,
    // Initiate an array of random length
    // Destructure array
    // Map a random value to each array element
    // (Above all commented out to allow testing your own arrays)
    // Log the initial array
    l("Initial: ",a/*=[...Array(r%6+5)].map(x=>r%20+1)*/),
    // Assign a.indexOf to shortcut i
    i=v=>~a.indexOf(v),
    // Check for the presesnce of 7
    // Invoke the first rule, decrementing the value of each element by 1
    // Log the resulting array
    i(7)&&l("Rule 1: ",a=a.map(x=>--x)),
    // Check for the presesnce of 0
    // Invoke the second rule, incrementing the value of each element by 1
    // Log the resulting array
    i(0)&&l("Rule 2: ",a=a.map(x=>++x)),
    // Check for the presence of 13
    // Invoke the third rule, slicing the array to the index of 13
    // Log the resulting array
    i(13)&&l("Rule 3: ",a=a.slice(0,~i(13))),
    // Check for the presence of 2
    // Invoke the fourth rule, removing all elements whose value have a remainder when divided by 2
    // Log the resulting array
    i(2)&&l("Rule 4:",a=a.filter(x=>x%2)),
    // Assign 20 to variable t
    // (Note: this does not yet save any bytes, but it doesn't cost any either)
    // Check for the presence of 20
    // Invoke the fifth rule, returing 20 times the array length ...
    // ... if the third element (2 in a 0 based index) leaves a remainder when divided by 2 ...
    // ... or just 20, if not
    i(t=20)?"Rule 5: "+(a[2]%2?t*a.length:t):
    // Assign the sum of the array to variable s
    // Invoke the sixth rule by filtering through the array, ...
    // ... adding the value of each element to s, as long as the result is less than 51 ...
    // ... otherwise remove the element from the array
    // Log the current array
    l("Rule 6 :",a=a.filter(x=>s+x<51?s+=x:0,s=0))|
    // Check for the presence of 16
    // If present, invoke the seventh rule, returning the sum and its hex value (as an array)
    // Otherwise simply return the sum
    i(16)?"Rule 7: "+[s,s.toString(16)]:"Sum: "+s
);

document.querySelector`button`.addEventListener(`click`,_=>(console.clear(),console.log(f(document.querySelector`input`.value.split`,`.map(eval)))))

<input><button>Test</button>

স্নিপেট প্রসারিত করুন

* স্ক্রিনশটটি মুছে ফেলার ক্ষেত্রে:

— রোমশ
সূত্র

4

সি (জিসিসি) , 621 619 593 585 570 562 557 552 529 517 500 482 461 444 442 441 438 বাইট

এখানে পুরো প্রচুর গল্ফের দরকার আছে ... একটি বাগ স্থির করে যেখানে তালিকায় প্রতি 16 টির জন্য একবার হেক্সিডেসিমাল প্রিন্ট করা হবে ...

গল্ফ সাহায্যের সাথে জ্যাকারিটিকে বিশেষ ধন্যবাদ

#define R r[i]
#define P printf("%d "
#define L for(d=i=0;i<l;i++)
d,i,j,l,r[11];p(i){L P,R);puts("");}main(){srand(time(0));for(l=5+rand()%5;i<l;R=1+rand()%20,i++);for(p();i--;)if(R==7){L--R;j=i=1;}for(p();j&&i<l;i++)if(!R){L++R;j=i=l;}p();L if(R==13)l=i;p();L if(R==2)for(d=1;d;)L if(R&1)for(d=1,--l;i<=l;i++)R=r[i+1];p();L if(R==20)return P,r[3]&1?20*l:20);for(j=i=0;i<l&&j+R<51;j+=R,i++);l=i;p();P,j);L if(R==16)printf("0x%x",j,i=l);}

এটি অনলাইন চেষ্টা করুন!

— cleblanc
সূত্র

1

যদিও আপনি এখনও প্রচুর গল্ফ করতে পারেন, আপনি ইতিমধ্যে আমার জাভা উত্তরের 1 বাইট নিচে রয়েছেন .. এক্সডি আসুন দেখি আমি আপনার বর্তমান জমাটি কোনওভাবেই এটির জন্য গল্ফ করতে পারি কিনা। ;)

— কেভিন ক্রুইজসেন

ঠিক আছে, -৩ বাইটের জন্য কিছু খুঁজে পেয়েছি; পি

— কেভিন ক্রুইজসেন

আপনি যদি এটিকে গলফ করতে পারেন তবে আপনি সেখানে "ক্রস আউট 444 এখনও 444 এখনও" পেতে সক্ষম হতে পারেন! : ডি

— হাইপারনিউট্রিনো

@ হাইপার নিউট্রিনো আরও 2 বাইট

— গল্ফ করেছে

হ্যাঁ! চমৎকার কাজ: ডি

— হাইপারনিউট্রিনো 15:51

3

জাভাস্ক্রিপ্ট (ES6), 296 295 290 289 বাইট

একটি সম্পূর্ণ প্রোগ্রাম যা প্রাথমিক অ্যারে, মধ্যবর্তী ফলাফল এবং কনসোলে চূড়ান্ত যোগফল লগ করে s

f="z=[...Array(5+6j)]Z1+20jw7`-1w0`+1w13_qi+1<-kw2_qn&1^1w20_z[2]&1?a.length*20:20);else{q(s+=n)<51,s=0w16_b.toString(16_;b)}zconsole.log(aw_;if(k=~a.indexOf(v((n,i)=>qz=a.filtervj*Math.random()|0bz.reducevn+i,0)`_z=aZn_))Z.mapv";for(g of "Z_`bjqvwz")e=f.split(g),f=e.join(e.pop());eval(f)

স্নিপেট প্রসারিত করুন

কিভাবে এটা কাজ করে

এটি এই জেএস প্যাকারটি ব্যবহার করে সংকুচিত হয়েছিল ।

ভাঙ্গন:

প্যাক করা স্ট্রিং: ~~226~~ 225 বাইট
আনপ্যাকিং কোড: 69 64 বাইট

নীচে কিছু অতিরিক্ত শ্বেত স্পেস এবং পঠনযোগ্যতার জন্য লাইন ফিড সহ মূল উত্স কোড রয়েছে। স্ট্যান্ডার্ড গল্ফিং ট্রিকস প্রয়োগ করার পরিবর্তে, এটি এমনভাবে লেখা হয়েছিল যা প্যাকারকে খুশি করার জন্য যতটা সম্ভব পুনরাবৃত্ত স্ট্রিং তৈরি করে। উদাহরণস্বরূপ, বাক্য if(k=~a.indexOf(N))গঠনটি সর্বত্র নকল করা হয়েছে যদিও kএটি কেবল তৃতীয় নিয়মে ব্যবহৃত হয়।

console.log(a=[...Array(5+6*Math.random()|0)].map((n,i)=>1+20*Math.random()|0));
if(k=~a.indexOf(7))
  console.log(a=a.map((n,i)=>n-1));
if(k=~a.indexOf(0))
  console.log(a=a.map((n,i)=>n+1));
if(k=~a.indexOf(13))
  console.log(a=a.filter((n,i)=>i+1<-k));
if(k=~a.indexOf(2))
  console.log(a=a.filter((n,i)=>n&1^1));
if(k=~a.indexOf(20))
  console.log(a[2]&1?20*a.length:20);
else {
  console.log(a=a.filter((n,i)=>(s+=n)<51,s=0));
  if(k=~a.indexOf(16))
    console.log(a.reduce((n,i)=>n+i,0).toString(16));
  console.log(a.reduce((n,i)=>n+i,0))
}

আনপ্যাকিং পদ্ধতিগুলি

মূল আনপ্যাকিং কোডটি হ'ল:

f="packed_string";for(i in g="ABCDEFGHI")e=f.split(g[i]),f=e.join(e.pop());eval(f)

নিম্নলিখিত সমস্ত ES6 ভেরিয়েন্টের হুবহু একই আকার রয়েছে:

eval([..."ABCDEFGHI"].reduce((f,g)=>(e=f.split(g)).join(e.pop()),"packed_string"))
[..."ABCDEFGHI"].map(g=>f=(e=f.split(g)).join(e.pop()),f="packed_string")&&eval(f)
eval([..."ABCDEFGHI"].map(g=>f=(e=f.split(g)).join(e.pop()),f="packed_string")[8])

কয়েকটা বাইট চাঁচা করার জন্য আমি এখন পর্যন্ত যে একমাত্র উপায় খুঁজে পেয়েছি তা হ'ল for ... of:

f="packed_string";for(g of "ABCDEFGHI")e=f.split(g),f=e.join(e.pop());eval(f)

— Arnauld
সূত্র

ফোনে এটি পড়া যাতে আমি ভুল হতে পারি তবে আপনার আনপ্যাকড কোডে দেখে মনে হচ্ছে নিয়ম 2 প্রয়োগ করা হচ্ছে মনে হচ্ছে নির্বিশেষে আইন 1 থাকুক বা না থাকুক।

— শেগি

1

পছন্দ করুন নিয়ম 1 ট্রিগার না করা পর্যন্ত আপনি একটি শূন্য পেতে পারবেন না।

— আর্নৌল্ড

ডি আহা! অবশ্যই! মানুষ, আমি এই চ্যালেঞ্জের সময় একটি হাস্যকর সংখ্যক মস্তিষ্কে ছড়িয়ে পড়েছি :(

— শেগি

1

দুর্ভাগ্যক্রমে তবে আমরা এর সাথে একটি বাইট সংরক্ষণ করতে পারি n&1^1(এটি মোটেও প্যাক হয় না, তবে এটির তুলনায় কেবল একটি বাইট কম !(n&1))। আমি এটি সম্পর্কে এক পর্যায়ে ভেবেছিলাম এবং এটি অন্তর্ভুক্ত করতে ভুলে গেছি।

— আরনাউল্ড

1

@ শাগি আহাহ! সুন্দর কাজ!

— আর্নৌল্ড

2

কোড গল্ফ এ প্রথম চেষ্টা করুন!

ইতিমধ্যে অন্যান্য জাভাস্ক্রিপ্টারে পরাজিত! ধূর! আমি ভাল করবো!!! =)

জাভাস্ক্রিপ্ট -> 550 402 বাইট

অবশ্যই উন্নত করা যেতে পারে। সংকুচিত এখন:

f="ba=[];bl;yz5+5`^=0;i<y;i++)a[i]z20+1|~7j-1|~0j+1|}}~13_l=indexOf(13`ql,y-l-Y_^ in a)if(a[i]%2)qi,Y0)&&(!a[3]%2_k'20'`throw new Error(`}do{l=Vreduce((X,num)=>X+num`ifW)qy-1,1`}whileW|kl`~16))kl.toString(16)`~if(Vincludes(|`ka`z=Zound(Zandom()*yVlengthqVsplice(kalert(j_Vmap((i)=>ibvar `);_)){^for(biZMath.rY1|}~2XtotalW(l>50Va.";for(i in g="VWXYZ^_`bjkqyz|~")e=f.split(g[i]),f=e.join(e.pop());eval(f)

Originial:

var a=[];var l;a.length=Math.round(Math.random()*5+5);for(var i=0;i<a.length;i++)a[i]=Math.round(Math.random()*20+1);alert(a);if(a.includes(7)){a.map((i)=>i-1);alert(a);if(a.includes(0)){a.map((i)=>i+1);alert(a);}}if(a.includes(13)){l=indexOf(13);a.splice(l,a.length-l-1);alert(a);}if(a.includes(2)){for(var i in a)if(a[i]%2)a.splice(i,1);alert(a);}if(a.includes(20)&&(!a[3]%2)){alert('20');throw new Error();}do{l=a.reduce((total,num)=>total+num);if(l>50)a.splice(a.length-1,1);}while(l>50);alert(a);alert(l);if(a.includes(16))alert(l.toString(16));

— ব্লু ওকিরিস
সূত্র

2

জাভা 7, 622 619 618 বাইট

import java.util.*;void c(){Random r=new Random();List<Long>l=new ArrayList();int i=0,c=r.nextInt(6)+5;for(;i++<c;l.add(r.nextInt(20)+1L));p(l);if(l.contains(7)){for(i=0;i<c;l.set(i,l.get(i++)-1));p(l);}if(l.contains(0)){for(i=0;i<c;l.set(i,l.get(i++)+1));p(l);}if((i=l.indexOf(13))>=0){for(;i<l.size();l.remove(i));p(l);}if(l.contains(2)){for(i=0;i<l.size();)if(l.get(i)%2>0)l.remove(l.get(i));else i++;p(l);}if(l.contains(20)){p(20*(l.get(2)%2<1?1:l.size()));return;}i=0;for(long x:l)i+=x;for(;i>50;)i-=l.remove(l.size()-1);p(l);if(l.contains(16))p(Byte.valueOf(i+"",16));p(i);}<T>void p(T t){System.out.println(t);}

-1 বাইট @ পোকে ধন্যবাদ

ব্যাখ্যা:

import java.util.*;                      // Imports used for List, ArrayList and Random

void c(){                                // Main method
  Random r=new Random();                 //  Random generator
  List<Long>l=new ArrayList();           //  The list
  int i=0,                               //  Temp index we use multiple times
      q=r.nextInt(6)+5;                  //  Random size of the list (5-10)
  for(;i++<q;l.add(r.nextInt(20)+1L));   //  Fill the list with random long-integers (1-20)
  p(l);                                  //  Print the initial list
  if(l.contains(7)){                     //  If the list contains a 7
    for(i=0;i<c;l.set(i,l.get(i++)-1));  //   Decrease each number in the list by 1
    p(l);                                //   And then print the list again
  }                                      //  End of if
  if(l.contains(0)){                     //  If the list now contains a 0
    for(i=0;i<c;l.set(i,l.get(i++)+1));  //   Increase each number in the list by 1
    p(l);                                //   And then print the list again
  }                                      //  End of if
  if((i=l.indexOf(13))>=0){              //  If the list contains a 13 (and save it's index in `i` at the same time)
    for(;i<l.size();l.remove(i));        //   Remove everything from that index and onward
    p(l);                                //   And then print the list again
  }                                      //  End of if
  if(l.contains(2)){                     //  If the list now contains a 2
    for(i=0;i<l.size();)                 //   Loop over the list
      if(l.get(i)%2>0)                   //    If the current list item is odd
        l.remove(l.get(i));              //     Remove it
      else                               //    If it's even instead
        i++;                             //     Go to the next item
                                         //   End of loop (implicit / single-line body)
    p(l);                                //   And print the list again
  }                                      //  End of if
  if(l.contains(20)){                    //  If the list now contains a 20
    p(20*(l.get(2)%2<1?1:l.size()));     //   Print 20 if the third item in the list is odd, or 20*size if it's even instead
    return;                              //   And then terminate the method
  }                                      //  End of if
  i=0;                                   //  Reset `i` to 0
  for(long x:l)i+=x;                     //  And calculate the total sum of the list (stored in `i`)
  for(;i>50;)                            //  Loop as long as this list's sum is above 50
    i-=l.remove(l.size()-1);             //   Subtract the last item from this sum, and then remove it from the list
                                         //  End of loop (implicit / single line body)
  p(l);                                  //  And print the list again
  if(l.contains(16))                     //  If the list now contains a 16
    p(Byte.valueOf(i+"",16));            //   Print the sum (still stored in `i`) as hexadecimal
                                         //  End of if (implicit / single-line body)
  p(i);                                  //  And print the sum as integer either way
}                                        // End of main method

<T>void p(T t){                          // Separate method with a generic parameter
  System.out.println(t);                 //  Print the given parameter including a new-line
}                                        // End of separated method

নমুনা আউটপুট: নমুনা আউটপুটগুলির
পিছনে মন্তব্যগুলি মুদ্রিত হয় না, তবে আমি সেগুলি স্পষ্টতা হিসাবে যুক্ত করেছি।

এখানে চেষ্টা করুন।

[17, 5, 3, 1, 16, 17, 11, 7, 13]   // Initial print (size 9)
[16, 4, 2, 0, 15, 16, 10, 6, 12]   // Rule 1 (contains a 7)
[17, 5, 3, 1, 16, 17, 11, 7, 13]   // Rule 2 (contains a 0)
[17, 5, 3, 1, 16, 17, 11, 7]       // Rule 3 (contains a 13)
[17, 5, 3, 1, 16]                  // Rule 6 (sum must be <= 50)
66                                 // Rule 7 (contains a 16 -> print as Hexadecimal)
42                                 // Print sum as integer

[4, 18, 17, 12, 11, 8]             // Initial print (size 6)
[4, 18, 17]                        // Rule 6 (sum must be <= 50)
39                                 // Print sum as integer

[4, 14, 6, 14, 7, 20, 2, 2]        // Initial print (size 8)
[3, 13, 5, 13, 6, 19, 1, 1]        // Rule 1 (contains a 7)
[3]                                // Rule 3 (contains a 13)
[3]                                // Print is always done after rule 6
3                                  // Print sum as integer

— কেভিন ক্রুইজসেন
সূত্র

1

আমি এখন 594 বাইটে

— নামছি :

@ ক্লেব্ল্যাঙ্ক আমি দেখতে পাচ্ছি আপনি এখন ৪৪৪ এর নিচে নেমে এসেছেন I জাভা দিয়ে আমি এর সাথে প্রতিযোগিতা করতে পারছি না। :) (মজার কথা যে 444 যেহেতু অন্যান্য উত্তরগুলির তুলনায় জয়ের কাছাকাছি নয় ..)

— কেভিন ক্রুইজসেন

আমি এটি জানি, এমনকি 05AB1E এর মতো গল্ফিং ভাষা প্রায় 100 বাইট দীর্ঘ। এই চ্যালেঞ্জ একটি ব্যথা ছিল।

— ক্লাব্ল্যাঙ্ক

আপনি আপনার তালিকা জেনেরিক ছেড়ে যেতে পারেন List a = new ArrayList()? কিছু বাইট সংরক্ষণ করতে পারে। যদিও আসল পাটিগণিত করার সময় আপনার একটি টাইপকাস্ট যুক্ত করার প্রয়োজন হতে পারে। যদি না হয়, Longতুলনায় খাটোInteger

— অকর্মা

একটি জেনেরিক সঙ্গে @Poke Listআমি একজন ব্যবহার করতে হবে (int)ঢালাই থেকে পাঁচবার, সেইসাথে পরিবর্তনের জন্য-প্রতিটি লুপ intথেকে Objectএবং একটি ষষ্ঠ ঢালাই যোগ করুন। হিসাবে Long: ধন্যবাদ, যে 1 বাইট :) সংরক্ষণ (এখনও জন্য-প্রতিটি পরিবর্তন করতে হবে intকরতে long, এবং r.nextInt(20)+1থেকে r.nextInt(20)+1L)।

— কেভিন ক্রুইজসেন

2

রুবি 2.4, 260 বাইট

রুবি 2.4 এর জন্য প্রয়োজনীয় Enumerable#sum।

p a=(1..s=5+rand(5)).map{1+rand(19)}
a.map!{|i|i-1}if a.index 7
p a
a.map!{|i|i+1}if a.index 0
p a
a.pop s-(a.index(13)||s)
p a
a.reject! &:odd?if a.index 2
p a
a.index(20)?p(20*[1,s][(a[2]||1)%2]):((a.pop;p a)while a.sum>50
p m=a.sum;puts"%x"%m if a.index 16)

এটি অনলাইন চেষ্টা করুন! (কেউই repl.it বা tio.run এখনও রুবি ২.৪ সমর্থন করে না, সুতরাং এই অনলাইন সংস্করণটি প্রতিস্থাপন sumকরে inject(:+), যার একই আচরণ রয়েছে))

— মান কালি
সূত্র

1

আর (3.3.1), 325 বাইট

সুন্দর নিষ্পাপ বাস্তবায়ন; আমি মনে করি এটি সম্ভবত কিছুটা খাটো করে তুলতে পারি।

s=sample(1:20,sample(5:10,1));print(s);if(7%in%s){s=s-1;print(s);if(0%in%s)s=s+1;print(s)};if(13%in%s){s=s[1:(which(s==13)-1)];print(s)};if(2%in%s){s=s[!(s%%2)];print(s)};if(20%in%s){if(s[3]%%2){20*length(s);print(s)}else{20;print(s)}};while(sum(s)>50){s=s[-length(s)];print(s)};if(16%in%s){print(as.hexmode(sum(s)))};sum(s)

— : Giuseppe
সূত্র

1

পাওয়ারশেল , 525 413 বাইট

filter a{"$a"};0..(4..9|random)|%{$a+=@(1..20|random)};a;if(7-in$a){$a=($a|%{$_-1});a;if(0-in$a){$a=($a|%{$_+1});a}}$b=$a;$a=@();foreach($z in $b){if($z-ne13){$a+=@($z)}else{a;break}}if(2-in$a){$a=($a|?{$_%2-eq0});a}if(20-in$a){if($a[2]%2){20*$a.count;exit}else{20;exit}}while(($h=$a-join'+'|iex)-gt50){$a=$a[0..($a.count-2)];a}if(16-in$a){$l=0..9+'a b c d e f'-split' ';$q=[math]::floor($h/16);"$q"+$l[$h%16]};$h

এটি অনলাইন চেষ্টা করুন!

আমি এটির চেষ্টা করতে চেয়েছিলাম যদিও আমি বুঝতে পেরেছিলাম যে উত্তরগুলি ইতিমধ্যে এখানে পরাজিত করব না: পিআই এখনও এটিকে গল্ফ দেওয়ার চেষ্টা করছেন, আমি নিশ্চিত যে এটি কম বাইটের সাহায্যে সম্ভব। হেক্সের জন্য একটি আরও ভাল পদ্ধতি পাওয়া গেছে তবে সম্ভবত এখনও উন্নতি করতে পারে।

$aএকটি স্ট্রিং এ এতবার কাস্ট করতে হয়েছিল এর জন্য ফিল্টার তৈরি করা ভাল ছিল ...

বেশ কয়েকটি সহজ গল্ফ আমি মিস করেছি যেমন বন্ধনী এবং স্পেস। এখনও কিছু বাইরে থাকতে পারে?

কোড পড়তে কিছুটা সহজ:

filter a{"$a"};0..(4..9|random)|%{$a+=@(1..20|random)};a;
if(7-in$a){$a=($a|%{$_-1});a;if(0-in$a){$a=($a|%{$_+1});a}}
$b=$a;$a=@();foreach($z in $b){if($z-ne13){$a+=@($z)}else{a;break}}
if(2-in$a){$a=($a|?{$_%2-eq0});a}
if(20-in$a){if($a[2]%2){20*$a.count;exit}else{20;exit}}
while(($h=$a-join'+'|iex)-gt50){$a=$a[0..($a.count-2)];a}
if(16-in$a){$l=0..9+'a b c d e f'-split' ';$q=[math]::floor($h/16);"$q"+$l[$h%16]};$h

— Sinusoid
সূত্র

0

ম্যাটল্যাব, 275 বাইট

আমি প্রথমে সম্ভবত একটি ওয়ান-লাইনার অষ্টাভে উত্তর সম্পর্কে পরিকল্পনা করেছি, তবে প্রয়োগকৃত সমস্ত নিয়মের আউটপুট প্রয়োজন আমার পরিকল্পনাটিকে ব্যর্থ করে দিয়েছে। পরিবর্তে, কয়েকটি আকর্ষণীয় অপটিমাইজেশন সহ মোটামুটি সোজা ম্যাটল্যাব উত্তর, যেমন rule রুলের cumsumসুস্পষ্ট পরিবর্তে এর ব্যবহার whileStill তবুও, ifকোনও নিয়ম প্রয়োগ না করা থাকলে আউটপুট প্রতিরোধে বাইট গণনাটি প্রচুর অপচয় করা হয়।

A=randi(20,1,randi(6)+4)
if any(A==7)
A=A-1
if any(~A)
A=A+1
end;end
q=find(A==13,1);if q
A=A(1:q-1)
end
if any(A==2)
A=A(2:2:end)
end
if any(A==20)
if mod(A(3),2)
20*length(A)
else
20
end;return;end
q=cumsum(A)<51;if any(~q)
A=A(q)
end
q=sum(A)
if(any(A==16))
dec2hex(q)
end

এটি অনলাইন চেষ্টা করুন!

— Sanchises
সূত্র

0

587 বাইট এক লাইনার স্কেল করুন

import scala.util.Random;object A{def main(args:Array[String])={val s=5+Random.nextInt(6);var a=new Array[Int](s);for(i<-1 to s){a(i-1)=1+Random.nextInt(20)};p(a);if(a.contains(7)&& !a.contains(1)){a.map(a=>a-1);p(a)};if(a.contains(13)){if(a(0)==13)a=new Array[Int](0)else a=a.slice(0,a.indexOf(13));p(a)};if(a.contains(2)){a=a.filter(pred=>pred%2==0);p(a)};if(a.contains(20)){if(a(2)%2==0)println(20)else println(20*a.length)}else{while(a.sum>50)a=a.dropRight(1);val u=a.sum;if(a.contains(16))println(Integer.toHexString(u));println(u)}};def p[T](a: Array[T])=println(a.mkString(","))}

স্কালা, 763 বাইট যেমন রয়েছে

import scala.util.Random
object TA {
  def main(args:Array[String])={
    val s=5+Random.nextInt(6)
    var a=new Array[Int](s)
    for (i<-1 to s)
      a(i-1)=1+Random.nextInt(20)
    p(a)
    if(a.contains(7) && !a.contains(1)){
      a.map(a=>a-1)
      p(a)
    }
    if(a.contains(13)){
      if (a(0)==13) a=new Array[Int](0) else a=a.slice(0,a.indexOf(13))
      p(a)
    }
   if(a.contains(2)){
      a=a.filter(pred=>pred%2== 0)
      p(a)
    }
    if(a.contains(20)){
      if (a(2)%2==0) println(20) else println(20*a.length)
    }else{
      while(a.sum>50)
        a=a.dropRight(1)
      val u =a.sum
      if (a.contains(16)) println(Integer.toHexString(u))
      println(u)
    }
  }
  def p[T](a: Array[T])={
    println(a.mkString(","))
  }
}

— সাইদীপ সমবারাজু
সূত্র

যেহেতু এটি একটি কোড-গল্ফ প্রশ্ন তাই আমরা আপনাকে জিজ্ঞাসা করি যে আপনি কমপক্ষে সহজ গল্ফগুলি তৈরি করুন যেমন অপ্রয়োজনীয় সাদা স্থান সরিয়ে ফেলার মতো।

— অ্যাডহক গার্ফ হান্টার

আমি এক লাইন লো বাইট সংস্করণ যুক্ত করেছি

— সাদিপ সমবারাজু

আমি স্কেলা জানি না, তবে স্থানটি a: Array[T]প্রয়োজনীয়? আপনার কোনও স্থান নেই args:Array[String], যা আমার তদন্তের ফলাফল।

— জাচারা

না আমি মনে করি আমি এটি মিস করেছি।

— সদীপ সমবারাজু

0

ম্যাটল্যাব, 228 241 বাইটস

a=randi(20,1,randi(6)+4)
b=@any; 
a=a-b(a==7)
a=a+b(a==0)
a(find(a==13,1):end)=[]
a(and(mod(a,2),b(a==2)))=[]
if b(a==20)
a=[a 0 0 0];
s=20*(1+mod(a(3),1)*(numel(a)-4))
else
a(cumsum(a)>50)=[]
s=sum(a)
if b(a==16)
h=['0x' dec2hex(s)]
end
end

এটি প্রতিটি পদক্ষেপের পরে অ্যারে মানটি মুদ্রণ করে সমস্ত নিয়ম প্রয়োগ করবে।

ফলাফলের উপাদানগুলির সংখ্যা তিনটির চেয়ে কম হলে প্রোগ্রামটি নিয়ম 5 এ ক্রাশ হবে। তৃতীয় উপাদান না থাকলে কী হবে তা বলার জন্য বর্তমানে কিছুই নেই, তাই আমি ধরে নিচ্ছি যে ক্র্যাশটি গ্রহণযোগ্য। 3 টিরও কম উপাদান এবং এক বা একাধিক 20 হলে প্রোগ্রামটি এখন 20 মুদ্রণ করবে।

আকর্ষণীয়ভাবে পদক্ষেপ 2 প্রয়োগ করা যেতে পারে নির্বিশেষে পদক্ষেপ 1 ছিল। এটি কারণ ইনপুট অ্যারে এর মধ্যে কখনই 0 থাকে না অর্থ এই যে অ্যারেটিতে 0 এর 0 থাকে তবে এটি অবশ্যই পদক্ষেপ 1 এর ফলাফল হিসাবে হওয়া উচিত।

কোনও পরিবর্তন না থাকলেও 5 টি পর্যন্ত সমস্ত নিয়ম পরিবর্তে প্রয়োগ করা হয়। ফলস্বরূপ অ্যারে শুরুতে মুদ্রণ করা হবে এবং তারপরে প্রতিটি পদক্ষেপের পরে until পর্যন্ত until পদক্ষেপের পরে আপনি হয় যোগফল প্রয়োগ করলে তা যোগফল পাবেন, বা step ধাপ না হওয়া পর্যন্ত কোনও আউটপুট থাকবে না পরে যুক্ত একটি অতিরিক্ত লাইন aযুক্ত করা যেতে পারে অন্য বিবৃতিটি অ্যারে মান 2 বাইটের ব্যয়ে ধাপ 5 পরে মুদ্রিত হবে তা নিশ্চিত করার জন্য statement

আমি আরও উল্লেখ করতে চাই যে আমি এটি লেখার আগে পর্যন্ত অন্যান্য উত্তরগুলির দিকে তাকাচ্ছি না। আমি এখন দেখছি যে আরও কিছু মিলের সাথে আরও একটি ম্যাটল্যাব উত্তর রয়েছে - এগুলি সবই কাকতালীয়।

— টম কার্পেন্টার
সূত্র

0

পাইথন 3, 297 293 289 , 278 বাইট

আরনাউল্ড স্পট হিসাবে, নিয়ম 1 প্রয়োগ না করা হলে আপনি 0 পেতে পারবেন না, যা ইনডেন্টিংয়ে সংরক্ষণ করা হয়েছে। পরামর্শের সাথে যারা মন্তব্য করেছেন তাদের প্রত্যেককে ধন্যবাদ।

from random import*
p=print
a=b=sample(range(1,20),randint(5,10))
p(a)
if 7in a:a=[i-1for i in a];p(a)
if 0in a:a=b;p(a)
if 13in a:a=a[:a.index(13)];p(a)
if 2in a:a=[i for i in a if~i%2];p(a)
if 20in a and~a[2]%2:a=[20]
while sum(a)>50:a=a[:-1]
b=sum(a)
p(b)
if 16in a:p(hex(b))

এটি অনলাইনে চেষ্টা করুন

— নটস 90 মনিকা সমর্থন করে
সূত্র

আমি মনে করি না যে আপনার andএবং এর মধ্যে স্থান দরকার ~।

— জাচারা

আমি বিশ্বাস করি যে from random import* a=b=sample(range(1,20),randint(5,10))আপনি কিছু বাইট সংরক্ষণ করতে পারেন যেহেতু আপনি 2 লাইনটি মুছতে পারেন

— নোক্টুরামা

0

পার্ল 6 , 246 বাইট

my&f={.grep($^a)};my&s=->{.say};$_=[(1..20).pick xx(5..10).pick];s;$_»--
if f 7;s;$_»++ if f 0;s;.splice(.first(13):k//+$_);s;$_=[f*%%2]if f 2;
s;say(20*(.[2]%%2||$_)),exit if $_>2&&f 20;s;.pop while
.sum>49;$/=f 16;$_=.sum;s;.base(16).say if $/

Ungolfed:

my &f = { .grep($^a) };  # Helper function: search $_ for something
my &s = -> { .say };     # Helper function: print $_
$_ = [ (1..20).pick xx (5..10).pick ];  # Generate the initial array
s;  # Print the array
$_»-- if f 7;  # Decrement all elements if it contains a 7
s;  # Print the array
$_»++ if f 0;  # Increment all elements if a zero is found
s;  # Print the array
.splice(.first(13):k // +$_);  # Splice out everything from the first 13 onward
s;  # Print the array
$_ = [ f *%%2 ] if f 2;  # Remove all odd elements if a 2 is found
s;  # Print the array
say(20*(.[2] %% 2 || $_)), exit if $_ > 2 && f 20;  # Print and exit, maybe
s;  # Print the array
.pop while .sum > 49;  # Remove elements from the end until sum is below 50
$/ = f 16;  # Save in $/ whether $_ contains a 16
$_ = .sum;  # Set $_ to its own sum
s;  # Print the sum
.base(16).say if $/  # Print the sum in hexadecimal if the last array contained a 16

— শন
সূত্র

0

কমন লিস্প, 490 বাইট

এখানে অ্যারেটি একটি সাধারণ লিস্পের তালিকা হিসাবে উপস্থাপিত হয়।

(let((a(loop for i from 1 to(+ 5(random 5))collect(1+(random 19)))))(flet((p()(format t"~a~%"a))(m(x)(member x a))(h(x)(map-into a x a)))(p)(and(m 7)(h'1-))(p)(and(m 0)(h'1+))(p)(let((p(position 13 a)))(and p(setf a(butlast a (-(length a)p)))))(p)(and(m 2)(setf a(remove-if'oddp a)))(p)(or(and(m 20)(or(and(third a)(oddp(third a))(* 20(length a)))20))(p)(and(setf a(loop for x in a sum x into s while (<= s 50) collect x)) nil)(p)(let((s(reduce'+ a)))(print s)(and(m 16)(format t"~x"s))))))

স্বাভাবিক, বড় ব্যবহার andএবং orনিয়ন্ত্রণ কাঠামো হিসাবে।

(let ((a (loop for i from 1 to (+ 5 (random 5))  ; create initial list
            collect (1+ (random 19)))))
  (flet ((p () (format t "~a~%" a))     ; auxiliary functions: print list
         (m (x) (member x a))           ; check membership
         (h (x) (map-into a x a)))      ; operate on elements
    (p)
    (and (m 7) (h '1-))                 ; if 7 is present decrement all values
    (p)
    (and (m 0) (h '1+))                 ; if 0 is now present increment all values
    (p)
    (let ((p (position 13 a)))          ; remove from 13 (if exists)
      (and p (setf a (butlast a (- (length a) p)))))
    (p)
    (and (m 2) (setf a (remove-if 'oddp a)))   ; if 2 is present remove odd values
    (p)
    (or (and (m 20)                            ; if 20 is present
             (or (and (third a)                ;    when third is present
                      (oddp (third a))         ;         and it is odd
                      (* 20 (length a)))       ;         return 20 times the length
                 20))                          ;    otherwise return 20
        (p)                                    ; otherwise (20 is not present)
        (and (setf a (loop for x in a sum x into s ; compute sum of elements
                        while (<= s 50)            ; limited to 50
                        collect x))                ; and return those elements
             nil)                                  ; (to execute the rest of the code)
        (p)
        (let ((s (reduce '+ a)))                   ; compute the final sum
          (print s)                                ; print the result in decimal
          (and (m 16) (format t "~x" s))))))       ; if 16 is present print also in hexadecimal

— Renzo
সূত্র

Rules নিয়মের ক্লান্তিকর অ্যারে

রুনডাউন

অ্যারে সেটআপ

7 বিধি

উদাহরণ

মন্তব্য

পাইথন 3, 294 301 287 356 বাইট

05 এ বি 1 ই , 91 বাইট

জাভাস্ক্রিপ্ট (ES6), 344 342 340 342 335 331 333 313 311 305 298 297 290 289 283 279 বাইট

চেষ্টা করে দেখুন

পঠনযোগ্য ও পরীক্ষামূলক সংস্করণ

সি (জিসিসি) , 621 619 593 585 570 562 557 552 529 517 500 482 461 444 442 441 438 বাইট

জাভাস্ক্রিপ্ট (ES6), 296 295 290 289 বাইট

কিভাবে এটা কাজ করে

আনপ্যাকিং পদ্ধতিগুলি

জাভাস্ক্রিপ্ট -> 550 402 বাইট

জাভা 7, 622 619 618 বাইট

রুবি 2.4, 260 বাইট

আর (3.3.1), 325 বাইট

পাওয়ারশেল , 525 413 বাইট

ম্যাটল্যাব, 275 বাইট

587 বাইট এক লাইনার স্কেল করুন

স্কালা, 763 বাইট যেমন রয়েছে

ম্যাটল্যাব, 228 241 বাইটস

পাইথন 3, 297 293 289 , 278 বাইট

পার্ল 6 , 246 বাইট

কমন লিস্প, 490 বাইট