स्रोत कोड को खोलना [क्रैकिंग प्रयासों के लिए डाकू धागा]

44

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

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

सबसे अधिक अंक (सफल दरार) के साथ डाकू जीतता है।

लीडरबोर्ड

बहुत सारे हल

20 हल

15 हल

10 हल

7 हल

5 हल

4 हल

3 हल

2 हल

1 हल

cops-and-robbers 
— PhiNotPi
स्रोत
1
पर्ल 5, आकार 27, मोरोट द्वारा - प्रिंट'पिन '= ~ tr (a-za) (z-z) r
@ WumpusQ.Wumbley हम सब वहाँ रहे हैं ...;)
— मार्टिन
3
मैं इसे तुष्ट करने के प्रयास में अपना समय बर्बाद करने से इनकार करता हूं।
दो प्रश्न निकायों को देखते हुए, ऐसा प्रतीत होता है कि तले हुए / असंबद्ध उत्तर उलट दिए गए हैं
— Mooing Duck
रूबी, मेगाटॉम द्वारा 23 = p% ++। तरीके [80] [1 ..- 1]
— histocrat

जवाबों:

32

CJam, आकार 20, मार्टिन ब्यूटनर द्वारा

Hi "petStorm!", mame

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

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

Hi                      "           int(17)                     ";
   "petStorm!",         "                    len('petStorm!')   ";
                ma      "     atan2(       ,                 )  ";
                  me    " exp(                                ) ";
                        " exp(atan2(int(17), len('petStorm!'))) ";

कोड क्रैक करना

वांछित आउटपुट, 2.956177636986737एक डबल या एक डबल है जिसके बाद एक लॉन्ग होता है।

केवल पात्रों का उपयोग करते हुए "Stop, Hammer time!", चार बिल्टइन ऑपरेटर होते हैं जो गैर-पूर्णांक डबल्स लौटाते हैं:

  • mS, जो है asin
  • ma, जो है atan2
  • me, जो है exp
  • mt, जो है tan

उन सभी में एक है m, इसलिए हम उनमें से अधिकतम तीन पर उपयोग कर सकते हैं। एक Sऔर एक ही है a।

उन सभी ऑपरेटरों को इनपुट की आवश्यकता होती है, और maकेवल एक ही है जो दो इनपुट का उपभोग करता है। हमारे पास केवल तीन तरीके हैं:

  • "...",, जो स्ट्रिंग की लंबाई को बढ़ाता है (कड़ाई से 18 से कम)।
  • H, जो 17 को धक्का देता है।
  • ...!, जो तार्किक नहीं की ओर धकेलता है ...।

हमारे पास किसी भी तरह के झूठे को आगे बढ़ाने का कोई तरीका नहीं है ..., इसलिए अंतिम विकल्प हमेशा 0 को धक्का देगा।

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

यह मानते हुए, कोड को निम्नलिखित श्रेणियों में से एक में गिरना है:

  • <Long> <mS|me|mt>{1,3}
  • <Long> <mS|me|mt>{x} <Long> <mS|me|mt>{y} ma <mS|me|mt>{z}।
  • उपरोक्त में से कोई, किसी कास्ट के साथ लॉन्ग ( i) या गोलाई ( mo) में डबल पर लागू होता है।

दूसरे मामले में, x + y + zया तो 1 या 2 है और लोंग्स में से एक 0 या 17 है।

बाकी मूल रूप से पाशविक बल था। कुछ कोशिशों के बाद,

18 , {H \ ma me 2.956177636986737 =} =

वापस 9, जिसका अर्थ है

H 9 ma me

वांछित उत्पादन करता है।

जो कुछ बचा है वह स्ट्रिंग से सभी लेकिन 9 अक्षरों को खत्म करना है। रिक्त स्थान नोज हैं और iलोंग्स पर एक नोक है, इसलिए "petStorm!"संभावित विकल्पों में से एक है।

— डेनिस
स्रोत
1
वह पागल है - आपने यह कैसे पता लगाया कि संख्या क्या थी?
— Sp3000
1
मैंने उस संख्या का लघुगणक (और अन्य) खोजा, लेकिन कोई परिणाम नहीं मिला। अब मैंने पाया कि मैं बहुत उच्च परिशुद्धता का उपयोग कर रहा था।
— jimmy23013
2
@ Sp3000: मैंने अपना उत्तर संपादित कर लिया है।
— डेनिस
1
बहुत अच्छा! मुझे लगता है कि मुझे लगता है कि स्ट्रिंग से दो और पात्रों को निकालना चाहिए। मेरे मूल में वास्तव में स्ट्रिंग के अंदर रिक्त स्थान था, लेकिन mrलंबाई लेने से पहले। ऐसा नहीं है कि आपने कुछ बिंदु पर यह पता नहीं लगाया होगा। ;)
— मार्टिन एंडर
25

अजगर 3, आकार 12, xnor द्वारा

()and bciprt

कुछ भी नहीं करता है (अभिव्यक्ति एक खाली टपल पैदा करता है, जो मुद्रित नहीं है)। यह शॉर्ट-सर्किट मूल्यांकन के कारण काम करता है।

