पावरप्रोग्रामिंग: O (1 ^ N), O (N ^ 1), O (2 ^ N), O (N ^ 2) सभी एक में

Question

एक प्रोग्राम (या फ़ंक्शन) लिखें जो चार सामान्य बड़ी ओ समय जटिलताओं को प्रदर्शित करता है कि यह कैसे चलाया जाता है। किसी भी रूप में यह एक सकारात्मक पूर्णांक एन में लेता है जिसे आप मान सकते हैं कि 2 ³¹ से कम है ।

1. जब कार्यक्रम अपने मूल रूप में चलाया जाता है तो इसमें निरंतर जटिलता होनी चाहिए । यही है, जटिलता Θ (1) या, समकक्ष, 1 (1 ^ एन) होनी चाहिए ।

2. जब कार्यक्रम को उलट दिया जाता है और इसे चलाया जाता है तो इसमें रैखिक जटिलता होनी चाहिए । यही है, जटिलता Θ (एन) या, समकक्ष, N (एन ^ 1) होनी चाहिए ।
   (इसका उल्टा N^1होता 1^Nहै।)

3. जब कार्यक्रम को दोगुना कर दिया जाता है , अर्थात स्वयं को सम्‍मिलित किया जाता है, और इसे चलाने के लिए घातीय जटिलता होनी चाहिए , विशेष रूप से 2 ^एन । यही है, जटिलता Θ (2 ^ एन) होनी चाहिए ।
   (यह समझ में आता है क्योंकि 2अंदर 2^Nसे दोगुना 1है 1^N।)

4. जब कार्यक्रम को दोगुना और उलट दिया जाता है और इसे चलाया जाता है तो इसमें बहुपद जटिलता होनी चाहिए , विशेष रूप से एन ² । यही है, जटिलता Θ (एन ^ 2) होनी चाहिए ।
   (इसका उल्टा N^2होता 2^Nहै।)

ये चार मामले केवल वही हैं जिन्हें आपको संभालने की आवश्यकता है।

ध्यान दें कि अनिश्चितता के लिए मैं बड़े O के बजाय बड़ी थीटा (ation) संकेतन का उपयोग कर रहा हूं क्योंकि आपके कार्यक्रमों के रनटाइम को आवश्यक जटिलताओं से ऊपर और नीचे दोनों से बांधा जाना चाहिए। अन्यथा केवल O (1) में एक फ़ंक्शन लिखने से सभी चार बिंदुओं को पूरा किया जाएगा। यहां बारीकियों को समझना बहुत जरूरी नहीं है। मुख्य रूप से, यदि आपका प्रोग्राम कुछ निरंतर k के लिए k * f (N) संचालन कर रहा है तो यह Θ (f (N)) में होने की संभावना है।

उदाहरण

यदि मूल कार्यक्रम थे

ABCDE

फिर इसे चलाने के लिए निरंतर समय लेना चाहिए। यही है, चाहे इनपुट एन 1 या 2147483647 (2 ³¹ -1) या बीच में कोई मूल्य है, इसे लगभग उसी समय में समाप्त करना चाहिए।

कार्यक्रम का उलटा संस्करण

EDCBA

N के संदर्भ में रैखिक समय लेना चाहिए। अर्थात, समाप्त होने में लगने वाला समय N के समानुपाती रूप से होना चाहिए। इसलिए N = 1 को कम से कम समय लगता है और N = 2147483647 सबसे अधिक लेता है।

कार्यक्रम का दोगुना संस्करण

ABCDEABCDE

एन के संदर्भ में दो-टू-एन समय लेना चाहिए। अर्थात, समाप्त होने में लगने वाला समय लगभग 2 ^{एन के} समानुपातिक होना चाहिए । अतः यदि N = 1 लगभग एक सेकंड में समाप्त हो जाता है, तो N = 60 को समाप्त होने में ब्रह्मांड की आयु से अधिक समय लगेगा। (नहीं, आपको इसका परीक्षण करने की आवश्यकता नहीं है।)

