Deadfish es un "lenguaje de programación" de broma con cuatro comandos. Como la página de Esolang es un poco contradictoria y los intérpretes de esa página no funcionan exactamente igual, debe implementar la siguiente variación:

Especificación

1. Hay un acumulador que tiene al menos 16 bits de tamaño, se permite más pero no menos. Los números negativos no necesitan ser compatibles. El acumulador es 0cuando comienza el programa.
2. Existen los siguientes dos conjuntos de cuatro comandos, y su programa debe admitir ambos al mismo tiempo.

     Deadfish estándar │ Variante XKCD │ Significado
     ─────────────────────┼──────────────────┼───────── ───────────────────────────
           i │ x │ Incremento acumulador
           d │ d │ Decremento acumulador
           s │ k │ Cuadrado (acc = acc * acc)
           o │ c │ Acumulador de salida, como un número
   

3. Si, después de ejecutar un comando, el acumulador es -1o 256, el acumulador debe restablecerse a cero. Tenga en cuenta que esto no es normal. Si, por ejemplo, el acumulador es 20, y el scomando se ejecuta, el acumulador debería estar 400después. Del mismo modo, si el acumulador es 257y dse ejecuta el comando, el acumulador debería convertirse 0.
4. Cualquier entrada que no sea uno de estos comandos debe ignorarse.

Programas de prueba

• xiskso debería salir 0
• xiskisc debería salir 289

I / O

Su programa debe mostrar un mensaje: >>. La solicitud debe estar al comienzo de una nueva línea. Luego debería leer una línea de entrada del usuario y ejecutar los comandos dados de izquierda a derecha. Al generar números, los números deben estar separados. Es decir, 12 34está bien, 12,34está bien,

12
34 

está bien, pero 1234no lo está.

Su programa debe seguir haciendo esto en un bucle, al menos hasta que EOFse alcance.

Sesión de ejemplo:

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

