9 बाइट्स में 40 नंबर

Question

कर रहे हैं 40 तरीके एक निर्देशित Hamiltonian पथ : पर एक 3 × 3 ग्रिड व्यवस्था की जा सकती

यह ग्राफिक ( धन्यवाद Sp3000! ) से पता चलता है केवल 20 अनिर्दिष्ट पथ। 40 निर्देशित रास्तों के लिए प्रत्येक रंगीन रेखा को दोनों दिशाओं में पार करें।

चुनौती

केवल मुद्रण योग्य ASCII का उपयोग करते हुए , अक्षरों का 3 × 3 ग्रिड लिखें, जैसे:

ABC
DEF
GHI

जब इस ग्रिड से 40 निर्देशित पथों में से प्रत्येक को 40 एकल-पंक्ति, 9-वर्ण कार्यक्रमों के रूप में पढ़ा जाता है, तो लक्ष्य प्रत्येक कार्यक्रम को 1 से 40 तक एक अद्वितीय पूर्णांक आउटपुट करना है। सभी 40 पथों के लिए ऐसा करना कठिन और संभावना नहीं लगता है, इसलिए आपको केवल उतने रास्तों के लिए काम करने की आवश्यकता है जितना आप कर सकते हैं।

सबमिशन जिसका 40 पथ-कार्यक्रम 1 से 40 तक सबसे अलग संख्या में आउटपुट करता है, विजेता होगा। टाईब्रेकर पहले की सबमिशन में जाता है।

पथ-प्रोग्राम जो त्रुटि को पूर्णांक से 1 से 40 तक आउटपुट नहीं करते हैं या एक पूर्णांक को आउटपुट करते हैं जो पहले से कवर किए गए किसी अन्य पथ-क्रम की गणना नहीं की जाती है। विशेष रूप से:

• प्रोग्राम जो त्रुटि, संकलन, दौड़ या बाहर निकलते समय गिने नहीं जाते हैं। चेतावनी ठीक है।
• कार्यक्रम कि नहीं उत्पादन 1 से 40 या उत्पादन कुछ करने के लिए एक पूर्णांक करना थोड़ा जैसे विकृत -35या 35 36नहीं गिने जाते हैं।
• प्रोग्राम जिसमें आउटपुट का उत्पादन करने के लिए उपयोगकर्ता इनपुट की आवश्यकता होती है, उन्हें गिना नहीं जाता है।
• ऐसे कार्यक्रम जो कभी समाप्त नहीं होते हैं।
• से अब पर , प्रोग्राम हैं जो निर्धारित करने योग्य नहीं हैं गिने जाते हैं।
• अन्यथा मान्य प्रोग्राम जो 1 से 40 तक पूर्णांक का उत्पादन करते हैं, जो कि एक अन्य मान्य प्रोग्राम पहले से ही आउटपुट है, गिना नहीं जाता है। (पहला कार्यक्रम है गिना।)
• केवल प्रोग्राम जो 1 से 40 (समावेशी) से संख्याओं के पूर्णांक आउटपुट का प्रतिनिधित्व करते हैं, उन्हें आपके कुल की ओर गिना जाता है। संख्या सामान्य 1, 2... 39, 40प्रारूप, प्रारूप में होने की उम्मीद है , जब तक कि यह आपकी भाषा के लिए आदर्श न हो। (आउटपुट में एक अनुगामी न्यूलाइन ठीक है।)
• आपके प्रोग्राम के आउटपुट कौन से हैं और वे किस क्रम में हैं, इससे कोई फर्क नहीं पड़ता। केवल मान्य कार्यक्रमों से अलग पूर्णांक की संख्या मायने रखती है।

सभी पथ-कार्यक्रम एक ही भाषा में चलने चाहिए। हालांकि, "प्रोग्राम" वास्तव में फ़ंक्शन हो सकते हैं (बिना किसी आवश्यक तर्क के) या REPL कमांड, साथ ही पूर्ण प्रोग्राम, जो अपने लक्ष्य पूर्णांक को प्रिंट या वापस करते हैं। आप फ़ंक्शन, REPL कमांड और पूर्ण कार्यक्रमों के बीच मिश्रण और मिलान कर सकते हैं।

आपके 9 मुद्रण योग्य ASCII वर्णों को अलग होने की आवश्यकता नहीं है।

उदाहरण

यदि आपके 3 × 3 ग्रिड थे

ABC
DEF
GHI

और आपके 40 कार्यक्रम और आउटपुट इस तरह दिखे

ABCFEDGHI -> 26
ABCFIHEDG -> 90
ABCFIHGDE -> 2
ABEDGHIFC -> syntax error
ADEBCFIHG -> prints 40 but then errors
ADGHEBCFI -> 6
ADGHIFCBE -> 6
ADGHIFEBC -> 6
CBADEFIHG -> runtime error
CBADGHEFI -> 3
CBADGHIFE -> 4
CFEBADGHI -> -32
CFIHEBADG -> 38.0
CFIHGDABE -> "36"
EDABCFIHG -> 33
EFCBADGHI -> no output
EHGDABCFI -> compilation error
EHIFCBADG -> 8
GDABCFEHI -> 22
GHEDABCFI -> 41
IHGDEFCBA -> 0
GDEHIFCBA -> '9'
EDGHIFCBA -> +10
CFIHGDEBA -> 11
GHIFCBEDA -> error
IFCBEHGDA -> error
EBCFIHGDA -> prints 23 but then loops infinitely
CBEFIHGDA -> randomly prints either 24 or 44
GHIFEDABC -> error
IFEHGDABC -> 30
EFIHGDABC -> 39
IHGDABEFC -> 7
GDABEHIFC -> 29
EBADGHIFC -> -1
GHIFCBADE -> 26
IHGDABCFE -> 1
IFCBADGHE -> error
GDABCFIHE -> no output
IHEFCBADG -> no output
IFCBADEHG -> "quack"