कार्यक्रम का दोहरा और उलटा संस्करण

EDCBAEDCBA

N के संदर्भ में चुकता समय लेना चाहिए। अर्थात, समाप्त होने में लगने वाला समय N * N के लगभग आनुपातिक होना चाहिए। इसलिए यदि N = 1 लगभग एक सेकंड में समाप्त हो जाता है, तो N = 60 को समाप्त होने में लगभग एक घंटा लगेगा।

विवरण

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

• यह ठीक है अगर अभ्यास के समय आपके कार्यक्रम पूरी तरह से उनकी जटिलता (या यहां तक ​​कि नियतात्मक) के प्रतिनिधि नहीं हैं। उदाहरण के लिए इनपुट N + 1 कभी-कभी N की तुलना में तेज़ी से चल सकता है।

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

• यहां सभी जटिलताओं के लिए हम मानते हैं कि हम सबसे खराब स्थिति के बारे में बात कर रहे हैं , सबसे अच्छा मामला या औसत-मामला नहीं।

• कार्यक्रमों की अंतरिक्ष जटिलता मायने नहीं रखती है, केवल समय जटिलता।

• कार्यक्रम कुछ भी उत्पादन कर सकते हैं। यह केवल मायने रखता है कि वे सकारात्मक पूर्णांक एन में लेते हैं और सही समय जटिलताएं हैं।

• टिप्पणियों और बहुस्तरीय कार्यक्रमों की अनुमति है। (आप मान सकते हैं कि \r\nउलट \r\nविंडोज संगतता के लिए है।)

बिग ओ रिमाइंडर्स

सबसे तेज़ से लेकर सबसे धीमी गति तक O(1), O(N), O(N^2), O(2^N)(क्रम 1, 2, 4, 3 ऊपर)।

धीमी शर्तें हमेशा हावी रहती हैं, जैसे O(2^N + N^2 + N) = O(2^N)।

O(k*f(N)) = O(f(N))निरंतर कश्मीर के लिए। तो O(2) = O(30) = O(1)और O(2*N) = O(0.1*N) = O(N)।

याद रखें O(N^2) != O(N^3)और O(2^N) != O(3^N)।

नीट बड़ा ओ धोखा पत्रक।

स्कोरिंग

यह सामान्य कोड गोल्फ है। बाइट्स जीत में सबसे छोटा मूल कार्यक्रम (लगातार समय एक)।

Comments

बहुत बढ़िया सवाल! न्यूनतम बिंदु: हमें सबसे खराब स्थिति / सर्वश्रेष्ठ-मामले / औसत-मामले को निर्दिष्ट करने की आवश्यकता नहीं है, क्योंकि केवल इनपुट जो कि आकार एन के रूप में गिना जाता है, वह संख्या एन ही है (जो कि बीटीडब्ल्यू इनपुट आकार की सामान्य धारणा नहीं है: वह है) इनपुट एन का इलाज आकार लॉग एन के होने के नाते)। इसलिए प्रत्येक एन के लिए केवल एक ही मामला है, जो एक साथ सबसे अच्छा, सबसे खराब और औसत मामला है।

— श्रीवत्सआर

ऐसा प्रतीत होता है कि आप जटिलता की सामान्य परिभाषा से भटक गए हैं। हम हमेशा एक एल्गोरिथ्म के समय की जटिलता को उसके इनपुट के आकार के कार्य के रूप में परिभाषित करते हैं । मामले में जहां इनपुट एक संख्या है, इनपुट का आकार उस संख्या का आधार -2 लघुगणक है। तो कार्यक्रम n = input(); for i in xrange(n): passमें घातीय जटिलता है, क्योंकि यह 2 ** kकदम उठाता है, जहां k = log_2(n)इनपुट आकार है। आपको यह स्पष्ट करना चाहिए कि क्या यह मामला है, क्योंकि यह नाटकीय रूप से आवश्यकताओं को बदलता है।

