101

अपनी भाषा का समर्थन करने वाले किसी भी पांच वर्ण को चुनें। 5 हैं! = 5 × 4 × 3 × 2 × 1 = 120 तरीकों से इन्हें 5-वर्ण स्ट्रिंग में व्यवस्थित किया जा सकता है जिसमें प्रत्येक वर्ण एक बार होता है; 120 क्रमोन्नति ।

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

अर्थात्, आपके 5 वर्णों में से प्रत्येक 120 के क्रमपरिवर्तन के लिए, जो कि रन कोडेबल कोड का उत्पादन करता है, जो एकल संख्या को आउटपुट करता है, आप चाहते हैं कि उन सभी संख्याओं का सेट 1 से 120 तक पूर्णांक के सेट के जितना करीब हो सके।

तो, आदर्श रूप से, आपका पहला क्रमपरिवर्तन होगा 1, अगला 2, अगला 3, सभी तरह से 120। लेकिन अधिकांश भाषाओं और पात्रों के लिए यह आदर्श असंभव है।

5-वर्ण स्ट्रिंग्स निम्नानुसार चलाए जा सकते हैं:

कोई इनपुट वाला प्रोग्राम
कोई तर्क के साथ एक समारोह
एक REPL कमांड

अलग-अलग तार वांछित होने पर अलग-अलग तरीकों से चलाए जा सकते हैं

आउटपुट की गणना के लिए, यह सामान्य तरीके से एकल पूर्णांक आउटपुट होना चाहिए , जैसे:

स्टडआउट के लिए मुद्रित किया जा रहा है
समारोह से लौटे
REPL अभिव्यक्ति का परिणाम है

कोड को सामान्य रूप से समाप्त किया जाना चाहिए (जिसमें पहले नंबर पर आउटपुट होने तक इरेटिंग शामिल हो सकती है )। कोड जो बिल्कुल नहीं चलता है, ठीक है, बस (कोई नहीं) आउटपुट की गिनती नहीं है। जब तक एक अलग आधार आपकी भाषा के लिए आदर्श न हो, तब तक संख्या का आउटपुट दशमलव में होना चाहिए।

सबमिशन जो 120 जीत के माध्यम से 1 से सबसे अलग संख्या उत्पन्न करता है। पहले जमा करने के मामले में जीत हासिल होती है।

आपके 5 वर्णों को अलग-अलग होने की आवश्यकता नहीं है, लेकिन निश्चित रूप से डुप्लिकेट वर्ण होने से क्रमपरिवर्तन की प्रभावी संख्या कम हो जाती है।
फ्लोट आउटपुट जैसे कि 32.0काउंट के साथ-साथ प्लेन भी 32। (लेकिन 32.01नहीं होगा।)
ज़ीरो जैसे कि 032गिनती के साथ-साथ सादे भी 32।
मान्य आउटपुट नियतात्मक और समय अपरिवर्तनीय होना चाहिए।
हम पात्रों के साथ काम कर रहे हैं , बाइट्स से नहीं।

उदाहरण

पात्र 123+*पायथन (या कई भाषा के) REPL के लिए एक उचित पहली पसंद हैं। जिसके परिणामस्वरूप 120 क्रमांकन और आउटपुट हैं:

123+* n/a
123*+ n/a
12+3* n/a
12+*3 n/a
12*3+ n/a
12*+3 36
132+* n/a
132*+ n/a
13+2* n/a
13+*2 n/a
13*2+ n/a
13*+2 26
1+23* n/a
1+2*3 7
1+32* n/a
1+3*2 7
1+*23 n/a
1+*32 n/a
1*23+ n/a
1*2+3 5
1*32+ n/a
1*3+2 5
1*+23 23
1*+32 32
213+* n/a
213*+ n/a
21+3* n/a
21+*3 n/a
21*3+ n/a
21*+3 63
231+* n/a
231*+ n/a
23+1* n/a
23+*1 n/a
23*1+ n/a
23*+1 23
2+13* n/a
2+1*3 5
2+31* n/a
2+3*1 5
2+*13 n/a
2+*31 n/a
2*13+ n/a
2*1+3 5
2*31+ n/a
2*3+1 7
2*+13 26
2*+31 62
312+* n/a
312*+ n/a
31+2* n/a
31+*2 n/a
31*2+ n/a
31*+2 62
321+* n/a
321*+ n/a
32+1* n/a
32+*1 n/a
32*1+ n/a
32*+1 32
3+12* n/a
3+1*2 5
3+21* n/a
3+2*1 5
3+*12 n/a
3+*21 n/a
3*12+ n/a
3*1+2 5
3*21+ n/a
3*2+1 7
3*+12 36
3*+21 63
+123* n/a
+12*3 36
+132* n/a
+13*2 26
+1*23 23
+1*32 32
+213* n/a
+21*3 63
+231* n/a
+23*1 23
+2*13 26
+2*31 62
+312* n/a
+31*2 62
+321* n/a
+32*1 32
+3*12 36
+3*21 63
+*123 n/a
+*132 n/a
+*213 n/a
+*231 n/a
+*312 n/a
+*321 n/a
*123+ n/a
*12+3 n/a
*132+ n/a
*13+2 n/a
*1+23 n/a
*1+32 n/a
*213+ n/a
*21+3 n/a
*231+ n/a
*23+1 n/a
*2+13 n/a
*2+31 n/a
*312+ n/a
*31+2 n/a
*321+ n/a
*32+1 n/a
*3+12 n/a
*3+21 n/a
*+123 n/a
*+132 n/a
*+213 n/a
*+231 n/a
*+312 n/a
*+321 n/a

उत्पन्न संख्या 36 हैं, सभी सौभाग्य से 1 से 120 के भीतर हैं:

36, 26, 7, 7, 5, 5, 23, 32, 63, 23, 5, 5, 5, 7, 26, 62, 62, 32, 5, 5, 5, 7, 36, 63, 36, 26, 23, 32, 63, 23, 26, 62, 62, 32, 36, 63

हालांकि, उनमें से केवल 8 अद्वितीय हैं:

36, 26, 7, 5, 23, 32, 63, 62

तो इस तरह की सबमिशन अधिकतम १२० में से केवल only अंक हासिल करेगी।

— केल्विन के शौक
स्रोत

21

मैं इस चुनौती को करना चाहता हूँ लेकिन यह समान cभाषाओं में महत्वपूर्ण लगता है !!!

— मुकुल कुमार

3

@ मुकुलकुमार का मानना है कि सी-लाइक भाषा में भी REPLs होते हैं (उदाहरण के लिए gdb का उपयोग किया जा सकता है - एक हद तक - C के लिए REPL के रूप में) ताकि पायथन के लिए प्रदर्शित दृष्टिकोण अभी भी एक विकल्प हो।

— मार्टिन एंडर

1

संबंधित (निश्चित लिंक)।

— 13

3

@ सत्य बात के लिए नहीं। एक और आधार की अनुमति देना पसंद है।

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

3

@ OldBunny2800 वैध आउटपुट नियतात्मक और समय अपरिवर्तनीय होना चाहिए।

— डेनिस

41

पायथन 3, 21 27 मान

पात्र: 3479%

अद्वितीय नंबर: [1,2,3,4,5,6,7,8,9,11,12,19,20,21,24,29,34,35,36,37,39,43,46,47,49,73,74]

जैसा कि यह अनुरोध किया गया था, यहां क्रमपरिवर्तन हैं जो [1, 120] श्रेणी में आते हैं । इसे ऑनलाइन आज़माएं!

— Yytsi
स्रोत

2

क्या आपको पायथन 2 में बेहतर परिणाम नहीं मिलेंगे, जहां /पूर्णांक विभाजन है?

— नील

@ केड मी भी। मैंने जो सबसे बड़ा प्रयास किया, वह "0123456789 * - + & |% ^ 0123456789" की पंक्तियों में कुछ था

— Yytsi

