रनडाउन

एक प्रोग्राम बनाएं जो यादृच्छिक संख्याओं के साथ यादृच्छिक लंबाई का एक सरणी उत्पन्न करता है, फिर सरणी को बदलने वाले नियमों की एक श्रृंखला लागू करें। नियम लागू होने के बाद, सरणी का योग तब तक प्रिंट करें जब तक कि अन्यथा निर्दिष्ट न हो

ऐरे सेटअप

सरणी 5 और 10 के बीच एक यादृच्छिक लंबाई होनी चाहिए , जिसमें 1 और 20 समावेशी के बीच यादृच्छिक पूर्णांक होते हैं। प्रत्येक सरणी की लंबाई होने की समान संभावना होनी चाहिए और प्रत्येक पूर्णांक को प्रति तत्व को उठाए जाने की समान संभावना होनी चाहिए।

7 नियम

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

यदि सरणी में एक 7 है, तो प्रत्येक तत्व से 1 घटाएं
यदि नियम 1 लागू होता है और सरणी में अब 0 होता है, तो प्रत्येक तत्व में 1 जोड़ें
यदि सरणी में 13 हैं, तो 13 को छोड़कर, और सभी तत्व जो सरणी से आते हैं
यदि सरणी में 2 हैं, तो सभी विषम संख्याओं को बाहर करें
यदि सरणी में 20 हैं, और तीसरा तत्व सम है, तो 20 को उस राशि के रूप में वापस लौटाएं। यदि 20 मौजूद है और तीसरा तत्व विषम है, तो सरणी के रूप में समाप्त होने पर लंबाई की 20 गुना वापसी करें।
यदि योग 50 से अधिक है, तो अंतिम तत्व को बार-बार हटाएं जब तक कि यह 50 से कम या उसके बराबर न हो
यदि सरणी में 16 हैं, तो दशमलव और हेक्साडेसिमल दोनों में योग को प्रिंट करें।

उदाहरण

यहाँ एक प्रारंभिक सरणी है,

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

नियम 1 लागू किया जा सकता है:

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

नियम 3 अगले लागू किया जाता है:

[19, 1, 4, 6]

अन्य नियमों की आवश्यकता नहीं है, इसलिए कार्यक्रम 30 राशि के रूप में देता है ।

मैं एक अनुभवी कोड गोल्फर नहीं हूं, हालांकि मैं कह सकता हूं कि मेरा व्यक्तिगत रिकॉर्ड 369 बाइट्स के साथ पायथन 3 में है ।
नियमों को वास्तव में क्रम में लागू करने की आवश्यकता नहीं है, लेकिन ऐसा करना होगा जैसे कि उन्होंने किया था।

code-golf array-manipulation

— Graviton
स्रोत

1

"यादृच्छिक" होना कितना यादृच्छिक है?

— हाइपरनेट्रिनो

1

@ हैपरनेट्रिनो यह सूडो-रैंडम के रूप में हो सकता है जैसा आप चाहते हैं, लेकिन फेंकने की चुनौती नहीं। दोहराए जाने की अनुमति है।

— ग्रेविटॉन

यदि आप वास्तव में नियमों को लागू करते हैं तो आप कैसे जांच करेंगे? मैं सिर्फ 50 के तहत एक यादृच्छिक संख्या उत्पन्न कर सकता हूं और यह अभी भी तकनीकी रूप से किसी भी नियम को नहीं तोड़ सकता है, और मैं इसे नियमों का "पालन" कर सकता हूं। संपादित करें: मुझे पता है कि यह काम नहीं करेगा, लेकिन लोग यादृच्छिक नियमों को दरकिनार करने के तरीके खोजने जा रहे हैं। क्या आप इसे रोकने जा रहे हैं?

— clismique

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 से कम तत्व हैं?

— एमिगा

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 बाइट्स; कुछ बाइट्स बचाने के लिए @YamB को धन्यवाद; पिछली त्रुटि को ठीक करने के लिए बहुत अधिक जोड़ा गया।
-14 बाइट्स @RootTwo और खुद को धन्यवाद और त्रुटि को भी ठीक किया।
+83 बाइट्स; यह बहुत लंबा हो रहा है क्योंकि ओपी नियमों में बदलाव करता रहता है। @ZacharyT की बदौलत बाइट्स की संख्या