K, 77 bytes

  {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

Tenga en cuenta que esto es K4 . Una solución K6 es un poco más larga porque los verbos IO son más largos, incluso si todo lo demás es mejor:

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

• ""0:imprime y devuelve su argumento. Tenga en cuenta que en K4 simplemente aplicamos a 1 .
• 0 f/ args demuestra reducir con un valor inicial, es decir f[f[0;first arg];second arg]…
• {x*2=-1 256?x…clasifica x en 0 (para -1), 1 (para 256) y 2 para todos los demás valores. 2=significa que obtenemos 1valores no clasificados y0 , de lo contrario, multiplicar por xes más corto que un condicional. En K6 podemos hacerlo un poco mejor porque se {x*^-1 256?x:y@x}basa en el hecho de que -1 256?xdevuelve 0N(nulo) y ^detecta nulos.
• El "analizador" es el mapa en "xkcdiso"lugar del orden sugerido porque 7#envolverá los cuatro argumentos, es decir, 7#"abcd"retornos, lo "abcdabc"que mantiene nuestra tabla más pequeña
• El mapa se traduce "x" y "i"de la proyección 1+que es equivalente a la función {1+x}pero más corto.
• El mapa se traduce "d" a la proyección -1+que es equivalente a la función {-1+x}pero más corta.
• El mapa se traduce "k"y "s"a la función{x*x}
• El mapa se traduce "c"y"o" de la función de salida {-1@$x;x}que a su vez en K6 es un poco más largo: {""0:,$x;x}pero ambos imprimir su salida seguido de una nueva línea, y luego devuelve el argumento.
• .zs es autorrecurrencia. En K6 simplemente podemos decir o`cuál es más corto.

Perl 5 , 90 bytes

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

Pruébalo en línea!

¡Gracias a @xfix por su ayuda en esto anteriormente! ¡Guardado 4 bytes gracias a @Xcali !

Powershell, 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){...} - establece el acumulador en 0 y repite para siempre
• read-host '>>' - obtener la entrada del usuario con solicitud >>
• [char[]](...) - convierte la entrada del usuario en una matriz de caracteres
• |%{...} - realiza lo que hay dentro {} de cada personaje
• switch -r($_) - interruptor de expresiones regulares para cada personaje
• "i|x"{$x++} - igualar io x- aumentar el acumulador
• "d"{$x-=!!$x} - coincidir d- disminuir $xen !!$x, lo que será 0si $xes 0, y de lo 1contrario. Esto asegura que el acumulador nunca llegue -1.
• "s|k"{$x*=$x} - partido so k- cuadrado
• "o|c"{$x} - emparejar oo c- sacar el acumulador
• $x*=$x-ne256 - multiplique el acumulador por 0 si es así 256o por 1otro

Salida de ejemplo

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

Supongo que la implementación de read-hostes específica del host, por lo que este host Powershell (ConsoleHost) se agrega :al indicador especificado.

Rebol 3, 178 169 161 159 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]

Versión más bonita:

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]

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

Rubí, 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;'}}

Sesión de muestra (igual que la tuya):

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

Aquí hay una implementación de Ada para los pocos interesados ​​en este lenguaje. Me llevó bastante tiempo utilizar algunas de las mejores prácticas de Ada (como el uso de Indefinite_Holders en lugar de acceso) y también comprender completamente cómo debe funcionar 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;

Y la salida:

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

Si algunas personas experimentaron en Ada podrían darme algunos consejos de optimización, estaría agradecido.

C, 159 caracteres

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

Intenté otro enfoque basado en configurar una tabla de búsqueda para la decodificación de instrucciones, pero desafortunadamente eso terminó más tiempo ( 169 ). Lo incluí ya que a alguien se le ocurre un ajuste inteligente para reducir el tamaño. (Debe ejecutarse sin ningún argumento)

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

Pitón 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,""))

Esto genera una nueva línea después del >>, pero el OP no dijo que no estaba permitido. ¡Ya no!

Gracias a GlitchMr, miniteche 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")}}

Versión sin golf:

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

Ejemplo de sesión (en modo interactivo):

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

Pitón 3, 141

Sé que llego tarde, pero quería aprovechar la oportunidad para publicar una versión más corta de Python (y mi primer intento de 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,'')+')')

La declaración impresa fue un poco complicada para esto. Si la solicitud tiene que terminar con un espacio en blanco, agregue un carácter al conteo. :)

Explicación

v Es el acumulador.

mcomprueba si el valor dado es -1o256 . Si es así,0 se devolverá, el valor de lo contrario.

En las siguientes líneas, las operaciones se asignan a las variables correspondientes (ya que algunas tienen el mismo significado (como iy x) esto es más corto que crear instancias de un nuevo diccionario). Esos son luego utilizados en elexec continuación.

while 1: es el bucle principal

Ahora comienza la diversión. Al igual que la solución de @jazzpi , itera sobre cada carácter de la entrada. locals()es el diccionario de todas las variables actuales (visibles). Con .get(n,'')la clave correspondiente se colocará en la cadena de ejecución (una cadena vacía, si no se encontró la clave (= otra entrada)). Esto será, cuando se ejecute, se concatene vy pase hacia m. El valor de retorno se almacenará vnuevamente.

Breve ejemplo:

Sea n = 'i'( n= input-char), salimos '+1'del localsbloque como ies la variable con valor '+1'.
La cadena de los execque es similar al siguiente: 'v=m(v+1)'.
Quizás ahora sea más fácil ver que, al ejecutar, llamará mcon el valor de v+1y almacenará su salida vnuevamente.

Repita esto hasta que esté aburrido. :)

Pitón 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

Esto es ordenado, pero también bastante sencillo. Aquí hay una versión más larga y fresca:

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)

Con un peso de 190 caracteres, quizás no sea la respuesta más competitiva aquí. Por otro lado, las corutinas son bastante radicales y siempre estoy buscando una excusa para usarlas (y compartirlas)

TI-BASIC, 104 107 102 100 98

Para calculadoras de la serie TI-83 + / 84 +.

Nombra esto prgmD; eventualmente desborda la pila al llamarse a sí mismo. Reemplace la recursión con a While 1, al costo de dos bytes, para arreglar esto.

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 es 0 por defecto, así que ejecute esto con una calculadora recién borrada de memoria o almacene 0 a Y manualmente antes de ejecutar esto.

Lástima que las letras minúsculas (en los literales de cadena) sean de dos bytes cada una; de lo contrario, esto sería más corto que la respuesta de Dom Hastings.

EDITAR: se corrigió un error de división por cero (0 ^ 0) a costa de tres bytes.

107 -> 102: Utilicé el truco de exponenciación imaginaria para guardar cuatro bytes (incluido 1 de paréntesis y -1 de alargar la cadena de búsqueda) y utilicé Y en lugar de X, que toma un byte menos para inicializar.

Posdata 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

Sin golf:

/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 caracteres)

Esta es probablemente una mala elección de idioma, pero bueno. No es que un lenguaje como C pueda funcionar mejor que un lenguaje de programación dinámico. En Clang, deberá especificar un valor para return(esto no es necesario para 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();}}

Lua, 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 _

No lo peor, no lo mejor.

NOTA: según lo informado por @mniip 256or puede no funcionar en su intérprete. Más información en comentarios.

(más o menos) Versión legible:

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 _

Salida:

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

Editar: gracias a @mniip para la optimización de 2 caracteres: until nil->until _

Haskell , 186 178 bytes

Esto tiene que ejecutar con runhaskell(o en el interior ghci), ya que ambos establecen el BufferModeque NoBufferingpor defecto que cajas fuertes un buen montón de bytes:

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

Pruébalo en línea!

Explicación

Esto define un nuevo operador state # source(la declaración fijeza nos permite caer paréntesis, cuando se utiliza en conjunción con otros operadores (+), (-), (^), (:)y (>>)):

• las dos primeras líneas "arreglan" los estados -1y256
• luego coincide con el primer personaje y actúa sobre él
• una vez que se queda sin caracteres ( r#_), lee otros nuevos y comienza de nuevo manteniendo el estado anterior

Para comenzar el proceso, inicializamos el estado 0y leemos una nueva línea de origen, es decir. Comience con una fuente vacía:

main=0#""

Lote de Windows, 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

Ignora con éxito otros comandos. Realmente se hinchó sin teneror que trabajar con ...

Editar:

Fijo:

• No más ecos de todos los comandos
• Hecho en realidad HACER matemáticas con / a
• Restablecer en -1
• Restablecer entrada después de cada ciclo

Esto costó 52 caracteres.

No arreglado:

• Cuadrando 0 escribe "0 * 0" en a.
• Ingresar espacio (o ingresar nada, cuando lo acaba de abrir) bloquea el script.
• NECESITA ingresar un carácter a la vez.

Script de comando de Windows - 154

Abusin características desconocidas al máximo.

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

He hecho otra respuesta> <> ya que no pude probar las fases y usó comandos preapilados en lugar de emular un shell de todos modos.

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

Ciertamente se puede jugar golf, ¡pero no estoy seguro de tener la valentía de locura necesaria !

Lo probé con el intérprete oficial que se ejecuta en Python 3.5 en Cygwin en Windows 7 y pude reproducir la ejecución de prueba:

$ 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

En caso de que no pueda ejecutarlo en su máquina (la entrada parece ser complicada) o simplemente desea probarlo sin ningún otro software, puede usar la siguiente versión en el intérprete en línea .

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

Obviamente, ignora \ ny EOF ya que no puede ingresarlos en el intérprete en línea, pero se comportará como si se hubiera presionado enter después de cada comando de salida.

C (gcc) , 139 bytes

Compilar con -Dk="_nZZiaeY"(incluido en el recuento de bytes). -2 bytes si >>\nse permite la solicitud .

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

Pruébalo en línea!

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

Barril , 68B

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

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

¡Ojalá pudiera deshacerme de esa molesta hFlush stdoutllamada! Sin él, la solicitud no se muestra hasta oque se realiza una operación. ¿Algún consejo?

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>

la salida es un poco incompleta (el historial / sesión se muestra en un área de texto, y con el informe de errores habilitado se imprimen muchas advertencias) pero todo funciona

> <>, 239

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

La pila inicial es la entrada. Puedes probarlo en línea aquí .

Golf-Basic 84, 88 caracteres

: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

Solicita un comando a la vez, como en al menos otras 3 soluciones. Aquí hay una prueba de funcionamiento paraxiskisc :

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

También, xisksosalidas 0, como debería.

JavaScript (Node.js), 204 bytes

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)

Esto probablemente se puede jugar al golf. Node.js nuevamente demuestra que es extraño verbosidad disfrazada una vez más. Código explicado:

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 bytes

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

sería de 283 bytes si los usos y la declaración de clase, etc. pudieran omitirse simplemente proporcionando una definición de función