Deadfish 는 네 가지 명령이있는 농담 "프로그래밍 언어"입니다. Esolang 페이지는 약간 모순되며 해당 페이지의 인터프리터가 모두 동일하게 작동하지 않으므로 다음 변형을 구현해야합니다.

사양

1. 최소 16 비트 크기 의 누산기가 있으며 더 많이 허용되지만 더 적습니다. 음수는 지원할 필요가 없습니다. 누산기는 0프로그램이 시작될 때입니다.
2. 다음 두 가지 네 가지 명령 세트가 있으며 프로그램은 동시에 두 가지를 모두 지원해야합니다.

     표준 데드 피쉬 │ XKCD 변형 │ 의미
     ──────────────────────┼───────────────────┼────────── ─────────────────────────────
           i │ x │ 증분 누산기
           d │ d │ 누산기
           s │ k │ 제곱 (acc = acc * acc)
           o │ c │ 출력 누산기 (숫자)
   

3. 명령을 실행 한 후 누산기가 -1또는 256이면 누산기가 0으로 재설정되어야합니다. 이것은 일반적인 랩 어라운드가 아닙니다. 예를 들어, 누산기가 20이고 s명령이 실행되면 누산기가 400이후에 있어야합니다 . 마찬가지로 누산기가 257있고 d명령이 실행되면 누산기가 0됩니다.
4. 이러한 명령 중 하나가 아닌 입력은 무시해야합니다.

테스트 프로그램

• xiskso 출력해야합니다 0
• xiskisc 출력해야합니다 289

I / O

프로그램에 프롬프트가 표시되어야합니다 >>.. 프롬프트는 새 줄의 시작 부분에 있어야합니다. 그런 다음 한 줄의 사용자 입력을 읽고 주어진 명령을 왼쪽에서 오른쪽으로 실행해야합니다. 숫자를 출력 할 때는 숫자를 구분해야합니다. 즉, 12 34OK, 12,34OK입니다.

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
>> 

K, 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의 입출력 동사는 다른 모든 좋은 경우에도 더 이상 때문에 솔루션은 약간 이상 :

{""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에서는 (null) {x*^-1 256?x:y@x}을 -1 256?x반환 0N하고 null을 ^감지 한다는 사실에 의존 하기 때문에 조금 더 잘할 수 있습니다 .
• "파서 (parser)"는 "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`더 짧은 것을 말할 수 있습니다 .

펄 5 , 90 바이트

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

온라인으로 사용해보십시오!

이전에 도움 을 주신 @xfix 에게 감사드립니다 ! @Xcali 덕분에 4 바이트가 절약되었습니다 !

파워 쉘, 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($_) -각 문자에 대한 정규식 스위치
• "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이 호스트별로 다르 므로이 Powershell 호스트 (ConsoleHost) :가 지정된 프롬프트에 추가 됩니다.

REBOL 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]

더 예쁜 버전 :

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]

하스켈, 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

루비, 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
>>

K, 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
>>

에이다

다음은이 언어에 관심이있는 소수를위한 Ada 구현입니다. Ada의 모범 사례 (액세스 대신 Indefinite_Holders 사용)를 사용하고 Deadfish의 작동 방식을 완전히 이해하려면 시간이 많이 걸렸습니다.

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
>>

Ada에서 실험 한 일부 사람들이 나에게 최적화 힌트를 줄 수 있다면 감사 할 것입니다.

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();
}

C, 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 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,""))

이 후 개행을 출력 >>하지만 OP는 허용되지 않았다고 말하지 않았습니다. 더 이상은 아닙니다!

덕분에 GlitchMr, minitech와 golfer9338!

R, 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")}}

언 골프 버전 :

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, 141

나는 늦었다는 것을 알고 있지만 더 짧은 Python 버전 (및 첫 번째 CodeGolf 시도)을 게시 할 기회를 갖기를 원했습니다. :)

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 의 솔루션 과 마찬가지로 입력의 각 문자를 반복합니다. locals()모든 현재 (보이는) 변수의 사전입니다. .get(n,'')해당 키 와 함께 exec-string (키 (= 다른 입력)을 찾을 수없는 경우 빈 문자열)에 입력됩니다. 이것은 실행될 때와 연결되어 v전달됩니다 m. 반환 값이 v다시 저장 됩니다.

간단한 예 :