— matsjoyce
स्रोत
1
पायथन 3 IDLE में, यह आउटपुट करता है ()।
— होशो 250250
@ hosch250 एक प्रोग्राम (एक अजगर फ़ाइल) में इसके बाद से, कुछ भी आउटपुट नहीं है, क्योंकि वहाँ कोई नहीं है print।
— मैटसॉयज
समझा। मैं कमांड लाइन की बात से भाग रहा था।
— होशो 250250
47
.... "बात" ....
— TheDoctor
4
@ लघु-संचलन के कारण - पाइथन टुपल को लोड करता है और जाँचता है कि क्या टपल का मूल्य सही है, क्योंकि यह खाली है, यह गलत है। चर को लोड करने का कोड bciprtकभी निष्पादित नहीं होता है, इसलिए यह कभी भी NameError नहीं बनाता है।
— Mateon1
20

अजगर, आकार 74, xnor द्वारा

any(print(set is
set)for i in oct(chr is
map))and aeeeeeggiilnnpprrrrrstvw

अच्छा यह मजा था। सुझाव / मदद के लिए FryAmTheEggman, hosch250 और isaacg का धन्यवाद।

— Sp3000
स्रोत
1
अच्छी नौकरी! मेरा समाधान काफी समान था list(\nprint(range is range)for aacdeeeeehmppprrrrssvwy in\noct(int is int)):।
— xnor
@xnor LOL वह परिवर्तनशील नाम। क्या यह बुरा है कि मैंने ऐसा कभी नहीं सोचा होगा? : P
— FryAmTheEggman
2
@FryAmTheEggman मुझे लगता है कि हर कोई मुझे अपने पहले पुलिस वाले से चाल का उपयोग करने की उम्मीद कर रहा था ।
— xnor
@FryAmTheEggman चिंता न करें, आप केवल एक ही नहीं हैं: P
— Sp3000
13

पाइबॉन 2, आकार 50, जियोबिट्स द्वारा

print 2**2**2*2**2-22-2**2**2**2/2**2**2**2**2/2/2

आउटपुट 42।

— Ypnypn
स्रोत
1
एक बिंदु है :) संदर्भ के लिए, मूल था print 2**2**2**2/2**2**2/2**2**2/2-2**2**2*2**2-22, लेकिन यह बिल्कुल आश्चर्यजनक नहीं है कि एक से अधिक विकल्प सही हैं।
— जियोबिट्स
13

पीटर टेलर द्वारा गोल्फस्क्रिप्ट, आकार 13

,22,{.4&?+.}/

इसका परीक्षण यहां करें।

एक और, कि मैं केवल sp3000 से बड़ी मदद से फटा। धन्यवाद!

तो यहाँ है कि हम वहाँ कैसे पहुंचे। Sp3000 ने आउटपुट में लगातार संख्याओं के रनों का एक गुच्छा देखा:

1,2,3,4,[2608852181],4582,4583,4584,4585,4586,[253225388392299],
142924,142925,142926,142927,142928,[302928],497409,497409

इसके आधार पर हमने यह धारणा बनाई, कि यह एक बढ़ता हुआ क्रम था, जिसने केवल शेष संख्याओं के संभावित विभाजन के लिए अनुमति दी थी:

1,2,3,4,260,885,2181,4582,4583,4584,4585,4586,25322,53883,92299,
142924,142925,142926,142927,142928,302928,497409,497409

वह 23 नंबर है, जो 22 बार ब्लॉक को दोहराने के लिए एक मजबूत संकेतक था, साथ ही ब्लॉक .(डुप्लिकेट टॉप स्टैक एलिमेंट) के साथ समाप्त होता है , जैसे कि पिछला परिणाम स्टैक पर पीछे छूट गया और इस तरह कि अंतिम पुनरावृत्ति दिखाई देगी दो बार स्टैक। वह है 22,{____.}/।

अब अंतराल को देखते हुए, वे 4 शक्तियां बन जाते हैं (जो अच्छा है, क्योंकि हमारे पास है 4और ?)। अधिक सटीक रूप से, वे वर्तमान संख्या के सूचकांक की चौथी शक्ति हैं। इसके बाद हमने देखा कि किन सूचकांकों ने अंतर पैदा किया:

4,5,6,7, 12,13,14,15, 20,21,..?

बाइनरी में वे हैं

00100
00101
00110
00111
01100
01101
01110
01111
10100
10101

उन सभी के पास तीसरा बिट सेट है, जिसका अर्थ है कि सूचकांक शायद बिटवाइज़-एंडेड है 4(जो फिर से अच्छा है, क्योंकि हम दूसरे के 4साथ बना सकते हैं और .एक है &)। यह विशेष रूप से अच्छी तरह से काम करता है, क्योंकि इस ऑपरेशन का परिणाम 0या तो होता है 4, और अगर हम इसका उपयोग करते हैं कि घातांक के रूप में हमें 1या तो एक या चौथी शक्ति मिलती है, जो कि ठीक उसी तरह है जो हमें चाहिए। तो आइए डालते हैं एक साथ:

22,{.4&?+.}/

यहाँ है कि ब्लॉक क्या करता है:

.      # Duplicate current index
 4     # Push a 4
  &    # Bitwise and
   ?   # Raise index to resulting power
    +  # Add to previous result
     . # Duplicate for use in next iteration

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

— मार्टिन एंडर
स्रोत
सटीक। यह OEIS में एक अनुक्रम से प्रेरित था जो अब मुझे नहीं मिल सकता है।
— पीटर टेलर
3
और यही कारण है कि लुटेरों के लिए एक अलग धागा रखना एक अच्छा विचार है। अच्छी नौकरी!
— डेनिस
11