आपका स्कोर 14 होगा, क्योंकि 1 से 40 वैध आउटपुट से 14 अलग पूर्णांक हैं, अर्थात् 26 2 6 3 4 33 8 22 11 30 39 7 29 1।

Comments

-1, चुनौती में झंडे का कोई संदर्भ नहीं है

— एलेक्स ए।

@ Sp3000 एक विशेष क्रम में छवि में व्यवस्था है? (मुझे लगता है कि चुनौती के लिए आदेश देना महत्वपूर्ण नहीं है, लेकिन मैं छवि के बारे में जिज्ञासा से मर रहा हूं। विशेष रूप से, यदि ये हिल्बर्ट स्पेस कर्व के लिए एल-सिस्टम में बीज के रूप में उपयोग किए गए थे, तो क्या इसके लिए एक प्राकृतिक एन्कोडिंग है। सेट?)

— लूजर droog

@luserdroog खैर, Sp ने छवि बनाई , उसे पूछने के लिए सबसे अच्छा।

— केल्विन के

@luserdroog यदि आप कोशिकाओं को 1 से 9 तक संख्या देते हैं, तो उन्हें लेक्सिकोग्राफ़िक क्रम में होना चाहिए , जैसे पहला है123654789

— Sp3000

@luserdroog (यह है कि, निर्देशित रास्तों की प्रत्येक जोड़ी के लेक्सियोग्राफ़िक-पहले के प्रतिनिधि को चुनें, और फिर उन 20 प्रतिनिधियों को

— लेक्सोग्राफिक रूप से

Answer 1

PARI / जीपी - 24

1%1
 8
2+3

PARI / GP अंकों के बीच रिक्त स्थान को अनदेखा करता है, इसलिए 1 8 2, उदाहरण के लिए जैसा माना जाता है 182। वही अंडरस्कोर के साथ रिक्त स्थान को बदलकर पर्ल के लिए काम कर सकता है। मैंने संपूर्ण खोज स्थान को समाप्त नहीं किया है, इसलिए बेहतर उम्मीदवार हो सकते हैं।

एक कार्यक्रम के रूप में जीपी को खिलाया जा सकता है gp -q -f program.gp, या उत्तर में अंतःक्रियात्मक रूप से ।

---

उत्पादन

1%1 8 2+3 -> 4
1%1 3+8 2 -> 83 # invalid
1%1 3+2 8 -> 29
1%8 2+3 1 -> 32
1 8%1 3+2 -> 7
1 2+8%1 3 -> 20
1 2+3 1%8 -> 19
1 2+3 8%1 -> 12
1%1 8 3+2 -> 3
1%1 2+8 3 -> 84 # invalid
1%1 2+3 8 -> 39
1 8%1 2+3 -> 9
1 3+8%1 2 -> 21
1 3+2 1%8 -> 18
8 1%1 3+2 -> 5
8 1%1 2+3 -> 12 # dup
8+2 1%1 3 -> 16
8+3 1%1 2 -> 15
2 1%1 8+3 -> 6
2+8 1%1 3 -> 5  # dup
3+2 8 1%1 -> 3  # dup
2 8+3 1%1 -> 28
8 2+3 1%1 -> 82 # invalid
1 3+2 8%1 -> 13
2+3 1%8 1 -> 33
3 1%8+2 1 -> 28 # dup
8%1 3+2 1 -> 29 # dup
1%8 3+2 1 -> 22
2+3 8 1%1 -> 2
3 8+2 1%1 -> 38
8 3+2 1%1 -> 83 # invalid
3+2 1%8 1 -> 24
2 1%8+3 1 -> 36
8%1 2+3 1 -> 39 # dup
2+3 1%1 8 -> 15 # dup
3+2 1%1 8 -> 6  # dup
3 1%1 2+8 -> 15 # dup
2 1%1 3+8 -> 16 # dup
3+8 1%1 2 -> 12 # dup
3 1%1 8+2 -> 15 # dup

सभी लेकिन 4 मान 12 डुप्लिकेट प्रविष्टियों के साथ आवश्यक सीमा के भीतर हैं।

---

अद्यतन करें

मैंने क्रंचिंग पूरी कर ली है, छह अलग-अलग 23 हैं, और केवल एक 24 (जैसा कि पंक्तियों द्वारा पढ़ा गया है):

23 1%1 6 2+3 [2, 3, 4, 5, 7, 8, 11, 12, 13, 14, 16, 17, 18, 19, 22, 24, 26, 27, 32, 33, 34, 36, 37]
23 1 2%3+2*8 [2, 5, 7, 8, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 22, 23, 25, 26, 29, 31, 32, 37, 40]
23 2 3%1+8 2 [2, 4, 6, 7, 10, 11, 12, 13, 14, 15, 16, 20, 21, 23, 24, 28, 29, 30, 31, 32, 33, 34, 40]
23 4%6%5*7+6 [2, 4, 5, 6, 7, 8, 9, 12, 13, 19, 21, 23, 24, 26, 29, 31, 32, 33, 34, 37, 38, 39, 40]
23 5%6%4*7+6 [2, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 16, 18, 25, 26, 29, 31, 33, 34, 37, 38, 39, 40]
23 5%6%4*8+6 [1, 3, 5, 6, 8, 9, 10, 12, 14, 15, 18, 22, 24, 25, 27, 29, 30, 32, 34, 36, 37, 39, 40]

24 1%1 8 2+3 [2, 3, 4, 5, 6, 7, 9, 12, 13, 15, 16, 18, 19, 20, 21, 22, 24, 28, 29, 32, 33, 36, 38, 39]

क्रंचिंग के लिए मैंने जिस प्रोग्राम का इस्तेमाल किया, वह नीचे है। PARI / GP में सीमित स्ट्रिंग प्रसंस्करण क्षमताएं हैं, इसलिए मुख्य रूप से char arrays (उर्फ Vecsmall) के साथ व्यवहार करें । ऑपरेटरों का परीक्षण कर रहे हैं +, -, *, \(मंजिल div), %, ;(अभिव्यक्ति विभाजक, अनिवार्य रूप से छोड देता है यह पहले सब कुछ), और (अंतरिक्ष, ऊपर वर्णित के रूप में)। घातांक ऑपरेटर ^भी जोड़ा जा सकता है, लेकिन यह बहुत धीमी गति से परीक्षण करने के लिए धीमा हो जाता है।

perms = {[
  [1, 2, 3, 6, 5, 4, 7, 8, 9], [1, 2, 3, 6, 9, 8, 5, 4, 7], [1, 2, 3, 6, 9, 8, 7, 4, 5], [1, 2, 5, 4, 7, 8, 9, 6, 3],
  [1, 4, 5, 2, 3, 6, 9, 8, 7], [1, 4, 7, 8, 5, 2, 3, 6, 9], [1, 4, 7, 8, 9, 6, 3, 2, 5], [1, 4, 7, 8, 9, 6, 5, 2, 3],
  [3, 2, 1, 4, 5, 6, 9, 8, 7], [3, 2, 1, 4, 7, 8, 5, 6, 9], [3, 2, 1, 4, 7, 8, 9, 6, 5], [3, 6, 5, 2, 1, 4, 7, 8, 9],
  [3, 6, 9, 8, 5, 2, 1, 4, 7], [3, 6, 9, 8, 7, 4, 1, 2, 5], [5, 4, 1, 2, 3, 6, 9, 8, 7], [5, 6, 3, 2, 1, 4, 7, 8, 9],
  [5, 8, 7, 4, 1, 2, 3, 6, 9], [5, 8, 9, 6, 3, 2, 1, 4, 7], [7, 4, 1, 2, 3, 6, 5, 8, 9], [7, 8, 5, 4, 1, 2, 3, 6, 9],
  [9, 8, 7, 4, 5, 6, 3, 2, 1], [7, 4, 5, 8, 9, 6, 3, 2, 1], [5, 4, 7, 8, 9, 6, 3, 2, 1], [3, 6, 9, 8, 7, 4, 5, 2, 1],
  [7, 8, 9, 6, 3, 2, 5, 4, 1], [9, 6, 3, 2, 5, 8, 7, 4, 1], [5, 2, 3, 6, 9, 8, 7, 4, 1], [3, 2, 5, 6, 9, 8, 7, 4, 1],
  [7, 8, 9, 6, 5, 4, 1, 2, 3], [9, 6, 5, 8, 7, 4, 1, 2, 3], [5, 6, 9, 8, 7, 4, 1, 2, 3], [9, 8, 7, 4, 1, 2, 5, 6, 3],
  [7, 4, 1, 2, 5, 8, 9, 6, 3], [5, 2, 1, 4, 7, 8, 9, 6, 3], [7, 8, 9, 6, 3, 2, 1, 4, 5], [9, 8, 7, 4, 1, 2, 3, 6, 5],
  [9, 6, 3, 2, 1, 4, 7, 8, 5], [7, 4, 1, 2, 3, 6, 9, 8, 5], [9, 8, 5, 6, 3, 2, 1, 4, 7], [9, 6, 3, 2, 1, 4, 5, 8, 7]
]}

ops = Vecsmall("+-*\\%; ")

ms = 1

for(c = 48, 57, {
 for(d = c, 57,
  for(f = d, 57,
   for(g = c, 57,
    for(e = 48, 57,
     print1(Strchr([c,d,e,f,g,13]));
     for(h = 1, #ops,
      for(i = 1, #ops,
       for(j = 1, #ops,
        for(k = 1, #ops,
         a = Vecsmall([c, ops[h], d, ops[i], e, ops[j], f, ops[k], g]);
         s = Set();
         for(m = 1, #perms,
          v = Strchr(vecextract(a, perms[m]));
          iferr(b = eval(v), E, b = 0);
          if(b >= 1 && b <= 40, s = setunion(s, [b]))
         );
         if(#s >= ms, ms = min(23, #s); print(#s, " ", Strchr(a), " ", s));
        )
       )
      )
     )
    )
   )
  )
 )
})

Comments

काश, एक पर्ल प्रोग्राम अपने अंतिम मूल्य को आउटपुट नहीं करता। एक पर्ल सबरूटीन करता है, लेकिन एक सबरूटीन में ब्रेसिज़ होते हैं। ( "हस्ताक्षर एक सबरूटीन के शरीर का हिस्सा है। आम तौर पर एक सबरूटीन का शरीर कोड का एक लटके हुए ब्लॉक होता है।" ) तो मुझे नहीं लगता कि यह पर्ल में उल्लेखनीय है।

— msh210

Answer 2

डेडफिश , १,

यह वास्तव में पहली भाषा थी जिसे मैंने infix ऑपरेटरों के विचार से पहले आजमाया था। मैं इसे अब इस विचार की सघनता के लिए पोस्ट कर रहा हूं कि डेडफिश किसी चीज के लिए उपयोगी हो सकती है।

iii
ios
sii

उन लोगों के लिए जो डेडफिश नहीं जानते हैं, iवेतन वृद्धि है, sचौकोर है और oआउटपुट है, जिसमें 0 पर शुरू होने वाला संचायक ( dयहां उपयोग नहीं किए जाने वाले वेतन वृद्धि के लिए 4 वाँ निर्देश भी है)। तथ्य यह है कि हमारे पास स्वचालित मुद्रण नहीं है और उपयोग करने की आवश्यकता oएक बड़ी खामी है, लेकिन आश्चर्यजनक रूप से डेडफिश यहां बहुत अधिक नहीं करती है, सभी चीजों पर विचार किया जाता है। यह पता चला है कि आउटपुट ऑपरेटर का इष्टतम स्थान बीच में है।

iiisoisii 9
iiisiiois 11
iiisiisio 122
iioisiisi 2
iioiisiis 2
iisioiisi 5
iisiisiio 38
iisiisoii 36
iiiiosiis 4
iiiisiosi 17
iiiisiiso 324
isoiiisii 1
isiioiiis 3
isiisiiio 12
oiiiisiis 0
osiiiisii 0
oisiiiisi 0
oiisiiiis 0
siiiisoii 16
sioiiiisi 1
iisiosiii 5
sioiisiii 1
oisiisiii 0
isiisioii 10
siisiioii 6
isiioisii 3
oiisiisii 0
iiosiisii 2
siisoiiii 4
isoisiiii 1
osiisiiii 0
iisiiiosi 7
siiioiisi 3
oiiisiisi 0
siisiiiio 8
iisiiiiso 64
isiiiisio 26
siiiisiio 18
iiosiiiis 2
isiiiiois 5

Answer 3

पायथन आरईपीएल और कई और अधिक, 22 23

6+7
*5%
6%4

मुख्य अवलोकन: यदि आप ग्रिड को एक बिसात की तरह रंग देते हैं, तो पथ ग्रिड रंगों को वैसा ही चुनता है जैसा वह जाता है और उसी रंग पर शुरू और समाप्त होता है।

फिर भी बेहतर के लिए मजबूर करना। +*%(और यहां तक ​​कि **जहां ^प्रतिपादक भाषाओं के लिए भी ) कोशिश करना बेहतर नहीं है, दुर्भाग्य से। मैंने बिटवाइज़ ऑपरेटरों में भी फेंकने की कोशिश की और केवल ^(एक्सोर) हल्के से मदद करने के लिए लग रहा था, लेकिन खोज में बहुत समय लग रहा था इसलिए मैंने छोड़ दिया है।

6+7%5*6%4 6
6+7%4%5*6 24
6+7%4%6*5 21
6+5*6%4%7 8
6*5+7%4%6 33
6*6%5+7%4 4
6*6%4%7+5 5
6*6%4%5+7 7
7+6*5%4%6 9
7+6*6%5%4 8
7+6*6%4%5 7
7%5+6*6%4 2
7%4%5+6*6 39
7%4%6*6+5 23
5*6+7%4%6 33
5%7+6*6%4 5
5%6*6+7%4 33
5%4%7+6*6 37
6*6+7%5%4 38
6%5*6+7%4 9
4%6*5%7+6 12
6*5%4%7+6 8
5*6%4%7+6 8
7%4%6*5+6 21
6%4%7+5*6 32
4%7+5%6*6 34
5+7%4%6*6 23
7+5%4%6*6 13
6%4%5*6+7 19
4%5%6*6+7 31
5%4%6*6+7 13
4%6*6+5%7 29
6*6+5%4%7 37
5+6*6%4%7 5
6%4%7+6*5 32
4%6*6+7%5 26
4%7+6*6%5 5
6*6+7%4%5 39
4%5%7+6*6 40
4%7+6*5%6 4

Comments

अगला कार्य: एक प्रोग्राम लिखें जो प्रोग्राम को सबसे अनूठे मूल्यों के साथ उत्पन्न करता है। फिर उस कार्यक्रम को गोल्फ। :)

— रेटो कोरदी

@RetoKoradi पहला भाग जो मैंने किया। दूसरा ... बाद में: P

— Sp3000

@ Sp3000 मैंने समाधान की इस शैली के लिए मजबूर किया। वहाँ है 6+7*5%6%4, 6+7*4%6%5और 6+8*4%6%5(बाएं से दाएं, ऊपर से नीचे), और कुछ नहीं।

— isaacg

यदि आप कुछ और ऑपरेटरों की तरह फेंकते हैं तो @isaacg 23-पॉइंट सॉल्यूशन हैं, जैसे & ^ ^

— Sparr

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

— रीटो कोराडी

Answer 4

जे, 15

2 + 1
* 3 *
2 + 3

यह केवल मान्य संख्याओं को आउटपुट करता है, लेकिन बहुत सारे डुप्लिकेट हैं। अद्वितीय मूल्य हैं 17 11 16 28 31 23 13 10 21 33 18 24 22 29 27। आप निश्चित रूप से ऑपरेटर और पूर्णांक को बदलकर बेहतर कर सकते हैं।

2+1*3*2+3 -> 17
2+1*3+3*2 -> 11
2+1*3+2*3 -> 11
2+3*2+3*1 -> 17
2*3+1*3+2 -> 16
2*2+3+1*3 -> 16
2*2+3*1+3 -> 28
2*2+3*3+1 -> 28
1+2*3*3+2 -> 31
1+2*2+3*3 -> 23
1+2*2+3*3 -> 23
1*3+2*2+3 -> 13
1*3+3+2*2 -> 10
1*3+2*2+3 -> 13
3*2+1*3+2 -> 21
3*1+2*2+3 -> 33
3+2*2+1*3 -> 13
3+3*1+2*2 -> 18
2*2+1*3+3 -> 16
2+3*2+1*3 -> 17
3+2*3*1+2 -> 21
2*3+3*1+2 -> 24
3*2+3*1+2 -> 33
1*3+2*3+2 -> 13
2+3*1+3*2 -> 23
3*1+3+2*2 -> 24
3+1*3+2*2 -> 10
1+3*3+2*2 -> 22
2+3*3*2+1 -> 29
3*3+2*2+1 -> 27
3*3+2*2+1 -> 27
3+2*2+3*1 -> 13
2*2+3+3*1 -> 16
3+2*2+3*1 -> 13
2+3*1+2*3 -> 23
3+2*2+1*3 -> 13
3*1+2*2+3 -> 33
2*2+1*3+3 -> 16
3+3*1+2*2 -> 18
3*1+2*3+2 -> 33

Comments

वैसे, 1k प्रतिनिधि मारने पर बधाई! :)

