डेडफिश एक मजाक "प्रोग्रामिंग भाषा" है जिसमें चार कमांड होते हैं। क्योंकि Esolang पृष्ठ थोड़ा विरोधाभासी है और उस पृष्ठ पर व्याख्या करने वाले सभी समान कार्य नहीं करते हैं, आपको निम्नलिखित भिन्नता को लागू करना चाहिए:

विशिष्टता

एक संचायक है जो आकार में कम से कम 16 बिट्स है, अधिक की अनुमति है लेकिन कम नहीं है। नकारात्मक संख्याओं का समर्थन करने की आवश्यकता नहीं है। 0प्रोग्राम शुरू होने पर संचायक होता है।

चार कमांड के निम्नलिखित दो सेट हैं, और आपके प्रोग्राम को एक ही समय में दोनों का समर्थन करना चाहिए।

  स्टैंडर्ड डेडफिश Dead एक्सकेसीडी वेरिएंट │ अर्थ
  ─────────────────────┼──────────────────┼───────── ───────────────────────────
        i │ x re वृद्धि संचयकर्ता
        d │ d re घटता संचायक
        s acc k │ स्क्वायर (acc = acc * acc)
        o number c │ एक संख्या के रूप में आउटपुट संचायक

यदि, एक कमांड निष्पादित करने के बाद, संचायक -1या तो है 256, तो संचायक को शून्य पर रीसेट किया जाना चाहिए। ध्यान दें कि यह सामान्य रैप-अराउंड नहीं है। यदि, कहते हैं, संचायक है 20, और sकमांड चलाया जाता है, तो संचायक 400बाद में होना चाहिए । इसी तरह, यदि संचायक है 257और dकमांड चलाया जाता है, तो संचायक बन जाना चाहिए 0।
ऐसा कोई भी इनपुट जो इन कमांडों में से एक नहीं है, उसे अनदेखा किया जाना चाहिए।

परीक्षण कार्यक्रम

xiskso आउटपुट चाहिए 0
xiskisc आउटपुट चाहिए 289

आई / ओ

आपके कार्यक्रम को शीघ्र प्रदर्शित करना चाहिए >>:। प्रॉम्प्ट एक नई लाइन की शुरुआत में होना चाहिए। इसके बाद उपयोगकर्ता इनपुट की एक पंक्ति को पढ़ना चाहिए, और दिए गए आदेशों को बाएं से दाएं चलाना चाहिए। संख्याओं को आउटपुट करते समय, संख्याओं को अलग किया जाना चाहिए। यानी, 12 34ठीक है, 12,34ठीक है,

12
34

ठीक है, लेकिन 1234नहीं है।

आपके कार्यक्रम को लूप में ऐसा करते रहना चाहिए, कम से कम तब तक जब तक EOFवह पहुंच न जाए।

उदाहरण सत्र:

>> xiskso
0
>> xiskisc
289
>> ddddo ddddo
285
281
>> ddddo ddddo
277
273
>> dddddddo
266
>> dddddddddo
257
>> do
0
>> do
0
>> io
1
>>

code-golf interpreter deadfish

— मारीनस
स्रोत