— HyperNeutrino
स्रोत

मेरे लिए सभी जाँचें, ईमानदार होने के लिए धन्यवाद।

— ग्रेविटॉन

यदि आप 7in k और 1not in k: k = [i-1 ... 'से' if 7in k: k = [i + 1-int (1in k) ) ... '

— ग्रेविटॉन

जब k को इनिशियलाइज़ किया जाता है, तो आपको i की वैल्यू की आवश्यकता नहीं होती है, इसलिए आप 6 बाइट बचा सकते हैं k=[r(1,20)for _ in'-'*r(5,11)]। आप k=[i+~-(1in k)*(7in k)for i in k]नियमों 1 और 2 का उपयोग करके एक और बाइट बचा सकते हैं

— रूटट्वो

1

@ Notts90 इस चुनौती को लिखने के बाद नियम बदल दिए गए। जब मैं कंप्यूटर पर पहुंचूंगा तो इसे ठीक कर दूंगा। धन्यवाद।

— हाइपरनेत्रिनो

पांच और सात की तर्ज पर, आपके पास के बाद एक अनावश्यक स्थान है 1, और आप printदूसरी और तीसरी से अंतिम पंक्तियों को बदल सकते हैं p। और आपने ... अपने बायटेकाउंट को अपडेट नहीं किया है।

— ज़ाचरी

6

05AB1E , 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/…

— मैजिक ऑक्टोपस Urn

@carusocomputing: मैंने इसे पूरी तरह से नहीं देखा है, लेकिन यह शुरुआत में यादृच्छिक सरणी उत्पन्न नहीं करता है और न ही यह मध्यवर्ती परिणाम प्रिंट करता है। उन हिस्सों को जोड़ने पर थोड़ा लंबा होगा।

— एमिगा

6

जावास्क्रिप्ट (ईएस 6), 344 342 340 342 335 331 333 313 311 305 298 297 290 289 283 279 बाइट्स

हुज़्ज़ाह! अंत में बीट अरनौलड ~~से बंधे~~ !

इस विनिमय के बाद * चुनौती की टिप्पणियों में और बहुत विचार-विमर्श के बाद मैंने 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 बाइट्स सहेजे गए।
के Array(x).fill()साथ प्रतिस्थापित करके 2 बाइट्स सहेजे गए [...Array(x)]।
जोड़ा गया 2 बाइट्स का कारण मैं नियम 5 पर गड़बड़ कर दूंगा!
सहेजे गए 7 बाइट्स मेस को ठीक करके मैंने पिछली मेस को ठीक करने की कोशिश की!
Arnauld को नियम 3 पर एक ब्रेनफार्ट को ठीक करने में मेरी मदद करने के लिए 3 बाइट्स का धन्यवाद दिया और एक के +1साथ एक अतिरिक्त बाइट को बचा लिया ~।
जोड़ा गया 2 बाइट्स सुनिश्चित करना 0एक खाली सरणी के लिए वापस आ गया है।
सहेजे गए 20 बाइट्स को आखिरकार पता चलता है कि उस झटके वाले whileलूप को कैसे खोदा जाए ।
सहेजे गए 2 बाइट्स ,को अंतिम 2 कथनों के बीच में बदलकर |और संलग्नक को हटाकर ()।
के console.logसाथ बदलकर 6 बाइट्स बचाए alert।
की शॉर्टकटिंग में सुधार करके 7 बाइट्स बचाए a.includes()।
नियम 3 के कार्यान्वयन को संपादित करके 1 बाइट को बचाया।
बची हुई 7 बाइट्स खाई includes()और बस indexOf()भर में उपयोग करके ।
sचर की प्रारंभिक घोषणा को स्थानांतरित करके 1 बाइट को कहीं न कहीं से इसे अल्पविराम की आवश्यकता नहीं थी।
के Math.random()साथ बदलकर 6 बाइट्स बचाए 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

C (gcc) , 621 619 593 585 570 562 557 552 529 517 500 482 461 444 442 441 438 बाइट्स

यहाँ पूरी तरह से गोल्फिंग की आवश्यकता है ... एक बग फिक्स्ड है जहां यह सूची में प्रत्येक 16 के लिए एक बार हेक्सिडेसिमल प्रिंट करेगा ...

गोल्फ की मदद से ZacharyT के लिए विशेष धन्यवाद

#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 बाइट नीचे हैं। XD आइए देखें कि क्या मैं इसे किसी तरह से आपके वर्तमान सबमिशन को हरा सकता हूं। ;)

— केविन क्रूज़सेन

ठीक है, -3 बाइट्स के लिए कुछ मिला; पी

— केविन क्रूज़सेन

यदि आप इसे नीचे गोल्फ कर सकते हैं, तो आप वहां "पार किया हुआ 444 अभी भी 444 है" प्राप्त करने में सक्षम हो सकते हैं! : डी

— हाइपरएन्यूट्रीनो

@HyperNeutrino golfed एक और 2 बाइट्स बंद

— cleblanc

वाह! अच्छी नौकरी: D

— HyperNeutrino

3

जावास्क्रिप्ट (ईएस 6), 296 295 290 289 बाइट्स

एक पूरा कार्यक्रम जो प्रारंभिक सरणी, मध्यवर्ती परिणाम और अंतिम योग को सांत्वना में जोड़ता है।

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इसका उपयोग केवल 3 नियम में किया जाता है।

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)