इसके लिए 2 और विकल्प हैं, जिसके परिणामस्वरूप समान मान हैं: 5679%और5789%

— गबोर फेकेट

FYI करें - यह (या 5679%और 5789%लोगों) की संभावना PowerShell के लिए इष्टतम रूप में अच्छी तरह कर रहे हैं।

— AdmBorkBork

मुझे यह उत्तर (साथ में 5679%और साथ 5798%ही) 0123456789+-*/&|^#%प्रतिस्थापन के साथ सभी संयोजनों पर एक संपूर्ण खोज के माध्यम से मिला । मैं मानता हूं कि ये संभवत: इष्टतम हैं।

— जारेडल

34

05AB1E , 27 38 41 नंबर

4·>Ìn

अद्वितीय नंबर उत्पन्न करता है:

[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 25, 27, 32, 33, 34, 35, 36, 37, 38, 49, 50, 52, 54, 64, 65, 66, 67, 72, 73, 74, 81, 83, 98, 100, 101, 102]

निरंतर उपयोग करता है 4संचालन के साथ +1, +2, *2और ^2।

— Emigna
स्रोत

परीक्षण नहीं किया गया है, लेकिन इसके गैर-कम्यूटेटिव प्रॉपर्टी के आधार पर परिणामों की एक विस्तृत विविधता का उपयोग -करने के बजाय होगा +?

— Osable

@Oable: मैं के -रूप में अच्छी तरह से परीक्षण किया है , लेकिन कभी नहीं 30 अद्वितीय संख्या में मिल गया। एक मुद्दा यह है कि आपको नकारात्मक मूल्य मिलते हैं जो सीमा के बाहर आते हैं। हो सकता है कि कुछ अन्य ऑपरेटरों ने इसे बदल दिया हो, यह बेहतर हो सकता है, लेकिन मुझे अभी तक कोई सुधार नहीं मिला है।

— इमिग्ना

ठीक है, मैंने यह कहते हुए भाग (हालांकि बोल्ड अंदाज में) को छोड़ दिया कि आउटपुट की सीमा [1,120] होनी चाहिए। मेरा बुरा

— Osable

मैं थोड़ी देर के लिए कोशिश की और ~ 35 की तरह सब कुछ पर छाया हुआ है।

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

32

पायथन, 18 नंबर

237#-

मान्य परिणाम के रूप में उत्पादन:

1, 2, 3, 4, 5, 7, 16, 23, 24, 25, 27, 32, 35, 37, 69, 71, 72, 73

संपादित करें: मैं इस बात की पुष्टि कर सकता हूं कि पायथन के लिए तुकएक्सएक्स का समाधान इष्टतम है। मैंने निम्नलिखित कोड को 5 मुद्रण योग्य ASCII वर्णों के सभी संभावित संयोजनों को पूरा करते हुए चलाया:

from itertools import permutations,combinations_with_replacement

def perms(chars):
  result=set()
  for permut in permutations(chars):
    try:
      current=eval(''.join(permut))
      assert str(int(current))==str(current)
      result.add(int(current))
    except:
      pass
  return sum([1 for x in result if 1<=x<=120])

best=1
for c in combinations_with_replacement(' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~',5):
    string=''.join(c)
    r=perms(string)
    if r>=best:
        best=r
        print(r,string,end='\n')

परिणाम (लगभग 7 घंटे के लिए चलाने के बाद) से पता चला कि इष्टतम समाधान 27 अलग अलग संख्या, तीन अलग अलग समाधान सभी चार नंबर का उपयोग कर और आधुनिक (द्वारा उत्पादित वास्तव में %): %3479, %5679और %5789।

— सिंह
स्रोत

25

@ T @xCräftîñg वास्तव में यह नहीं है, एक सेट एक अनियंत्रित संग्रह है।

— सिंह

2

@ T @xCräftîñg https://repl.it/El9V/0 कोर्स सेट तत्वों का ट्रैक रखने के लिए एक आंतरिक छँटाई का उपयोग करता है, मुद्दा यह है कि आप इस छँटाई पर भरोसा नहीं कर सकते हैं, क्योंकि आवश्यक रूप से आइटम आप क्रम में क्रमबद्ध नहीं हैं उनसे उम्मीद करें

— सिंह

1

@TuukkaX मैं देखता हूं कि यह अप्रत्याशित व्यवहार है और इससे हल करने की तुलना में अधिक समस्याएं होती हैं, इसलिए मैंने इसे संपादित किया। असुविधा के लिए खेद है :)

— सिंह

1

@ hBy2Py यदि आप दो पुनरावृत्तियों के बीच सेट पर कोई अन्य ऑपरेशन नहीं करते हैं, तो मुझे लगता है कि आप मान सकते हैं कि दो पुनरावृत्तियाँ एक ही क्रम का पालन करेंगी। सामान्य मामले में, हालांकि, नियम यह है कि सेट अनियोजित संग्रह हैं, इसलिए आपको कभी भी उन पर किसी भी तरह का आदेश नहीं देना चाहिए।

— सिंह राशि

3

@ लिओ समझे: सेट नाइट्रोग्लिसरीन हैं। उचित रूप से स्थिर जब तक आप उन्हें टक्कर नहीं देते।

— hBy2Py 18

23

जावा 8, 2 4 नंबर

n->12  // returns 12
n->21  // returns 21
n1->2  // returns 2
n2->1  // returns 1

एक जावा जवाब की उम्मीद नहीं थी, क्या आप थे?

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

वास्तव में उत्तर में सुधार हुआ, टिप्पणी से कुछ मदद के लिए धन्यवाद! यह नहीं देखा कि 0 मान्य नहीं था, और यह भूल गए कि चर, y'know, एक से अधिक वर्ण हो सकते हैं। हमें 4 मिले हैं!

एक भी बदतर समाधान

()->1

लेकिन, चमकदार पक्ष पर, जावा में दो अद्वितीय उत्तर!

— Xanderhall
स्रोत

2

क्या जावा में REPL है? हो सकता है कि आप इस तरह से और अधिक प्रतीकों का उपयोग कर सकते हैं

— आर्टोरो टॉरेस सैंचेज़

मुझे पता नहीं है। मैं ना कहने के लिए इच्छुक हूं। इसके अलावा, मेरा जवाब मूल रूप से अन्य REPL जवाबों का

— नकल

3

जावा 9 में एक वेनिला REPL होगा !! लेकिन अब हम तीसरे पक्ष के सामान के साथ फंस गए हैं ।

— NonlinearFruit

17

मुझे लगता है कि आप बेहतर कर सकते हैं n->12। : यह आप चार अलग जवाब है कि सभी सीमा के भीतर हैं देता है n->12, n->21, n1->2, n2->1।

2

जावा 9 और इसकी आरईपीएल आज एक प्रारंभिक पहुंच संस्करण में उपलब्ध हैं। वास्तव में, मैंने इसका उपयोग करते हुए अन्य सवालों के जवाब यहां प्रस्तुत किए हैं।

— डेविड कॉनरैड

18

जेली, 26 30 32 नंबर

‘’3²Ḥ

यह (और इसके विपर्यय) पूर्ण कार्यक्रम हैं, जो कोई इनपुट नहीं लेते हैं, और मानक आउटपुट पर आउटपुट का उत्पादन करते हैं।

120 कार्यक्रमों से आउटपुट हैं, इस क्रम में जेली उन्हें उत्पन्न करता है यदि आप इसे कार्यक्रम के क्रमपरिवर्तन उत्पन्न करने के लिए कहते हैं:

018 036 06 03 09 03 18 116 116 117 125 135 06 03 14 15 13 22 19 13 24
28 33 42 018 036 06 03 09 03 -132 -164 -120 -119 -149 -137 26 43 18 17 
33 24 -19 13 -216 -210 53 44 18 36 30 31 49 63 18 36 10 9 25 17 18 19
18 17 18 18 36 48 36 26 36 36 06 03 14 15 13 22 06 03 -18 -17 -13 -24
06 07 06 05 06 06 03 12 03 -14 03 03 09 03 14 18 03 12 09 03 -116 -110 
23 14 09 015 09 05 09 09 03 12 03 -14 03 03

