लुटेरे: छिपे हुए OEIS पदार्थ

Question

यह एक पुलिस और लुटेरे चुनौती है। यह डाकू का धागा है। पुलिस के धागे यहाँ है ।

पुलिस OEIS से किसी भी अनुक्रम को उठाएगी , और उस अनुक्रम से पहला पूर्णांक प्रिंट करता है एक प्रोग्राम p लिखेगा । वे कुछ स्ट्रिंग एस भी पाएंगे । आप सम्मिलित हैं रों में कहीं पी , इस कार्यक्रम अनुक्रम से दूसरे पूर्णांक प्रिंट चाहिए। यदि आप p में उसी स्थान पर s + s डालें , तो इस प्रोग्राम को अनुक्रम से तीसरा पूर्णांक प्रिंट करना होगा। s + s + s एक ही स्थान पर चौथे को प्रिंट करेगा, और इसी तरह आगे भी। यहाँ एक उदाहरण है:

पायथन 3, अनुक्रम A000027

print(1)

छिपी हुई स्ट्रिंग दो बाइट्स है ।

स्ट्रिंग है +1, क्योंकि प्रोग्राम print(1+1)A000027 में दूसरे पूर्णांक print(1+1+1)को प्रिंट करेगा , कार्यक्रम तीसरे पूर्णांक को प्रिंट करेगा, आदि।

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

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

नियम

• आपके समाधान को अनुक्रम में किसी भी संख्या के लिए काम करना चाहिए, या कम से कम एक उचित सीमा तक जहां यह स्मृति प्रतिबंध, पूर्णांक / स्टैक फ़्लो, आदि के कारण विफल रहता है।

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

• जीतने वाला पुलिस सबसे छोटा स्ट्रिंग s वाला पुलिस है जो फटा नहीं है। टाईब्रेकर सबसे छोटा पी है । अगर कोई अनियंत्रित सबमिशन नहीं हैं, तो पुलिस वाले के पास सबसे लंबी जीत के लिए एक समाधान नहीं है।

• सुरक्षित घोषित किए जाने के लिए, आपका समाधान 1 सप्ताह तक बिना रुके रहना चाहिए और फिर छिपी हुई स्ट्रिंग (और उसे डालने का स्थान) का पता चला।

• एस नेस्टेड नहीं हो सकता है, इसे अंत तक समाप्त होना चाहिए। उदाहरण के लिए, यदि रों था 10, प्रत्येक यात्रा जाना होगा 10, 1010, 101010, 10101010...बजाय10, 1100, 111000, 11110000...

• सभी क्रिप्टोग्राफ़िक समाधान (उदाहरण के लिए, प्रतिस्थापन के हैश की जाँच) पर प्रतिबंध लगाया गया है।

• यदि रों किसी भी गैर ASCII वर्ण हैं, आप भी एन्कोडिंग इस्तेमाल किया जा रहा निर्दिष्ट करना होगा।

Answer 1

पायथन 2 , अनुक्रम ए 138147 एक्सनोर द्वारा

मूल:

print 10

फटा:

print "1%s0"%10
      ^^^^^^^

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

Comments

आपको यह मिला! यही उपाय मैं सोच रहा था। मुझे यह दिलचस्प लगता है कि यह उस %वाम-सहयोगियों को दिया गया काम है ।

— xnor

हाँ, लेकिन एक प्रारूप स्ट्रिंग एक स्ट्रिंग है, और "1% s0"% "1% s0" "11% s00" है जो अभी भी वह चीज करता है जो हम चाहते थे।

— हॉब्स

Answer 2

ब्रेन-आलोचना , A000984 द्वारा Nitrodon

({({}<>({}))<>}<>){({}<>)<>}<>

यह केवल 30 बाइट्स है, यह निश्चित नहीं है कि नाइट्रोडॉन के दिमाग में क्या था।

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

व्याख्या

मैंने बहुत सी चीजों की कोशिश की, लेकिन यहां वह काम किया है। A000984 की शर्तें पास्कल के त्रिकोण के केंद्रीय तत्व हैं।

अब मुझे पता चला कि मैं उनके ऊपर के विकर्णों को जोड़कर उन्हें प्राप्त कर सकता हूं:

उदाहरण के लिए:

$1+3+6+10 = 20$

और जब से नाइट्रोडॉन के कार्यक्रम में अंतिम क्रिया है, सब कुछ योग करने के लिए एक अच्छा उम्मीदवार की तरह लग रहा था (जैसे कि मैंने चीजों की एक गुच्छा की कोशिश की लेकिन यह एक काम खत्म हो गया)।

