?::`}:("(!@
perfect:
{:{:;%"}
+puts; "
}zero: "
}else{(:
"negI" _~
""""""{{{"!@
लैटिन अक्षर perfect puts zero else neg Iवास्तव में केवल टिप्पणियां हैं *।
यानी अगर इनपुट सही है 0तो प्रिंट किया जाता है, अन्यथा -1।
इसे ऑनलाइन आज़माएं!
* तो यह या यह काम भी ...
?::`}:("(!@ ?::`}:("(!@
: BEWARE :
{:{:;%"} {:{:;%"}
+ ; " +LAIR; "
} : " } OF : "
} {(: }MINO{(:
" " _~ "TAUR" _~
""""""{{{"!@ """"""{{{"!@
कैसे?
एक इनपुट के रूप में एक धनात्मक पूर्णांक लेता है nऔर -nसहायक स्टैक पर एक संचायक चर को रखता है , फिर प्रत्येक पूर्णांक के लिए n-1नीचे से, और सहित, 1जो कोई भी nसंचयकर्ता को विभाजित करते हैं, के लिए एक विभाज्यता परीक्षण करता है । एक बार यह पूरा हो जाता है यदि संचायक चर गैर-शून्य है एक -1आउटपुट है, अन्यथा ए0 यह है।
?::`}:(केवल निष्पादन की शुरुआत में एक बार निष्पादित किया जाता है,:
?::`}:( Main,Aux
? - take an integer from STDIN and place it onto Main [[n],[]]
: - duplicate top of Main [[n,n],[]]
: - duplicate top of Main [[n,n,n],[]]
` - negate top of Main [[n,n,-n],[]]
} - place top of Main onto Aux [[n,n],[-n]]
: - duplicate top of Main [[n,n,n],[-n]]
( - decrement top of Main [[n,n,n-1],[-n]]
अगला निर्देश, "एक नो-ऑप है, लेकिन हमारे पास तीन पड़ोसी निर्देश हैं इसलिए हम मेन के शीर्ष पर मूल्य के अनुसार शाखा देते हैं, शून्य हमें आगे ले जाता है, जबकि गैर-शून्य हमें सही लेता है।
यदि इनपुट था 1तो हम आगे बढ़ गए क्योंकि मेन का शीर्ष शून्य है:
(!@ Main,Aux
( - decrement top of Main [[1,1,-1],[-1]]
! - print top of Main, a -1
@ - exit the labyrinth
लेकिन अगर इनपुट से अधिक 1हम सही मोड़ लेते हैं क्योंकि मेन का शीर्ष गैर-शून्य है:
:} Main,Aux
: - duplicate top of Main [[n,n,n-1,n-1],[-n]]
} - place top of Main onto Aux [[n,n,n-1],[-n,n-1]]
इस बिंदु पर हमारे पास तीन-पड़ोसी शाखा है, लेकिन हम जानते हैं n-1कि गैर-शून्य है, इसलिए हम सही मोड़ लेते हैं ...
"% Main,Aux
" - no-op [[n,n,n-1],[-n,n-1]]
% - place modulo result onto Main [[n,n%(n-1)],[-n,n-1]]
- ...i.e we've got our first divisibility indicator n%(n-1), an
- accumulator, a=-n, and our potential divisor p=n-1:
- [[n,n%(n-1)],[a,p]]
अब हम एक और तीन-पड़ोसी शाखा में हैं %।
यदि %गैर-शून्य का परिणाम था, तो हम अपने संभावित भाजक को कम करने के लिए छोड़ देते हैं p=p-1, और संचायक को छोड़ देते हैं a, जैसा कि यह है:
;:{(:""}" Main,Aux
; - drop top of Main [[n],[a,p]]
: - duplicate top of Main [[n,n],[a,p]]
{ - place top of Aux onto Main [[n,n,p],[a]]
- three-neighbour branch but n-1 is non-zero so we turn left
( - decrement top of Main [[n,n,p-1],[a]]
: - duplicate top of Main [[n,n,p-1,p-1],[a]]
"" - no-ops [[n,n,p-1,p-1],[a]]
} - place top of Main onto Aux [[n,n,p-1],[a,p-1]]
" - no-op [[n,n,p-1],[a,p-1]]
% - place modulo result onto Main [[n,n%(p-1)],[a,p-1]]
- ...and we branch again according to the divisibility
- of n by our new potential divisor, p-1
... लेकिन अगर परिणाम %शून्य था (केवल पहली बार पास होने पर n=2) हम सीधे बीओटीएच पर जाते हैं, तो हमारे संचयकर्ता को विभाजक जोड़ते हैं a=a+p, और हमारे संभावित भाजक को घटाते हैं p=p-1:
;:{:{+}}""""""""{(:""} Main,Aux
; - drop top of Main [[n],[a,p]]
: - duplicate top of Main [[n,n],[a,p]]
{ - place top of Aux onto Main [[n,n,p],[a]]
: - duplicate top of Main [[n,n,p,p],[a]]
{ - place top of Aux onto Main [[n,n,p,p,a],[]]
+ - perform addition [[n,n,p,a+p],[]]
} - place top of Main onto Aux [[n,n,p],[a+p]]
} - place top of Main onto Aux [[n,n],[a+p,p]]
""""""" - no-ops [[n,n],[a+p,p]]
- a branch, but n is non-zero so we turn left
" - no-op [[n,n],[a+p,p]]
{ - place top of Aux onto Main [[n,n,p],[a+p]]
- we branch, but p is non-zero so we turn right
( - decrement top of Main [[n,n,p-1],[a+p]]
: - duplicate top of Main [[n,n,p-1,p-1],[a+p]]
"" - no-ops [[n,n,p-1,p-1],[a+p]]
} - place top of Main onto Aux [[n,n,p-1],[a+p,p-1]]
इस बिंदु पर अगर p-1हम अभी भी गैर-शून्य हैं तो हम बाएं मुड़ते हैं:
"% Main,Aux
" - no-op [[n,n,p-1],[a+p,p-1]]
% - modulo [[n,n%(p-1)],[a+p,p-1]]
- ...and we branch again according to the divisibility
- of n by our new potential divisor, p-1
... लेकिन अगर p-1शून्य पर हम सीधे :भूलभुलैया की दूसरी पंक्ति पर जाते हैं (आपने पहले सभी निर्देशों को देखा है, तो मैं उनका वर्णन छोड़ रहा हूं और बस अपना प्रभाव दे रहा हूं):
:":}"":({):""}"%;:{:{+}}"""""""{{{ Main,Aux
: - [[n,n,0,0],[a,0]]
" - [[n,n,0,0],[a,0]]
- top of Main is zero so we go straight
- ...but we hit the wall and so turn around
: - [[n,n,0,0,0],[a,0]]
} - [[n,n,0,0],[a,0,0]]
- top of Main is zero so we go straight
"" - [[n,n,0,0],[a,0,0]]
: - [[n,n,0,0,0],[a,0,0]]
( - [[n,n,0,0,-1],[a,0,0]]
{ - [[n,n,0,0,-1,0],[a,0]]
- top of Main is zero so we go straight
- ...but we hit the wall and so turn around
( - [[n,n,0,0,-1,-1],[a,0]]
: - [[n,n,0,0,-1,-1,-1],[a,0]]
"" - [[n,n,0,0,-1,-1,-1],[a,0]]
} - [[n,n,0,0,-1,-1],[a,0,-1]]
- top of Main is non-zero so we turn left
" - [[n,n,0,0,-1,-1],[a,0,-1]]
% - (-1)%(-1)=0 [[n,n,0,0,0],[a,0,-1]]
; - [[n,n,0,0],[a,0,-1]]
: - [[n,n,0,0,0],[a,0,-1]]
{ - [[n,n,0,0,0,-1],[a,0]]
: - [[n,n,0,0,0,-1,-1],[a,0]]
{ - [[n,n,0,0,0,-1,-1,0],[a]]
+ - [[n,n,0,0,0,-1,-1],[a]]
} - [[n,n,0,0,0,-1],[a,-1]]
} - [[n,n,0,0,0],[a,-1,-1]]
""""""" - [[n,n,0,0,0],[a,-1,-1]]
- top of Main is zero so we go straight
{ - [[n,n,0,0,0,-1],[a,-1]]
{ - [[n,n,0,0,0,-1,-1],[a]]
{ - [[n,n,0,0,0,-1,-1,a],[]]
अब यह {तीन पड़ोसी निर्देश हैं, इसलिए ...
... अगर aशून्य है, जो कि पूर्ण के लिए होगा n, तो हम सीधे जाते हैं:
"!@ Main,Aux
" - [[n,n,0,0,0,-1,-1,a],[]]
- top of Main is a, which is zero, so we go straight
! - print top of Main, which is a, which is a 0
@ - exit the labyrinth
... अगर aगैर-शून्य है, जो गैर-परिपूर्ण के लिए होगा n, तो हम बाएं मुड़ते हैं:
_~"!@ Main,Aux
_ - place a zero onto Main [[n,n,0,0,0,-1,-1,a,0],[]]
~ - bitwise NOT top of Main (=-1-x) [[n,n,0,0,0,-1,-1,a,-1],[]]
" - [[n,n,0,0,0,-1,-1,a,-1],[]]
- top of Main is NEGATIVE so we turn left
! - print top of Main, which is -1
@ - exit the labyrinth