— वचर्जिन

Answer 1

पायथन 3 , 102 बाइट्स

try:l=eval(input());k=1#)]0[*k**l(tnirp
except:k=2#2=k:tpecxe
print(k**l*[0])#1=k;))(tupni(lave=l:yrt

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

यह O (1 ^ n) का है, क्योंकि यह वही है जो कार्यक्रम करता है:

• इनपुट का मूल्यांकन करें
• सरणी बनाएँ [0]
• इसे छापो

---

उलट:

try:l=eval(input());k=1#)]0[*l**k(tnirp
except:k=2#2=k:tpecxe
print(l**k*[0])#1=k;))(tupni(lave=l:yrt

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

यह O (n ^ 1) का है, क्योंकि यह वही है जो कार्यक्रम करता है:

• इनपुट का मूल्यांकन करें
• सरणी बनाएं [0] * इनपुट (0 इनपुट के रूप में कई बार दोहराया गया)
• इसे छापो

---

दोगुनी:

try:l=eval(input());k=1#)]0[*k**l(tnirp
except:k=2#2=k:tpecxe
print(k**l*[0])#1=k;))(tupni(lave=l:yrt
try:l=eval(input());k=1#)]0[*k**l(tnirp
except:k=2#2=k:tpecxe
print(k**l*[0])#1=k;))(tupni(lave=l:yrt

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

यह O (2 ^ n) का है, क्योंकि यह वही है जो कार्यक्रम करता है:

• इनपुट का मूल्यांकन करें
• सरणी बनाएँ [0]
• इसे छापो
• इनपुट का मूल्यांकन करने का प्रयास करें
• असफल
• सरणी बनाएं [0] * (2 ^ इनपुट) (0 को 2 ^ इनपुट के रूप में कई बार दोहराया गया)
• इसे छापो

---

संदेह और उलट:

try:l=eval(input());k=1#)]0[*l**k(tnirp
except:k=2#2=k:tpecxe
print(l**k*[0])#1=k;))(tupni(lave=l:yrt
try:l=eval(input());k=1#)]0[*l**k(tnirp
except:k=2#2=k:tpecxe
print(l**k*[0])#1=k;))(tupni(lave=l:yrt

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

यह O (n ^ 2) का है, क्योंकि यह वही है जो कार्यक्रम करता है:

• इनपुट का मूल्यांकन करें
• सरणी बनाएं [0] * इनपुट (0 इनपुट के रूप में कई बार दोहराया गया)
• इसे छापो
• इनपुट का मूल्यांकन करने का प्रयास करें
• असफल
• सरणी बनाएं [0] * (इनपुट ^ 2) (इनपुट वर्ग के रूप में कई बार दोहराया गया)
• इसे छापो

Comments

जब एकाधिक कॉल होते हैं, तो यह उपयोगकर्ता सहभागिता का इंतजार क्यों नहीं करता है input()?

— जोनाथन एलन

यह एक खामी है कि "ट्रांसमिशन का अंत" ट्रांसमिशन के अंत में प्रसारित होता है?

— लीक नून

क्या आप इसे समझा सकते हैं?

— ब्रेन गाइडर

पुन: "फ़ाइल का अंत" तर्क, आप चीजों को पीछे की ओर देख रहे हैं। जब आप टर्मिनल का उपयोग कर रहे होते हैं, तो इनपुट हैंग के लिए अनुरोध करते हैं क्योंकि इसमें कुछ जुड़ा होता है; ctrl-D को स्पष्ट रूप से कोई इनपुट भेजने के लिए भेजा जा सकता है। यदि इनपुट एक खाली फ़ाइल से जुड़ा है (जैसे कि TIO करता है यदि आप इनपुट बॉक्स को खाली छोड़ देते हैं), या यदि यह किसी फ़ाइल से जुड़ा है, जहां सभी इनपुट पढ़े गए हैं, तो इनपुट के लिए अनुरोध की कोई आवश्यकता नहीं है; यह पहले से ही पता है कि कोई इनपुट नहीं है। UNIX / Linux पर, "फ़ाइल का अंत" और "कोई इनपुट उपलब्ध नहीं" नियमित फ़ाइलों पर अप्रभेद्य हैं।