इसलिए हम एक प्रोग्राम चाहते हैं जो एक आंशिक राशि लेता है और अगले का उत्पादन करता है। सौभाग्य से इनमें से किसी एक को प्राप्त करने के लिए बहुत साफ-सुथरा तरीका है। प्रत्येक पंक्ति अगली पंक्ति का डेल्टा है। यह एक पंक्ति में $n$ वें शब्द है $n$ और $n-1$ बीच अंतर है - अगली पंक्ति में 1 वें शब्द।

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

$1+3+6=10$

और अगर आप ब्रेन-फ्लैक से परिचित हैं जो आपको कुछ ऐसा करना चाहिए जो वास्तव में करने में आसान होने वाला है।

अब कोड के लिए:

शुरू करने के लिए हम अगली पंक्ति की गणना करते हैं जहां प्रत्येक नया सदस्य दो आसन्न पुराने सदस्यों का योग होता है। इसके साथ किया जा सकता है:

{({}<>({}))<>}<>

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

{({}<>({}))<>}<>{({}<>)<>}<>

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

({({}<>({}))<>}<>){({}<>)<>}<>

और बस।

Comments

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

— नाइट्रॉडन

@ निट्रोडॉन स्पष्टीकरण तय। अगर मैंने अपना कोड पढ़ा होता तो मैं देख सकता था कि वह गलत था।

— गेहूं जादूगर

Answer 3

ब्रेन-फ्लैक, ए 1000290 , श्रीकोटिलिज्म ओ'जैसिक द्वारा

मूल:

((()))({}<>)

फटा:

((()))({}([])[]<>)
         ^^^^^^

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

वैकल्पिक रूप से:

((())([])[])({}<>)
     ^^^^^^

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

Comments

यह मेरी छिपी हुई स्ट्रिंग है! लेकिन यह वह जगह नहीं है जहाँ मैं इसे रख रहा था। अच्छी नौकरी के बावजूद!

— गेहूं जादूगर

@ श्रीतोचिलिज्म'ओजाइक तब यह मूल होना चाहिए।

— jimmy23013

Answer 4

MATL , अनुक्रम A005206 लुइस मेंडो द्वारा

मूल:

voOdoO

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

फटा:

voOdoOdNq17L/k
      ^^^^^^^^

मैं एक MATL विशेषज्ञ नहीं हूं, लेकिन जो मैं समझता हूं, उससे मूल voOdoOदो खाली सरणियों और [0]स्टैक पर एक सरणी बनाता है । यह [0]वह है जो अनुक्रम के पहले तत्व के रूप में कोष्ठक के बिना मुद्रित हो जाता है। दरार / समाधान तो निम्न कार्य करता है:

• dस्टैक से एक तत्व लेता है और (यह संख्या या आकार 1 का मान लेता है) इसे एक खाली सरणी में बदल देता है। ये खाली सरणियाँ मुद्रित नहीं होती हैं, लेकिन स्टैक आकार में योगदान करती हैं
• Nqस्टैक का आकार गिनता है और एक को घटाता है। n+1फ़ंक्शन का मूल्यांकन करते समय यह शब्द है (चूंकि यह 2 से शुरू होता है और dस्टैक में अदृश्य सामान जोड़ने के कारण हर पुनरावृत्ति में वृद्धि होती है )
• 17L यह निरंतर है Phi = (1+sqrt(5))/2
• /kयह वह floor((n+1)/Phi)सूत्र है जो अनुक्रम के तत्वों की गणना करने वाले सूत्रों में से एक है। यह सूत्र OEIS पर सूचीबद्ध है क्योंकि a(n) = floor(sigma*(n+1)) where sigma = (sqrt(5)-1)/2हम पहचान का उपयोग करते हैं(sqrt(5)-1)/2 = 1/Phi

Comments

मैं एक Matl विशेषज्ञ नहीं हूँ ठीक है, मुझे लगता है कि आप में से एक बन गया है - :) संदर्भ के लिए, मेरी छिपा स्ट्रिंग थी \N17L/k&(नोट के दो विभिन्न उपयोगों के &बीच में और कोड के अंत में), लेकिन अपने समाधान सरल है और अधिक सुंदर

— लुइस मेंडो

Answer 5

अजगर 3 - A__

print(100+-1)

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