इनपुट के लिए संकेत देने के कारण, मैं GolfScript का उपयोग नहीं कर सकता :-(

— ProgramFOX

@ProgramFOX: आप माणिक इनपुट का उपयोग कर सकते हैं?

— मारिनस

गोल्फस्क्रिप्ट ट्यूटोरियल के अनुसार, आप गोल्फस्क्रिप्ट में इनपुट के लिए संकेत नहीं दे सकते हैं, सभी इनपुट एसटीडीआईएन से आते हैं।

— प्रोग्रामफॉक्स

@ProgramFOX: मैंने सोचा होगा कि कुछ #{STDIN.gets}ऐसा काम करेगा लेकिन वास्तव में ऐसा नहीं है।

— मारिनस

क्या हमें इसके बजाय अपरकेस अक्षरों के साथ इनपुट लेने की अनुमति है?

— २०:०२ पर lirtosiast

6

के, 77 बाइट्स

  {1">>";0{x*2=-1 256?x:y@x}/("xkcdiso"!7#(1+;{x*x};{-1@$x;x};-1+))@0:0;.z.s`}`
>>xiskso
0
>>xiskisc
289

ध्यान दें यह K4 है । एक K6 समाधान थोड़ा लंबा है क्योंकि IO क्रियाएं लंबी हैं, भले ही बाकी सब कुछ बेहतर हो:

{""0:">>";0{x*^-1 256?x:y@x}/("xkcdiso"!7#(1+;{x*x};{""0:,$x;x};-1+))@0:"";o`}`

""0:प्रिंट करता है और अपना तर्क देता है। K4 में ध्यान दें, हम केवल 1 पर लागू होते हैं ।
0 f/ args प्रदर्शन एक प्रारंभिक मूल्य के साथ कम करता है, अर्थात f[f[0;first arg];second arg]…
{x*2=-1 256?x… अन्य सभी मानों के लिए x को 0 (-1 के लिए), 1 (256 के लिए) और 2 में वर्गीकृत करता है। 2=इसका मतलब है कि हम 1अवर्गीकृत मूल्यों के लिए हैं और 0अन्यथा, गुणा करना xएक सशर्त से कम है। K6 में हम थोड़ा बेहतर कर सकते हैं क्योंकि {x*^-1 256?x:y@x}इस तथ्य पर निर्भर करता है कि -1 256?xरिटर्न 0N(नल) और नल का ^पता लगाता है।
"पार्सर" "xkcdiso"सुझाए गए आदेश के बजाय नक्शा है क्योंकि 7#चारों तर्कों के चारों ओर लिपटेगा यानी 7#"abcd"रिटर्न "abcdabc"जो हमारी तालिका को छोटा रखता है
नक्शा अनुवाद करता है "x"और "i"प्रक्षेपण के लिए 1+जो फ़ंक्शन के बराबर होता है {1+x}लेकिन छोटा होता है।
नक्शा "d"प्रक्षेपण के लिए अनुवाद करता है -1+जो फ़ंक्शन के बराबर है {-1+x}लेकिन कम है।
नक्शा अनुवाद करता है "k" और "s"फ़ंक्शन के लिए{x*x}
मानचित्र का अनुवाद "c"और"o" आउटपुट फ़ंक्शन के लिए {-1@$x;x}जो K6 में फिर से थोड़ा लंबा होता है: {""0:,$x;x}लेकिन दोनों इसके आउटपुट को प्रिंट करते हैं उसके बाद एक नई लाइन, और फिर तर्क को लौटाते हैं।
.zs आत्म-पुनरावृत्ति है K6 में हम बस कह सकते हैं o`जो छोटा है।

— geocar
स्रोत

8

पर्ल 5 , 90 बाइट्स

do{print+(map{$?+=/i|x/-/d/;$?**=1+/s|k/;$?=~s/-1|^256$/0/;"$?
"x/o|c/}/./g),'>> '}while<>

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

इस पर उसकी मदद के लिए @xfix का धन्यवाद ! @ बॅकली को धन्यवाद दिया 4 बाइट्स बचाए !

— डोम हेस्टिंग्स
स्रोत

1

आपका प्रोग्राम प्रिंट करता है 1जब संचायक ओवरफ्लो होता है। इसके अलावा, आप अपने प्रोग्राम को पाँच वर्णों तक छोटा कर सकते हैं, (जिसे शुरू में बदल $aदिया $?जाता है 0, और तब तक नहीं बदलेगा जब तक आप पर्ल से कुछ बाहरी प्रोग्राम नहीं चलाते)।

— कोनराड बोरोस्की

आह, मैं एक चर के लिए शिकार कर रहा था जिसका मैं उपयोग कर सकता था, पूर्ण, धन्यवाद! ओवरफ्लो करने के लिए, मैंने इसे नोटिस नहीं किया क्योंकि यह केवल तब होता है जब आप isssoएक कमांड के रूप में चलाते हैं , न कि यदि आप प्रत्येक को अलग-अलग करते हैं ... तो मैं इस पर बाद में एक नज़र डालूंगा और निश्चित रूप से उपयोग करूंगा $?। धन्यवाद!

— डोम हेस्टिंग्स

इसलिए मुझे लगता है कि मैंने कोड अनुभाग में एक पुराने संस्करण को शीर्ष ''स्थान पर छोड़ दिया , ""ताकि जब perl -e '...'परिणाम के साथ मानचित्र समाप्त हो जाए तो उसका उपयोग किया जा सके s///। एक बार फिर धन्यवाद!

— डोम हेस्टिंग्स

ठीक है, तुम सबसे छोटे हो।

— मारिनस

1

अब सबसे छोटा जवाब नहीं।

— जियोकार जूल

6

पॉवरशेल, 131 126 121 114 113

for($x=0){[char[]](read-host ">>")|%{switch -r($_){"i|x"{$x++}"d"{$x-=!!$x}"s|k"{$x*=$x}"o|c"{$x}}
$x*=$x-ne256}}

for($x=0){...} - संचायक को 0 पर सेट करें और हमेशा के लिए लूप करें
read-host '>>' - प्रॉम्प्ट के साथ यूजर इनपुट प्राप्त करें >>
[char[]](...) - वर्णों के एक सरणी के लिए उपयोगकर्ता इनपुट परिवर्तित
|%{...} - {}प्रत्येक चरित्र के लिए अंदर क्या है प्रदर्शन करें
switch -r($_) - प्रत्येक चरित्र के लिए regex स्विच
"i|x"{$x++} - मैच iया x- संचायक में वृद्धि
"d"{$x-=!!$x} - मैच d- $xद्वारा कमी !!$x, जो होगा 0अगर $xहै 0, और 1अन्यथा। यह सुनिश्चित करता है कि संचायक कभी नहीं पहुंचता है -1।
"s|k"{$x*=$x} - मैच sया k- वर्ग
"o|c"{$x} - मैच oया c- संचायक का उत्पादन
$x*=$x-ne256- 0यदि यह 256या 1अन्यथा द्वारा संचयकर्ता को गुणा करें

उदाहरण आउटपुट

>>: xiskso
0
>>: xiskisc
289
>>: ddddo ddddo
285
281
>>: ddddo ddddo
277
273
>>: dddddddo
266
>>: dddddddddo
257
>>: do
0
>>: do
0
>>: io
1
>>:

मुझे लगता है कि read-hostहोस्ट का कार्यान्वयन विशिष्ट है, इसलिए यह पॉवर्सहेल होस्ट (कंसोलहॉस्ट) :निर्दिष्ट प्रॉम्प्ट पर लागू होता है।

— डैंको डर्बीक
स्रोत

अच्छा! प्यार में कमी से !!$x, शर्म की बात है कि मैं इसका इस्तेमाल नहीं कर सकता ...

— डोम हेस्टिंग्स

हे डैंको, क्या आप कुछ परीक्षण आउटपुट पोस्ट कर सकते हैं? मुझे नहीं लगता कि मैं गैर-खिड़कियों पर पावर शेल का परीक्षण कर सकता हूं ... (कृपया मुझे गलत होने पर सही करें!)

— डोम हेस्टिंग्स

मैंने उत्तर के लिए कुछ परीक्षण आउटपुट जोड़े हैं।

— डैंको डर्बिएक

6

रीबोल 3, 178 169 161 159

f: does [if a = -1 or (a = 256)[a: 0]]d: [any[["i"|"x"](++ a f)|["d"](-- a f)|["s"|"k"](a: a * a f)|["o"|"c"](print a)| skip]]a: 0 forever [parse (ask ">>") d]

Prettier संस्करण:

f: does [if a = -1 or (a = 256) [a: 0]]
d: [
    any [
        ["i"|"x"] (++ a f) |
        ["d"] (-- a f) |
        ["s"|"k"] (a: a * a f) |
        ["o"|"c"] (print a) |
        skip
    ]
]
a: 0 
forever [parse (ask ">>") d]

— kealist
स्रोत

6

हास्केल, 202

r=pure;-1%c=0%c;256%c=0%c;s%'o'=s<$print s;s%'c'=s%'o';s%'i'=r$s+1;s%'x'=s%'i'
s%'d'=r$s-1;s%'s'=r$s^2;s%'k'=s%'s';s%_=r s;n s(c:[])=s%c;n s(c:f)=s%c>>=(`n`f)
main=p 0;p s=putStr">> ">>getLine>>=n s>>=p

— Ry-
स्रोत

आप शायद कुछ पात्रों को बदलकर eऔर vऑपरेटरों में सहेज सकते हैं । मैंने पुनर्लेखन का भी प्रयास किया vऔर gइसलिए कि पैरामीटर xIO में रहता है, और printआदि उठ जाते हैं। मैंने इसे काम करने के लिए प्रबंधित नहीं किया, लेकिन मुझे लगता है कि यह किसी के लिए जाने के लिए एक अच्छी जगह हो सकती है जो अपने हैसेल को जानता है।

— शियोना

@ सियोना: हाँ, चीजों को रखने के बारे में IOयह है कि वे या तो बहुत बार प्रिंट करते हैं (इसीलिए मैंने r nइसके बजाय प्रयोग किया है x) या पर्याप्त नहीं है क्योंकि मूल्य कभी भी नहीं पूछा जाता है। तो मैं कैसे बदलूंगा eऔर vऑपरेटरों में?

— राय-

मुझे प्रिंटिंग में भी यही समस्या थी। ऑपरेटरों के लिए क्या आप कर सकते हैं (उदाहरण के रूप में ई का उपयोग करके) 'i'%x=x+1;'d'%x=x-1... और बस इसे v में कॉल करें do n<-x;r$w$o%n। अंतरिक्ष संचालकों को बचाने का कारण यह है कि उन्हें अपने आसपास रिक्त स्थान की आवश्यकता नहीं है।

— शियोना

@ सियोना: ओह! अच्छा है, धन्यवाद!

— Ry-

कोई बात नहीं। मैंने पहले अपना खुद का उत्तर बनाने के बारे में सोचा था, लेकिन जब से मैं अपने बड़े विचारों को काम नहीं कर पाया, मैंने सोचा कि यह ठीक उसी तरह का कोड होगा जिसमें समान फ़ंक्शन के लिए बस अलग-अलग संकेतन के साथ एक ही कोड होगा।

— शायना

4

रूबी, 140 138

a=0
loop{$><<'>> '
eval gets.gsub(/./){|c|({i:i='a+=1',x:i,d:'a-=1',s:s='a**=2',k:s,o:o='p a',c:o}[:"#{c}"]||'')+';a=a==-1||a==256?0:a;'}}

नमूना सत्र (आपके जैसे ही):

c:\a\ruby>deadfish
>> xiskso
0
>> xiskisc
289
>> ddddo ddddo
285
281
>> ddddo ddddo
277
273
>> dddddddo
266
>> dddddddddo
257
>> do
0
>> do
0
>> io
1
>>

— Doorknob
स्रोत

4

के, 121

i:0;while[1;1">> ";{i{(r;0)(-1~r)|256~r:y x}/d{x@&x in y}[x;!d:"ixdskoc"!,/(2#(1+);-1+;2#{x*x};2#{-1@$i::x;})]}'" "\:0:0]

।

C:\q>q deadfish.k -q
>> xiskso
0
>> xiskisc
289
>> ddddo ddddo
285
281
>> ddddo ddddo
277
273
>> dddddddo
266
>> dddddddddo
257
>> do
0
>> do
0
>> io
1
>>

— tmartin
स्रोत

मेरा संस्करण छोटा है। मैंने नक्शा संकुचित कर दिया, किस पर भरोसा किया ? "रैपिंग" मूल्यों के लिए वर्गीकृत करने के लिए, जबकि बदले के बजाय पुनरावृत्ति का इस्तेमाल किया, और संशोधन के बजाय एक कार्यात्मक दुभाषिया।

— जियोकार जूल

4

एडीए

यहाँ कुछ लोगों के लिए एक Ada कार्यान्वयन है जो इस भाषा में रुचि रखते हैं। एडा की कुछ सर्वोत्तम प्रथाओं (जैसे एक्सेस के बजाय Indefinite_Holders का उपयोग) और यह भी पूरी तरह से समझने के लिए कि डेडफिश को कैसे काम करना चाहिए, इसका उपयोग करने में मुझे काफी समय लगा।

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Containers.Indefinite_Holders;
with Ada.Integer_Text_IO;

procedure Deadfish is
   package String_Holder is new Ada.Containers.Indefinite_Holders(String);
   use String_Holder;

   value_output : Natural := 0;
   str_input : String_Holder.Holder := To_Holder("");
begin
   Prompt :
   loop
      Put(">> ");
      String_Holder.Replace_Element(str_input, Get_Line);
      for rg in str_input.Element'Range loop
         case str_input.Element(rg) is
            when 'i' | 'x' => 
               case value_output is
                  when 255 => value_output := 0;
                  when others => value_output := Natural'Succ(value_output);
               end case;

            when 'd'       =>                   
               case value_output is
                  when 257 => value_output := 0;
                  when 0 => null;
                  when others => value_output := Natural'Pred(value_output);
               end case;
            when 's' | 'k' => 
               case value_output is
                  when 16 => value_output := 0;
                  when others =>value_output := value_output * value_output;
               end case;
            when 'o' | 'c' => Ada.Integer_Text_IO.Put(value_output, Width => 0); Put_Line("");
            when others => null;
         end case;
      end loop;
   end loop Prompt;
end Deadfish;

और आउटपुट:

>> xiskso
0
>> xiskisc
289
>> ddddo ddddo
285
281
>> ddddo ddddo
277
273
>> dddddddo
266
>> dddddddddo
257
>> do
0
>> do
0
>> io
1
>>

अगर अडा में प्रयोग किए गए कुछ लोग मुझे कुछ अनुकूलन संकेत दे सकते हैं, तो मैं आभारी रहूंगा।

— जेरेमी रूएल
स्रोत

1

PPCG में आपका स्वागत है! कोड-गोल्फ का लक्ष्य सबसे कम संभव कोड बनाना है, और आपको हेडर में कार्यक्रम का आकार शामिल करना चाहिए (1396 बाइट्स)

— TuxCrafting

4

C, 159 वर्ण

A; main(c) {
  printf(">> ");
  while (c = getchar(), ~c)
    A = c - 'i' & c - 'x'?
        c - 'd'?
        c - 's' & c - 'k'?
        c - 'o' & c - 'c'?
        c - '\n'?
        A :
        printf(">> "), A :
        printf("%d\n", A), A :
        A * A :
        A - 1 :
        A + 1,
    A *= ~A && A - 256;
}

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

#define X !--c?A

A,M[256];
main(c) {
  for(; !M['x']; c++) M["@osid\nckx"[c]]-=c%5+1;
  for (printf(">> "); c = ~M[getchar()]; A *= ~A && A - 256)
  A= X,printf("%d\n", A),A:X*A:X+1:X-1:A;
  main();
}

— जुगनू
स्रोत

3

सी, 163

#define i(u,v);if(c==u+89|c==v+89)
a;main(c){printf(">>");while(c=getchar()-10){i(6,21)a++i(1,1)a--i(8,16)a*=a;i(0,12)printf("%d\n",a);a=a==-1|a==256?0:a;}main();}

— डैरेन स्टोन
स्रोत

3

पायथन 3, 181 175 171 162

a=0
s=lambda x:"a=%d"%(x!=-1and x!=256and x)
while 1:
 for i in input(">>"):u,b,o=s(a+1),s(a*a),"print(a)";exec(dict(i=u,x=u,d=s(a-1),s=b,k=b,o=o,c=o).get(i,""))

~~के बाद यह एक नई लाइन आउटपुट करता है >>, लेकिन ओपी ने कहा कि अनुमति नहीं थी।~~ अब और नहीं!

धन्यवाद GlitchMr, minitechऔर golfer9338!

— jazzpi
स्रोत

1

आप एक फ़ंक्शन lambdaके defलिए उपयोग कर सकते हैं जो तुरंत लौटता है।

— कोनराड बोरोस्की

x in(-1,256)दो पात्रों को बचाता है। वैकल्पिक रूप से, s=lambda x:"a=%d"%(x!=-1and x!=256and x)कुछ बचा सकता है।

— रय।

1

आप इसके बजाय हटा print(">>")और उपयोग कर सकते हैं for i in input(">>"); input()एक संकेत निर्दिष्ट करने की अनुमति देता है। फिर, बाद में कोई नई पंक्ति नहीं होगी >>, और आप वर्ण सहेजते हैं।

— गोल्फर

आपका स्कोर होना चाहिए, मुझे लगता है, एक चार अभी छोटा है । कृपया डबलचेक करें, लेकिन मुझे पोस्ट किए गए 162 के बजाय 161 की एक गिनती मिलती है: 3 + 40 + 8 + 107 की पंक्तियाँ, साथ ही 3 नई लाइनें। सच कहा जाए, तो मुझे जलन हो रही है, क्योंकि किसी भी तरह से, आप मेरे सी उत्तर से कम कुछ चार्ट हैं। चीयर्स!

— डैरेन स्टोन

3

आर, 161 , 148 , 138

a=0;repeat{x=readline(">> ");for(i in utf8ToInt(x)-99){a=a^((i==8|i==16)+1)+(i==6|i==21)-(i==1&a);a=a*(a!=256);if(i==0|i==12)cat(a,"\n")}}

Ungolfed संस्करण:

a = 0
repeat{
  x = readline(">> ")
  for(i in utf8ToInt(x) - 99) {
    a = a ^ ((i == 8 | i == 16) + 1) + (i == 6 | i == 21) - (i == 1 & a)
    a = a * (a != 256)
    if(i == 0 | i == 12) cat (a, "\n")
  }
}

उदाहरण सत्र (इंटरेक्टिव मोड में):

>> xiskso
0
>> xiskisc
289
>> ddddo ddddo
285
281
>> ddddo ddddo
277
273
>> dddddddo
266
>> dddddddddo
257
>> do
0
>> do
0
>> io
1
>>

— स्वेन होहेंस्टीन
स्रोत

3

अजगर 3, 141

मुझे पता है कि मुझे देर हो गई है, लेकिन मैं एक छोटे पायथन-संस्करण (और मेरा पहला कोडगॉल्फ-प्रयास) पोस्ट करने का अवसर लेना चाहता था। :)

v=0
m=lambda y:(0,y)[-1!=y!=256]
i=x='+1'
d='-1'
s=k='*v'
c=o=');print(v'
while 1:
 for n in input('>>'):exec('v=m(v'+locals().get(n,'')+')')

इसके लिए प्रिंट-स्टेटमेंट थोड़े मुश्किल था। यदि प्रॉम्प्ट को एक व्हाट्सएप के साथ समाप्त करना है, तो गिनती में एक चार जोड़ें। :)

व्याख्या

v संचायक है।

mयह जांच करता है कि दिया गया मूल्य है -1या नहीं 256। यदि ऐसा है तो,0 वापस कर दिया जाएगा, अन्यथा मूल्य।

निम्नलिखित पंक्तियों में परिचालनों को इसी चर में सौंपा गया है (जैसा कि कुछ का एक ही अर्थ है (जैसे iऔर x) यह एक नया शब्दकोश तात्कालिक बनाने की तुलना में छोटा है)। फिर execनीचे में उनका उपयोग किया जाता है ।

while 1: मुख्य-पाश है

अब मजा शुरू हुआ। जैसा @jazzpi के समाधान, यह इनपुट के प्रत्येक चार से अधिक iterates। locals()सभी वर्तमान (दृश्यमान) चर का शब्दकोश है। .get(n,'')इसी कुंजी के साथ निष्पादन-स्ट्रिंग (एक रिक्त स्ट्रिंग, यदि कुंजी (= अन्य इनपुट) नहीं मिली थी) में डाल दिया जाएगा। यह तब होगा, जब निष्पादित किया जाएगा, के साथ सहमति व्यक्त की vऔर पारित किया m। वापसी मूल्य vफिर से संग्रहीत किया जाएगा।

संक्षिप्त उदाहरण:

Be n = 'i'( n= input-char), हम -ब्लॉक से '+1'बाहर localsनिकलते हैं जैसा iकि वैल्यू के साथ वैरिएबल है '+1'।
इस execतरह दिखता है के लिए स्ट्रिंग 'v=m(v+1)':।
हो सकता है कि अब यह देखना आसान हो, कि निष्पादित करते समय, यह mमूल्य के साथ कॉल करेगा v+1और स्टोर करेगा जो इसमें आउटपुट हैv फिर से ।

इसे तब तक दोहराएं जब तक आप बोर न हों। :)

— डेव जे
स्रोत

मुझे एहसास है कि मैं पार्टी के लिए बहुत देर से जा रहा हूँ, लेकिन मी के y*(-1!=y!=256)लिए

— लम्बा

सिर्फ 5 साल :) इनपुट के लिए धन्यवाद। मैं जवाब को ठीक करने के लिए बहुत आलसी हूं, लेकिन मैं इसे ध्यान में रखूंगा

— डेव जे

3

अजगर २, १३ ९

a=0
while 1:
 for c in raw_input(">> "):
  if c in'ix':a+=1
  if c=='d':a-=1
  if c in'sk':a*=a
  if c in'oc':print a
  if a in(-1,256):a=0

यह साफ-सुथरा है, लेकिन बहुत सीधा भी है। यहाँ एक लंबा, कूलर संस्करण है:

def i(a):
 while 1:
  c=yield
  if c in'ix':a+=1
  if c=='d':a-=1
  if c in'sk':a*=a
  if c in'oc':print a
  if a in(-1,256):a=0
 j=i(0);next(j)
while 1: 
 for c in raw_input(">> "):j.send(c)

190 वर्णों का वजन, यह शायद सबसे अधिक प्रतिस्पर्धी लंबाई वाला उत्तर नहीं है। दूसरी ओर, कोराउटीन बहुत ही अच्छे हैं और मैं हमेशा उन्हें (और शेयर) इस्तेमाल करने का बहाना ढूंढ रहा हूं

— dingusman
स्रोत

3

टीआई-बेसिक, 104 107 102 100 98

TI-83 + / 84 + श्रृंखला कैलकुलेटर के लिए।

यह नाम prgmD; यह अंततः खुद को कॉल करके स्टैक को ओवरफ्लो करता है। While 1इसे ठीक करने के लिए, दो बाइट्स की लागत के साथ पुनरावृत्ति को बदलें ।

Input ">>",Str1
For(I,1,length(Str1
int(.5inString("?ixskd?oc",sub(Str1,I,1
If Ans=4
Disp Y
imag(i^Ans)+Y^int(e^(Ans=2     //decrements when Ans=3; increments when Ans=1
min(0,Ans(Ans≠256→Y
End
prgmD

Y डिफ़ॉल्ट रूप से 0 है, इसलिए या तो इसे एक ताज़ा मेमोरी-क्लियर कैलकुलेटर के साथ चलाएं या इसे चलाने से पहले मैन्युअल रूप से 0 से Y स्टोर करें।

बहुत बुरा है कि लोअरकेस अक्षर (स्ट्रिंग शाब्दिक में) दो बाइट्स हैं; अन्यथा यह डोम हेस्टिंग्स के उत्तर से कम होगा।

संपादित करें: तीन बाइट्स की लागत पर एक विभाजित-दर-शून्य (0 ^ 0) त्रुटि।

107 -> 102: चार बाइट्स (कोष्ठक से 1 और लुकअप स्ट्रिंग को लंबा करने सहित) को बचाने के लिए काल्पनिक घातांक चाल का इस्तेमाल किया और एक्स के बजाय वाई का उपयोग किया, जो आरंभ में एक कम बाइट लेता है।

— lirtosiast
स्रोत

2

पोस्टस्क्रिप्ट 272

/cmd<</i{1 add}/x 1 index/d{1 sub}/s{dup mul}/k 1 index/o{dup =}/c 1 index>>def
0{(>> )print flush{/f(%lineedit)(r)file def}stopped{exit}if{f
1 string readstring not{exit}if cmd exch 2 copy known{get exec}{pop pop}ifelse
dup -1 eq 1 index 256 eq or{pop 0}if}loop pop}loop

Ungolfed:

/cmd <<  % define commands
/i { 1 add }
/x 1 index
/d { 1 sub }
/s { dup mul }
/k 1 index
/o { dup = }
/c 1 index
>> def
0        % accumulator on stack
{
    (>> )print flush   % print prompt
    { /f (%lineedit) (r) file def } stopped {exit} if  % read input line or quit
    {
        f 1 string readstring not {exit} if   % read 1-char string from line
        cmd exch 2 copy known { get exec }{ pop pop } ifelse   % execute command or don't
        dup -1 eq 1 index 256 eq or { pop 0 } if   % adjust accumulator if needed
    } loop
    pop
}loop

— luser droog
स्रोत

2

सी (224 212 अक्षर)

यह शायद एक बुरी भाषा विकल्प है, लेकिन ओह अच्छी तरह से। ऐसा नहीं है कि सी जैसी भाषा कुछ गतिशील प्रोग्रामिंग भाषा से बेहतर कर सकती है। क्लैंग पर, आपको इसके लिए एक मान निर्दिष्ट करना होगा return(यह जीसीसी के लिए आवश्यक नहीं है)।

#define s(x,y)case x:y;break;
main(){int c=10,a=0;for(;;){switch(c){s(-1,return)s('i':case'x',++a)s('d',--a)s('s':case'k',a*=a)s('c':case'o',printf("%d\n",a))s(10,printf(">> "))}a!=-1&a!=256||(a=0);c=getchar();}}

— कोनराड बोरोस्की
स्रोत

क्या यह सिर्फ define qऔर सिर्फ उपयोग करने के लिए छोटा नहीं होगा printf?

— दरवाज़े

@DoorknobofSnow वास्तव में नहीं। q3 बार उपयोग किया जाता है, इसलिए define q~ 2 वर्ण बचाता है।

— जस्टिन

2

लुआ, 230 228

a=0repeat io.write(">> ")x=io.read()for i=1,#x do c=x:sub(i,i)if c=="i"or c=="x"then a=a+1 elseif c=="d"then a=a-1 elseif c=="s"or c=="k"then a=a*a elseif c=="o"or c=="c"then print(a)end if a==256or a==-1then a=0 end end until _

सबसे बुरा नहीं, सबसे अच्छा नहीं।

नोट: जैसा कि @mniip द्वारा बताया गया है 256or, आपके दुभाषिया में काम नहीं कर सकता है। टिप्पणियों में अधिक जानकारी।

(अधिक या कम) पठनीय संस्करण:

a=0
repeat
  io.write(">> ")
  x=io.read()
  for i=1,#x do
    c=x:sub(i,i)
    if c=="i"or c=="x"then
      a=a+1
    elseif c=="d"then
      a=a-1
    elseif c=="s"or c=="k"then
      a=a*a
    elseif c=="o"or c=="c"then
      print(a)
    end
    if a==256or a==-1then
      a=0
    end
  end  
until _

आउटपुट:

>> xiskso
0
>> xiskisc
289
>> ddddo ddddo
285
281
>> ddddo ddddo
277
273
>> dddddddo
266
>> dddddddddo
257
>> do
0
>> do
0
>> io
1
>>

संपादित करें: 2 चार अनुकूलन के लिए @mniip के लिए धन्यवाद : until nil->until _

— Egor305
स्रोत

repeat until x(एक्स शून्य के रूप में परिभाषित नहीं किया गया है) 2 चार्ट छोटा है, और while 1 do endसटीक एक ही लंबाई है, इसके अलावा क्या लुआ संस्करण है? 256orमेरे दुभाषिया में अमान्य वाक्यविन्यास है

— mniip

@mniip संकेत के लिए धन्यवाद repeat until x। मैं यहाँ से नवीनतम विंडोज़ बाइनरी का उपयोग कर रहा हूँ । जैसा कि आप देख सकते हैं a=a+1 elseifकि जगह है। ऐसा इसलिए है क्योंकि e, हेक्साडेसिमल अंक है, जबकि oमें 256or, नहीं है तो मेरे दुभाषिया लेता है orएक और बयान / ब्लॉक / howYouCallIt के रूप में।

— Egor305

हाँ बहुत ज्यादा इसके अलावा 256or, 0repeatऔर 1then; मैं lua.org से आधिकारिक लुआ का उपयोग कर रहा हूं, आपका कोड ५.१, ५.२, या ५.३ में या तो संकलित नहीं करता है

— mniip

2

हास्केल , 186 178 बाइट्स

इसे runhaskell(या अंदर ghci) चलाने की आवश्यकता है क्योंकि वे दोनों डिफ़ॉल्ट रूप BufferModeसे सेट होते हैं NoBufferingजो बहुत सारे बाइट्स को सुरक्षित करता है:

infix 4#
-1#x=0#x
256#x=0#x
r#x:y=case x of 'i'->r+1#y;'x'->r+1#y;'d'->r-1#y;'s'->r^2#y;'k'->r^2#y;'o'->print r>>r#y;'c'->r#'o':y;_->r#y
r#_=putStr">> ">>getLine>>=(r#)
main=0#""

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

व्याख्या

यह एक नया ऑपरेटर को परिभाषित करता है state # source(स्थिरता घोषणा हमें जब यह अन्य ऑपरेटरों के साथ संयोजन के रूप में उपयोग करते हुए कोष्ठकों ड्रॉप करने की अनुमति देता है (+), (-), (^), (:)और (>>)):

पहली दो पंक्तियाँ राज्यों को "ठीक" करती हैं -1और256
यह तब पहले चरित्र से मेल खाता है और इस पर कार्य करता है
एक बार जब यह पात्रों से बाहर हो जाता है ( r#_), तो यह नया पढ़ता है और पुराने राज्य को फिर से शुरू कर देता है

प्रक्रिया को शुरू करने के लिए हम राज्य के साथ 0एक नई स्रोत लाइन पढ़ते हैं, अर्थात। खाली स्रोत से शुरू करें:

main=0#""

— ბიმო
स्रोत

1

विंडोज बैच, 204 256

@echo off
set a=0
:a
set /p i=^>^> 
if %i%==i set /a a=%a%+1
if %i%==x set /a a=%a%+1
if %i%==d set /a a=%a%-1
if %i%==s set /a a=%a%*%a%
if %i%==k set /a a=%a%*%a%
if %i%==o echo %a%
if %i%==c echo %a%
if %a%==256 set a=0
if %a%==-1 set a=0
set i=n
goto a

अन्य आदेशों की सफलतापूर्वक उपेक्षा करता है। वास्तव में के orसाथ काम करने के बिना फूला हुआ है ...

संपादित करें:

फिक्स्ड:

कोई और अधिक सभी आदेश गूंज

इसे वास्तव में / ए के साथ गणित किया

-1 पर रीसेट करें

हर चक्र के बाद इनपुट रीसेट करें

इसमें 52 पात्रों का खर्च आया।

तय नहीं किया गया:

चुकता 0 लिखता है "0 * 0" में।

स्पेसिंग इनपुट (या इनपुट कुछ भी नहीं, जब आपने इसे खोला था) स्क्रिप्ट को क्रैश करता है।

आप एक समय में एक चार इनपुट करने की आवश्यकता है।

— Timtech
स्रोत

2

यह केवल सादा काम नहीं करता है (विंडोज 7)। मैं एक गधे होने का मतलब नहीं है लेकिन क्या आपने यह परीक्षण किया है?

— मारिनस

@marinus यह तय हो गया है।

— टाइमटेक

1

विंडोज कमांड स्क्रिप्ट - 154

Abusin अधिकतम करने के लिए अज्ञात सुविधाएँ।

@echo off
set i=1
set x=1
set d=-1
set/as=[*[-[
set/ak=[*[-[
set.=0
set/p.=^>^> 
set/a[=[+%.%
e%.:o=c%h%.:c=o% %[% 2>nul
set[=%[:-1=%
if;%[%==256 set[=
%0

— रॉबर्ट सोरली
स्रोत

1

> <> , 258 बाइट्स

मैंने एक और> <> जवाब दिया है क्योंकि मैं चरण के परीक्षण का परीक्षण नहीं कर सका और इसने वैसे भी शेल का अनुकरण करने के बजाय पूर्व-स्टैक्ड कमांड का उपयोग किया।

0v
"<vooo">> 
!~>i:0)?v~ >
 ^?=a:  /  ^!?="c"v?="o":v?="s":v?="k":v?="d":v?="x":v?="i":
   voan:<        ~<  v*:~<      <  v-1~<  v+1~<      <
   <                 <             <      <vv?=-10:v?=*:+1f:
  v                                        <>      >~0

यह निश्चित रूप से नीचे गिरा हो सकता है, लेकिन मुझे यकीन नहीं है कि मुझे आवश्यक ~~पागलपन होगा~~ बहादुरी होगी!

मैंने इसे आधिकारिक इंटरप्रेटर के साथ 7 विंडोज के तहत साइबरविन के तहत अजगर 3.5 के तहत परीक्षण किया और परीक्षण रन को पुन: उत्पन्न कर सकता है:

$ python fish.py deadfish.fish
>> xiskso
0
>> xiskisc
289
>> ddddo ddddo
285
281
>> ddddo ddddo
277
273
>> dddddddo
266
>> dddddddddo
257
>> do
0
>> do
0
>> io
1
>> (pressed ctrl-Z)Stopped

यदि आप इसे अपनी मशीन पर नहीं चला सकते हैं (इनपुट ट्रिकी लगता है) या आप इसे किसी अन्य सॉफ़्टवेयर के बिना आज़माना चाहते हैं, तो आप ऑनलाइन इंटरप्रेटर पर निम्न संस्करण का उपयोग कर सकते हैं ।

0v
 <vooo">> "<
  >i:0)?v~
      o:/  ^!?="c"v?="o":v?="s":v?="k":v?="d":v?="x":v?="i":
 ^oanoa:<        ~<  v*:~<      <  v-1~<  v+1~<      <
   <                 <             <      <vv?=-10:v?=*:+1f:
  v                                        <>      >~0

यह स्पष्ट रूप से \ n और EOF की अवहेलना करता है क्योंकि आप उन्हें ऑनलाइन दुभाषिया में इनपुट नहीं कर सकते हैं, लेकिन व्यवहार करेंगे जैसे कि प्रत्येक आउटपुट कमांड के बाद दर्ज किया गया था।

— हारून
स्रोत

1

सी (जीसीसी) , 139 बाइट्स

के साथ संकलन -Dk="_nZZiaeY"(बाइट गिनती में शामिल)। -2 बाइट्स अगर प्रॉम्प्ट >>\nकी अनुमति है।

x;f(c){for(printf(">>");c=getchar()-10;x+=c--?c--?c--?c||printf("%i\n",x),0:x*x-x:-1:1,x*=~x&&x^256)c=strchr(k,c)-k>>1;f();}

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

Degolf

/** Preprocessor **/
-Dk="_nZZiaeY" // This is a lookup string; it corresponds to "ixddskoc",
               // with 10 deducted from each character. Upon compilation, 
               // all occurences of the string literal are replaced with a 
               // pointer to its location in memory.

/** Source **/
x;f(c){ // x: 32-bit accumulator, c: local variable for read character
    for(printf(">>"); // Start for-loop and print prompt.
            c=getchar()-10; // Read a character from STDIN.
                            // Loop breaks if it is '\n'.

            // The below happens at the end of each iteration.
            x+=c--?c--?c--? 
               // Find the correct operation by testing c and post-
               // decrementing with multiple ternary-ifs. If c is 0, 
               // operation was found, add the else-value to the 
               // accumulator x.
               //     If the character is invalid, the value of c is
               // very large, and will not reach 0 with 3 decrements.

               c||printf("%i\n",x),0 
               // If c-3 is 0, print accumulator, else do nothing.
               // Returns 0 regardless of what happens. (No change to x)
               :x*x-x 
               // Square. Results in x=x+x*x-x, and is shorter than (x*=x)
               :-1:1, 
               // Decrement, Increment.
               x*=~x&&x^256 
               // Because -1==0xffffffff, ~x==0 when x==-1. Likewise,
               // x^256==0 only when x==256. The logical-AND coerces the result
               // to boolean 1 (no match) or 0 (match). Multiplication resets
               // the accumulator as appropriate.
           )
        // This is the actual body of the for-loop
        c=strchr(k,c)-k>>1; 
           // Finds the index of the read character in the lookup string,
           // then "divides" it by two.
           // Because strchr() returns NULL (0) when character is not found,
           // deducting k from it results in a very negative number.
           // The right-shift results in division by 2 for positive numbers, 
           // while the negative numbers become very large positive numbers
           // (c >= 0x70000000) because of the 2's complement representation.
    // Finally, recurse until forceful termination.
    f();
}

1

केग , 68b

0{'::"ÿ1+=$0<+['_0"] \>\>\
,,,,?:o=[':."]:i=['1+"]:d=['1-"]:s=[':*"

— ए
स्रोत

0

हास्केल, 230

import System.IO
i""n=[]
i(a:b)n 
 |a=='o'||a=='c'=[n]++i b n
 |True=i b$v a n
v a n=w(case a of 'i'->n+1;'x'->n+1;'d'->n-1;'s'->n^2;'k'->n^2)
w(-1)=0
w 256=0
w n=n
main=do;putStr ">> ";hFlush stdout;s <- getLine;print$i s 0;main

अगर केवल मैं उस pesky hFlush stdoutकॉल से छुटकारा पा सका ! इसके बिना, oऑपरेशन प्रदर्शित होने तक संकेत प्रदर्शित नहीं किया जाता है। कोई सुझाव?

— danmcardle
स्रोत

आप संकलन के बजाय ( मेरे उत्तर देखें ) hFlushका उपयोग करके छुटकारा पा सकते हैं , लेकिन इस समाधान के लिए यह मान्य नहीं है और त्रुटियां समाप्त हो गई हैं। runhaskell

— ბიმო

0

PHP + HTML 345

<form><?php $i=0;$o='';if(isset($_GET[i])){$i=$_GET[a];foreach(@str_split($_GET[i]) as $j=>$v){$v==i||$v==x?$i++:($v==d?$i--:($v==k||$v==s?$i*=$i:($v==o||$v==c?$o.=$i."\n":'')));($i==256||$i==-1)&&$i=0;}$_GET[p].='>> '.$_GET[i]."\n".$o;echo"<textarea locked name=p>$_GET[p]</textarea><input type=hidden name=a value=$i><br>";}?>>> <input name=i>

आउटपुट एक छोटा सा स्केच है (इतिहास / सत्र एक textarea पर दिखाया गया है, और त्रुटि रिपोर्टिंग में सक्षम होने के साथ बहुत सी चेतावनियों को मुद्रित किया जाता है) लेकिन सब कुछ काम करता है

— Einacio
स्रोत

0

> <>, 239

v
\r0&
v                  <
\&::&01-=$f1+:*=+?v
v             &0~&<
\:"i"=?v
       >~&1+&      ^
\:"d"=?v
       >~&1-&      ^
\:"s"=?v
       >~&:*&      ^
\:"o"=?v
       >~&:o&      ^
\:"h"=?v
       >~;        (^)
>~                 ^

प्रारंभिक स्टैक इनपुट है। आप इसे यहाँ ऑनलाइन आज़मा सकते हैं ।

— अवस्था
स्रोत

0

गोल्फ-बेसिक 84, 88 वर्ण

:0_A:0_O:1_I:2_D:3_S:O_C:I_X:S_Kl`1i`N@A=256:0_A@N=0d`A@N=1:A+1_A@N=2:A-1_A@N=3:A^2_Ag`1

कम से कम 3 अन्य समाधानों के रूप में, एक समय में एक कमांड का संकेत देता है। यहाँ एक परीक्षण चलाने के लिए है xiskisc:

?X
?I
?S
?K
?I
?S
?C
             289

इसके अलावा, xisksoआउटपुट 0, जैसा कि यह होना चाहिए।

— Timtech
स्रोत

कौन से अन्य समाधान एक समय में एक कमांड को संकेत देते हैं?

— Ry-

1

मैंने हास्केल एक लिखा था, और नहीं, यह नहीं है। न ही पर्ल एक है, इसलिए मैं वास्तव में निश्चित नहीं हूं कि आप किस बारे में बात कर रहे हैं।

— Ry-

1

यह I / O नियमों का पालन नहीं करता है।

— मारिनस

1

अभी भी नियमों का पालन नहीं करता है, और लोअरकेस के बजाय अपरकेस अक्षरों का उपयोग करता है।

— lirtosiast

1

यदि आप TI-BASIC के बारे में जानते हैं, तो यह केवल अपरकेस इनपुट का समर्थन करता है।

— टाइमटेक

0

जावास्क्रिप्ट (Node.js), 204 बाइट्स

process.openStdin(f=a=>process.stdout.write((i=0,""+a).split` `.map(x=>([...x.slice(0,-1)].map(d=>({i:x=e=>i++,d:e=>i--,s:k=e=>i*=i,o:c=e=>e,x,k,c})[d](i=-1||i==256?i=0:0)),i))+"\n>> "),f``).on("data",f)

यह शायद गोल्फ हो सकता है। Node.js फिर से यह साबित करता है कि यह एक बार फिर से अजीब रूप से विकृत है। कोड समझाया गया:

process.openStdin( // This function has to be called to take input, but doesn't have arguments
  f=a=> // Define a function f. This is the deadfish interpreter. It takes an argument `a` which is a Buffer
  process.stdout.write( // Same as console.log, but doesn't output trailing newline
    (i = 0, "" + a) // Take advantage of comma operator to (A) define the accumulator i, and casts a (which is a Buffer) to a String
      .split` ` // Split the string a at spaces, making it an array
      .map(     // Map through each element of the array
        x=>     // Map function, takes argument x, the value in the array (string)
          ([...x.slice(0,-1)] // Remove the last character (newline) and than use the spread operator to divide the string into an array of it's chars
            .map(d=> // Map function, you know how this works
              ({ // Here I define the various deadfish commands
                i: x = e => i++,
                d: e => i--,
                s: k = e => i*=i,
                o: c = e => e,
                // Take advantage of ES6 object notation. Equivilent to {"x": x, "k": k, "c", c}
                x,
                k,
                c
              })
              [d] // Get the command to execute. If this is passed something which isn't valid, a giant error will appear
              (
                i==-1 || i==256 ? i = 0 : 0 // Take advantage of the fact that none of the command functions take arguments to handle the strange "overflow"
              )
            ),
          i)
      ) +
  "\n>> "), // Display the prompt again, as well as a newline
  f`` // Initalize the prompt by passing an empty script
)
.on("data",f) // Bind the f function to newline on STDIN

— MayorMonty
स्रोत

0

सी #, 311 बाइट्स

using System;class p{static void Main(){int a=0;int s(int b)=>b==-1||b==256?0:b;while(true){Console.Write(">>");var c=Console.ReadLine();for(int i=0;i<c.Length;i++){switch(c[i]){case'i':case'x':a=s(a+1);break;case'd':a=s(a-1);break;case's':case'k':a=s(a*a);break;case'o':case'c':Console.WriteLine(a);break;}}}}}

283 बाइट होगा यदि usings और वर्ग घोषणा आदि को केवल एक फ़ंक्शन परिभाषा प्रदान करके ommitted किया जा सकता है

— रॉबिन बी
स्रोत

एक इंटरैक्टिव डेडफिश दुभाषिया लिखें

विशिष्टता

परीक्षण कार्यक्रम

आई / ओ

के, 77 बाइट्स

पर्ल 5 , 90 बाइट्स

पॉवरशेल, 131 126 121 114 113

रीबोल 3, 178 169 161 159

हास्केल, 202

रूबी, 140 138

के, 121

एडीए

C, 159 वर्ण

सी, 163

पायथन 3, 181 175 171 162

आर, 161 , 148 , 138

अजगर 3, 141

व्याख्या

संक्षिप्त उदाहरण:

अजगर २, १३ ९

टीआई-बेसिक, 104 107 102 100 98

पोस्टस्क्रिप्ट 272

सी (224 212 अक्षर)

लुआ, 230 228

हास्केल , 186 178 बाइट्स

व्याख्या

विंडोज बैच, 204 256

विंडोज कमांड स्क्रिप्ट - 154

> <> , 258 बाइट्स

सी (जीसीसी) , 139 बाइट्स

Degolf

केग , 68b

हास्केल, 230

PHP + HTML 345

> <>, 239

गोल्फ-बेसिक 84, 88 वर्ण

जावास्क्रिप्ट (Node.js), 204 बाइट्स

सी #, 311 बाइट्स