रूबी, आकार 17, Doorknob द्वारा

p 2,%r~n~i=~'*tN'

वो बड़ा मजेदार था। इस के साथ मेरी मदद करने के लिए Sp3000 को धन्यवाद! और मैंने सीखा है कि %r?...?शाब्दिक किसी भी सीमांकक हो सकते हैं। :)

— मार्टिन एंडर
स्रोत
10
Doorknob के लिए insanely भ्रामक होने के लिए print, केवल इसे pमुद्रण के लिए, %rregexes के लिए और iकेस-असंवेदनशील rexx मिलान के लिए विभाजित करता है ।
— Sp3000
11

PHP, आकार 49, bwoebi द्वारा

print@substr(new exception,+~$$a+=++$$m+$$i+2+n);

वह बिल्कुल मानसिक था ।

यह मिल गया

print@substr(new exception,);

काफी जल्दी, जिस बिंदु पर मुझे कुछ चाहिए था जो -6अल्पविराम के बाद देता है , $++$++$++$+=$~main$2छोड़ दिया है।

मुख्य पकड़ वह है $a, $mऔर $iसभी हैं NULL, इसलिए उन्हें अप्रत्यक्ष रूप से चर चर में उपयोग करते हुए , इसका मतलब है कि वे सभी एक ही चर की ओर इशारा करते हैं। हालाँकि, PHP चर चर को हल करने के बारे में कुछ अजीब बातें कर रहा है। सामान्य चर के साथ आप जैसे काम कर सकते हैं

echo $a+$a=2;

जो प्रिंट 4( 2को सौंपा गया है $aऔर फिर खुद को जोड़ा गया है)। लेकिन अगर मैं चर चर के साथ भी ऐसा ही करता हूं:

echo $$a+$$a=2;

मुझे मिलता है 2, क्योंकि अब $$aपहले असाइनमेंट से पहले मूल्यांकन किया जाता है।

अंत में मैंने आरएचएस पर कुछ वेतन वृद्धि को लागू करने के लिए कुछ आदेश देने में कामयाबी हासिल की, +=जिसमें उस अतिरिक्त-असाइनमेंट से पहले मूल्यांकन किया जाना था। इस तरह मुझे वह मिल गया 5जिसे मैं बस थोड़ा-सा पूरक बना सकता था। फिर भी ... कुछ रहस्यमय चीजें चल रही हैं, और मुझे पता नहीं है कि मैंने जिन चीजों की कोशिश की उनमें से आधे काम क्यों नहीं किए।

— मार्टिन एंडर
स्रोत
संदर्भ के लिए, मेरा मूल:print@substr(new exception,~$$mn+=2+$$a+++$$i++);
— bwoebi
Btw। मुझे उम्मीद है कि सभी डॉलर के संकेत और तथ्य यह है कि mainस्ट्रिंग के लिए सभी पत्र आपको बहुत गुमराह कर रहे थे। इसके अलावा, निकालने के लिए एक असामान्य तरीका है {main}, मुझे लगता है ;-)
— bwoebi
@bwoebi स्पॉटिंग के mainबाद exception, newऔर substr। मुझे लगा कि वे केवल चर नाम होंगे। मुझे चर चर का उपयोग करने के लिए थोड़ा सा समय लगा और जितना मैंने संचालन के कुछ आदेश का पता लगाने में अधिकांश समय बिताया, वह वास्तव में एक उपज होगी 5जो मैं दूसरे कोष्ठक के सेट का उपयोग किए बिना पूरक कर सकता था।
— मार्टिन एंडर
खैर, अगली बार, अगर वर्णों की तुलना में अधिक डॉलर हैं, तो यह आमतौर पर चर चर होते हैं। (इस मामले में मैंने बाएं-से-दाएं मूल्यांकन के लिए बल देने के लिए varvars का दुरुपयोग किया।) आपको नए अपवाद को स्पॉट करने में कितना समय लगा? इसके अलावा, मेरे पास Zend इंजन का गहरा ज्ञान है, इसलिए मैं अपने आप को पूरी तरह समझा सकता हूं कि चीजों का मूल्यांकन किस क्रम में किया जाता है और इन चुनौतियों के लिए अच्छा है;; यदि कोई विशिष्ट चीज आपको नहीं मिलती है, तो मैं ' खुशी से आपको यह समझाता हूँ।
— बोवेबी
@bwoebi कल चैट में आओ , और हम इसके बारे में बात कर सकते हैं, लेकिन मैंने आज इस पर काफी लंबा समय बिताया है। ;) के रूप में अपने पहले सवाल के लिए, exceptionस्पष्ट था, जो आवारा पात्रों के लिए छोड़ दिया substrऔर newचारों ओर झूठ बोल रही है। यह वस्तुतः पहली चीज थी जिसे मैंने देखा जब इस पर काम करना शुरू किया।
— मार्टिन एंडर
9

रूबी, आकार 38, डॉर्कनोब द्वारा

[$><<(!$pece60).to_s[rand($win)].succ]

मुझे पूरा यकीन है कि यह मूल स्रोत के पास कहीं नहीं है। यह उपयोग करने के बावजूद नियतात्मक है rand।

यहाँ है कि यह कैसे काम करता है। $><<बस उत्पादन है। $pece60और $winअपरिभाषित वैश्विक चर हैं, जो इसलिए बस हैं nil(और उन्होंने मुझे कुछ बाहरी पात्रों से छुटकारा पाने की अनुमति दी)। !$pece60बनाता है trueऔर to_sस्ट्रिंग देता है "true"।