100 बोतल बीयर, -1अगला नंबर पाने के लिए जोड़ें 99, आदि।

Comments

मुझे 7 सेकंड से हराया। :) इसके अलावा, नियम कहते हैं कि किसी भी स्ट्रिंग को उस लंबाई तक ढूंढना है ताकि आप -1इसके बजाय बस कर सकें । मैं इसे और स्पष्ट कर दूँगा।

— DJMcMayhem

@DJMcMayhem मैंने पढ़ा था कि मैंने जमा करने के बाद, लेकिन इस तरह के एक आसान दरार के लिए अतिरिक्त प्रतिबंध लगाने के लिए अधिक मज़ा है :-)

— Giuseppe

Answer 6

केग , अनुक्रम A000045 , द्वारा A__

मूल:

0.

फटा:

01":&+.
 ^^^^^

ध्यान दें कि चुनौती लंबाई का एक विकल्प ढूंढ रही थी <= 6, लेकिन पाया गया स्ट्रिंग की लंबाई 5 है।

केग विनिर्देश को देखने के लिए बहुत आलसी हैं उन लोगों के लिए आदेशों की परिभाषा: 0और 1संबंधित संख्या को स्टैक पर धक्का दें; "स्टैक टॉप को स्टैक बॉटम (रोल) में ले जाता है; &यदि यह खाली है, तो रजिस्टर में स्टैक शीर्ष को हटा देता है, अन्यथा स्टैक पर रजिस्टर खाली कर देता है; +शीर्ष दो स्टैक मान जोड़ता है।

प्रारंभिक 1"बस स्टैक के नीचे एक 1 सम्मिलित करता है। 1 की केवल बढ़ती हुई सूची पहले पुनरावृत्ति में एक भूमिका निभाती है, जहां यह हमें यह मानने की अनुमति देती है कि स्टैक 1 0केवल के बजाय शुरू होता है 0। वास्तव में, कार्यक्रम 10:&+., जहां :&+भाग दोहराया जाता है, ऊपर दिए गए समाधान के समान सटीक व्यवहार होता है, सिवाय इसके कि इसमें नीचे की तरफ 1 की बढ़ती सूची नहीं है।

चूंकि &दोहराव वाले भाग में केवल एक बार उपयोग किया जाता है और वैकल्पिक व्यवहार होता है, व्यवहार 1":&+पुनरावृत्ति की समानता पर निर्भर करता है।

अब, यह प्रोग्राम वास्तव में शुरू से 0, 1 के साथ अनुक्रम फाइबोनैचि अनुक्रम को प्रिंट नहीं करता है; यह वास्तव में दूसरे से 1, 0 फाइबोनैचि अनुक्रम को प्रिंट करता है, अर्थात 0. से (यह उसी क्रम में परिणाम है।) यह जानकर, कार्यक्रम का आसानी से विश्लेषण किया जाता है:

• पहले, तीसरे, ... पुनरावृत्ति में, राज्य के रूप में शुरू होता है [a, b]और समाप्त होता है a+b (&=b)।
• दूसरे, चौथे, ... पुनरावृत्ति में, राज्य के रूप में शुरू होता है [b] (&=a)और समाप्त होता है [b, b+a]।

यह वास्तव में आवश्यकतानुसार अनुक्रम की गणना करता है।

Comments

अच्छा लगा, अब मेरी तरह केग का इस्तेमाल करने वाला कोई है।

— एक

@A__ आपका मूल 6-वर्ण स्ट्रिंग क्या था? :)

— टॉस

यह वास्तव में आपकी स्ट्रिंग के समान है; एकमात्र अंतर यह है कि मैंने :स्ट्रिंग की शुरुआत में एक कमांड जोड़ा है ।

— एक

क्या यह सबसे छोटा संभव डाला गया स्ट्रिंग है जिसे आप पा सकते हैं?

— एक

अरे। मुझे यह एक मिला, लेकिन जब चुनौती <= 4 बाइट्स थी।

— खुल्द्रेशेथ न'बर्या

Answer 7

जावा 8+, बेंजामिन अर्कहार्ट द्वारा अनुक्रम A010686

()->System.out.println(1^4);
                        ^^

Comments

वह मेरा तार है। बहुत बढ़िया।

— बेंजामिन उक्राहर्ट

Answer 8

ब्रेन-फ्लैक, श्रीओटचिलिज्म ओज़ैसिक द्वारा ए 1000578

मूल:

((())<>)

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

फटा:

((())(({})([][][]){})<>)
    ^^^^^^^^^^^^^^^^

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

Answer 9

Pyret , अनुक्रम A083420 , MLavrentyev द्वारा

fold({(b,e):(2 * b) + 1},1,[list: 0,0,])
                                  ^^^^

आप इसे यहां चला सकते हैं, लेकिन मुझे पता नहीं चला है कि कोड से कैसे लिंक किया जाए। आपको कॉपी-पेस्ट करना होगा।

प्रदान की गई फ़ंक्शन इसके दूसरे तर्क की उपेक्षा करती है। यह अपने पहले को दोगुना करता है और एक को जोड़ता है, जो 2^n - 1यहां आवश्यक आवश्यक अनुक्रम उत्पन्न करेगा - मुझे जो कुछ भी करने की ज़रूरत है वह बताएंगे कि उस ऑपरेशन को करने के लिए कितनी बार गुना सूची की लंबाई को बदलकर किया जाता है। सौभाग्य से, Pyret उस अनुगामी अल्पविराम के बारे में शिकायत नहीं करता है।

Answer 10

पायथन 3 , अनुक्रम A268575 द्वारा NieDzejkob

मूल:

from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW")
print(len(W))

फटा (100 बाइट्स):

from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW");A=-1,1,0;*X,=F(lambda a:(S(a,x)for x in product(A,A)),W);W={p for p in X if 2<X.count(p)<4+({p}<W)}
print(len(W))

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

मैं जो इकट्ठा कर सकता हूं, उससे मूल कोड छिपी हुई स्ट्रिंग को यथासंभव संक्षिप्त बनाने के लिए परिभाषाएं स्थापित कर रहा है और फिर प्रारंभिक गेम ऑफ लाइफ पैटर्न को परिभाषित कर रहा है। छिपी हुई स्ट्रिंग तब 102 बाइट्स में कॉनवे के गेम ऑफ लाइफ के पुनरावृति लिखने के बराबर है।

इस दरार के प्रयोजनों के लिए, Sएक ऐसा फ़ंक्शन है जो तत्वों को अपने तर्कों (जो पुनरावृत्तियाँ हैं) के भीतर रखता है और Fएक सूची के प्रत्येक तत्व के लिए पुनरावृत्ति देने वाला फ़ंक्शन लागू करता है और सभी परिणामों को एक साथ मिटा देता है।

• ;A=-1,1,0;पूर्ववर्ती कथन को समाप्त करता है और A के साथ tuple (-1,1,0) को संक्षिप्त करता है, जिसका उपयोग किया जाता है, जो product(A,A)सभी पड़ोसियों को किसी दिए गए सेल के साथ-साथ सेल के लिए भी देता है।
• *X,=F(lambda a:(S(a,x)for x in product(A,A)),W);एक नई सूची बनाता Xमें कोशिकाओं के सभी पड़ोसियों पकड़े Wमें कोशिकाओं और Wप्रत्येक कोशिका के लिए पड़ोसियों के सापेक्ष स्थिति को जोड़ने और एक सूची में उन्हें एक साथ स्मैश से खुद को।
• W={p for p in X if 2<X.count(p)<4+({p}<W)}इस सूची के माध्यम से जाता है Xऔर यह निर्धारित करता है कि Xअगले पुनरावृत्ति में प्रत्येक कोशिका कोशिकाओं के सेट में है या नहीं । यह गेम ऑफ लाइफ गोल्फ से लगभग शब्दशः लिया गया था ।

Comments

मैं NieDzejkob के उत्तर (102 बाइट छिपी हुई स्ट्रिंग!) द्वारा इतना स्टार्स्ट्रक था कि मैं इसे क्रैक करने के प्रयास में StackExchange में शामिल हो गया, लेकिन यह पता चला कि मेरा नया खाता अन्य लोगों के पोस्ट पर टिप्पणी नहीं कर सकता है, इसलिए मैं नियमों का पूरी तरह से पालन नहीं कर सकता ( जो मेरी गलती है)

— Liresol

CGCC में आपका स्वागत है! मैंने आपके लिए कॉप उत्तर पर टिप्पणी की है। मुझे आशा है कि आप चारों ओर चिपकेंगे!

— जो राजा

धन्यवाद! मैंने वास्तव में इन जैसी कोड चुनौतियों की कोशिश नहीं की है लेकिन ऐसा करना एक विस्फोट था।

— लिरसोल

बहुत बढ़िया! समय मिलने पर मैं अपनी इच्छित स्ट्रिंग प्रकट करूँगा।