यदि आप यूनिक आउटपुट को संख्यात्मक क्रम में लेते हैं, तो आपको मिलता है:

-216 -210 -164 -149 -137 -132 -120 -119 -116 -110 -24 -19 -18 -17 -14 -13
03 05 06 07 09 10 12 13 14 15 17 018 19 22 23 24 25 26 28 30 31 33 036 42
43 44 48 49 53 63 116 117 125 135

इनमें से कई बहुत छोटे हैं, और 135 बहुत बड़े हैं, लेकिन अभी भी 32 हैं जो सीमा में हैं।

मूल विचार ज्यादातर मौद्रिक निर्देशों का उपयोग करना है (केवल मोनड्स और निलाड्स के साथ एक कार्यक्रम में, ये प्रत्येक बस पिछले आउटपुट को बदलते हैं), और वे जो मूल्य को जल्दी से हटाने की अनुमति देते हैं। अपवाद के साथ है 3, जो एक निलाद (स्थिर मान 3) है। यदि यह प्रोग्राम के प्रारंभ में दिखाई देता है, तो सभी ऑपरेशन 3 से हो जाएंगे। यदि यह बीच में दिखाई देता है, तो यह प्रोग्राम को दो हिस्सों में विभाजित करता है, जिनमें से प्रत्येक पूर्णांक को आउटपुट करता है (और जैसा कि वे प्रत्येक मानक आउटपुट पर प्रिंट करते हैं, परिणाम समाप्‍त होते जा रहे हैं, इस प्रकार हमें "समरूप" बनाने के लिए एक अतिरिक्त ऑपरेशन के रूप में संख्याओं को उत्पन्न करना है)।

हमारे पास जो ऑपरेशन हैं, इस संदर्भ में कार्यक्रम उन्हें उत्पन्न करता है, वे हैं: वेतन वृद्धि; घटती; निरंतर 3; वर्ग; और डबल। वृद्धि और गिरावट दुर्भाग्य से विपरीत हैं, और पहले सेक्शन में -1 या -2 का उत्पादन करने की दुर्भाग्यपूर्ण प्रवृत्ति है (इस प्रकार एक नकारात्मक संख्या के लिए अग्रणी), लेकिन इसने अभी भी अन्य आउटपुट की तुलना में अधिक प्रसार दिया, जो मैंने कोशिश की थी। । विशेष रूप से, हमें संख्या के पहले और दूसरे दोनों हिस्सों में बहुत अच्छा प्रसार मिलता है (ध्यान दें कि पहली छमाही शून्य स्ट्रिंग हो सकती है, अगर 3कार्यक्रम में पहला चरित्र है)।

@TuukkaX यह करता है, मैं दोनों monadic लागू किया Œ¿और dyadic œ¿(विकी के के तल के पास देखना परमाणुओं पेज ), लेकिन वे दोनों 2-बाइट dyads जो कोड क्रमपरिवर्तन ऐसा आप क्या चाहते हैं कम हो जाएगा रहे हैं, साथ ही आप आवश्यकता होगी आपके सभी इनपुट सूची के लिए ( 12सूची नहीं है)।

— जोनाथन एलन

16

जावास्क्रिप्ट, 27 नंबर

तुक्केका के उत्तर के समान , अंकों के एक और सेट के साथ।

5789%

27 अलग-अलग मूल्य हैं:

589 %   7 -> 1
987 %   5 -> 2
978 %   5 -> 3
879 %   5 -> 4
985 %   7 -> 5
958 %   7 -> 6
975 %   8 -> 7
 95 %  87 -> 8
  9 % 875 -> 9
 97 %  85 -> 12
 89 %  75 -> 14
 95 %  78 -> 17
 78 %  59 -> 19
 79 %  58 -> 21
 98 %  75 -> 23
 87 %  59 -> 28
 89 %  57 -> 32
 97 %  58 -> 39
 98 %  57 -> 41
 57 %  98 -> 57
 58 %  97 -> 58
 59 %  87 -> 59
 75 %  98 -> 75
 78 %  95 -> 78
 79 %  85 -> 79
 85 %  97 -> 85
 87 %  95 -> 87

— Arnauld
स्रोत

बिटवाइज़ का उपयोग करना, बिल्कुल ~भी मदद नहीं करेगा ? यह एक संचालन है जो उपयोगी हो सकता है।

— जॉलीजोकर 13

1

@JollyJoker खैर, सबसे अच्छा मैं अब तक के साथ मिल सकता है ~है 257&~, जो 11 अलग-अलग मान पैदा करता है।

— अरनौलद

मैं थोड़ा हैरान हूं, लेकिन मुझे लगता है कि मेरा अंतर्ज्ञान यहां बहुत अच्छा नहीं है।

— जॉलीजोकर 14

15

Brachylog , 26 नंबर

3+*^-

यह निम्न संख्याओं का आउटपुट देता है: [2,3,4,5,6,7,8,9,10,16,17,18,19,20,25,26,30,31,32,35,36,37,48,49,63,64]

व्याख्या

3 पूर्णांक 3 है, जाहिर है।
+ वेतन वृद्धि है
* डबल है
^ वर्ग है
- कमी है

ऐसी बहुत सी स्थितियाँ हैं जहाँ कार्यक्रम में केवल त्रुटियाँ हैं: उदाहरण के लिए *+^3-त्रुटियों क्योंकि यह पूछता है "ले 0, इसे दोगुना करें, वृद्धि, वर्ग, उस वर्ग का परिणाम 3 है, वेतन वृद्धि" जो स्पष्ट रूप से गलत है।

किसी भी कार्यक्रम के साथ समाप्त होता है 3या तो उत्पादन होगा3 काम नहीं ।

*3बग के कारण असीम रूप से लूप के साथ शुरू होने वाला कोई भी कार्यक्रम (ब्रेक्ग्लॉग सब्लिस्ट्स की एक सूची खोजने का प्रयास कर रहा है जो 3 में उत्पाद परिणाम जो संभव नहीं है)।

— Fatalize
स्रोत

1

गोल्फ के बारे में अच्छा जवाब और इदक कुछ भी लेकिन गणित पक्ष में आप केवल 3. 1,3,9,27 और 81 की पहली पांच शक्ति जोड़कर या घटाकर 121 तक कोई भी संख्या प्राप्त कर सकते हैं। आशा है कि मदद करता है।

— श्योस

11

विम, 16 नंबर

i1234

छाप

1, 2, 3, 4, 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43

— Sefa
स्रोत

1

@ymbirtt कहां 3और कहां गया 4? आपको सभी लंबाई -5 क्रमांक चाहिए।

— काडे

i1234प्रिंट "1234", क्या यह किसी प्रकार की स्क्रिप्ट या कीसे है? अगर यह keypresses यह काम नहीं करता है।

— कैप्टन मैन

@Captain Man's पॉइंट पर विस्तार करते हुए, स्क्रिप्ट के रूप में क्रमपरिवर्तन को चलाने का स्पष्ट तरीका: मानदंड के साथ होगा। यह 1-120 रेंज में किसी भी संख्या को प्रिंट नहीं करता है, हालांकि। क्या आपके पास एक और तरीका है?

— सिमोन

आप उन्हें वी के लिए ऑनलाइन दुभाषिया में रख सकते हैं जो विम के साथ कम या ज्यादा पीछे संगत है

— nmjcman101

4

