रटर , 310 बाइट्स
n=e=$Input;
a=0;
w=While[{m=Modulo[$e];Not[m[1]];}];
w=w[{f=For[4];f=f[@x];f=f[{Print[$e];q=Equal[$x];i=If[{q[1];}];i=i[{k=Times[$e];}];Do[$i];i=If[{q[2];}];i=i[{k=Add[$e];}];Do[$i];i=If[{q[3];}];i=i[{k=Subtract[$e];}];Do[$i];i=If[{q[4];}];i=i[{k=Divide[$e];}];Do[$i];e=k[a=Increment[$a]];}];Do[$f];}];
Do[$w];
इसे ऑनलाइन आज़माएं!
यह समय है जब मैंने रटर का फिर से इस्तेमाल किया। दुर्भाग्य से, यह कार्य के लिए सबसे अच्छी भाषा नहीं हो सकती है, क्योंकि इसका कोई रूप नहीं है eval, मुझे चार बयानों का उपयोग करने के लिए मजबूर करता है
यह काम किस प्रकार करता है
रटर कैसे काम करता है
भाषा कैसे काम करती है, इस पर एक संक्षिप्त पूर्वानुमान: सब कुछ या तो एक असाइनमेंट या फ़ंक्शन है, और प्रत्येक फ़ंक्शन बिल्कुल एक तर्क लेता है। उन ऑपरेशनों के लिए जिनमें एक से अधिक तर्क (जैसे गुणा) की आवश्यकता होती है, पहला कॉल एक आंशिक फ़ंक्शन देता है, जब दूसरे तर्क के साथ फिर से कॉल किया जाता है, तो अपेक्षित परिणाम देता है। उदाहरण के लिए:
left = Times[5];
Print[left[6]];
30 का प्रिंट आउट लेंगे: इसे ऑनलाइन आज़माएं! । हालांकि आम तौर पर यह सामान्य विकल्प से अधिक लंबा होता है, यह कई बार बाइट्स को बचा सकता है, अगर किसी फ़ंक्शन को एक बार एक निरंतर तर्क के साथ बार-बार कहा जाता है, और एक बदलते तर्क, उदाहरण के लिए जब बार टेबल को प्रिंट करते हैं।
यह एक तर्क नियम उन सभी पर लागू होता है जो एक निरंतर या एक चर नहीं है, जिसमें लूप और सशर्त शामिल हैं। हालांकि, लूप और सशर्त, ( For, Each, While, DoWhile, Ifऔर IfElse) कर रहे हैं साध्य जिसका अर्थ है कि आदेश वास्तव में उन्हें चलाने के लिए, Doसमारोह बुलाया जाना चाहिए (उत्तर में अंतिम पंक्ति देखें)। फिर से, यह बाइट्स को बार-बार एक ही लूप को चलाने से बचा सकता है, या आपको लूप की परिभाषा और रनिंग के बीच मनमाना कोड चलाने की अनुमति देता है।
अंत में, चर का जिक्र करने के तीन तरीके हैं, जो सभी इस कार्यक्रम में उपयोग किए जाते हैं। पहला प्रत्यक्ष संदर्भित है , जहां चर नाम एक $प्रतीक के साथ उपसर्ग है । यह सीधे चर के मूल्य तक पहुँचता है और इसे वापस करता है। दूसरा कार्यात्मक संदर्भित है , जिसमें एक उपसर्ग वर्ण नहीं है। यह कोड को चर (संभावित आंशिक) कार्यों के बीच अंतर करने की अनुमति देता है, चर और वास्तविक चर विशिष्ट मूल्य वाले होते हैं। अंत में, अप्रत्यक्ष संदर्भ , एक @प्रतीक के साथ उपसर्ग , एक चर बनाता है (यदि यह पहले से मौजूद नहीं है) और किसी दिए गए दायरे के भीतर चर वस्तु को वापस करता है। यह आपको एक लूप वेरिएबल (जैसे ) iमें बनाने की अनुमति देता है for i in range(...)।
वास्तविक समाधान कैसे काम करता है
यहाँ अ-कोडित कोड है:
n = elem = $Input;
var = 0;
while = While[{
mod = Modulo[$elem];
Not[mod[1]];
}];
while = while[{
for = For[4];
for = for[@index];
for = for[{
Print[$elem];
equal = Equal[$index];
if = If[{ equal[1]; }];
if = if[{ func = Times[$elem]; }];
Do[$if];
if = If[{ equal[2];}];
if = if[{ func = Add[$elem];}];
Do[$if];
if = If[{ equal[3];}];
if = if[{ func = Subtract[$elem];}];
Do[$if];
if=If[{ equal[4];}];
if=if[{ func = Divide[$elem];}];
Do[$if];
elem = func[var = Increment[$var]];
}];
Do[$for];
}];
Do[$while];
इसे ऑनलाइन आज़माएं!
जैसा कि आप देख सकते हैं, यह तीन चर को निर्दिष्ट करके शुरू होता है n, eऔर a, जो क्रमशः इनपुट, अनुक्रम में बदलते तत्व और प्रत्येक नए तत्व के लिए संशोधन संख्या का प्रतिनिधित्व करता है। हम फिर थोड़ी देर का लूप बनाते हैं:
w=While[{m=Modulo[$e];Not[m[1]];}];
{}me % m100→1n→0,n≠0
इसके बाद हम लूप के शरीर से मिलकर पूरी तरह से संकीर्णता में आ जाते हैं:
w=w[{f=For[4];f=f[@x];f=f[{Print[$e];q=Equal[$x];i=If[{q[1];}];i=i[{k=Times[$e];}];Do[$i];i=If[{q[2];}];i=i[{k=Add[$e];}];Do[$i];i=If[{q[3];}];i=i[{k=Subtract[$e];}];Do[$i];i=If[{q[4];}];i=i[{k=Divide[$e];}];Do[$i];e=k[a=Increment[$a]];}];Do[$f];}];
4x
Print[$e];
q=Equal[$x];
i=If[{q[1];}];i=i[{k=Times[$e] ;}];Do[$i];
i=If[{q[2];}];i=i[{k=Add[$e] ;}];Do[$i];
i=If[{q[3];}];i=i[{k=Subtract[$e] ;}];Do[$i];
i=If[{q[4];}];i=i[{k=Divide[$e] ;}];Do[$i];
e=k[a=Increment[$a]];
पहला कथन अनुक्रम के प्रत्येक पुनरावृत्ति को संशोधित करने से पहले प्रिंट करता है। फिर हम लूप वेरिएबल के साथ समानता की जांच करने के लिए एक आंशिक फ़ंक्शन बनाते हैं x, और यदि कथन में चार का सामना करते हैं। प्रत्येक कथन की जाँच करता है कि क्याx है क्रमशः 1, 2, 3 या 4 के बराबर है, और फिर प्रदान करती है kमें प्रत्येक कार्य करने के लिए *, +, -और /, तो यह एक आंशिक समारोह में बनाता है के साथ eअपने तर्क के रूप में। अंत में, हम इसके दूसरे तर्क और वेतन वृद्धि के रूप में चलाने के eलिए असाइन करते हैं ।kaa