— नीदेज्जेकोब

Answer 11

हास्केल, A014675 द्वारा खुल्द्रेसथ ना'बरिया

मूल कोड

main=print$uncurry(!!)([2],0)

विकल्प के साथ

main=print$uncurry(!!)                                   ([2],0)
                      $(\(a,n)->(a>>= \e->2:[1|e>1],n+1))

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

Comments

वह ऐसा करेगा! मेरे पास flip take[1,2]उस आंतरिक मेमने की जगह थी। अन्यथा समान।

— खुल्द्रेसथ न'बर्या

@ खुलद्रसेठना’बेर्या: (`take`[2,1])यहां तक ​​कि एक बाइट भी छोटी है

— nimi

वह डंक मारता है। शायद यह एक स्पर्श के लिए सुरक्षित हो सकता था अब मुझे एहसास हुआ था कि। (`take`)एक संकलन त्रुटि मिली, तो मुझे लगा (`take`[2,1])कि यह भी होगा। :(

— खुल्द्रेसथ ना'बरिया

Answer 12

डेस्कटॉप कैलकुलेटर, A006125 , A__ द्वारा

मूल:

1n

फटा:

1 2lx1+dsx^*n
 ^^^^^^^^^^^

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

सीधा कार्यान्वयन।

Comments

मेरा मूल स्ट्रिंग है Sa2Lad1-*2/^, अगर कोई मुझसे इसके बारे में पूछता है।

— एक

Answer 13

CQuents , अनुक्रम स्टीफन द्वारा A003617

=10#2:pZ
  ^

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

सबसे कम n + 1-अंकीय संख्या के साथ शुरू करें, एक n शून्य के बाद। #2निर्दिष्ट करता है कि केवल दृश्य है, जो अनुक्रम परिभाषा बीज के लिए एक बार ही लागू है के दूसरे कार्यकाल, मुद्रित किया जाएगा; यह अनुक्रम परिभाषा बस अगले प्रमुख को ढूंढती है और वापस लाती है।

Answer 14

अजगर 3 - अगरबत्ती

from sympy import isprime, primerange
from itertools import count
r=1
r+=1
while isprime(r-2)or r&1<1and r>3:r+=1
print(r)

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

Comments

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

— FryAmTheEggman

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

— agtoever

@FryAmTheEggman हाँ, OEIS के "सूत्र" खंड ने उल्लेख नहीं किया कि यह एक अनुमान पर निर्भर करता है ... एक प्रमाण के साथ

— brb

Answer 15

MATL , अनुक्रम A000796 लुइस मेंडो द्वारा

मूल:

'pi'td1_&:_1)Y$J)

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

फटा:

'pi'td1_&:|SQ_1)Y$J)
          ^^^

मूल लेखक ने चुपके से सरणी बनाई [-7:-1]और फिर इसे पाने के लिए पहले तत्व को निकाला और नकार दिया 7। उन्होंने तब उपयोग किया था कि पाई (जो है 3) के गोल 7 वें अंक को पाने के लिए और इसे पाई के पहले अंक के रूप में प्रस्तुत किया। में जोड़ा जा रहा है |SQमूल सरणी सभी सकारात्मक, बनाता है यह सॉर्ट करता, और सब कुछ करने के लिए एक कहते हैं। इसका मतलब यह है कि सूचकांक प्राप्त करने के बजाय सब कुछ एक आवेदन के बाद 7सूचकांक -2, -3दो अनुप्रयोगों के बाद, और इसी तरह। यह -महत्वपूर्ण है क्योंकि यह Y$फ़ंक्शन को अंकों को गोल नहीं करने के लिए कहता है ।

Comments

मेरी सटीक छिपी हुई स्ट्रिंग! बहुत बढ़िया!

— लुइस मेन्डो

Answer 16

फोर्थ (gforth) , A000042 , NieDzejkob द्वारा

.( 1)1 .
^^^^^

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

तुच्छ 1-बटर बस शाब्दिक रूप से विस्तार कर रहा है। समस्या यह है, कि 64 बिट्स उन्नीसवें अंक के रूप में जल्दी हो जाता है। आसान निर्धारण एकल अंक को बार-बार प्रिंट करना है, है ना? हां, लेकिन यह इतना आसान नहीं है। हालांकि 1 .अंत में निपटने के लिए हमारे द्वारा आवश्यक अतिरिक्त अंकों को प्रिंट किया जाएगा, वे रिक्त स्थान से अलग हो जाएंगे। यह काम करने वाला नहीं है।