수 n = 'i'( n= 입력 문자), 우리가 얻을 '+1'의 아웃 locals로 - 블록 i값을 가진 변수입니다 '+1'.
의 문자열은 exec다음과 같습니다 'v=m(v+1)'.
어쩌면 이제는 실행시 m값으로 호출 하고 다시 v+1출력에 저장 한다는 것을 쉽게 알 수 있습니다 v.

지루해질 때까지이 과정을 반복하십시오. :)

파이썬 2, 139

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 자로 된 무게는 아마도 가장 경쟁력있는 답변이 아닙니다. 다른 한편으로, 코 루틴은 꽤 rad하고 나는 항상 그것들을 사용하고 공유 할 변명을 찾고 있습니다.

TI-BASIC, 104 107 102 100 98

TI-83 + / 84 + 시리즈 계산기 용.

이름을 prgmD; 결국 스스로 호출하여 스택을 오버플로합니다. While 1이 문제를 해결 하려면 재귀를 2 바이트의 비용으로 대체하십시오 .

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를 수동으로 저장하십시오.

소문자 (문자열 리터럴에서)가 각각 2 바이트라는 것이 너무 나쁩니다. 그렇지 않으면 Dom Hastings의 답변보다 짧을 것입니다.

편집 : 3 바이트의 비용으로 0으로 나누기 (0 ^ 0) 오류가 수정되었습니다.

107-> 102 : 가상의 지수 트릭을 사용하여 4 바이트 (괄호에서 1, 조회 문자열 연장에서 -1 포함)를 저장하고 X 대신 Y를 사용하여 초기화하는 데 1 바이트가 덜 걸립니다.

포스트 스크립트 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

언 골프 드 :

/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

C (224 212 자)

이것은 아마도 잘못된 언어 선택 일 것입니다. C와 같은 언어가 일부 동적 프로그래밍 언어보다 더 잘할 수있는 것은 아닙니다. Clang에서는 값을 지정해야합니다 return(gcc에는 필요하지 않음).

#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();}}

루아, 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 _

하스켈 , 186178 바이트

둘 다 기본적으로로 설정되어 있기 때문에 많은 바이트를 안전하게 보호 하기 때문에 runhaskell(또는 inside ghci) 와 함께 실행해야 합니다.BufferModeNoBuffering

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#""

윈도우 배치, (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작업 하지 않아도 정말 부풀어 오릅니다 ...

편집하다:

결정된:

• 더 이상 모든 명령을 에코하지 않습니다
• 실제로 / a로 수학을 수행하게했습니다.
• -1로 재설정
• 매 사이클마다 입력 리셋

이 비용은 52 자입니다.

수정되지 않았습니다 :

• Squaring 0은 "0 * 0"을 씁니다.
• 공간을 입력하거나 방금 열었을 때 아무것도 입력하지 않으면 스크립트가 충돌합니다.
• 한 번에 하나의 문자를 입력해야합니다.

Windows 명령 스크립트-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

> <> 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

확실히 골프를 칠 수는 있지만, 필요한 광기 용기 가 있을지 모르겠습니다 !

Windows 7의 cygwin에서 python 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는 무시하지만 각 출력 명령 후에 enter가 눌린 것처럼 작동합니다.

C (gcc) , 139 바이트

-Dk="_nZZiaeY"(바이트 수에 포함)로 컴파일하십시오 . 프롬프트 >>\n가 허용 되면 -2 바이트 입니다.

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();}

온라인으로 사용해보십시오!

데 고프

/** 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();
}

통 , 68B

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

하스켈, 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

내가 그 성가신 hFlush stdout전화를 제거 할 수 있다면 ! 그렇지 않으면 o작업이 수행 될 때까지 프롬프트가 표시되지 않습니다 . 어떤 충고?

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>

출력은 약간 스케치입니다 (역사 / 세션은 텍스트 영역에 표시되고 오류보고가 활성화되면 많은 경고가 인쇄됩니다).

> <>, 239

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

초기 스택이 입력입니다. 여기에서 온라인으로 사용해 볼 수 있습니다 .

골프 기본 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

또한 필요에 따라 xiskso0을 출력합니다.

자바 스크립트 (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

C #, 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;}}}}}

함수 정의를 제공하여 using 및 클래스 선언 등을 생략 할 수있는 경우 283 바이트입니다.