उम्र के लिए, मैंने वहां पहुंचने 2या वहां -2पहुंचने का प्रयास uकिया, लेकिन तब मुझे एहसास हुआ कि मैं इसे बनाने के लिए बस ले सकता हूं t, और .succ(निबंधकार) कॉल कर सकता हूं u।

randएक nilपैरामीटर के साथ अंतराल में एक यादृच्छिक फ्लोट देता है [0,1)। जब फ्लोट्स को इंडेक्स में स्ट्रिंग्स में उपयोग करते हैं, तो वे पूर्णांकों को काटते हैं, इसलिए यह हमेशा पहले वर्ण को लौटाएगा।

अंत में, मेरे पास एक अतिरिक्त जोड़ी थी []इसलिए मैंने बस इसमें सब कुछ लपेट लिया, क्योंकि शुक्र है कि सब कुछ रूबी में एक अभिव्यक्ति है।

चैट में चारों ओर कुछ विचारों को फेंकने के लिए Sp3000 के लिए धन्यवाद।

— मार्टिन एंडर
स्रोत
8
रूबी एक डरावनी दिखने वाली भाषा है।
— feersum
8

C, 51 es1024 द्वारा

c=0xf.cp9,hhtaglfor;main() {;; printf("%d",(++c));}

प्रोग्रामिंग सी के 20 साल बाद आज मैंने हेक्साडेसिमल फ्लोटिंग पॉइंट कॉन्स्टेंट्स के बारे में जाना।

— कला
स्रोत
8

रूबी, 45 (हिस्टोक्रेट)

%q[zyfnhvjkwudebgmaclprs x].to_i(36)/51074892

वू हू! यह एक कोड गोल्फ समस्या पर मेरी पहली दरार है, और मेरे पास मूल पोस्ट पर टिप्पणी करने के लिए पर्याप्त प्रतिनिधि नहीं है। मैंने तुरंत उपयोग की गई चाल को पहचान लिया, क्योंकि मैंने वास्तव में इसके लिए उत्पादन कोड में उपयोग पाया है। पूरे ढांचे के बारे में जानने के लिए लगभग 5 मिनट लगे और पूरे जवाब के साथ आने में कुछ घंटे।

स्पष्टीकरण:

  • %q[]तार बनाने के लिए एक वैकल्पिक विधि है। कोष्ठक और घुंघराले ब्रेसिज़ का उपयोग भी किया जा सकता है।
  • String#to_i रूबी 2 से 36 तक किसी भी आधार में संख्याओं को स्वीकार करता है। यह स्ट्रिंग में पहले वर्ण को अनदेखा करेगा जो संख्या का हिस्सा नहीं है, इसलिए किसी भी अतिरिक्त वर्ण को अंतरिक्ष के बाद "फेंक दिया" जा सकता है।

और यहाँ कोड मैं इसे दरार करने के लिए इस्तेमाल किया है:

require 'set'

# return true if the string is made up of unique characters
def uniq(s)
  a = s.each_char.to_a
  return a == a.uniq
end

def uniq_while_same(a,b)
  s = Set.new
  a.each_char.zip(b.each_char).each do |ai, bi|
    return true if ai != bi
    return false if s.include? ai
    s << ai
  end
  return true
end

def ungolf(answer)
  # For each base that even makes sense
  [            36, 35, 34,     32, 31, 30,
   29, 28, 27, 26, 25, 24, 23,     21, 20,
   19, 18, 17, 16, 15, 14, 13, 12,     10].each do |base|
    # Ignore bases where it is not possible to create a unique-string number greater than answer
    next if answer > base ** base
    # Pick digits for the denominator that are not duplicates of the digits in base
    denominator_digits = ('1234567890'.each_char.to_a - base.to_s.each_char.to_a)
    # For each permutation of those digits for the denominator
    (1..10).each do |denominator_length|
      denominator_digits.permutation(denominator_length) do |denominator_s|
        # Maybe the denominator is in octal
        denominator_base = 10
        if denominator_s[0] == '0'
          next if denominator_s.include?('8') || denominator_s.include?('9')
          denominator_base = 8
        end
        denominator_s = denominator_s.join
        denominator = denominator_s.to_i denominator_base
        print "#{"\b"*64}(%q[#{(answer * denominator).to_s(base).ljust(36)}].to_i #{base})/#{denominator_s.ljust(10)}" if rand < 0.01
        # Ignore denominators that are definitely impossible to have answers for
        next unless uniq_while_same "qtoi#{base}#{denominator_s}#{(answer * denominator).to_s(base)}",
                                    "qtoi#{base}#{denominator_s}#{((answer + 1) * denominator).to_s(base)}"

        # For each numerator that gives answer when divided by the denominator
        (answer * denominator...(answer + 1) * denominator).each do |numerator|
          print "#{"\b"*64}%q[#{numerator.to_s(base).ljust(36)}].to_i(#{base})/#{denominator_s.ljust(10)}" if rand < 0.01
          # Remove any that are still not unique
          s = "#{numerator.to_s(base)}#{base}#{denominator_s}qtoi"
          next unless uniq s
          # Done. Compute which characters need to be thrown away to fill the remaining space
          remains = ('0123456789abcdefghijklmnopqrstuvwxyz'.each_char.to_a - s.each_char.to_a).join
          print "#{"\b"*64}#{" "*64}#{"\b"*64}"
          return "%q[#{numerator.to_s(base)} #{remains}].to_i(#{base})/#{denominator_s}"
        end
      end
    end
  end
  print "#{"\b"*64}"
  puts "\nnone"
  return nil