@ nmjcman101 इस मामले में यह "ज्यादातर" के छेद में 12i34 के बाद से V के परिणाम में आता है, जिसमें 34 की 12 घटना होती है, जैसे कि यदि आप इसे vim में टाइप करते हैं तो यह आपको 34 देता है (मुझे लगता है कि V एक अंतिम esc है

— Sefa

11

IA-32 मशीन कोड, 8 नंबर

हेक्साडेसिमल बाइट मान:

2c 40 48 b0 c3

मान में लौटने वाले फ़ंक्शन के रूप में कोड चलाया जाता है al ।

मान्य क्रमपरिवर्तन:

b0 2c c3 xx xx => 2c (mov al, 2c)

b0 40 c3 xx xx => 40 (mov al, 40)

b0 48 c3 xx xx => 48 (mov al, 48)

b0 2c 40 c3 48 => 2d (mov al, 2c; inc eax)

b0 2c 48 c3 40 => 2b (mov al, 2c; dec eax)

b0 40 48 c3 2c => 3f (mov al, 40; dec eax)

b0 48 40 c3 2c => 49 (mov al, 48; inc eax)

b0 48 2c 40 c3 => 8 (mov al, 48; sub al, 40)

मैंने निम्नलिखित बाधाओं के साथ एक जानवर-बल खोज की:

पहला बाइट है b0- इनिशियलाइज़ करने के लिएal रजिस्टर
आखिरी बाइट है c3 - वापसी; निम्नलिखित बाइट्स को छोड़ दिया जाता है
संभावित opcode बाइट हैं:
- 0x04 - add
- 0x0c - or
- 0x24 - and
- 0x2c - sub
- 0x34 - xor
- 0xd4 - aad
- 0x40 - inc
- 0x48 - dec

यह अधिकतम 15 संभावित परिणामों के साथ केवल 3 परिवर्तनशील बाइट्स को छोड़ देता है। इनमें से, अधिकतम 9 अलग हो सकते हैं (वास्तव में, यह बाइट्स के केवल एक सेट के लिए होता है!)। मूल्यों में से एक सीमा से बाहर है, इसलिए यह 8 मान छोड़ता है। बाइट्स का एक और सेट है

34 40 48 b0 c3

जो 8 अलग-अलग मान भी देता है - कार्यक्रम समान हैं, केवल subप्रतिस्थापित के अलावाxor , जिनके , जो संभव आउटपुट के दो समान बनाता है।

बाइट्स के अन्य सभी सेट 7 या उससे कम संभावित परिणाम देते हैं।

— anatolyg
स्रोत

10

जेली , 33 नंबर

Ḥ23+c

Ḥडबल (बाएं);
2शाब्दिक 2;
3शाब्दिक 3;
+जोड़ें (बाएं, दाएं); तथा
c (बाएं, दाएं) चुनें, यानी बाईं वस्तुओं के संग्रह से सही वस्तुओं को चुनने के तरीकों की संख्या।

एक उदाहरण कार्यक्रम के साथ उपज संख्या:

 1 +32Ḥc   18 3Ḥc2+    45 2+3Ḥc
 2 c3Ḥ+2   20 2+Ḥc3    47 23c+Ḥ
 3 c2Ḥ+3   21 2Ḥ+3c    48 c+23Ḥ
 4 +2Ḥc3   22 3Ḥc+2    53 2c+Ḥ3
 5 2+3cḤ   23 23cḤ+    56 3Ḥ+2c
 6 3c+2Ḥ   24 cḤ+23    63 c+2Ḥ3
 8 2c+3Ḥ   30 3+c2Ḥ    65 32c+Ḥ
 9 3c2+Ḥ   32 32cḤ+    66 c+32Ḥ
12 +3cḤ2   33 cḤ+32    72 3c+Ḥ2
13 +2cḤ3   36 3+Ḥc2    82 c+3Ḥ2
15 +3Ḥc2   42 cḤ3+2   120 3+2Ḥc

मैंने लोगों को पार्स करने के लिए आसान चुनने की कोशिश की, लेकिन कुछ लोग पार्स के लिए दुर्लभ और थोड़ा अजीब हैं, उदाहरण के 23लिए:

23cḤ+: (23 c (2 * 23)) + 23 = (23 c 46) + 23 = 0 + 23 = 23

... और 72और 13अंतर्निहित मुद्रण का उपयोग करें:

3c+Ḥ2: z = (3 c 0) + (3 * 2); print(z); z = 2; print(z)
       z =    1    +    6   ; print(z); z = 2; print(z)

+2cḤ3: z = (0 + 2) c (2 * 0); print(z); z = 3; print(z)
       z =    2    c    0   ; print(z); z = 3; print(z)
       z =         1        ; print(z); z = 3; print(z)

ध्यान दें कि में अद्वितीय मूल्य Ḥ34+cभी पैदा करता 33है [1,120]।

— जोनाथन एलन
स्रोत

10

मस्तिष्क-फलक १

(())#

ब्रेन-फ्लैक को संतुलित ब्रेस की आवश्यकता होती है, इसलिए 5 वर्ण कार्यक्रम केवल तभी मान्य होता है जब कोई पात्र टिप्पणी शुरू करता है। यह हमें 4 पात्रों के साथ काम करने के लिए छोड़ देता है। उन में से, 2 को होना चाहिए (और )अन्यथा कुछ भी ढेर पर धकेल नहीं दिया जाएगा। उन लोगों को अंतिम और टिप्पणी के साथ पहले और चौथे स्थान पर जाना होगा (..)#। अब हम डाल सकते हैं (), {}, <>, या []अंदर। {}, <>और []प्रत्येक 0 का मूल्यांकन करता है, लेकिन ()1. इसका मतलब है कि (())#केवल 5 वर्ण स्ट्रिंग है जो एक मान्य ब्रेन-फ्लैक प्रोग्राम का उत्पादन करता है।

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

यदि प्रश्न " 6 सबसे शक्तिशाली अक्षर क्या हैं" के बजाय थे , तो इसका उत्तर यह होगा (){}[]कि ब्रेन-फ्लैक केवल "सबसेट" का उपयोग करते हुए पूरा हो रहा है।

— रिले
स्रोत

एक खराब प्रलेखित सुविधा: @ijडिबग ध्वज प्रोग्राम को रोक देता है और उपयोगकर्ता को मस्तिष्क-फ्लैक कोड को इनपुट करने की अनुमति देता है जहां @ijध्वज कोड में दिखाई देता है। बहुत शक्तिशाली लेकिन दुर्भाग्य से उपयोगकर्ता इनपुट की आवश्यकता है और इसलिए यहां उपयोगी नहीं है।

— 0 '

थोड़ा सुधार: (){}[]स्कोर होगा 0. आप क्रमपरिवर्तन नियम भूल गए?)

— कैलकुलेटरफनल

8

हेक्सागोनी , 13 संख्या

)24!@

इनमें से प्रत्येक के लिए एक संभावित कार्यक्रम के साथ 13 मुद्रण योग्य संख्याएं हैं:

)!@24 1
2!@)4 2
2)!@4 3
4!@)2 4
4)!@2 5
)2!@4 12
)4!@2 14
24!@) 24
24)!@ 25
2)4!@ 34
42!@) 42
42)!@ 43
4)2!@ 52

कार्यक्रम काफी आत्म-व्याख्यात्मक होने चाहिए। @कार्यक्रम को समाप्त करता है, !वर्तमान मूल्य को प्रिंट करता है, )इसे बढ़ाता है, 2और 4खुद को वर्तमान मूल्य से जोड़ता है (जहां प्रारंभिक मूल्य है)0 ) । स्रोत कोड का वास्तविक हेक्सागोनल लेआउट यहां अप्रासंगिक है, कार्यक्रमों को बस बाएं से दाएं पढ़ा जा सकता है।

यह इष्टतम होना चाहिए, हालांकि इसके बजाय 2और 4आप किसी भी जोड़ी अंक xऔर yऐसे चुन सकते हैं2 ≤ x ≤ y-2 ।

उपरोक्त समाधान (लगभग संपूर्ण) क्रूर बल द्वारा पाया गया था, जिसमें से एक की आवश्यकता थी !(अन्यथा यह कुछ भी प्रिंट नहीं करेगा), एक @(अन्यथा कार्यक्रम समाप्त नहीं होगा), और शेष तीन पात्रों को किसी भी (दोहराया) संयोजन से भरना। वर्णों के निम्नलिखित सेट:

#[]\/_|<>)!0123456789$

मैं यह नहीं देख सकता कि कोई भी अन्य कमांड संभवतः अधिक विविधता कैसे उत्पन्न कर सकता है।

— मार्टिन एंडर
स्रोत

मैं एक भूलभुलैया उत्तर के रूप में अच्छी तरह से पोस्ट करने जा रहा था, लेकिन सही समाधान का एक ही सेट वहाँ इष्टतम होने के साथ (प्रभावी रूप से एक ही शब्दार्थ, भी) प्रतीत होता है।

— मार्टिन एंडर

7

पर्ल, 27 नंबर

3479%

पर्ल में एक अंतर्निहित REPL नहीं है, इसलिए आप Devel :: REPLre.pl से उपयोग कर सकते हैं ।

परिणाम:

%9743 -> N/A
9%743 -> 9
97%43 -> 11
974%3 -> 2
9743% -> N/A
%7943 -> N/A
7%943 -> 7
79%43 -> 36
794%3 -> 2
7943% -> N/A
%7493 -> N/A
7%493 -> 7
74%93 -> 74
749%3 -> 2
7493% -> N/A
%7439 -> N/A
7%439 -> 7
74%39 -> 35
743%9 -> 5
7439% -> N/A
%9473 -> N/A
9%473 -> 9
94%73 -> 21
947%3 -> 2
9473% -> N/A
%4973 -> N/A
4%973 -> 4
49%73 -> 49
497%3 -> 2
4973% -> N/A
%4793 -> N/A
4%793 -> 4
47%93 -> 47
479%3 -> 2
4793% -> N/A
%4739 -> N/A
4%739 -> 4
47%39 -> 8
473%9 -> 5
4739% -> N/A
%9437 -> N/A
9%437 -> 9
94%37 -> 20
943%7 -> 5
9437% -> N/A
%4937 -> N/A
4%937 -> 4
49%37 -> 12
493%7 -> 3
4937% -> N/A
%4397 -> N/A
4%397 -> 4
43%97 -> 43
439%7 -> 5
4397% -> N/A
%4379 -> N/A
4%379 -> 4
43%79 -> 43
437%9 -> 5
4379% -> N/A
%9734 -> N/A
9%734 -> 9
97%34 -> 29
973%4 -> 1
9734% -> N/A
%7934 -> N/A
7%934 -> 7
79%34 -> 11
793%4 -> 1
7934% -> N/A
%7394 -> N/A
7%394 -> 7
73%94 -> 73
739%4 -> 3
7394% -> N/A
%7349 -> N/A
7%349 -> 7
73%49 -> 24
734%9 -> 5
7349% -> N/A
%9374 -> N/A
9%374 -> 9
93%74 -> 19
937%4 -> 1
9374% -> N/A
%3974 -> N/A
3%974 -> 3
39%74 -> 39
397%4 -> 1
3974% -> N/A
%3794 -> N/A
3%794 -> 3
37%94 -> 37
379%4 -> 3
3794% -> N/A
%3749 -> N/A
3%749 -> 3
37%49 -> 37
374%9 -> 5
3749% -> N/A
%9347 -> N/A
9%347 -> 9
93%47 -> 46
934%7 -> 3
9347% -> N/A
%3947 -> N/A
3%947 -> 3
39%47 -> 39
394%7 -> 2
3947% -> N/A
%3497 -> N/A
3%497 -> 3
34%97 -> 34
349%7 -> 6
3497% -> N/A
%3479 -> N/A
3%479 -> 3
34%79 -> 34
347%9 -> 5
3479% -> N/A

निम्नलिखित प्रोग्राम का उपयोग करते हुए जानवर-मजबूर:

use strict;
use warnings 'all';
use 5.010;

use Algorithm::Combinatorics qw(combinations);
use Algorithm::Permute;
use Scalar::Util::Numeric qw(isint);

my @chars = ( 0..9, qw(+ - * / . ; ' " \ @ $ # ! % ^ & ( ) { } =) );
my $iter  = combinations(\@chars, 5);
my $max   = 0;
my @best;

while (my $combo = $iter->next) {
    my $count = count_valid([@$combo]);

    if ($count > $max) {
        $max  = $count;
        @best = @$combo;
    }
}

say "$max -> @best";

sub count_valid {
    my ($chars) = @_;

    my $iter = Algorithm::Permute->new($chars);
    my %results;

    while (my @perm = $iter->next) {
        no warnings;
        my $val = eval join '', @perm;
        use warnings 'all';

        $results{$val} = 1 if isint($val) && $val > 0 && $val <= 120;
    }

    return scalar keys %results;
}

— ThisSuitIsBlackNot
स्रोत

पर्ल वास्तव में एक अंतर्निहित आरईपीएल के बहुत करीब है। perl -de 1कुछ समय चलने का प्रयास करें । यह तकनीकी रूप से डिबगर को एक खाली प्रोग्राम पर खोलता है, लेकिन डीबगर का एक REPL- एक जैसे निर्माण होता है, दुर्भाग्य से, आपको p वास्तव में परिणाम प्रिंट करने के लिए प्रत्येक पंक्ति की शुरुआत में लिखना होगा ।

@ ais523 इसलिए मैंने इसका उल्लेख नहीं किया; आप केवल स्ट्रिंग टाइप नहीं कर सकते हैं और आउटपुट प्राप्त कर सकते हैं, जो आवश्यकताओं में से एक है।

— ThisSuitIsBlackNot

7

आर, 15 18 नंबर

एक बड़ी संख्या नहीं है, लेकिन यह सबसे अच्छा हो सकता है जो आर के साथ किया जा सकता है। मैंने अंकों 0..9, ऑपरेटरों + - * / ^और टिप्पणी चार के सभी संयोजनों की खोज की #, और निम्नलिखित आठ सभी आउटपुट 18 अद्वितीय पूर्णांक 1 और 120 के बीच।

-#146
-#157
-#237
-#238
-#256
-#267
-#278
-#378
-#467
-#568

एक उदाहरण के रूप में, आइए लेते हैं -#146। यहां 18 पूर्णांक हैं जिन्हें हम प्राप्त कर सकते हैं:

1#-46      = 1
6-4#1      = 2
4-1#6      = 3
4#-16      = 4
6-1#4      = 5
6#-14      = 6
14-6#      = 8
16-4#      = 12
14#-6      = 14
16#-4      = 16
41-6#      = 35
41#-6      = 41
46-1#      = 45
46#-1      = 46
61-4#      = 57
61#-4      = 61
64-1#      = 63
64#-1      = 64

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

allchars = c("1","2","3","4","5","6","7","8","9","0","+","-","*","/","^")
apply(gtools::combinations(n=15, r=5, v=allchars, repeats.allowed=TRUE),
      1,
      function(chars) {
        x = apply(apply(e1071::permutations(length(chars)), 
                        1,
                        function(i) chars[i]
                        ),
                  2,
                  paste, collapse=""
            )
        u = unique(x)
        o = as.numeric(unlist(sapply(u, function(i) eval(try(parse(t=i),TRUE)))))

        f = factor(unique(o[o<=120 & o>=1 & o%%1==0]))
        write(paste(nlevels(f), paste(chars, collapse="")), "datafile", append=TRUE)
      }
)

— rturnbull
स्रोत

आप कहते हैं कि यह बदसूरत कोड है ... मुझे लगता है कि यह सुंदर है! लागू करने के कई उपयोग मुझे विस्मित करने के लिए कभी नहीं रोकते हैं!

— सुमेर

6

अष्टक, १,

यह प्रतीकों पर एक bruteforce खोज का उपयोग करते हुए पाया गया था *+-/0123456789:;<\^|~%। लेकिन गणना करने में बहुत लंबा समय लगा ...

-139%

संभव आउटपुट:

1, 2, 3, 4, 6, 8, 9,13,16,19,22,31,38,39,88,91,92,93

— flawr
स्रोत

5

ऑक्टेव, 15 नंबर

ज्यादा डींग मारने के लिए नहीं, लेकिन यह सबसे अच्छा है जो मैं ऑक्टेव में पा सकता हूं:

124+%

यह नंबर देता है:

1    2    3    4    5    6   12   14   16   21   24   25   41   42   43

मुझे 16 भी मिले, लेकिन ऐसा लगता है कि यह सेफा के उत्तर के समान है ...

1234%

1    2    3    4   12   13   14   21   23   24   31   32   34   41   42   43

— स्टीवी ग्रिफिन
स्रोत

मेरे परीक्षणों के अनुसार, 0123456789+-*.%ऑक्टेव के लिए इष्टतम विकल्प है 139-%, जो 18 की एक सरणी का उत्पादन करता है 1 2 3 4 6 8 9 13 16 19 22 31 38 39 88 91 92 93:। तो आप एक और 3 नंबर हासिल कर सकते हैं :)

2

बहुत क्रूड ब्रूट-फोर्स जो मैंने 18-नंबर समाधान प्राप्त करने के लिए इस्तेमाल किया: pastebin.com/umckG0VS

2

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

— स्टेवि ग्रिफिन

4

PHP, 15 नंबर

1230\r

इस तथ्य का उपयोग करता है कि php अपने टैग वर्बटीम के बाहर कुछ भी प्रिंट करता है (इसका उपयोग किए बिना आप बिल्कुल कुछ ऐसा ही कर सकते हैं <?=1; )। इसके बजाय एक वास्तविक गाड़ी वापसी चरित्र का उपयोग करता है \r।

सृजित (क्रमबद्ध, हटाया गया प्रमुख 0s):

 1 1 2 2 3 3 10 10 12 12 12 12 13 13 13 13 20 20 21 21 21 21 23 23 23 23 30 30 31 31 31 31 32 32 32 32 102 102 103 103 120 120 123 123 123  123  130  130  132  132  132  132  201  201  203  203  210  210  213  213  213  213  230  230  231  231  231  231  301  301  302  302  310  310  312  312  312  312  320  320  321  321  321  321  1023  1023  1032  1032  1203  1203  1230  1230  1302  1302  1320  1320  2013  2013  2031  2031  2103  2103  2130  2130  2301  2301  2310  2310  3012  3012  3021  3021  3102  3102  3120  3120  3201  3201  3210  3210

जिनमें से मान्य अनन्य नंबर हैं:

1 2 3 10 12 13 20 21 23 30 31 32 102 103 120

— user59178
स्रोत

3

यह वास्तव में उन नंबरों को प्रिंट नहीं करता है। 12\r30प्रिंट 12\r30, टर्मिनल सिर्फ पहले दो वर्णों को अधिलेखित करता है।

— डेनिस

@ डेनिस यह कहने की तरह है कि किसी भी चुनौती में जिसे टेक्स्ट को अधिलेखित करने के लिए नियंत्रण वर्णों की तकनीक की आवश्यकता होती है, आउटपुट को अंत में नहीं देखा जाता है, लेकिन लिखित बाइट्स का योग। चूंकि \rप्रिंट करने योग्य नहीं है, इसलिए आउटपुट 12\r30है 30।

— बिल्ली

3

@ हमने वास्तव में मेटा पर इस पर चर्चा की है ; यदि नियंत्रण ASCII कला से संबंधित है, तो केवल नियंत्रण वर्णों का उपयोग करने की अनुमति है।

— डेनिस

4

क्यूबिक्स , 7 नंबर

"2)@O

इन नंबरों को आउटपुट करता है:

")O2@ ->  1
")2O@ ->  2
"2)O@ ->  3
2"O@) -> 41
)"O@2 -> 50
2"O)@ -> 64
2")O@ -> 65