— एलेक्स ए।

@AlexA। J उत्तर पर 1k मारना, प्रोग्ल उत्तर के अलावा कुछ नहीं।

— बेवफा

यह ठीक है, मुझे यकीन है कि प्रोलॉग समझ जाएगा।

— एलेक्स ए।

@AlexA। Yes।

— जॉन ड्वोरक

@JanDvorak क्या आप प्रोलोग की ओर से बोल रहे हैं?

— एलेक्स ए।

Answer 5

> <>, 36 *

यदि आप पर्याप्त भाग्यशाली हैं!

x;x
lxl
xnx

चूंकि चुनौती के लिए कोड को नियतात्मक होने की आवश्यकता नहीं होती है, इसलिए हमें केवल यह साबित करना होगा कि 36 नंबरों को वापस करना संभव है (भले ही असंभव)। यह अच्छा था जबकि यह मुझे लगता है कि चली।

(उन लोगों के लिए जो <> से परिचित नहीं हैं, उनके लिए एक महान परिचय यहां पाया जा सकता है )

> <> स्टैक-आधारित 2D भाषा है। इसका मतलब यह है कि निर्देशों को अधिकांश पारंपरिक भाषाओं की तरह रैखिक रूप से निष्पादित नहीं किया जाता है - कार्यक्रम प्रवाह ऊपर, नीचे, बाएं या दाएं हो सकता है!