end


print ungolf 9410663329978946297999932

एक पहेली के अंदर एक एनपी समस्या एम्बेड करने के लिए रास्ता। मुझे पूरी तरह से बेवकूफ बनाया गया है। बहुत बढ़िया!

— charredUtensil
स्रोत
मैंने आपके लिए मूल उत्तर में एक टिप्पणी जोड़ दी।
— फायरफली
यह भयानक (और इच्छित उत्तर के करीब) है, लेकिन तकनीकी रूप से मान्य नहीं है क्योंकि इसमें आउटपुट नहीं है।
— 20
* फेसपालम वैसे मुझे अभी भी मज़ा आया था।
— charredUtensil
2
@charredUtensil अगर आपको कुछ और के लिए अपनी स्क्रिप्ट चलाने में कोई आपत्ति नहीं है, तो मुझे लगता है कि प्रिंटिंग अभी pअभिव्यक्ति के पहले की ओर बढ़ रही है । संभवतया शेष पात्रों का उपयोग स्थिरांक बनाने के लिए किया जा सकता है जैसा आपने किया है।
— फायर
मुझे वास्तव में इसे फिर से चलाने की जरूरत नहीं है। स्ट्रिंग के अंतिम कुछ वर्णों को बिना परिणाम बदले बदला जा सकता है - p %q[zyfnhvjkwudebgmaclrsx].to_i(36)/51074892मुझे पता है कि मैंने अपने वास्तविक खुर के प्रयास को तोड़ दिया है :)
— charredUtensil
7

कैरिडोर द्वारा पाइथन [कोई] शेल आकार 44,

__name__[3]  or (enfin_____[42], manager[1])

मुझे यकीन है कि वहाँ इस की तुलना में यह करने के लिए अधिक होना चाहिए था रहा हूँ, लेकिन जब से __name__बराबर __main__, 4 चरित्र 'एक' चुना गया है और लाइन के बाकी का मूल्यांकन कभी नहीं किया गया है।

— बग़ल में ossifrage
स्रोत
बस मूल कार्यक्रम के संदर्भ के लिए[__name__ for ___name__ in range(1,4)][2][3]
— कारिडोरक
7

पेरल, आकार 36, स्क्विश ओस्सिफ्रेज द्वारा

$_=rof;for$i(1..2129<<7){$_++}print;

एक और मुश्किल।

— gRC
स्रोत
1
अच्छा किया :-) यह बिल्कुल है।
— स्क्वीश ossifrage
@squeamishossifrage धन्यवाद। आपके पास उस कार्यक्रम में कुछ बहुत अच्छी 'पर्ल सुविधाएं' छिपी हुई थीं।
— grc
7

सीजाम, आकार 13, उपयोगकर्ता 23013 द्वारा

G,Cf#If/sE*K%

इसका परीक्षण यहां करें।

हाथ से हल, जैसे:

सबसे पहले, गैर- CJammers के लिए कुछ पृष्ठभूमि:

  • CEGIKसभी चर, जो कर रहे हैं के लिए पूर्व initialised हैं 12, 14, 16, 18, 20, क्रमशः।
  • s शीर्ष स्टैक तत्व को स्ट्रिंग में कनवर्ट करता है।
  • तार तकनीकी रूप से सिर्फ पात्रों के सरणियाँ हैं।
  • fबहुत जादू है। इस उत्तर के उद्देश्य के लिए, सरलीकृत संस्करण वह है, जो किसी सरणी के लिए a, कुछ अन्य मूल्य bऔर एक ऑपरेटर के लिए g, अनुक्रम abfgमानचित्र g(_,b)पर a(जहां प्रत्येक तत्व स्लॉट aमें जाता है _)।
  • / विभाजन और विभाजन सरणियाँ हैं (अन्य चीजों के बीच)।
  • * गुणन और सरणी पुनरावृत्ति (अन्य चीजों के बीच) है।
  • %मोडुलो और कुछ अजीब ऑपरेशन है, जो ad%सरणी aऔर पूर्णांक के लिए फार्म में dप्रत्येक dतत्व को लेता है a(जैसे कि पायथन के स्टेपिंग स्टेप चौड़ाई के साथ d)।
  • # प्रतिपादक है (अन्य चीजों के बीच)।
  • ,श्रेणियों में बदल जाता है नंबर (से 0करने के लिए n-1) और रिटर्न एक सरणी की लंबाई।

ठीक है, इस तरह से ...

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

मैंने पहली बार माना था कि fएस का उपयोग किया गया था #और %, लेकिन इसका मतलब है कि हमें अंत में अंकों की सही मात्रा प्राप्त करने के लिए लगभग 90 की संख्या की आवश्यकता होगी। और यह भी, यह स्पष्ट नहीं किया कि क्या करना है s, और जब से उत्तर वास्तव में गोल्फ दिख रहा था, मैंने user23013 पर संदेह किया, बस sलोगों को फेंकने के लिए एक प्रभावी नो-ऑप के रूप में जोड़ा ।