अब विकिपीडिया के अनुसार, " .((dot-paren) एक तात्कालिक शब्द है जो एक कोष्ठक-सीमांकित स्ट्रिंग को पार्स करता है और इसे प्रदर्शित करता है।" सौभाग्य से, उस प्रदर्शन में कोई अन्य अजीब चरित्र नहीं है, इसलिए .(एक ही प्रिंट करने के लिए उपयोग करना चाहिए। और यह करता है। क्लोज़-पार्न के बाद किसी भी स्थान की आवश्यकता नहीं होती है, इसलिए ये पांच वर्ण (ओपन-परन के बाद एक स्थान है) को हमारे दिल की सामग्री में दोहराया जा सकता है। प्रदर्शित करने के लिए, मैंने TIO में एक उदाहरण शामिल किया है जो कई बार ओवर-64 64-बिट int को ओवरफ्लो कर चुका होगा। एक जादू की तरह काम करता है।

Comments

बहुत बढ़िया! बिलकुल मेरी स्ट्रिंग।

— निएडजेजकोब

Answer 17

Unefunge-98 (PyFunge) , अनुक्रम A000108 , द्वारा NieDzejkob

1# 2g1+:2p4*6-*2g/.@
 ^^^^^^^^^^^^^^^^^

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

छह बार दोहराया

उन्नीस से दो बाइट की अनुमति है! क्या प्रतीत होता है कि एक जगह है वास्तव में हैडर चरित्र का एक 0x01 प्रारंभ है।

स्पष्टीकरण:

इस चुनौती के बारे में सब उत्पन्न कर रहा है a(n)से a(n-1)और शायदn । OEIS स्पष्ट सूत्र प्रदान करता है a(n) = (2n)!/(n!(n+1)!), जो आसानी से पर्याप्त रूपांतरित हो जाता हैa(n) = a(n-1) * (4n-6) / n । अब इसे फंज में लागू करना है।

मुझे 1और के बीच कोड डालने होंगे. । यह आधी पहेली पहले ही हो चुकी है। वह सब रहता है जो सम्मिलित करने के लिए कोड है? स्टैक हेरफेर टूल में फ़ंज की काफी कमी है, इसलिए स्टैक का निचला भाग ऑफ-लिमिट है; मुझे दोनों को ट्रैक करने की आवश्यकता है nऔरa(n) स्टैक बढ़ने के बिना । और फ़ंज स्पेस के साथ ऐसा करना कितना बेहतर है?

वह 0x01 वर्ण मेरा काउंटर है n। मैं a(n)स्टैक पर रहता हूं , क्योंकि मेरे बिट के निष्पादन के बाद यह स्टैक पर होना चाहिए।

1# 2g1+:2p4*6-*2g/.@
1                       Push 1. This is a(0).
 #                        Skip the next instruction. Without this, I believe the instruction pointer will reverse direction upon encountering 0x01.
   2g                     Push the third character in the source, which starts out as 1.
     1+                   Increment it...
       :                  ...copy it...
        2p                ...and put it back. One copy remains atop the stack.
          4*6-            Multiply by four. Subtract six.
              *           Multiply by a(n), leaving the result alone on the stack.
               2g         Push n again...
                 /        ...and divide our intermediate result by it. Ta-da!
                          At this point, the stack is the same as at the start of the indented block, except the one item has been advanced one place in the sequence.
                          The source of the program has changed; the third character holds the number of times this indented block has run.
                  .@    Print and terminate.

Answer 18

पायथन 3 , टी 00 द्वारा ए 008574

print(1*2+2)
       ^^^^

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

Answer 19

V, A000290 , DJMcMayhem द्वारा

é*Ä2é*Ø.
  ^^^^

1 से वर्ग पैदा करता है।

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

आधार संपूर्ण बफ़र में गैर-न्यूलाइन वर्णों की संख्या é*सम्मिलित *और Ø.गिनता है। सम्मिलन Äशीर्ष पंक्ति को अपनी ही पंक्ति में डुप्लिकेट करता है, जिस पर 2é*आवेषण **। सम्मिलन के शीर्ष पर सबसे बड़े के साथ क्रमिक विषम संख्या प्राप्त होती है। Ø.प्रभाव में फाइनल पहले n विषम संख्याओं को बताता है, इसलिए n-th वर्ग की उपज है।

Comments

आह, विषम संख्याओं को सम्‍मिलित करें, मैंने उसके बारे में नहीं सोचा था। अच्छी तरह से किया :) मैं वाक्यांश ले लिया वर्ग संख्या के साथ भी बहुत कुछ सचमुचÄÎé*<CR>