मैंने "x" इंस्ट्रक्शन को> <> में इस्तेमाल करने का फैसला किया, जो इंस्ट्रक्शन पॉइंट्स की दिशा को ऊपर, नीचे, बाएं या दाएं रैंडम में बदल देता है। चूंकि हमारा कोड केवल एक पंक्ति होगा, इसका मतलब है कि हम केवल उन मामलों को देख सकते हैं जब यह दाएं या बाएं जाता है, क्योंकि यदि सूचक ऊपर या नीचे जाता है, तो यह बस "x" निर्देश को फिर से हिट करेगा।

"एन" निर्देश स्टैक के शीर्ष पर संख्या को पॉप करता है और इसे प्रिंट करता है। हालाँकि यदि स्टैक खाली है और पॉप करने के लिए कुछ भी नहीं है, तो एक त्रुटि उठाई जाती है।

"एल" निर्देश बस स्टैक पर स्टैक की लंबाई को बढ़ाता है (और हमारे लिए भाग्यशाली है कि यह एक त्रुटि नहीं भेजता है यदि स्टैक खाली है), इसलिए उदाहरण के लिए यदि स्टैक खाली थे और "एल" कहा जाएगा, तो यह स्टैक पर 0 धक्का होगा। यदि हम अब फिर से "एल" कहेंगे, तो चूंकि स्टैक में एक तत्व (0) है, यह स्टैक के शीर्ष पर 1 धक्का देगा और अब इसका मतलब यह होगा कि स्टैक पर दो चीजें होंगी और इसका मतलब यह होगा कि यदि हम "एल" को फिर से कॉल करने के लिए थे, तो हम स्टैक आदि पर 2 को आगे बढ़ाएंगे। इसलिए हम "एल" का उपयोग स्टैक पर एक मनमानी संख्या को पूर्व में दिखाए गए तरीके से करने के लिए कर सकते हैं।