इसलिए मुझे लगा, शायद वह संख्याओं को छोटा नहीं रख रहा है %, लेकिन इसके बजाय वह बहुत बड़ी संख्या में एक सरणी बनाता है, अपने स्ट्रिंग प्रतिनिधित्व को समेटता है s, लेकिन फिर इसके साथ कुछ अजीब टुकड़ा निकालता है %। इसलिए मैंने निम्नलिखित ढांचे के साथ थोड़ा सा खेला:

__*,_f#_f/s_%

(आप _f/पहले ऐसा नहीं कर सकते , क्योंकि इससे कम से कम पहले 12 तत्वों के लिए शून्य उपज होगी।)

जहां _चर के कुछ क्रमचय हैं। इससे पहले कि मैं ऊब गया, मैंने उन सभी की कोशिश नहीं की और इसके साथ मुख्य समस्या यह थी कि अंकों का अनुक्रम हमेशा की तरह बहुत लंबा था।

कुछ बिंदु पर यह मेरे साथ हुआ, कि हमें इतनी बड़ी रेंज (यानी दो नंबर का उत्पाद) की आवश्यकता नहीं होगी, अगर इसके बजाय हमने *परिणामी स्ट्रिंग को दोहराने के लिए उपयोग किया । के मापदंडों के बेमेल होने के कारण *और %इसके परिणाम में कोई पुनरावृत्ति नहीं होगी:

_,_f#_f/s_*_%

इस लंबाई के परिणाम बहुत करीब थे जो मैं देख रहा था। मैं वास्तव में उनमें से सभी 240 की कोशिश की है, लेकिन काफी जल्दी (तीसरे या चौथे प्रयास), मैं पर ठोकर खाई

E,Cf#If/sG*K%

कौन सी पैदावार

03081942753650251594592190492275006661328850322159030034930530649722385533653290754678977

और मुझे लगा कि पहले छह अंकों का एक मेल संयोग नहीं होगा। तो सवाल यह था कि वास्तविक गणना को परेशान किए बिना इसे पुनर्व्यवस्थित कैसे किया जाए:

  • मैं बदल नहीं सकता Kक्योंकि वह अलग-अलग अंकों को पूरी तरह से बाहर ले जाएगा।
  • मैं बदल नहीं सका Cया Iइसलिए कि दो मैप ऑपरेशंस के परिणामस्वरूप संख्या बदल जाएगी।
  • अगर मैं बदल गया Gजो केवल दोहराव की संख्या को बदल देगा, जो परिणाम की लंबाई को बदलने के अलावा कुछ नहीं करेगा। (कौन सा अच्छा है।)
  • अगर मैं बदल गया है Eजो सरणी की सीमा को बदल देगा, लेकिन सीमा अभी भी साथ शुरू होगी [0 1 2 3 ...], इसलिए यह गणना को प्रभावित नहीं करेगा। यह आधार स्ट्रिंग की लंबाई को प्रभावित करेगा s, जिसका अर्थ है कि इसका मतलब यह भी K%होगा कि अतिरिक्त पुनरावृत्ति पर अलग-अलग अंक निकालेंगे।

अदला-बदली तो मैं बस की कोशिश की Eऔर Gऔर देखा:

030819828850379075460427536222159187897761502517030034671154875945928930530907551421904962649729

सारांश में, यहाँ कोड क्या है:

G,            "Push [0 1 2 3 ... 13 14 15].";
  Cf#         "Raise each element to the 12th power.";
     If/      "Divide each element by 18.";
        s     "Concatenate all numbers into a string.";
         E*   "Repeat 14 times.";
           K% "Pick every 20th digit.";
— मार्टिन एंडर
स्रोत
6

अजगर, आकार 11, इसहाक द्वारा

:\\w$ ",d,N

वहीं कुछ मतलब बग दुर्व्यवहार है। यह संकलन:

Pprint("\n",at_slice("\",input(), ",d,N))

प्रासंगिक बग वह है जो इसके बजाय \\संकलन करता है , जो आपको Pyth को एक स्ट्रिंग में संकलित करने देता है।"\""\\"

— मार्टिन एंडर
स्रोत
होना Pprintचाहिए print, या कम से कम pprint?
— फायरफ्लाइ
@ पूरी तरह से यही डिबग आउटपुट कहा गया है। हो सकता है कि पायथ दुभाषिया अपनी ही छाप को परिभाषित करे?
— मार्टिन एंडर
ओह, ठीक है, फिर कोई बात नहीं।
— FireFly
6

पायथन, आकार 69, Sp3000 द्वारा

print(sum(list(map(ord,str((dict(((str(dict()),list()),)),str()))))))

यह कठिन था ...

— gRC
स्रोत
1
अच्छा! संदर्भ के लिए, मूल था print(sum(map(ord,str((dict(list(((str(),str(dict())),))),list()))))), लेकिन जाहिर है कि कीवर्ड के कई अलग-अलग क्रमांकन काम करेंगे।
— Sp3000
2
यह वहां के LISP-स्तर है!
— xnor
6

पायथन 3, 37 बाइट्स, Sp3000 द्वारा

print(sum(b"a".zfill(len(str(...)))))

अब तक सबसे मुश्किल हिस्सा स्ट्रिंग को बाइट में बदलने के लिए लगा रहा था। मुझे उस पर सोना था, और रात में एहसास हुआ 'दुआ, यह एक बाइट्स शाब्दिक है!'