— DJMcMayhem

@DJMcMayhem मैंने पहले भी ऐसा ही सोचा था, लेकिन कुछ गड़बड़ कर दी / 6 बाइट्स प्राप्त कर ली, इसलिए ब्रेनफ्लैक विकि के वर्ग संख्या निर्माण से प्रेरित विषम विषम संख्याओं से प्रेरित इस अन्य दृष्टिकोण की कोशिश की।

— क्रिति लिथोस

Answer 20

AsciiDots , अनुक्रम A019523 द्वारा Alion

\ +++ /
// \ / \

एक बार!

दो बार!

दस गुना!

यह पता लगाने की कोशिश करते हुए कि कोड / भाषा कैसे काम करती है, मैंने जाना कि मौजूदा कोड की पहली दो पंक्तियाँ फाइबोनैचि अनुक्रम को अनंत रूप से आउटपुट करने का काम करती हैं। जब कोई डॉट हिट करता है &, तो कोड समाप्त हो जाता है , इसलिए मुझे आउटपुट के लिए उचित संख्या में प्रविष्टियों की अनुमति देने के लिए शेष लाइनों में और विलंब को जोड़ने की आवश्यकता है।

कुछ परीक्षण, त्रुटि और अवलोकन के बाद, मुझे पता चला कि सही देरी अंतराल प्रति समय 16 यूनिट है। एक पंक्ति में पर्याप्त वर्णों को भरना संभव नहीं था, इसलिए मुझे वास्तविक देरी के लिए 10 वर्णों को छोड़कर, 2 पंक्तियों में देरी करने की आवश्यकता होगी। अपने आप से मेल खाने के पैटर्न के लिए, दोनों पंक्तियों में 5 वर्ण होने चाहिए, और चूँकि बीच के तीन वर्णों को दो बार ट्रेस किया जा सकता है, इससे 16 समय इकाइयाँ वांछित होती हैं।

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

Comments

निम्नलिखित भी काम करता है: \v/v>-----)

— SamYonnou

बढ़िया काम है, आप दो। @SamYonnou इच्छित समाधान के करीब था । इसके अतिरिक्त, मुझे ख़ुशी है कि एक अलग समाधान की ओर अग्रसर होने के बावजूद, सोचा प्रक्रिया समान थी!

— एलियन जूल

Answer 21

Brachylog , अनुक्रम A114018 से असंबंधित स्ट्रिंग

मूल कार्यक्रम:

≜ṗ↔ṗb&w

डालने के लिए स्ट्रिंग:

≜ṗ↔ṗẹbb&w
    ^^

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

व्याख्या

यहाँ पहले मूल कार्यक्रम की व्याख्या है (यह जानते हुए कि प्रयोग किया गया अनुक्रम "कम से कम n अंक प्रधान है जिसका अंक उलटा भी अभाज्य है")

≜         Assign an integer value to a variable named ? 
            (try 0, then 1, then -1, then 2, etc.)
 ṗ        ? must be prime
  ↔ṗ      The reverse of ? must be prime
    b     Remove the first element of ?
     &    Ignore that we removed that element
      w   Write ? to STDOUT

जैसा कि आप देख सकते हैं, एक चीज को छोड़कर कार्यक्रम काफी सीधा है: पूरी तरह से बेकार है b - behead विधेय कॉल है, जो हमारे नंबर के रिवर्स के पहले तत्व को हटा देता है, जिसके साथ हम कुछ भी नहीं करते हैं।

यह एक निश्चित सुराग है कि हम स्ट्रिंग कैसे पा सकते हैं। विचार यह है कि, चूंकि हम स्ट्रिंग को जोड़ने पर प्रत्येक बार संख्या की लंबाई को 1 अंक तक बढ़ाना चाहते हैं, इसलिए हमें उस बेकार का उपयोग करके किसी भी तरह से उस संख्या की लंबाई का "मूल्यांकन" करना होगा b।

