Kipple की व्याख्या करें!

Question

परिचय

Kipple एक स्टैक-आधारित, गूढ़ प्रोग्रामिंग भाषा है जिसका आविष्कार मार्च 2003 में Rune Berg ने किया था।

किप्पल में 27 स्टैक, 4 ऑपरेटर और एक नियंत्रण संरचना है।

ढेर

स्टैक नाम हैं a- zऔर 32-बिट हस्ताक्षरित पूर्णांक हैं। @आउटपुट संख्याओं को अधिक सुविधाजनक बनाने के लिए , एक विशेष स्टैक भी है । जब किसी संख्या को धकेला जाता है @, तो उस संख्या के अंकों के ASCII मान वास्तव में बदले जाते हैं। (उदाहरण के लिए, यदि आप 12 को धक्का देते हैं @, तो यह 49 और फिर 50 को @बदलेगा।

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

ऑपरेटर्स

एक ऑपरेंड या तो स्टैक आइडेंटिफ़ायर या हस्ताक्षरित 32 बिट पूर्णांक है।

धक्का: >या<

सिंटेक्स: Operand>StackIndentifierयाStackIndentifier<Operand

पुश ऑपरेटर ऑपरेटर को बाईं ओर ले जाता है और इसे निर्दिष्ट स्टैक पर धकेलता है। उदाहरण के लिए, 12>aस्टैक पर मान 12 को धक्का देगा a। a>bस्टैक से सबसे ऊपरी मूल्य पॉप होगा aऔर स्टैक पर इसे धक्का देगा b। एक खाली स्टैक को हमेशा वापस रखना 0. a<bके बराबर है b>a। a<b>cसे सबसे ऊपर मूल्य चबूतरे bऔर दोनों को धक्का cऔर a।

जोड़ें: +

वाक्य - विन्यास: StackIndentifier+Operand

एड ऑपरेटर स्टैक पर सबसे ऊपरी आइटम का योग और स्टैक पर ऑपरेंड को धक्का देता है। यदि ऑपरेंड स्टैक है, तो मान इससे पॉप होता है। उदाहरण के लिए, यदि स्टैक aका सबसे ऊपरी मूल्य 1 है, तो a+2उस पर 3 धक्का देगा। यदि aखाली है, तो a+2उस पर 2 धक्का देंगे। यदि स्टैक के सबसे ऊपरी मान हैं aऔर b1 और 2 हैं, तो a+bस्टैक से मान 2 पॉप होगा bऔर स्टैक पर 3 पुश करें a।

घटाएँ: -

वाक्य - विन्यास: StackIndentifier-Operand

सबट्रेक्टर ऑपरेटर ऐड ऑपरेटर की तरह ही काम करता है, सिवाय इसके कि वह जोड़ने के बजाय घटाता है।

स्पष्ट: ?

वाक्य - विन्यास: StackIndentifier?

क्लियर ऑपरेटर स्टैक को खाली कर देता है यदि इसकी सबसे ऊपरी वस्तु 0 है।

दुभाषिया किसी भी चीज़ को अनदेखा करेगा जो ऑपरेटर के बगल में नहीं है, इसलिए निम्न कार्यक्रम काम करेगा a+2 this will be ignored c<i:। हालाँकि, टिप्पणियों को जोड़ने का उचित तरीका #चरित्र का उपयोग करना है। #निष्पादन से पहले एंड-ऑफ-द-लाइन वर्ण के बीच कुछ भी हटा दिया जाता है। ASCII वर्ण # 10 को Kipple में एंड-ऑफ-लाइन के रूप में परिभाषित किया गया है।

संचालन को दो ऑपरेटरों द्वारा साझा किया जा सकता है, उदाहरण के a>b c>b c?लिए लिखा जा सकता है a>b<c?।

कार्यक्रम 1>a<2 a+aमें परिणाम होगा aमूल्यों से युक्त [1 4](नीचे से ऊपर) और नहीं [1 3]। इसी तरह -ऑपरेटर के लिए।

नियंत्रण संरचना

किप्पल में केवल एक नियंत्रण संरचना है: लूप।

वाक्य - विन्यास: (StackIndentifier code )

जब तक निर्दिष्ट स्टैक खाली नहीं होता है, तब तक मिलान कोष्ठक के भीतर कोड दोहराया जाएगा। लूप में अन्य लूप हो सकते हैं। उदाहरण के लिए, (a a>b)स्टैक aपर स्टैक के सभी मूल्यों को स्थानांतरित करेगा b, हालांकि ऑर्डर उलट हो जाएगा । एक कार्यात्मक समान, लेकिन ऐसा करने का अधिक सुरुचिपूर्ण तरीका है (a>b)।

उदाहरण

100>@ (@>o)

यह आउटपुट करेगा 100

33>o 100>o 108>o 114>o 111>o 87>o 32>o 111>o 108>o 108>o 101>o 72>o

यह छपेगा "Hello World!"। जब oस्टैक आउटपुट किया जा रहा है, तो यह स्टैक के ऊपर से नीचे तक पॉप अक्षरों को शुरू करता है।

#prime.k by Jannis Harder
u<200
#change 200


k<2>m
u-2
(u-1 u>t u>z u<t
  (k>e e+0 e>r)
  (e>k)
  m+1
  m>t
  m>z
  m<t
  t<0>z? t?
  1>g
  (r>b
    m+0 m>a
    b+0 b>w
    (a-1 
      b+0 b>j
      j?
      1>s
      (j<0>s j?)
      s?
      (s<0 w+0 w>b s?)
      a>t
      a>z
      t>a
      b-1
      b>t
      b>z
      t>b
      z<0>t? z?
    a?)
    b?
    1>p
    (b<0 b? 0>p)
    p?
    (p 0>r? 0>p? 0>g)
  )
  g?
  (g m+0 m>k 0>g?)
u?)
(k>@
  10>o
  (@>o)
)

यह एक प्राइम नंबर जनरेटर है, लेकिन मुझे यकीन नहीं है कि यह कैसे काम करता है।

नियम

• आपको एक प्रोग्राम / फ़ंक्शन लिखना होगा जो किप्ले की व्याख्या करता है। यह प्रोग्राम / फ़ंक्शन किसी स्रोत फ़ाइल के माध्यम से Kipple प्रोग्राम प्राप्त कर सकता है, या इसे उपयोगकर्ता से सीधे STDIN के माध्यम से प्राप्त कर सकता है। यदि STDIN उपलब्ध नहीं है, तो इसे कीबोर्ड इनपुट से प्राप्त करना होगा, और तब तक इनपुट प्राप्त करना जारी रखना चाहिए, जब तक कि एक विशिष्ट अप्रतिबंधित वर्ण दर्ज न हो जाए। उदाहरण के लिए, यदि आपके दुभाषिया को x86 मशीन कोड में लिखा गया है, तो इसे कीबोर्ड से चरित्र द्वारा किपल प्रोग्राम वर्ण मिलेगा, और ऐसा तब तक करना जारी रखें जब तक esc(या कोई अन्य कुंजी जो प्रिंट करने योग्य वर्ण का उत्सर्जन नहीं करता है) दबाया जाता है।

• यदि कोई त्रुटि है, उदाहरण के लिए एक सिंटैक्स त्रुटि या स्टैक अतिप्रवाह, तो इसे किसी तरह से स्वीकार करना होगा, उदाहरण के लिए, इंटरप्रेटर / कंपाइलर द्वारा उत्पादित 10 के बजाय 10 या रिटर्न संदेशों को वापस करके, लेकिन त्रुटि का पता लगाना न करें ।

• कोड गोल्फ के लिए कोई अन्य नियमित नियम इस चुनौती के लिए लागू होते हैं।

• आपके कोड को Kipple के नमूने संग्रह में कुछ उदाहरणों के साथ परीक्षण किया जाएगा

यह एक कोड-गोल्फ है । बाइट्स में सबसे छोटा कोड जीत जाएगा। शुभ लाभ!

---

ध्यान दें कि किप्पल में एक वैकल्पिक ऑपरेटर है ", लेकिन यह विनिर्देश का हिस्सा नहीं है और आधिकारिक दुभाषिया में सिर्फ एक अतिरिक्त सुविधा है। मैंने यहां इसका उल्लेख नहीं किया है, इसलिए इसे आपके सबमिशन में समर्थित होने की आवश्यकता नहीं है।

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

Comments

हम क्या है 32-बिट पर हस्ताक्षर किए पूर्णांक उपयोग करने के लिए या हम मेजबान कार्यान्वयन की प्राकृतिक पूर्णांक प्रकार के साथ जा सकते हैं? (सबसे महत्वपूर्ण मामलों में शायद 32-बिट पूर्णांक, हस्ताक्षरित या अहस्ताक्षरित 8-बिट पूर्णांक और मनमाना-सटीक पूर्णांक हैं।)

— मार्टिन एंडर

ठीक है, यह मैं क्या गूढ़ विकी पर पाया गया था। हां, क्योंकि आपके दुभाषिया अन्य किपल कार्यक्रमों के साथ असंगत हो सकते हैं जो उनका तंत्र इस विशेषता पर आधारित है

क्या आप त्रुटियों के मामले में व्यवहार के बारे में अधिक विशिष्ट हो सकते हैं? इसलिए हम एक गलत उत्तर दे सकते हैं या एक त्रुटि का उत्सर्जन कर सकते हैं, लेकिन हम त्रुटि को प्रिंट नहीं कर सकते हैं?

— एलेक्स ए।

@ एलेक्स ए। हाँ, क्योंकि इसे प्रोग्राम के आउटपुट के रूप में माना जा सकता है, और आप एक किपल प्रोग्राम बना सकते हैं जिसमें त्रुटि संदेश के समान आउटपुट हो सकता है। इसके अलावा यह "सस्ता" (कम वर्णों का उपयोग करता है) में फ़ंक्शन / स्टेटमेंट नहीं है जो एक त्रुटि संदेश प्रिंट करता है।

एक स्रोत कार्यक्रम में व्हॉट्सएप क्या हो सकता है? iयदि मैं स्रोत कार्यक्रम को स्टड से लेता हूं तो मैं इनपुट के लिए कैसे पूछ सकता हूं ?

— orlp

Answer 1

सी, 709 702 बाइट्स

बाइट स्कोर नईलाइन्स के साथ है (जिसे हटाया जा सकता है) हटा दिया गया है, लेकिन पढ़ने में आसानी के लिए मैं इसे यहां नई स्टोरीलाइन के साथ पोस्ट करता हूं:

#define R return
#define C ;break;case
c[999]={};*P=c;*S[28];M[99999]={};t;*T;
u(s,v){S[s]+=28;*S[s]=v;
if(s>26){for(t=v/10;t;t/=10)S[s]+=28;T=S[s];do{*T=48+v%10;T-=28;}while(v/=10);}}
o(s){t=S[s]-M>27;S[s]-=28*t;R S[s][28]*t;}
I(s){R s<65?27:s-97;}
O(int*p){if(!isdigit(*p))R o(I(*p));
for(;isdigit(p[-1]);--p);for(t=0;isdigit(*p);t*=10,t+=*p++-48);R t;}

main(i,a){for(i=0;i<28;++i)S[i]=M+i;
for(;~(*++P=getchar()););P=c+1;
for(;;){i=I(P[-1]);switch(*P++){
case 35:for(;*P++!=10;)
C'<':u(i,O(P))
C'>':u(I(*P),O(P-2))
C'+':u(i,*S[i]+O(P))
C'-':u(i,*S[i]-O(P))
C'?':if(!*S[i])S[i]=M+i
C'(':for(i=1,T=P;i;++T)i+=(*T==40)-(*T==41);if(S[I(*P)]-M<28)P=T;else u(26,P-c)
C')':P=c+o(26)-1
C-1:for(;i=o(14);)putchar(i); R 0;}}}

के साथ संकलित करें gcc -w golf.c( -wआपके विवेक के लिए चेतावनी)।

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

Comments

मैंने मुख्य पोस्ट की टिप्पणियों में "i" स्टैक के बारे में आपके प्रश्न का उत्तर दिया है।

btw यह किपल प्रोग्राम कैसे पढ़ता है? आदेश तर्कों के माध्यम से? मुझे इसका उपयोग कैसे करना चाहिए?

@GLASSIC यह स्टड पर कार्यक्रम की उम्मीद करता है।

— orlp

कब तक ? उत्तेजना कैसे शुरू करें?

@GLASSIC सिर्फ स्टड पर कार्यक्रम पास करें। जैसे ./a.out < prime.k।

— orlp

Answer 2

रूबी, 718 बाइट्स (वर्तमान में नॉन कमेटिंग)

मैं बहुत थक गया हूँ

फ़ाइल को कमांड लाइन तर्क के रूप में लोड किया गया है, और इनपुट STDIN के माध्यम से भेजा जाता है। यदि आपको अपने iरजिस्टर में इनपुट की आवश्यकता नहीं है, तो वैकल्पिक रूप से फ़ाइल को STDIN में पाइप करें ।

युक्ति के संबंध में कुछ भ्रम के कारण, वर्तमान संस्करण a<b>cठीक से नहीं चल रहा है, और इसलिए यह तब तक गैर-सक्षम होता है जब तक कि इसे ठीक नहीं किया जाता है।

a<b>cअब तय हो गया है। हालाँकि, यह अभी भी गलत परिणाम देता है जब प्राइम्स फ़ंक्शन चलाते हैं, तो यह अभी भी एक गैर-जवाबदेह उत्तर के रूप में रहता है।

(f=$<.read.gsub(/#.*?\n|\s[^+-<>#()?]*\s/m,' ').tr ?@,?`
t=Array.new(27){[]}
t[9]=STDIN.read.bytes
k=s=2**32-1
r=->c{c=c[0];c[0]==?(?(s[c[1..-2]]while[]!=t[c[1].ord-96]):(c=c.sub(/^(.)<(\D)>(.)/){$1+"<#{t[$2.ord-96].pop||0}>"+$3}.sub(/(\d+|.)(\W)(\d+|.)?/){_,x,y,z=*$~
a=x.ord-96
b=(z||?|).ord-96
q=->i,j=z{j[/\d/]?j.to_i: (t[i]||[]).pop||0}
l=t[a]
y<?-?(x==z ?l[-1]*=2:l<<(l.pop||0)+q[b]
l[-1]-=k while l[-1]>k/2):y<?.?(x==z ?l[-1]=0:l<<(l.pop||0)-q[b]
l[-1]+=k while l[-1]<-k/2-1):y<?>?t[a]+=a<1?q[b].to_s.bytes: [q[b]]:y<???
(t[b]+=b<1?q[a,x].to_s.bytes: [q[a,x]]): l[-1]==0?t[a]=[]:0
z||x}while c !~/^(\d+|.)$/)}
s=->c{(z=c.scan(/(\((\g<1>|\s)+\)|[^()\s]+)/m)).map &r}
s[f]
$><<t[15].reverse.map(&:chr)*'')rescue 0

Comments

वैसे भी +1। क्या आपने रिट्रेसमेंट प्रोग्राम की कोशिश की?

— edc65

@ edc65 Fibbonacci अनुक्रम कार्यक्रम गलत चीज़ को भी प्रिंट करता है: 0 1 1 2 4 8 16...मुझे आश्चर्य है कि अगर यह एक त्रुटि है

— मूल्य इंक

नहीं, फाइबोनैचि कार्यक्रम बकवास है, उदाहरण के लिए लाइन a+0बकवास है

— edc65

मुझे लगता है कि प्रमुख संख्याओं के बारे में समस्या यह है कि यह नेस्टेड कंट्रोल संरचनाओं को संभालती नहीं है, लेकिन मुझे माणिक के बारे में ज्यादा जानकारी नहीं है, मुझे अपने अनुमान के सही होने पर संदेह है।

इस कार्यक्रम को पैरेंस के नेस्टेड सेट को ठीक से संभालना चाहिए क्योंकि इस पर रिकर्सिव रेगेक्स मैच होने के कारण /(\((\g<1>|\s)+\)|[^()\s]+)/mयह टोकन और टोकन के समूहों पर विभाजित करने के लिए उपयोग करता है। ( इसे regex101 पर टेस्ट करें )। यह शायद मेरे पार्सिंग के बाकी हिस्सों में एक त्रुटि है, लेकिन मुझे नहीं पता कि कहां है।

— वैल्यू इंक