— ब्लेक वाल्श
स्रोत
अहा ने अच्छी तरह से किया, मैंने सोचा कि
— एलिप्सिस
मैं दीर्घवृत्त और zfill देखा, लेकिन बाइट्स वस्तुओं के बारे में पता नहीं था। वे पूर्णांक के गोल्फ सरणियों में उपयोगी हो सकते हैं!
— feersum
अच्छा काम! मैंने केवल प्रिंट और .zfill देखा, और मुझे पता था कि राशि इसका हिस्सा हो सकती है, लेकिन मैं इसे हल नहीं कर सका। एक +1 है।
— होसच २५
6

PHP, 53, PleaseStand द्वारा

पिछले पर यह टूट गया:

for($d=57,$o=35;$o+$d<999;)$o+=printf("$d%o",$d+=$o);

समाधान काफी तेजी से आया जब मैंने देखा कि अनुक्रम में दशमलव और अष्टक संख्याएं शामिल हैं:

Dec: 57...92...132...177...228...285...348...417...492....573....661....756....858....
     571349220413226117734422843528553434864141775449210755731225661136475615328581707
Oct: ..134..204...261...344...435...534...641...754...1075...1225...1364...1532...1707
==Dec:  92  132   177   228   285   348   417   492    573    661    756    858    967

इसके अलावा, संख्या के प्रत्येक सेट के बीच का अंतराल दर के बराबर बढ़ जाता है printf(), जो लौटाए गए मूल्य (यानी लिखे गए वर्णों की संख्या) के बराबर होता है ।

— बग़ल में ossifrage
स्रोत
3
वाह, अच्छा जासूसी का काम!
— Sp3000
6

पाइथन 2, आकार 132, वीआई द्वारा।

exec('from string import printable as e\nprint "cqance"\x2Ereplace("q",e[len("fgiillmmooprrsstt")])or ",,,\016:::S[]____tuuvyy" ""')

सभी बैकस्लैश और उद्धरण चिह्नों के लिए धन्यवाद :)

संपादित करें: अद्यतन 96-चार संस्करण:

exec "try:exec'from __future__ import braces\\nt(12)'\nexcept SyntaxError as q:print(q[0][6:])"

यह पूरी तरह से एलेक्स के समाधान से लिया गया है https://codegolf.stackexchange.com/a/41451/32353

— kennytm
स्रोत
हे, अच्छा है। सोच रहा था कि इसका हल क्या है ...
— FireFly
यह एक इच्छित समाधान नहीं है। मूल समाधान में कोई "फेंक-दूर" जैसी चीजें नहीं हैं fgiillmmooprrssttया ,,,\016:::S[]____tuuvyy।
— वि।
exec? मेरा कोड छोटा हो गया है ... मैं इसे compile+ के साथ अनुकरण कर रहा था evalक्योंकि मैं भूल गया था exec...
— Vi।
छोटे संस्करण को लागू किया। मूल चाल जानने की कोशिश करें।
— वि।
5

सीजाम, आकार 15, यपनीप द्वारा

98,{7%}%{6+}%:+

दिए गए वर्णों से, मैंने अनुमान लगाया कि यह निम्नलिखित तीन रूपों में से एक होना चाहिए:

__,{_%}%{_+}%:+
_,{_%}%{__+}%:+
__,{_+}%{_%}%:+

जो दो अंकों की सीमा बनाता है, फिर जोड़ पर एक सीमा और मोडुलो ऑपरेशन (या तो क्रम में) को मैप करता है। इसलिए मैंने बस पहले एक के साथ शुरुआत की, और व्यवस्थित रूप 6789से अंतराल में क्रमपरिवर्तन की कोशिश की ।

— मार्टिन एंडर
स्रोत
डेमिट, मैंने अभी इसे भी हल किया है: /
— ऑप्टिमाइज़र
5

पाइथन 2, आकार 61, फ्राइअम द इगमैन द्वारा

print(dir('~s]l.c:st_''-p_tp.l]-~.:o:Te[_u[.i_')[10][2:][:3])

अगर यह मूल से मेल खाता है तो मुझे बहुत आश्चर्य होगा।

— gRC
स्रोत
यह नहीं है, लेकिन वैसे भी बधाई! मेरा कोड था:print''.__doc__[::2][::3].split()[1].split('.')[0][:-~-~True]
— FryAmTheEggman
— पदयात्रा में
@FryAmTheEggman ओह वाह - अच्छा कार्यक्रम! मुझे यकीन था कि आप कम से कम dir()'पाने' की तलाश में थे। और हाँ, यह उद्धरण के बिना बहुत मुश्किल होता।
— grc
5

पायथन 3, Sp3000, आकार 44

print(~(~(()<((),))<<(()<((),))))<<((()<()))

पायथन 3 ने मुझे यहाँ मदद की क्योंकि मैं Noneउत्तर को प्रिंट करने के बाद एक त्रुटि ( किसी चीज़ के द्वारा छोड़ दिया जाना) का कारण बन गया था ।

— feersum
स्रोत
हम्म ... लगता है कि मैं अपने parens के साथ बहुत बेकार था। print(~(~(()<())<<((()<((),))<<(()<((),)))))मूल रूप से था ।
— Sp3000
5

PHP, आकार 52, kenorb द्वारा

_:@print_r(chr(@++$i+pow(3<<5,1)));if($i<2*4)goto _;