समाधान का उपयोग करना है ẹb: पहले, ẹ - elementsअंकों को एक सूची में बदल देगा; फिर, b - beheadइसके पहले तत्व को हटा देगा। ट्रिक यह है कि bअंकों की सूची खाली होने पर फेल हो जाएगी। तो हर बार जब हम एक को जोड़ते हैं b, तो हम आवश्यक संख्या की लंबाई 1 से बढ़ा देंगे (क्योंकि यह तब तक विफल रहेगा जब तक कि निर्धारित मूल्य ?पर्याप्त रूप से कई अंकों को शामिल करने के लिए पर्याप्त नहीं है ताकि अंतिम bएक अंक की सूची में लागू हो)।

ẹप्रत्येक बार फिर से दिखने का कोई प्रभाव नहीं पड़ता क्योंकि यह पहले से ही अंकों की एक सूची है। हमें शुरुआत में केवल एक बार इसकी आवश्यकता है क्योंकि अगर हम किसी संख्या 9001को उसके अंकों की सूची के बजाय मसल देते हैं, तो हम प्राप्त करेंगे 001 = 1जो अंकों की संख्या के बारे में जानकारी खो देता है।

Comments

बहुत अच्छी तरह से किया। मैंने कभी भी इस 9001b1मुद्दे के बारे में नहीं सोचा था , यह वास्तव में सिर्फ यह निकला कि हालांकि अंकों bकी सूची खाली होने पर विफल हो जाएगी, यह विफल नहीं होगा यदि आपके पास वास्तव में कभी कोई सूची नहीं है, क्योंकि एकल-अंकों की संख्या 0 पर है, जिसमें 0 शामिल हैं ।

— असंबंधित स्ट्रिंग

@ असंबंधित स्ट्रिंग संक्षेप में: bअजीब है

— घातक

Answer 22

VDM-SL , A000312 , समय सीमा समाप्त डेटा द्वारा

let m={1|->{0}}in hd reverse[let x=x+1 in x**x|x in set m(1)&x<card m(1)]
                             ^^^^^^^^^^^^^

चूंकि वीडीएम-एसएल के let-एक्सप्रेसेंस वैरिएबल को फिर से बाँध सकते हैं जो पहले से ही एक एनक्लोजिंग स्कोप में बंधे हैं, इसलिए x**xउन्हें स्कॉप्स में मनमाने ढंग से नेस्टेड में मूल्यांकन किया जा सकता है जिसमें xपिछले स्कोप से एक अधिक है, जबकि मूल xअभी भी कार्डिनैलिटी से कम है m(1)।

Comments

मैंने इसे n = 11 तक परीक्षण किया और इसने ठीक काम किया

— असंबंधित स्ट्रिंग

... यह केवल एक नंबर होना चाहिए। If you insert s somewhere into p, this program must print the second integer from the sequence. If you insert s + s into the same location in p, this program must print the third integer from the sequence. उदाहरण के व्यवहार पर ध्यान दें print(1)।

— असंबंधित स्ट्रिंग

आह चीर, समझने योग्य

— असंबंधित स्ट्रिंग

लगता है कि यह सुपर तुच्छ नहीं है, यह अभी भी बहुत अच्छा है!

— डेटा

++ओवरराइड मैप करने के लिए उपयोग करें

— समय सीमा समाप्त डेटा

Answer 23

हास्केल, एक्सन द्वारा A083318

f=length     [2]
        $show

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

Comments

आपको यह मिला! मुझे यकीन है कि प्यार करने के बार-बार दोहरानाshow ।

— xnor

Answer 24

रसेल के फूरियर ट्रांसफॉर्म द्वारा हास्केल , A000045 (फाइबोनैचि)

f = head $(flip(:)<*>sum.take 2)[0, 1]
         ^^^^^^^^^^^^^^^^^^^^^^^

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

23 बाइट्स बिल्कुल।

यह एक मजेदार और थोड़ा मुश्किल था। इससे पहले कि मैं एक मुद्दा नहीं था एहसास हुआ कि उलटा 0 और 1 मुझे थोड़ा सा फेंक दिया। $मूल की कमी ने मुझ पर स्केच किए गए सामान $...$id( जैसे एक बाइट बहुत पहले) की कोशिश की थी, इससे पहले कि मुझ पर यह लिखा कि मैं इसे केवल कोष्ठक में लपेट सकता हूं। सब सब में, एक अच्छा सा पहेली।

H.PWiz बताते हैं कि पैटर्न मिलान से मुझे कम से कम पाँच बाइट्स बचाए जा सकते थे $(\[x,y]->[y,x+y]):। उस डार पॉइंटफ्री चैलेंज ने मुझे हर जगह पॉइंटफ्री सोच दिया।