इस चुनौती के लिए किसी भी मान्य क्यूबिक्स कार्यक्रम में Oएक पूर्णांक और आउटपुट के लिए एक होना चाहिए@ कार्यक्रम को समाप्त करने के लिए (क्यूबिक्स ने कभी भी "त्रुटियों" के बारे में नहीं सुना है)। यह हमें सबसे अधिक आउटपुट उत्पन्न करने के लिए चारों ओर खेलने के लिए 3 चार्ट देता है। इसके अलावा, क्यूबिक्स जिस तरह से एक क्यूब पर कोड की व्यवस्था करता है, उसके कारण पहला चर बेकार हो जाएगा जब तक कि दूसरों में से एक सीधा चार नहीं हो।

कई संख्याओं को उत्पन्न करने के लिए मैंने सबसे कुशल तरीका "स्टैक के लिए चार-कोड की एक स्ट्रिंग को पुश करने के लिए उपयोग किया है। सावधानीपूर्वक पुनर्व्यवस्था के साथ, हम अंतिम स्थान पर कई चार्ट फिट कर सकते हैं और बस उनके चार-कोड का उत्पादन कर सकते हैं। का उपयोग करके) शीर्ष आइटम को बढ़ाने के लिए, हम इन व्यवस्थाओं के कई से अतिरिक्त outputs बना सकते हैं।

उपयोग में दो बुनियादी कार्यक्रम प्रकार हैं। पहला यह है:

"2)O@

जिसका विस्तार होता है

  "
2 ) O @
  .

परिणामी कार्यक्रम 2स्टैक को धकेलता है, इसके साथ वेतन वृद्धि करता है ), आउटपुट देता है Oऔर साथ समाप्त होता है @।

दूसरा यह है:

2")O@

जिसका विस्तार होता है

  2
" ) O @
  .

जिसके परिणामस्वरूप कार्यक्रम के चार-कोड धक्का ), Oऔर @, साथ पिछले एक वृद्धि कर देता है ), साथ आउटपुट O, और साथ समाप्त हो जाता है @।

— ETHproductions
स्रोत

3

> <> , 6 नंबर

चैती पेलिकन के लिए धन्यवाद 2 नंबर दिया

1ln";

अद्वितीय संख्याओं का उत्पादन करता है [1, 4, 5, 49, 59, 108]

हमें nएक नंबर प्रिंट करना होगा।
ज़रुरत है; समाप्त करने की है।

यह हमारे साथ काम करने के लिए केवल 3 वर्ण छोड़ देता है।

कुछ अलग संयोजनों के साथ valueऔर 6 अद्वितीय मूल्यों का निर्माण करने की पुष्टि के operatorसाथ ", लेकिन मुझे इससे बेहतर कुछ नहीं मिला।

— Emigna
स्रोत

मैं इसे बाहर काम करने की कोशिश कर रहा हूँ, लेकिन यह केवल 4 नंबर का उत्पादन नहीं करता है? सीमा 1-120 नहीं 0-120 है?

— चैले पेलिकन

@ टीलेपेलिकन: सही है। मुझे यह काम से घर के रास्ते पर महसूस हुआ और इसे ठीक करने वाला था।

— एमिग्ना

मैंने कुछ और मछली कार्यक्रमों जैसे कि quines और hello world आदि में थोड़ा सा विचार किया और मुझे एक विचार आया। पात्रों का उपयोग करके कुछ इस तरह; 1 एन; + "एक त्वरित गणना से 6+ उत्पन्न करेगा (लूप सुविधा और हमारे लाभ के लिए तार का उपयोग करके) - 1 और संचालन के लिए विभिन्न मूल्यों के साथ जांच के लायक हो सकता है।

— पेलिकन

@Tealpelican: यह एक अच्छा विचार है।

— एमिग्ना

3

ग्रूवी, 10 नंबर

मैन JVM समाधान इसके लिए BAD हैं ... कौन जानता था?

1200+

का परिणाम:

[3, 10, 12, 17, 21, 30, 66, 80, 102, 120]

रुको क्या? यह कैसे 17 आप पूछते हैं?