पहले मामले के लिए, kइनपुट है, और lएक है, तो आप अभी भी कंप्यूटिंग कर रहे हैं 1**k, है ना? कौन सा लेना चाहिए O(log(k))समय है कि तथ्य यह है कि तुम और मैं और सब लोग पहले से जानता है कि यह एक है के बावजूद,?

— रिचर्ड रस्त

Answer 2

पर्ल 5, 82 73 71 + 1 (एक ध्वज के लिए) = 72 बाइट्स

मुझे यकीन है कि मैं इसे (बहुत) अधिक गोल्फ कर सकता हूं, लेकिन यह सोने का समय है, मैंने पर्याप्त समय डिबगिंग के रूप में बिताया है, और मुझे गर्व है कि मेरे पास अभी तक क्या है।

#x$=_$;
$x.=q;#say for(1..2**$_)#)_$..1(rof _$=+x$;;
eval $x;$x=~s/#//;

कार्यक्रम स्वयं इनपुट का उपयोग नहीं करता है, और बस एक टिप्पणी के साथ एक स्ट्रिंग शुरुआत का मूल्यांकन करता है और फिर एकल स्ट्रिंग प्रतिस्थापन करता है, इसलिए यह निरंतर समय में स्पष्ट रूप से है। यह मूल रूप से इसके बराबर है:

$x="#";
eval $x;
$x=~s/#//;

दोगुनी:

#x$=_$;
$x.=q;#say for(1..2**$_)#)_$..1(rof _$=+x$;;
eval $x;$x=~s/#//;
#x$=_$;
$x.=q;#say for(1..2**$_)#)_$..1(rof _$=+x$;;
eval $x;$x=~s/#//;

बिट जो वास्तव में घातीय समय लेता है वह दूसरा प्रमाण है: यह कमांड का मूल्यांकन करता है say for(1..2**$_), जो 1 से 2 ^ एन तक सभी संख्याओं को सूचीबद्ध करता है, जो स्पष्ट रूप से घातीय समय लेता है।

उलट:

;//#/s~=x$;x$ lave
;;$x+=$_ for(1..$_)#)_$**2..1(rof yas#;q=.x$
;$_=$x#

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

$x+=$_ for(1..$_);
$_=$x;

अंतिम पंक्ति सिर्फ इतनी है कि जब इन आदेशों को दोहराया जाता है तो यह द्विघात समय लगेगा।

उलट और दोगुना:

;//#/s~=x$;x$ lave
;;$x+=$_ for(1..$_)#)_$**2..1(rof yas#;q=.x$
;$_=$x#
;//#/s~=x$;x$ lave
;;$x+=$_ for(1..$_)#)_$**2..1(rof yas#;q=.x$
;$_=$x#

यह अब इनपुट के योग का सारांश लेता है (और इसे इनपुट के योग में जोड़ता है, लेकिन जो भी हो)। चूंकि यह आदेश N^2जोड़ देता है, इसलिए इसमें द्विघात समय लगता है। यह मूल रूप से इसके बराबर है:

$x=0;
$x+=$_ for(1..$_);
$_=$x;
$x+=$_ for(1..$_);
$_=$x;

दूसरी पंक्ति इनपुट के योग को खोजती है, Nपरिवर्धन करती है, जबकि चौथी summation(N)परिवर्धन करती है, जो है O(N^2)।

Comments

महान! मुख्यधारा की भाषा में ऐसा करना कठिन होता! यह मेरा उत्थान है!

— अर्जुन