सभी निम्नलिखित ईएस 6 वेरिएंट का आकार समान है:

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 बाइट्स के लिए नीचे हूं :-D

— क्लीबलैंस

@cleblanc मैं देख रहा हूं कि आप अभी 444 पर हैं। मैं जावा के साथ प्रतिस्पर्धा नहीं कर सकता। :) (यह कहने के लिए कि 444 ऐसा नहीं है, जहाँ अन्य सभी उत्तरों की तुलना में जीतने के निकट नहीं है ..)

— केविन क्रूज़सेन

मुझे पता है, यहां तक कि 05AB1E जैसी गोल्फ भाषाएँ लगभग 100 बाइट्स लंबी होती हैं। यह चुनौती एक पीड़ा थी।

— क्लेब्लांक

क्या आप अपनी सूची को सामान्य छोड़ सकते हैं List a = new ArrayList()? कुछ बाइट्स बचा सकता है। हालांकि वास्तविक अंकगणित करते समय आपको टाइपकास्ट जोड़ना पड़ सकता है। यदि नहीं, Longतो इससे कम हैInteger

— पोक

@ एक सामान्य के साथ 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 अभी तक रूबी 2.4 का समर्थन करते हैं, इसलिए यह ऑनलाइन संस्करण के 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)

— ग्यूसेप
स्रोत

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

MATLAB, 275 बाइट्स

मैंने मूल रूप से एक-लाइनर ऑक्टेव उत्तर पर योजना बनाई थी, लेकिन सभी लागू नियमों के उत्पादन की आवश्यकता ने मेरी योजना को विफल कर दिया। इसके बजाय, कुछ दिलचस्प अनुकूलन के साथ एक काफी सीधा MATLAB जवाब, उदाहरण के लिए नियम 6. के cumsumबजाय स्पष्ट का उपयोग while6. फिर भी, 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(","))
  }
}

— सहदीप सांभराजू
स्रोत

चूंकि यह एक कोड-गोल्फ प्रश्न है जो हम पूछते हैं कि आप कम से कम आसान गोल्फ बनाते हैं जैसे अनावश्यक व्हाट्सएप को हटाना।

— तदर्थ गार्फ हंटर

मैंने एक लाइन कम बाइट संस्करण जोड़ा

— Saideep Sambaraju

मुझे स्काला का पता नहीं है, लेकिन क्या अंतरिक्ष की a: Array[T]आवश्यकता है? आपके पास कोई स्थान नहीं है args:Array[String], जिसके कारण मेरी पूछताछ हुई।

— ज़ाचरी

नहीं, मुझे लगता है कि मैं इसे याद किया।

— सहदीप सांभराजू

0