";" निर्देश कार्यक्रम को समाप्त करता है।

"X" का उपयोग करने वाला विचार वह है, उदाहरण के लिए यदि कोड में केवल एक "x" होता है (जहाँ A, B, C, D कुछ निर्देश हैं):

ABCx;D

यह कार्यक्रम ए तब बी और फिर सी पर अमल करेगा, और "एक्स" तक पहुंचने पर हमारे पास दो कब्जे होंगे: कोड या तो सही जाना जारी रखता है और "हिट" करता है; और बाहर निकलता है या यह बाईं ओर जाता है और फिर C तब B को A और फिर D को निष्पादित करता है। इसलिए यदि हमारे कोड में एक "x" होता है, तो प्रोग्राम दो संभावित प्रोग्राम फ्लो प्राप्त करता है जिसमें से हम सबसे अनुकूल प्रोग्राम चुन सकते हैं।

मैं दो या दो से अधिक "x" तों का हूं, तब हम संभावित कार्यक्रम प्रवाह की एक अनंत संख्या प्राप्त करते हैं।

हमारे कोड में पाँच "x" हैं, उनमें से प्रत्येक फथर्मोर हैमिल्टन के रास्तों के "शुरुआती सेल" में है, जिसका अर्थ है कि हर एक प्रोग्राम "x" से शुरू होगा, और हर प्रोग्राम में संरचना होगी:

xAxBxCxDx

जहां ए, बी, सी, डी {के हैं; , एन, एल, एल} इसका मतलब है कि केवल 12 अद्वितीय कार्यक्रम हैं। इसके अलावा जब से हम हमेशा एक "x" पर शुरू करते हैं, हम उस मामले को देख सकते हैं जब कार्यक्रम बाएं चला जाता है, इस प्रकार सममित कार्यक्रमों को भी समान माना जा सकता है। समरूपता तक केवल 6 अलग-अलग सकारात्मक कार्यक्रम हैं। उनमें से केवल 4 हैमिल्टनियन पथ के रूप में उत्पन्न कार्यक्रमों में होते हैं:

xnxlxlx;x
xlxnxlx;x
xnxlx;xlx
xlxnx;xlx

आइए हम पहले कार्यक्रम "xnxlxlx; x" को देखें, यदि हम पहले चरण में सही जाते हैं तो हम प्रिंट कमांड को हिट करते हैं जो कि स्टैक पर कुछ भी नहीं होने के कारण त्रुटि उत्पन्न करेगा। यदि हम बाएं जाते हैं तो हम अंतिम प्रोग्राम कमांड को हिट करते हैं। इसलिए हम इन कार्यक्रमों से किसी भी संख्या का उत्पादन नहीं कर सकते हैं।

दूसरा कार्यक्रम, "xlxnxlx; x", एक बहुत अधिक उम्मीद है, क्योंकि सही होने पर भीख मांगने पर शून्य को स्टैक पर रखा जाता है, अगर हम अगले "x" पर बाएं जाते हैं, तो हमारा स्टैक एक प्राप्त करता है, फिर फिर से सही होने पर हमारे पास एक 2 है जिसे हम प्रिंट कर सकते हैं और कार्यक्रम को समाप्त करने के लिए सही जारी रख सकते हैं। हम यह देख सकते हैं कि हम वास्तव में किसी भी संख्या को प्रिंट कर सकते हैं , क्योंकि शुरुआत में "xlx" भाग में हम एक निश्चित संख्या में मनमाने आकार तक पहुँच सकते हैं, फिर बाएँ से दाएँ फिर एक निश्चित संख्या में बार।

संभवतः यह देखा जा सकता है कि तीसरा प्रोग्राम xnxlx; xlx किसी भी विषम संख्या को आउटपुट कर सकता है , शुरुआत में बाएं जा कर और फिर "xlx" रूटीन को दोहराते हुए इस बार केवल बाएं से दाएं फिर बाएं।

और चौथा कार्यक्रम अनिवार्य रूप से दूसरे कार्यक्रम के समान है और किसी भी संख्या को आउटपुट कर सकता है ।

इसलिए हमारे पास आवश्यक कार्यक्रमों के लिए:

x;xlxlxnx (none)
x;xlxnxlx (any even number)
x;xlxnxlx (any even number)
x;xlxnxlx (any even number)
xlx;xlxnx (any odd number)
xlxnx;xlx (any even number)
xlxnxlx;x (any even number)
xlxnxlx;x (any even number)
x;xlxlxnx (none)
x;xlxnxlx (any even number)
x;xlxnxlx (any even number)
xlx;xlxnx (any odd number)
xlxnx;xlx (any even number)
xlxnxlx;x (any even number)
xlx;xlxnx (any odd number)
xlx;xlxnx (any odd number)
xnxlx;xlx (any odd number)
xnxlx;xlx (any odd number)
xlx;xlxnx (any odd number)
xnxlx;xlx (any odd number)
xnxlxlx;x (none)
xlxnxlx;x (any even number)
xlxnxlx;x (any even number)
xlxnxlx;x (any even number)
xnxlx;xlx (any odd number)
xlx;xnxlx (any even number)
x;xlxnxlx (any even number)
x;xlxnxlx (any even number)
xnxlxlx;x (none)
xlxnxlx;x (any even number)
xlxnxlx;x (any even number)
xnxlx;xlx (any odd number)
xlx;xnxlx (any even number)
x;xlxnxlx (any even number)
xnxlx;xlx (any odd number)
xnxlx;xlx (any odd number)
xlx;xlxnx (any odd number)
xlx;xlxnx (any odd number)
xnxlx;xlx (any odd number)
xlx;xlxnx (any odd number)

वह 4 प्रोग्राम है जो कि कैंट आउटपुट नंबर्स, 20 जो किसी भी सम संख्या को आउटपुट कर सकता है, 16 जो किसी भी विषम संख्या को आउटपुट कर सकता है। चूंकि रेंज 1 से 40 तक बिल्कुल 20 सम संख्याएं और कम से कम 16 विषम संख्याएं हैं, तो एक निश्चित संभावना के साथ इस कोड ब्लॉक द्वारा रेंज 1 से 40 आउटपुट में 36 विभिन्न संख्याएं होने की संभावना है।

Comments

36 को एक उत्तर के लिए

— भयानक रूप से उपसमिति

कभी-कभी मैं चाहता था कि मछली के लिए एक निर्देश था कि "स्टैक और एक्जिट पर आखिरी बात प्रिंट करें" जो एक बड़ी मदद करेगा। मैं जल्द ही पूरी तरह से इष्टतम बचाव का रास्ता हो सकता है, हालांकि

— सर्पिस

मैं ईमानदारी से गैर-नियतात्मक कार्यक्रमों की गिनती नहीं करने के बारे में एक नियम जोड़ना भूल गया। मैंने इसे अभी जोड़ा है। आप इसे बनाए रखने के लिए स्वागत करते हैं क्योंकि यह चतुर और अच्छी तरह से समझाया गया है, लेकिन मैं इस जवाब को स्वीकार नहीं करूंगा।

— केल्विन के शौक

निश्चित रूप से, यह जवाब वैसे भी एक प्रतिस्पर्धात्मक जवाब देने के लिए नहीं था, यह एक घुटने से झटका प्रतिक्रिया की अधिक थी जब मैं इस चुनौती को पढ़ रहा था और मछली का जवाब होने के बारे में सोचा था।

— सर्पिस

Answer 6

GolfScript, 8

192
6#7
281

वर्तमान में उच्चतम स्कोरिंग समाधान। : पी अच्छा था, जबकि यह चली।

कार्यक्रम

1927#6281 1927
192718#62 192718
19271826# 19271826
19#628172 19
16#927182 16
1628#9271 1628
16281729# 16281729
162817#92 162817
2916#7182 2916
291628#71 291628
29162817# 29162817
27#916281 27
2718#9162 2718
27182619# 27182619
#61927182 
#72916281 
#82619271 
#81729162 
261927#81 261927
28#619271 28
1826#7291 1826
26#817291 26
#62817291 
271826#91 271826
281729#61 281729
1729#8261 1729
#92718261 
29#718261 29
2817#6192 2817
17#826192 17
#71826192 
182619#72 182619
2619#8172 2619
#91628172 
28172916# 28172916
18261927# 18261927
17291628# 17291628
26192718# 26192718
18#729162 18
172916#82 172916

Comments

जब तक यह चलता रहा ... 30 मिनट तक ..

— ऑप्टिमाइज़र

सर्वश्रेष्ठ मुझे गोल्फस्क्रिप्ट के लिए मिल सकता है 0)1#2#3(415. सुंदर समरूपता भी।

— प्रिमो जूल

@primo: यह चतुर है। मुझे नहीं लगा कि अधिक टिप्पणी वास्तव में स्कोर में सुधार करेगी।

— डेनिस

Answer 7

CJam, 14

3(4
;];
0)1

काम कर रहे कार्यक्रमों के नीचे:

3(4;];0)1 = 11
3(4;1)0;] = 22
3(];0)1;4 = 14
3;0)](4;1 = 11
3;0)1;4(] = 13
3;0)1;](4 = 14
4(3;];1)0 = 20
4(3;0)];1 = 1
4(3;0)1;] = 31
4;1)](3;0 = 20
4;1)0;3(] = 22
0;3(4;])1 = 21
0)];3(4;1 = 21
1)0;];4(3 = 33
4;1)0;](3 = 23
0)1;4(];3 = 3
1;4(])0;3 = 33
4(];1)0;3 = 23
0)1;];3(4 = 24
1)0;3(];4 = 4
0;3(])1;4 = 24
0)1;4(3;] = 13
1)0;3(4;] = 22
1;4(3;0)] = 31
0;3(4;1)] = 22
1)];4(3;0 = 30
1;4(3;])0 = 30