अच्छा किया, यह बहुत अच्छा है। आप शायद $x.=q;##say...इसके बजाय मतलब था $x.=q;#say...( #1 के बजाय दो के साथ )। (यह बताएगा कि आपने 75 के बजाय 76 बाइट्स क्यों गिना)। इसके अलावा, आपको -nअपने बायटेकाउंट में ध्वज को गिनना चाहिए , क्योंकि आपका कार्यक्रम इसके बिना बहुत कुछ नहीं करता है।

— दादा

@ दादा मैंने गलती से evalऔर s///आदेशों को स्थानांतरित कर दिया । यदि आप evalपहले करते हैं तो आपको केवल एक की आवश्यकता है #। अच्छी पकड़!

— क्रिस

@ क्रिस राइट, यह वास्तव में काम करता है। आप अंतिम को छोड़ सकते हैं #: $x=~s/#//;उलट उत्पादन ;//#/s~=x$, जो आपके संदर्भ में कुछ भी नहीं करता है, जैसा कि यह एक अग्रणी के साथ होगा #। (हालांकि मैंने इसका परीक्षण नहीं किया है)। भले ही, एक +1 हो!

— दादा

@ डाडा नाइस कैच एक बार फिर!

— क्रिस

Answer 3

दरअसल , 20 बाइट्स

";(1╖╜ⁿr"ƒ"rⁿ@╜╖1(;"

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

इनपुट: 5

आउटपुट:

rⁿ@╜╖1(;
[0]
5

---

उलट:

";(1╖╜@ⁿr"ƒ"rⁿ╜╖1(;"

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

आउटपुट:

rⁿ╜╖1(;
[0, 1, 2, 3, 4]
5

---

दोगुनी:

";(1╖╜ⁿr"ƒ"rⁿ@╜╖1(;"";(1╖╜ⁿr"ƒ"rⁿ@╜╖1(;"

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

आउटपुट:

rⁿ@╜╖1(;
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]
rⁿ@╜╖1(;
rⁿ@╜╖1(;
[0]

---

संदेह और उलट:

";(1╖╜@ⁿr"ƒ"rⁿ╜╖1(;"";(1╖╜@ⁿr"ƒ"rⁿ╜╖1(;"

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

आउटपुट:

rⁿ╜╖1(;
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]
rⁿ╜╖1(;
rⁿ╜╖1(;
[0, 1, 2, 3, 4]

---

मुख्य विचार

दरअसल एक स्टैक-आधारित भाषा है।

• abcएक कार्यक्रम है जिसमें O (1 ⁿ ) जटिलता है, और इसके डबल में O (2 ^{n) है} ) जटिलता है।
• defएक ऐसा प्रोग्राम है जिसमें O (n ¹ ) जटिलता है, और इसके डबल में O (n ² ) जटिलता है।

फिर, मेरा सबमिशन है "abc"ƒ"fed", ƒमूल्यांकन कहां है। इस तरह, "fed"मूल्यांकन नहीं किया जाएगा।

व्यक्तिगत कार्यक्रम का निर्माण

पहले घटक का छद्म कोड ;(1╖╜ⁿr:

register += 1 # register is default 0
print(range(register**input))

दूसरे घटक का छद्म कोड ;(1╖╜ⁿ@r:

register += 1 # register is default 0
print(range(input**register))

Comments

मैंने कभी नहीं सोचा था कि यह भी संभव होगा! बड़ा काम है साहब! +1

— अर्जुन

@ अर्जुन आपकी सराहना के लिए धन्यवाद।

— लीक नून

यह उत्कृष्ट है और सही मायने में IMO टिप्पणियों का उपयोग करके चुनौती के लिए नहीं उठता है। बहुत बढ़िया!

— श्रीवत्सआर

खैर यह वास्तव में टिप्पणी है ... तार अविकसित हैं और NOP हैं ...

— लीक नून

Answer 4

जेली , 20 बाइट्स

आंशिक रूप से लीक नून के वास्तव में समाधान से प्रेरित है ।

अग्रणी और अनुगामी newlines महत्वपूर्ण हैं।

सामान्य:

⁵Ŀ⁵
R
R²
2*R
‘
⁵Ŀ⁵

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

इनपुट: 5

आउटपुट:

610

---

उलट:

⁵Ŀ⁵
‘
R*2
²R
R
⁵Ŀ⁵

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

इनपुट: 5

आउटपुट:

[1, 2, 3, 4, 5]10

---

दोगुनी

⁵Ŀ⁵
R
R²
2*R
‘
⁵Ŀ⁵

⁵Ŀ⁵
R
R²
2*R
‘
⁵Ŀ⁵

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

इनपुट: 5

आउटपुट:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]10

---

दुहराया और उलट दिया

⁵Ŀ⁵
‘
R*2
²R
R
⁵Ŀ⁵

⁵Ŀ⁵
‘
R*2
²R
R
⁵Ŀ⁵

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

इनपुट: 5

आउटपुट:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]10

---

व्याख्या

यहां कुंजी है Ŀ, जिसका अर्थ है "इंडेक्स एन पर लिंक को एक सनक के रूप में कॉल करता है।" लिंक 1 से शुरू होकर ऊपर से नीचे की ओर अनुक्रमित होते हैं, मुख्य लिंक (नीचे-सबसे एक) को छोड़कर।Ŀसाथ ही मॉड्यूलर है, इसलिए यदि आप लिंक 5 में से 7 नंबर को कॉल करने का प्रयास करते हैं, तो आप वास्तव में लिंक 2 को कॉल करेंगे।

इस कार्यक्रम में कहा जाने वाला लिंक हमेशा इंडेक्स 10 पर होता है ( ⁵) कोई फर्क नहीं पड़ता कि यह प्रोग्राम का कौन सा संस्करण है। हालांकि, इंडेक्स 10 पर कौन सा लिंक है यह संस्करण पर निर्भर करता है।

ऐसा ⁵प्रतीत होता है कि प्रत्येक के बाद होता Ŀहै इसलिए यह उलटा होने पर टूटता नहीं है। यदि कोई संख्या पहले नहीं है, तो कार्यक्रम पार्स-टाइम पर त्रुटि करेगा Ŀ। एक होने⁵ बाद यह जगह से बाहर है, जो सिर्फ उत्पादन के लिए सीधे चला जाता है।

मूल संस्करण लिंक को कॉल ‘करता है, जो n + 1 की गणना करता है।

उलटा संस्करण लिंक को कॉल करता है R, जो कि सीमा 1 .. n उत्पन्न करता है।

दोगुना संस्करण लिंक को कॉल 2*Rकरता है, जो 2 ^{एन की} गणना करता है और सीमा 1 .. 2 ^एन उत्पन्न करता है ।

दोहरा और उलटा संस्करण लिंक को कॉल ²Rकरता है, जो n ^{2 की} गणना करता है और रेंज 1 .. n ² उत्पन्न करता है ।

Answer 5

Befunge-98 , 50 बाइट्स

साधारण

\+]#:\-1vk  !:;#
@k!:-1 .: ;#]#$ <;
[*:>@ 
&$< ^&;

यह अब तक 4 का सबसे सरल कार्यक्रम है - केवल कमांड जो निष्पादित किए जाते हैं वे निम्नलिखित हैं:

\+]
  !
  : @
&$< ^&;

यह प्रोग्राम "टर्न राईट" कमांड ( ]) और एरो को हिट करने से पहले कुछ बेमतलब का सामान करता है । फिर यह 2 "टेक इनपुट" कमांड हिट करता है । क्योंकि इनपुट में केवल 1 नंबर है और टीआईओ के व्यवहार के &कारण कार्यक्रम 60 सेकंड के बाद बाहर निकलता है। यदि 2 इनपुट हैं (और क्योंकि मैं बाइट्स जोड़कर नहीं कर सकता), तो आईपी "एंड प्रोग्राम" फ़ंक्शन में यात्रा करेगा।

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

औंधा

;&^ <$&
 @>:*[
;< $#]#; :. 1-:!k@
#;:!  kv1-\:#]+\

यह एक और अधिक जटिल है। प्रासंगिक आदेश इस प्रकार हैं:

;&^  $
  >:*[
;< $#]#; :. 1-:!k@
  :

के बराबर है

;&^                   Takes input and sends the IP up. the ; is a no-op
  :                   Duplicates the input.
  >:*[                Duplicates and multiplies, so that the stack is [N, N^2
     $                Drops the top of the stack, so that the top is N
     ]#;              Turns right, into the loop
         :.           Prints, because we have space and it's nice to do
            1-        Subtracts 1 from N
              :!k@    If (N=0), end the program. This is repeated until N=0
;< $#]#;              This bit is skipped on a loop because of the ;s, which comment out things

यहाँ महत्वपूर्ण हिस्सा है :. 1-:!k@ थोड़ा है। यह उपयोगी है क्योंकि जब तक हम कम समय जटिलता में निष्पादित करने से पहले स्टैक पर सही जटिलता को धक्का देते हैं, हम वांछित प्राप्त कर सकते हैं। इस तरह से शेष 2 कार्यक्रमों में इसका उपयोग किया जाएगा।

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

दोगुनी

\+]#:\-1vk  !:;#
@k!:-1 .: ;#]#$ <;
[*:>@ 
&$< ^&;\+]#:\-1vk  !:;#
@k!:-1 .: ;#]#$ <;
[*:>@ 
&$< ^&;

और प्रासंगिक आदेश हैं:

\+]
  !
  :
&$< ^&;\+]#:\-1vk  !:;#
@k!:-1 .: ;#]#$ <;

यह कार्यक्रम 2 छोरों में जाता है। सबसे पहले, यह सामान्य प्रोग्राम के समान पथ का अनुसरण करता है, जो स्टैक पर 1 और एन को धक्का देता है, लेकिन दूसरे के चारों ओर लपेटने के बजाय &, आईपी एक लूप में एक टिप्पणी पर कूदता है जो धक्का देता है 2^N:

        vk!:    If N is 0, go to the next loop.
      -1        Subtract 1 from N
 +  :\          Pulls the 1 up to the top of the stack and doubles it
  ]#            A no-op
\               Pulls N-1 to the top again

लाइन 4 पर अन्य बिट्स का उपयोग कर छोड़ दिया गया ;रों

बाद में (2 ^ N) स्टैक पर धकेल दिया जाता है, हम एक पंक्ति को पूर्वोक्त मुद्रण लूप में ले जाते हैं। पहले लूप के कारण, समय जटिलता N (एन + 2 ^ एन) है, लेकिन यह घटकर Θ (2 ^ एन) हो जाती है।

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

दुहराया और उलट दिया

;&^ <$&
 @>:*[
;< $#]#; :. 1-:!k@
#;:!  kv1-\:#]+\;&^ <$&
 @>:*[
;< $#]#; :. 1-:!k@
#;:!  kv1-\:#]+\

प्रासंगिक आदेश:

;&^

;< $#]#; :. 1-:!k@

 @>:*[

  :

यह उलटा कार्यक्रम के लिए लगभग समान रूप से कार्य करता है, लेकिन N^2स्टैक से पॉपअप नहीं किया जाता है, क्योंकि कार्यक्रम की दूसरी प्रति की पहली पंक्ति को पहली की अंतिम पंक्ति में जोड़ा जाता है, जिसका अर्थ है कि ड्रॉप कमांड ( $) कभी भी निष्पादित नहीं होता है। , इसलिए हम N^2स्टैक के शीर्ष पर प्रिंटिंग लूप में जाते हैं ।

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