(भगवान, मुझे यह पता लगाने में कितना समय लगा कि शेष _rप्रत्यय का क्या करना है । जब तक मैंने देखा कि यह नहीं था print, लेकिन print_r...)

— bwoebi
स्रोत
और मुझे नहीं पता कि आपने इसका पता कैसे लगाया :) मूल _:print_r(chr(3*pow(2,5)+@++$i));if(@$i<4<<1)goto _;:।
— कीनॉर्ब
3
@kenorb ए) आपको कुछ प्रिंट करने की आवश्यकता है, इसलिए echoसंभव नहीं है; printबने रहे; बी) आपको कुछ लूप की आवश्यकता है, लेकिन एक forलूप के लिए, पर्याप्त अर्धविराम नहीं थे, और अच्छी तरह से, वहाँ एक बृहदान्त्र है ... इसलिए शायद गोटो के साथ संयोजन में एक लेबल है; ग) इसके बाद गोटो-लूप को खत्म करने की जरूरत है। अब X:print($Y);if($Y)goto X;(एक्स और वाई प्लेसहोल्डर्स) होने; d) एक है ++, लेकिन नहीं =, तो शायद ++$Z1 से 8 तक कुछ ; ई) एक पूर्णांक से पत्र प्राप्त करने के लिए, हमें ज़रूरत है chr()(आमतौर पर) - यह वहां था; च) अब मुझे chr के लिए ९ ६ और 96 और अगर संख्या खोजने की जरूरत है। फिर प्लेसहोल्डर्स में भरें और volià।
— ब्वॉइबी
5

PHP, आकार 54, स्टीव रॉबिंस द्वारा

echo(21<<($$$$$$${$aaaabbbbbbehi==$l&$w^2}^1==1));;;;

मूल समाधान नहीं, मुझे लगता है।

— jimmy23013
स्रोत
2
हाहा, यह प्यारा है। मैं बाहर मछली पकड़ने के द्वारा शुरू किया echoऔर whileहै, लेकिन फिर एक पाश है कि 42 का उत्पादन खोजने के लिए परेशान नहीं किया जा सकता है
— मार्टिन Ender
whileमेरे मूल में एक था ।
— स्टीव रॉबिन्स
5

सी, es1024, लंबाई 70

e='C',f;main(g){Chorkil:f=printf("40%.d",e+e-  -g);}hAx;*hotpoCkats();

कठिन हिस्सा समाप्त हो गया सभी अनावश्यक पात्रों पर नज़र रखने के लिए ... गंभीरता से ... मुझे उन्हें लगभग 10 बार फिर से करना पड़ा। केवल एक जिसने मुझे चिंतित किया, .लेकिन किसी तरह मैंने इसे printfप्रारूप स्ट्रिंग के बीच में अटका दिया और यह अदृश्य हो गया!

— feersum
स्रोत
5

हस्केल, आकार 34, पेट्र पुडलक द्वारा

main=print(0xb2f3d5^0x7f1f27::Int)

ध्यान दें कि यह प्रोग्राम 32-बिट मशीन पर चलना चाहिए। यदि आप यह जांचना चाहते हैं कि यह सही कार्यक्रम है और आपके पास 64-बिट मशीन है, तो आप इसके बजाय इसका उपयोग कर सकते हैं:

import Data.Int
main=print(0xb2f3d5^0x7f1f27::Int32)

कार्यक्रम के "फ्रेम" का अनुमान लगाना बहुत आसान था main=print(0x<hex digits>^0x<hex digits>::Int)। सभी जादू अंकों के विभाजन और व्यवस्था के सही तरीके की खोज में थे। मैंने यहां बहुत स्मार्ट नहीं किया, बस एक क्रूर-बल खोज ... हालांकि मैंने इस तथ्य का दुरुपयोग करने का ध्यान रखा कि कुछ अंकों को डुप्लिकेट किया गया था, शायद आधार और घातांक में लगभग समान अंक थे, और आधार का अंतिम अंक लगभग निश्चित रूप से भी नहीं था। पूरा खोज कोड नीचे शामिल है; यह मल्टीसेट-कंघी पैकेज का उपयोग करता है । पूर्ण खोज मेरी मशीन पर लगभग 10:33 लेता है (और निश्चित रूप से केवल एक सही उत्तर का उत्पादन करता है)।

{-# LANGUAGE NoMonomorphismRestriction #-}
import Control.Monad
import Data.Int
import Data.List (inits, tails, group)
import Numeric
import Math.Combinatorics.Multiset

main = print (searchFor (-1121766947))

searchFor n = do
    nl <- [6,5,7,4,8,3,9,2,10,1,11]
    (l_, r_)  <- chooseSubbag nl digits
    l <- perms l_
    guard (last l /= '2')
    r <- perms r_
    guard ((fromString l :: Int32) ^ (fromString r :: Integer) == n)
    return (l, r)

chooseSubbag n = chooseSubbag' n . group
chooseSubbag' n xss = go (drop (n-1) (concat xss)) n xss where
    go _  n xss | n < 0 = []
    go _  0 xss = [([],concat xss)]
    go [] n xss = []
    go m  n (xs:xss) = do
        (kx, tx) <- zip (tails xs) (inits xs)
        (k , t ) <- go (drop (length tx) m) (n-length kx) xss
        return (kx++k, tx++t)

digits = "1223577bdfff"
fromString = fst . head . readHex
perms = permutations . fromList
— डैनियल वैगनर
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.