उत्पन्न मूल्य इस प्रकार हैं: [1, 3, 4, 11, 13, 14, 20, 21, 22, 23, 24, 30, 31, 33]

Comments

क्या यह कोड आपने स्वयं लिखा है? या आपने कोड रूपांतरों को व्यवस्थित रूप से गणना और मूल्यांकन किया था? मैं सोच रहा था कि क्या infix संकेतन के साथ कोई भाषा इसके लिए स्वाभाविक रूप से बेहतर हो सकती है, या यदि स्टैक आधारित गोल्फिंग भाषा के साथ @ Sp3000 के दृष्टिकोण को हराया जाना संभव है।

— रेटो कोराडी

@Reto मैंने एक प्रोग्राम लिखा, जिसमें 4 न्यूमेरिकल पैरामीटर के लिए सभी वैल्यूज 0..9 है। मैंने मैन्युअल रूप से कुछ ऑपरेटरों को बदलने की भी कोशिश की। स्टैक आधारित भाषा के साथ समस्या यह है कि अधिकांश ऑपरेटरों को स्टैक पर 2 मापदंडों की आवश्यकता होती है, इस प्रकार हमारे पास बहुत सारी त्रुटियां हैं। Infix भाषाएं अपनी पोस्ट में Sp3000 द्वारा वर्णित चेकर संरचना से लाभान्वित होती हैं।

— अरनौद

हां, जब मैं मूल दृष्टिकोण को देख रहा था, तो ठीक यही मेरी भावना थी। एक सरल लेआउट होना जो सभी वैध अभिव्यक्तियों को उत्पन्न करने की गारंटी है, एक बड़ा लाभ है। CJam का एकमात्र लाभ यह है कि इसमें बहुत अधिक एक अक्षर वाले ऑपरेटर हैं।

— रेटो कोराडी

Answer 8

डीसी (20)

2+3
*p+
4+5

ABCFEDGHI -> 2+3+p*4+5 -> 5     $ **
ABCFIHEDG -> 2+3+5+p*4 -> 10    $ **
ABCFIHGDE -> 2+3+5+4*p -> 40    $ **
ABEDGHIFC -> 2+p*4+5+3 -> 2     $ **
ADEBCFIHG -> 2*p+3+5+4 -> 2       **
ADGHEBCFI -> 2*4+p+3+5 -> 6     $ **
ADGHIFCBE -> 2*4+5+3+p -> 14    $ **
ADGHIFEBC -> 2*4+5+p+3 -> 11    $ **
CBADEFIHG -> 3+2*p+5+4 -> 6       **
CBADGHEFI -> 3+2*4+p+5 -> 10      **
CBADGHIFE -> 3+2*4+5+p -> 15    $ **
CFEBADGHI -> 3+p+2*4+5 -> 3     $ **
CFIHEBADG -> 3+5+p+2*4 -> 8     $ **
CFIHGDABE -> 3+5+4*2+p -> 34    $ **
EDABCFIHG -> p*2+3+5+4 -> 
EFCBADGHI -> p+3+2*4+5 -> 
EHGDABCFI -> p+4*2+3+5 -> 
EHIFCBADG -> p+5+3+2*4 -> 
GDABCFEHI -> 4*2+3+p+5 -> 9     $ **
GHEDABCFI -> 4+p*2+3+5 -> 4     $ **
IHGDEFCBA -> 5+4*p+3+2 -> 20    $ **
GDEHIFCBA -> 4*p+5+3+2 -> 4       **
EDGHIFCBA -> p*4+5+3+2 -> 
CFIHGDEBA -> 3+5+4*p+2 -> 32    $ **
GHIFCBEDA -> 4+5+3+p*2 -> 12    $ **
IFCBEHGDA -> 5+3+p+4*2 -> 8       **
EBCFIHGDA -> p+3+5+4*2 -> 
CBEFIHGDA -> 3+p+5+4*2 -> 3       **
GHIFEDABC -> 4+5+p*2+3 -> 9       **
IFEHGDABC -> 5+p+4*2+3 -> 5       **
EFIHGDABC -> p+5+4*2+3 -> 
IHGDABEFC -> 5+4*2+p+3 -> 22    $ **
GDABEHIFC -> 4*2+p+5+3 -> 6       **
EBADGHIFC -> p+2*4+5+3 -> 
GHIFCBADE -> 4+5+3+2*p -> 24    $ **
IHGDABCFE -> 5+4*2+3+p -> 25    $ **
IFCBADGHE -> 5+3+2*4+p -> 20      **
GDABCFIHE -> 4*2+3+5+p -> 14      **
IHEFCBADG -> 5+p+3+2*4 -> 5       **
IFCBADEHG -> 5+3+2*p+4 -> 16    $ **

32 आउटपुट, उनमें से 20 अलग (एक के साथ चिह्नित $)

2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 14, 15, 16, 20, 22, 24, 25, 32, 34, 40