20+10 is 30.
0120+ is invalid.
2+001 is 3.
201+0 is 201.
2+100 is 102.
0+012 is 10.
21+00 is 21.
02+01 is 3.
0210+ is invalid.
10+20 is 30.
200+1 is 201.
0+210 is 210.
1200+ is invalid.
0201+ is invalid.
+0021 is 17.
1+002 is 3.
210+0 is 210.
100+2 is 102.
010+2 is 10.
00+12 is 12.
20+01 is 21.
01+20 is 21.
0+120 is 120.
+0120 is 80.
0+021 is 17.
+1020 is 1020.
0012+ is invalid.
02+10 is 12.
102+0 is 102.
012+0 is 10.
+2100 is 2100.
12+00 is 12.
00+21 is 21.
+2001 is 2001.
+0210 is 136.
+1200 is 1200.
1020+ is invalid.
0102+ is invalid.
2001+ is invalid.
001+2 is 3.
+0012 is 10.
2+010 is 10.
0021+ is invalid.
10+02 is 12.
2100+ is invalid.
+0201 is 129.
2010+ is invalid.
020+1 is 17.
1002+ is invalid.
+2010 is 2010.
1+020 is 17.
1+200 is 201.
01+02 is 3.
+1002 is 1002.
120+0 is 120.
0+102 is 102.
+0102 is 66.
002+1 is 3.
0+201 is 201.
021+0 is 17.

व्यापार रहस्य, ग्रूवी / जावा पूर्णांक में 0 के साथ पहले वाले ऑक्टल्स हैं। कोड मैं Groovy जवाब परीक्षण के लिए इस्तेमाल किया किसी को मुझे हराना चाहता है:

("1200+" as List).permutations().collect{
    it.join()
}.collect {
    print "$it is "
    x=-1;
    try {
        x=Eval.me(it);
        println "$x."
    } catch(Exception e) {
        println "invalid."
    }
    x<=120?x:-1;
}.unique().sort();

— जादू ऑक्टोपस Urn
स्रोत

मुझे लगता है कि एक ही जवाब जावा के लिए भी काम करेगा।

— पाओलो एबरमन

3

MATL, 15 नंबर

0123%

% टिप्पणी ऑपरेटर है, इसलिए यह एक बार सभी संभावित स्थानों में "कट" जाएगा, दिए गए अंकों और सबसेट के सभी संभावित संयोजनों को बनाने में मदद करेगा:

— सेड्रिक रीचेनबैक
स्रोत

3

जे, 16 नंबर

1234]

कुछ भी नहीं फैंसी, बस परीक्षण किया 1234 सभी 1-चरित्र क्रियाओं के साथ गया जो उचित थे।]अपने सही तर्क का चयन करता है।

निर्मित अद्वितीय संख्याएं हैं

0 4 3 34 43 2 24 42 23 32 234 243 324 342 423 432 1 14 41 13 31 134 143 314 341 413 431 12 21 124 142 214 241 412 421 123 132 213 231 312 321 1234 1243 1324 1342 1423 1432 2134 2143 2314 2341 2413 2431 3124 3142 3214 3241 3412 3421 4123 4132 4213 4231 4312 4321

जिनमें से 16:

4 3 34 43 2 24 42 23 32 1 14 41 13 31 12 21

सीमा में हैं [1,120]।

के साथ परीक्षण किया गया

# (#~e.&(>:i.120)) ~. (". :: 0:)"1 (A.~ i.@!@#) '1234]'

— बोलस बूसियर
स्रोत

3

Japt , 41 संख्या

बहुत ज्यादा सिर्फ परीक्षण और त्रुटि इसलिए एक बेहतर समाधान हो सकता है। पूर्णांक 3और 4जाप शॉर्टकट्स का उपयोग स्क्वेरिंग, जोड़ने 1और गुणा करने के लिए करता है 2। सभी 120 कार्यक्रम एक पूर्णांक का उत्पादन करते हैं >0लेकिन केवल 78 हैं <=120और उनमें से केवल 41 अद्वितीय हैं।

34²ÄÑ

संख्या उत्पन्न करता है:

1,3,4,5,6,7,8,9,13,14,17,20,21,26,27,29,30,31,32,33,34,35,36,37,38,39,42,43,44,45,47,56,59,68,69,72,73,86,87,92,93

संख्याओं की सूची या मान्य कार्यक्रमों का संग्रह देखें

व्याख्या

जाप के बारे में ध्यान देने योग्य कुछ बातें जो यहाँ प्रासंगिक हैं:

यदि कोई प्रोग्राम (इस मामले में) अंकों में से एक के साथ शुरू नहीं होता है, तो पहला इनपुट चर है U, जो चूक करता है0 , स्वचालित रूप से शुरुआत में डाला जाता है,
यदि या तो या दोनों अंक एक गणितीय ऑपरेशन के लिए तुरंत एक शॉर्टकट का पालन करते हैं, तो उन्हें इसके लिए जोड़ा जाता है (जैसे 3Ä4 = 3+14 = 17और, इसी तरह 4Ñ² = 4*2**2 = 16), और,
यदि अंकों में से एक तुरंत ²तत्कालीन ²और उससे पहले की सभी चीजों का अनुसरण करता है, तो अनिवार्य रूप से नजरअंदाज कर दिया जाता है।

कार्यक्रम (निर्माण करने में कुछ के लिए स्पष्टीकरण 1, 3, 37और 93, क्रमशः):

²Ñ34Ä  :Square 0, multiply by 234 and add 1
4ÄÑ²3  :Add 1 multiplied by 2 squared to 4, ignore that and return the 3
3²Ä4Ñ  :Square 3 and add 14 multiplied by 2
4Ñ3Ä²  :Multiply 4 by 23 and add 1 squared

— झबरा
स्रोत

2

Befunge, 11 नंबर

Befunge थोड़ा सीमित है क्योंकि यह केवल सिंगल डिजिट के शाब्दिक समर्थन करता है। तो सबसे अच्छा मैं 11 नंबरों के साथ आ सकता था, यह मानते हुए कि गणना हमें एक और स्टैक पर केवल एक संख्या के साथ छोड़नी चाहिए।

सर्वश्रेष्ठ पात्र: 358*%

उत्पन्न संख्या: (प्रत्येक का एक उदाहरण)

58*3% => 1
358*% => 3
38*5% => 4
538*% => 5
35*8% => 7
835*% => 8
385%* => 9
583%* => 10
358%* => 15
53%8* => 16
35%8* => 24

— जेम्स होल्डरनेस
स्रोत

2

पायथन, 16 नंबर

1234#

सभी अनावश्यक नंबरों को कमेंट करने के लिए # का उपयोग करता है।

— OldBunny2800
स्रोत

2

डीसी, 19 नंबर

*3zO+

आउटपुट स्टैक के शीर्ष पर है, और त्रुटियों (स्टैक अंडरफ्लो सहित) की अनदेखी की जाती है। मान्य क्रमपरिवर्तन हैं:

+O3*z:   1
+O*3z:   2
+Oz3*:   3
O*z3+:   4
O*3z+:   5
+O3z*:   6
+z3*O:  10
3*zO+:  11
3*Oz+:  12
Oz3*+:  13
O3z*+:  16
+3Oz*:  20
3Oz*+:  23
+zO3*:  30
O3*z+:  31
Oz+3*:  33
3Oz+*:  36
Oz3+*:  40
O3z+*:  50
TOTAL COUNT = 19 numbers

यहाँ पायथन कार्यक्रम मैंने उन परिणामों को दिखाने के लिए इस्तेमाल किया है:

#!/usr/bin/python

import sys
import itertools
import subprocess

if len(sys.argv[1]) != 5:
    print("Invalid input")
    sys.exit(1)

devnull = open("/dev/null", 'w');