MATLAB, 228 241bytes

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 पर क्रैश हो जाएगा। वर्तमान में यह कहने के लिए कुछ भी नहीं है कि कोई तीसरा तत्व नहीं होने पर क्या होना चाहिए, इसलिए मैं मान रहा हूं कि एक दुर्घटना स्वीकार्य है। कार्यक्रम अब 20 प्रिंट करेगा यदि 3 से कम तत्व हैं और एक या अधिक 20 है।

दिलचस्प यह है कि चरण 2 को लागू किया जा सकता है चाहे चरण 1 था। ऐसा इसलिए है क्योंकि इनपुट ऐरे में कभी 0 नहीं होगा, इसका मतलब यह है कि अगर ऐरे में कोई 0 है तो यह चरण 1 के परिणाम के रूप में होना चाहिए।

सभी नियम बदले में लागू किए जाते हैं, 5 तक, भले ही कोई बदलाव न किया गया हो। परिणामस्वरूप सरणी शुरू में मुद्रित हो जाएगी और फिर प्रत्येक चरण के बाद 5. तक चरण 5 के बाद आपको या तो योग मिलेगा यदि इसे लागू किया जाता है, या चरण के बाद तक कोई आउटपुट नहीं होता है। 6. के बाद एक अतिरिक्त लाइन युक्त aजोड़ा जा सकता है यह सुनिश्चित करने के लिए कि कथन मान 2 बाइट्स की कीमत पर चरण 5 के बाद मुद्रित किया गया है, और दूसरा कथन।

मैं यह भी उल्लेख करना चाहूंगा कि जब तक मैंने यह नहीं लिखा था, तब तक मैं अन्य उत्तरों को नहीं देखता था। मैं अब देखता हूं कि कुछ समानताओं के साथ एक और MATLAB उत्तर है - जो सभी संयोग हैं।

— टॉम बढ़ई
स्रोत

0

पायथन 3, 297 293 289 , 278 बाइट्स

जैसा कि अरनॉल्ड को देखा गया था, आप 0 प्राप्त नहीं कर सकते जब तक कि नियम 1 लागू नहीं किया गया था, जो इंडेंट करने पर बचाया गया था। सुझाव के साथ टिप्पणी करने वाले अन्य सभी के लिए भी धन्यवाद।

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

इसे ऑनलाइन आज़माएं

— Notts90 मोनिका का समर्थन करता है
स्रोत

मुझे नहीं लगता कि आपको andऔर के बीच की जगह की आवश्यकता है ~।

— जकार्इ

मेरा मानना from random import* a=b=sample(range(1,20),randint(5,10))है कि आप कुछ बाइट्स को बचाते हैं क्योंकि आप लाइन 2 को हटा सकते हैं

— रात्रि 16'17

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

— रेंज़ो
स्रोत

7 नियमों का कठिन सरणी

रनडाउन

ऐरे सेटअप

7 नियम

उदाहरण

टिप्पणियाँ

पायथन 3, 294 301 287 356 बाइट्स

05AB1E , 91 बाइट्स

जावास्क्रिप्ट (ईएस 6), 344 342 340 342 335 331 333 313 311 305 298 297 290 289 283 279 बाइट्स

कोशिश करो

पठनीय और परीक्षण योग्य संस्करण

C (gcc) , 621 619 593 585 570 562 557 552 529 517 500 482 461 444 442 441 438 बाइट्स

जावास्क्रिप्ट (ईएस 6), 296 295 290 289 बाइट्स

यह काम किस प्रकार करता है

अनपैक करने के तरीके

जावास्क्रिप्ट -> 550 402 बाइट्स

जावा 7, 622 619 618 बाइट्स

रूबी 2.4, 260 बाइट्स

आर (3.3.1), 325 बाइट्स

पॉवरशेल , 525 413 बाइट्स

MATLAB, 275 बाइट्स

स्केल 587 एक लाइनर को बाइट करता है

स्काला, 763 बाइट्स है

MATLAB, 228 241bytes

पायथन 3, 297 293 289 , 278 बाइट्स

पर्ल 6 , 246 बाइट्स

आम लिस्प, 490 बाइट्स