r = dict()
for s in itertools.permutations(sys.argv[1]):
    p = "".join(s)
    try:
        e = (subprocess.check_output(['dc', '-e', p, '-e', 'p'], stderr=devnull))
        e = int(e)
        if 0 < e <= 120:
            r[e] = p
    except e:
        pass

for i in sorted(r):
    print("%5s: %3d" % (r[i], i))

print("TOTAL COUNT = %d numbers" % len(r))

दो अन्य तार जो 19 के समान स्कोर देते हैं 32d+*और हैं *4zO+।

— टोबी स्पाईट
स्रोत

2

स्मालटाक, 26 नंबर

1235r

स्पष्टीकरण: 12r35 मूलांक 12 का उपयोग करने के लिए एक संकेतन है, और इस प्रकार 3 * 12 + 5 है।
यह चीख़ में सत्यापित किया जा सकता है:

((Array streamContents: [:s |
    '1235r'  permutationsDo: [:each | 
        | eval |
        eval := [Compiler evaluate: each] ifError: [nil].
        (eval isInteger and: [eval >=1 and: [eval <= 120]]) ifTrue: [s nextPut: each copy -> eval]]])
  collect: #value as: Set) sorted

देता है:

#(1 2 3 5 28 31 33 37 38 41 42 47 55 58 63 66 67 68 71 76 82 86 105 107 108 116)

यदि हम अंतिम पंक्ति को प्रतिस्थापित करते हैं:

    sorted: #value ascending)

हम तब भाव प्राप्त करते हैं:

'235r1' -> 1
'253r1' -> 1
'325r1' -> 1
'352r1' -> 1
'523r1' -> 1
'532r1' -> 1
'135r2' -> 2
'153r2' -> 2
'315r2' -> 2
'351r2' -> 2
'531r2' -> 2
'513r2' -> 2
'125r3' -> 3
'152r3' -> 3
'215r3' -> 3
'251r3' -> 3
'521r3' -> 3
'512r3' -> 3
'123r5' -> 5
'132r5' -> 5
'213r5' -> 5
'231r5' -> 5
'321r5' -> 5
'312r5' -> 5
'23r15' -> 28
'25r13' -> 28
'13r25' -> 31
'15r23' -> 33
'32r15' -> 37
'35r12' -> 37
'5r123' -> 38
'12r35' -> 41
'5r132' -> 42
'15r32' -> 47
'52r13' -> 55
'53r12' -> 55
'5r213' -> 58
'12r53' -> 63
'5r231' -> 66
'13r52' -> 67
'31r25' -> 67
'21r35' -> 68
'35r21' -> 71
'25r31' -> 76
'5r312' -> 82
'5r321' -> 86
'51r23' -> 105
'53r21' -> 107
'21r53' -> 108
'23r51' -> 116

मैं धोखा देना चाहता था और एक विधि r को पूर्णांक के रूप में परिभाषित करना चाहता था

Integer>>r
    ^self \\ 120 + 1

दुर्भाग्य से, संकलक 1235r पर चॉप करता है क्योंकि यह 1235 पर भेजे गए संदेश r के बजाय मूलांक के साथ एक अपूर्ण संख्या को पहचानता है ...
मैं आसानी से संकलक को भी बदल सकता था, लेकिन यह मेरे स्वाद के लिए थोड़ा सा धोखा है।

— aka.nice
स्रोत

1

गणितज्ञ, 16 संख्या

;1234

बहुत दिलचस्प नहीं है, लेकिन मैं अंकगणित का उपयोग करके कुछ भी बेहतर नहीं पा सकता हूं। केवल एक चीज जो काम कर सकती है वह है! है फैक्टोरियल या डबल फैक्टोरियल।

उपरोक्त 5 वर्णों से उत्पन्न होने वाली 16 संख्याएँ (श्रेणी में) हैं:

1, 2, 3, 4, 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43

— मार्टिन एंडर
स्रोत

क्यों नहीं, ६; not ९?

— डेविड जी स्टॉर्क

1

रूनिक एनकाउंटर, 19 नंबर

234p@

अनिवार्य रूप से 3 लीटर, पॉव ऑपरेटर, और "पूरे स्टैक को प्रिंट करें और समाप्त करें" कमांड। 234p@प्रिंट 812 (3 ^ 4 एक 2 के साथ समीपवर्ती)। पूर्ण क्रमांकन सूची , ध्यान दें कि प्रत्येक परिणाम के बीच एक नई लाइन उत्पन्न करने के लिए @प्रतिस्थापित किया गया है और यह सुनिश्चित करने के लिए जोड़ा गया है कि प्रत्येक पंक्ति स्वतंत्र रूप से निष्पादित होती है। यह भी ध्यान दें कि आउटपुट उसी क्रम में नहीं हैं जो प्रोग्राम उन्हें उत्पन्न करते हैं (जैसा कि कुछ प्रोग्राम अधिक तेज़ी से समाप्त हो सकते हैं)।ak@>

कई क्रमपरिवर्तन कुछ भी नहीं मुद्रित (जैसे। @234pया p234@), लेकिन 19 स्वीकार्य सीमा के भीतर उत्पादन में परिणाम है।

संख्या संभव (और एक संभावित कार्यक्रम जो इसमें परिणाम देता है; यह .दर्शाता है कि वे पद शेष वर्णों में से किसी भी हो सकते हैं क्योंकि इसे निष्पादित नहीं किया गया है):

2@...        2
3@...        3
4@...        4
23p@.        8
32p@.        9
42p@.       16
32@..       23
42@..       24
23@..       32
43@..       34
24@..       42
34@..       43
23p4@       48
32p4@       49
43p@.       64
34p@.       81
423p@       84
432p@       94

— Draco18s
स्रोत

1

TI-BASIC, 12 नंबर

23+4!

वहाँ एक बेहतर संयोजन होने की संभावना है, लेकिन मैं इसे खोजने में सक्षम नहीं था।

सब $24$ मान्य क्रमपरिवर्तन इस प्रकार हैं:

23+4!   -> 47
24+3!   -> 30
2+4!3   -> 74
2+3!4   -> 26
2!4+3   -> 11
2!+43   -> 45
2!+34   -> 36
2!3+4   -> 10
32+4!   -> 56
34+2!   -> 36
3+4!2   -> 51
3+2!4   -> 11
3!4+2   -> 26
3!+42   -> 48
3!+24   -> 30
3!2+4   -> 16
43+2!   -> 45
42+3!   -> 48
4+2!3   -> 10
4+3!2   -> 16
4!2+3   -> 51
4!+23   -> 47
4!+32   -> 56
4!3+2   -> 74

जिनमें से हैं $12$ अद्वितीय मूल्य:

$10,11,16,26,30,36,45,47,48,51,56,74$

— ताउ
स्रोत

आपकी भाषा के पाँच सबसे शक्तिशाली पात्र कौन से हैं?

टिप्पणियाँ

उदाहरण

पायथन 3, 21 27 मान

05AB1E , 27 38 41 नंबर

पायथन, 18 नंबर

जावा 8, 2 4 नंबर

एक भी बदतर समाधान

जेली, 26 30 32 नंबर

जावास्क्रिप्ट, 27 नंबर

Brachylog , 26 नंबर

व्याख्या

विम, 16 नंबर

IA-32 मशीन कोड, 8 नंबर

जेली , 33 नंबर

मस्तिष्क-फलक १

हेक्सागोनी , 13 संख्या

पर्ल, 27 नंबर

आर, 15 18 नंबर

अष्टक, १,

ऑक्टेव, 15 नंबर

PHP, 15 नंबर

क्यूबिक्स , 7 नंबर

> <> , 6 नंबर

ग्रूवी, 10 नंबर

MATL, 15 नंबर

जे, 16 नंबर

Japt , 41 संख्या

व्याख्या

Befunge, 11 नंबर

पायथन, 16 नंबर

डीसी, 19 नंबर

स्मालटाक, 26 नंबर

गणितज्ञ, 16 संख्या

रूनिक एनकाउंटर, 19 नंबर

TI-BASIC, 12 नंबर