在这个挑战中，您将为我编写的一种简单语言编写一个解释器。该语言基于单个累加器A，该累加器A的长度恰好是一个字节。在程序的开头，A =0。这些是语言说明：

!：反转

该指令仅将累加器的每一位取反。每个零变为1，每个零变为0。简单！

>：右移

该指令将A中的每一位右移一位。最左边的位变为零，最右边的位被丢弃。

<：左移

该指令将A中的每一位向左移一位。最右边的位变为零，最左边的位被丢弃。

@：交换Nybbles

该指令将A的高四位与低四位交换。例如，如果A是01101010并且您执行@，则A将是10100110：

 ____________________
 |                  |
0110 1010    1010 0110
      |_______|

这就是所有指示！简单吧？

规则

• 您的程序必须在开始时接受一次输入。这将是一行代码。这不是交互式解释器！您只能接受一次输入，而不必在执行该行后循环回到起始位置。
• 您的程序必须评估所述输入。上面没有提到的每个字符都将被忽略。
• 然后，您的程序应以十进制打印出累加器的最终值。
• 适用有效编程语言的常规规则。
• 不允许出现标准漏洞。
• 这是代码高尔夫球，最小字节数获胜。

这里有一些小程序可以测试您提交的内容。箭头之前是代码，之后是预期结果：

• ! -> 255
• !>> -> 63
• !<@ -> 239
• !nop!&6*! -> 255

请享用！

Pyth，36 35字节

u%@[t_G/G2yGi_jGJ16JG)x"!><@"H256z0

测试线束

累加器的内部表示形式是整数。根据需要，该整数在每次迭代中均以256进行修改。执行的操作是-G-1，G/2，G*2并G转化成基座16，反转，并且转换回基座10，其中G是累加器。

我错过了忽略其他一切的路线。这已得到纠正。谢谢，@丹尼斯。

C，96

假定ASCII（或兼容）输入：

a;main(c){while(c=getchar()+1)a=(c^34?c^61?c^63?c^65?a:a*257/16:a/2:a*2:~a)&255;printf("%u",a);}

整理者：

a;
main(c){
  while(c=getchar()+1)
    a=(c^34?
      c^61?
        c^63?
          c^65?
            a
          :
            a*257/16
        :
          a/2
      :a*2:~a
    )&255;
  printf("%u",a);
}

基本上，它只是嵌套三元表达式的集合。我增加了从中获得的值，getchar()以便EOF（-1）的值为零，并且程序退出。

（ideone链接）

Python 3，133个字节

使用字典来弥补Python中缺少转换用例语法的问题。在这里查看更多。

a="0"*8
for i in input():a={"!":''.join(str(1-int(b))for b in a),"<":a[1:]+"0",">":"0"+a[:-1],"@":a[4:]+a[:4]}.get(i,a)
print(int(a,2))

累加器是一个字符串，最后将其转换为以10为底的数字。

I / O示例：

$ python3 bitsnbytes.py
!
255
$ python3 bitsnbytes.py
!>>
63
$ python3 bitsnbytes.py
!<@
239
$ python3 bitsnbytes.py
!nop!&6*!
255

Javascript（ES6），80 91 90字节

a=>[...a].reduce((p,c)=>c=='!'?p^255:c=='<'?p*2%256:c=='>'?p>>1:c=='@'?p/16|0+p%16*16:p,0)

尽可能短。定义将程序作为输入的匿名函数。

• 对于!，采用x XOR 255，因为JS ~会考虑x使用32位数字。
• 对于<，乘以x2并得出结果mod 256。
• 对于>，将x1位的位真正右移。
• 对于@地板x/16，并将其添加到中x%16*16。

感谢@vihan建议使用reduce保存字节。

CJam，37个字节

0q{"!><@"#"~ 2/ 2* GmdG*+ "S/=~255&}/

在CJam解释器中在线尝试。

这个怎么运作

0                   e# Push 0 (accumulator).
q                   e# Read from STDIN.
{                   e# For each character in the input:
  "!><@"#           e#   Find its index in "!><@" (-1 if not found).
  "~ 2/ 2* GmdG*+ " e#   Push that string.
  S/                e#   Split at spaces to push ["~" "2/" "2*" "GmdG*+" ""].
                    e#     "~"      : signed 64-bit bitwise NOT
                    e#     "2/"     : divide by 2
                    e#     "2*"     : multiply by 2
                    e#     "GmdG*+" : (x) -> (x/16) (x%16) -> (16(x%16) + (x/16))
                    e#     ""       : NOOP
  =~                e#  Select the corresponding string and evaluate it.
  255&              e#  Zero all but the 8 least significant bits.
}/                  e#

的Java（8），514 483 411 366 359 239 224 229 198 194 187 186 184 182 181 180 177字符

哇，这已经打了很多！感谢所有给我建议的人！我非常感谢！

interface T{static void main(String[]g)throws Exception{int i,a=0;while((i=System.in.read())!=10)a=(i==33?255-a:i==62?a/2:i==60?a*2:i==64?a>>4|a<<4:a)%256;System.out.print(a);}}

通过使用按位操作（而不是冗长的Integer.???方法）优化半字节交换来分配了31（！）个字节。

通过删除为交换半字节而创建的不必要的字符串来打高尔夫球72（!!!!）个字符。比以前好多了？

通过取消直接使用java.util.Scanner和读取来打高尔夫球45（!!）个字符System.in。请注意，现在lambda表达式已消失，不再需要Java 8！仅Java 1就能做到！

感谢@bmarks，让班级打通了7个字符(default)（已删除public关键字）

将所有那些冗长的Integer类操作都翻转为，即可打入120个（!!!!!!!）字符255 - a。现在要短得多！

通过将移位转换为乘法和除法，从while语句中删除花括号并a在该main方法内设为局部，从而打入15个（！）字符。

Ungolfed 9 =（字符，因为左移的问题不会丢弃最左边的字节。因此，我现在做mod (256)。右移会使结果数字比以前短一比特，因此无需mod在右移上使用。我的半字节交换事物将交换最后4位和倒数第二个半字节，并and (&)截断所有其他位，如果原始数字小于256，我的反转程序不会造成任何问题。

@Geobits 通过将语句转换为很多三元语句，并将字符转换为整数，从而缩短了文字，从而获得了31个 35个字符switch。

通过去除不必要Golfed 7个字符&240中的半字节交换（(a&240)>>4到a>>4并转换(a&15)<<4到a<<4&240该最后变化仅golfed一个字符虽然。

Golfed 1个炭通过去除不必要=在a /= 2，因为a = a /= 2相当于a = a / 2。

通过转动Golfed 2个字符println来print。

通过消除（等于）中的意外a=来打高尔夫球2个字符a=255-aa=a=255-aa=255-a

通过转动Golfed 1吨焦炭a<<4&240进入a%16<<4。

通过在三元声明的外部添加括号并进行操作来打高尔夫球1个字符%256。这样，%16在半字节交换的左移部分就不需要了。括号加2个字符，%16节省3个字符。

通过更改class为Java 8的静态接口方法功能interface并从中删除，public可以打入3个字符。感谢@TheNumberOne（暂无评论，但在“ Java高尔夫技巧”中找到了答案）

Rust，121115字节

fn r(s:&str)->u8{let mut n=0u8;for t in s.chars(){match t{'!'=>n=!n,'>'=>n/=2,'<'=>n<<=1,'@'=>n=n>>4|n<<4,_=>()}}n}

样品运行：

fn main() {
    println!("{}", r("!"));    //=> 255
    println!("{}", r("!>>"));  //=> 63
    println!("{}", r("!<@"));  //=> 239
}

取消高尔夫：

fn run_ungolfed(s: &str) -> u8 {
    let mut n = 0u8;
    for t in s.chars() {
        match t {
            '!' => n = !n,
            '>' => n >>= 1,
            '<' => n <<= 1,
            '@' => n = (n >> 4) | (n & 15) << 4,
            _ => ()
        }
    }
    n
}

令人惊讶的是Rust的缩写。除了我今天学到了更多的优先级规则这一事实之外，没有什么真正有趣的了 -谁知道(a>>b)|c与谁相同a>>b|c？

通过更改n>>=1为减少一个字节n/=2; 但是，乘法不能做到这一点，因为在Rust中算术溢出是一种恐慌（即崩溃）。

HP 41C / CV / CX（？字节，42步）

纯粹是为咯咯笑，这是针对HP 41C / CV / CX计算器的。（不幸的是，需要扩展功能模块或ATOX功能使用41CX。）计算器不报告程序大小（以字节为单位）。

将您的程序放入Alpha寄存器中，这有点棘手，因为无法输入！或@直接从键盘输入（分别使用XTOA和ASCII码33和64附加它们）。

步骤08和10允许忽略无效的操作码；删除它们以保存2个步骤，但是该程序将在无效输入时崩溃。

01 LBL"BB
02 0
03 LBL A
04 ATOX
05 X=0?
06 GTO E
07 X<>Y
08 SF 25
09 XEQ IND Y
10 CF 25
11 GTO A
12 LBL 33
13 255
14 X<>Y
15 -
16 RTN
17 LBL 60
18 2
19 *
20 256
21 MOD
22 RTN
23 LBL 62
24 2
25 /
26 INT
27 RTN
28 LBL 64
29 RCL X
30 16
31 /
32 INT
33 X<>Y
34 16
35 *
36 256
37 MOD
38 +
39 RTN
40 LBL E
41 RDN
42 RTN

Python 2，79字节

我意识到我之前已经在Python中做过非常类似的事情。这只是我的Ruby答案的一部分，但是到目前为止，它是最短的Python答案：D

a=0
for i in raw_input():a=[~a,a/2,a*2,a*16+a/16,a]["!><@".find(i)]&255
print a

与Ruby版本的不同之处在于，该版本在迭代输入时不会忽略无效指令。相反，我利用了Python倾向于返回-1而不是nil没有匹配时返回的事实-的当前值a被附加到结果数组的后面，以便所有无效指令都映射到相同的，不变的值。

Python 3，124 94 93字节

a=0
for i in input():
 if i in"!><@":a=(i=='!')*(255-a)+(i==">")*a//2+(i=="<")*(a+a)%256+(i=="@")*(16*(a%16)+a//16)
print(a)

“！” 等于从255减去。
“ <”等于乘以2。但是8位寄存器表示mod256。
“>“与整数除以2相同。
“ @”表示将最后4位（a%16）移位4位（*16），然后加上前四位（a/16）。

编辑（阅读无耻复制）
在python中看到了另一个答案（通过Beta衰减）。它使用一种非常有效的方法来使用字典来模拟切换案例。使用它我们可以写

a=0
for i in input():a={"!":255-a,"<":a<<1&255,">":a//2,"@":(a%16)<<4+a>>4}.get(i,a)
print(a)

谢谢，Beta衰变。

Haskell，89个字节

a#'!'=255-a
a#'>'=div a 2
a#'<'=mod(a*2)256
a#'@'=mod(a*16)256+div a 16
a#_=a
f=foldl(#)0

用法示例：f "!>>"->63

锈，111字节

有关@Doorknob答案的更多评论，但由于我刚刚创建了一个帐户，因此我没有任何评论代表。

可以使用以下方法从他的Rust解决方案中减少10个字节：

fn r(s:&str)->u8{let mut n=0u8;for t in s.chars(){n=match t{'!'=>!n,'>'=>n>>1,'<'=>n<<1,'@'=>n>>4|n<<4,_=>n}}n}

Python 3，127个字节

编辑：短裤，谢谢@Jakube

Edit2：修复，谢谢@Anachor

a=0
for i in input():a=(a^255if i=="!"else a>>1if i==">"else a<<1if i=="<"else(a&15)<<4|(a&240)>>4if i=="@"else a)&255
print(a)

锡兰，297 290

shared void y(){value t=process.readLine()else"";variable Byte a=0.byte;for(c in t){switch(c)case('!'){a=a.not;}case('>'){a=a.rightLogicalShift(1);}case('<'){a=a.leftLogicalShift(1);}case('@'){a=a.and(#f0.byte).rightLogicalShift(4).xor(a.and(#f.byte).leftLogicalShift(4));}else{}}print(a);}

格式：

shared void y() {
    value t = process.readLine() else "";
    variable Byte a = 0.byte;
    for (c in t) { switch (c)
        case ('!') { a = a.not; }
        case ('>') { a = a.rightLogicalShift(1); }
        case ('<') { a = a.leftLogicalShift(1); }
        case ('@') { a = a.and(#f0.byte).rightLogicalShift(4).xor(a.and(#f.byte).leftLogicalShift(4)); }
        else {} }
    print(a);
}

#f并且#f0是半字节的十六进制数字，.byte将整数转换为字节。我很幸运，Byte的.string属性已经使用了字节的无符号表示。锡兰还具有switch语句而不会掉线，并且字符串是可以迭代的字符列表。

我还尝试通过使用别名导入来减少那些长移位方法的名称，但这实际上要长7个字节：

import ceylon.language{Byte{r=rightLogicalShift,l=leftLogicalShift}}shared void x(){value t=process.readLine()else"";variable Byte a=0.byte;for(c in t){switch(c)case('!'){a=a.not;}case('>'){a=a.r(1);}case('<'){a=a.l(1);}case('@'){a=a.and(#f0.byte).r(4).xor(a.and(#f.byte).l(4));}else{}}print(a);}

格式：

import ceylon.language {
    Byte {
        r=rightLogicalShift,
        l=leftLogicalShift
    }
}
shared void x() {
    value t = process.readLine() else "";
    variable Byte a = 0.byte;
    for (c in t) {
        switch (c)
        case ('!') { a = a.not; }
        case ('>') { a = a.r(1); }
        case ('<') { a = a.l(1); }
        case ('@') { a = a.and(#f0.byte).r(4).xor(a.and(#f.byte).l(4)); }
        else {}
    }
    print(a);
}

如果我们经常需要这些方法，这可能会很有用。

红宝石， 81 73字节

如此简单-无需评估！对于输入中的每个有效字符，它会评估每个指令，并通过索引$&（输入中的当前字符）找到合适的指令。

a=0
gets.scan(/[!><@]/){a=[~a,a/2,a*2,a*16+a/16]["!><@".index$&]&255}
p a

STATA，197个字节

di _r(a)
gl b=0
forv x=1/`=length("$a")'{
gl c=substr("$a",`x',1)
if"$c"=="!" gl b=255-$b
if"$c"==">" gl b=int($b/2)
if"$c"=="<" gl b=mod($b*2,256)
if"$c"=="@" gl b=mod($b,16)*16+int($b/16)
}
di $b

不打高尔夫球

display _request(a) //get the input via prompt and put in var a
global b=0 //initialise A to be 0
forv x=1/`=length("$a")'{ //for loop from 1 to last char in a
global c=substr("$a",`x',1) //get the char at index x in a
if "$c"=="!" global b=255-$b //invert is the same as 255-A
if "$c"==">" global b=int($b/2) //right shift is the same as A/2 (with integer division)
if "$c"=="<" global b=mod($b*2,256) //left shift is the same as A*2%256
if "$c"=="@" global b=mod($b,16)*16+int($b/16) //nibble swap is the same as A%16*16+A/16
}
display $b //display the result of A

不能与在线解释器一起使用，并且需要非免费的默认解释器。对于实际的按位运算，这会稍微容易一些，但我认为它们对于STATA的大多数常用用法并不太有用。

JavaScript的104

[].reduce.call(prompt(),function(a,i){return(i=='!'?~a:i=='>'?a/2:i=='<'?a*2:i=='@'?a>>4|a<<4:a)&255},0)

嵌套三元运算符映射到指令。

BITWISE AND用于将我们的Number类型限制为一个字节。

朱莉娅117 94 86 73字节

p->(a=0x0;[a=c==33?~a:c==60?a<<1:c==62?a>>1:c!=64?a:a<<4|a>>4for c=p];1a)

这是一个匿名函数，它接受一个字符串并返回一个整数。要调用它，请将其分配给变量。

取消高尔夫：

function f(p)
    # Initialize the accumulator to 0 as an 8-bit unsigned integer
    a = 0x0

    # Loop over the characters in the input
    for c in p
        a = c == 33 ? ~ a :        # '!'
            c == 60 ? a << 1 :     # '<'
            c == 62 ? a >> 1 :     # '>'
            c != 64 ? a :          # no-op
            a << 4 | a >> 4        # '@'
    end

    # Convert the accumulator to a regular integer and return
    return Int(a)
end

Sp3000节省了8个字节，Dennis节省了13个字节！

JavaScript（ES6），76 81

作为未命名的函数，返回累加器值

这是@daniero的超级聪明答案的移植（支持的方式太少了）

奖励：您可以传递累加器的初始值。如果未通过，则起始值为0（具体而言）。

(p,a)=>(p.replace(/[!<>@]/g,i=>a=(i<'<'?~a:i<'>'?a*2:i<'@'?a/2:a*257/16)&255),a)

在任何EcmaScript 6浏览器中测试运行以下代码段（我在Firefox中进行了测试）

f=(p,a)=>[...p].map(c=>a=255&[a,~a,a*2,a/2,a*257/16][1+'!<>@'.indexOf(c)])|a

// TEST
out=x=>O.innerHTML+=x+'\n'

function go(x) { out(x+' -> '+f(x)) }

go('!'),go('!>>'),go('!<@'),go('!nop!&6*!')

// LESS GOLFED
F=(p,a)=>// a as a parameter, if not passed its value starts as undefined, then becomes NaN, but the operators '&' and '~' treat it as 0
  [...p].map(c => // execute following function for each character p
    a = 255 & // any intermediate result is converted to numeric and truncate to a byte          
   // evaluate all possible results (then choose one bases on the current character)
   [a,   // NOP, if unexpected char 'a' remains the same
    ~a,  // tilde == binary not (will give a result wider than a byte)
    a*2, // < shift left is *2 (can give a result wider than a byte) 
    a/2, // > shift right is /2 (can give a non integer result)
    a *257 / 16  // move nibbles around (will give a result wider than a byte)
   ] // array of all results
   [1+'!<>@'.indexOf(c)] // find index to get the correct result
  ) // end map, returns an array in any case
    // eventually a single element array containg a
  | a // return accumulator

Test program:<input id=I><button onclick='go(I.value)'>go</button>
<pre id=O></pre>

水晶，139字节

def f x
b=0_u8
x.chars.each do|c|
b=case c
when'!'
~b
when'>'
b>>1
when'<'
b<<1
when'@'
b<<4|b>>4
else raise ""
end
end
puts b
end

C＃193

void Main(){byte a=0;foreach(var c in Console.ReadLine()){if(c=='!')a=(byte)~a;if(c=='>')a=(byte)(a>>1);if(c=='<')a=(byte)(a<<1);if(c=='@')a=(byte)(((a&240)>>4)|((a&15)<<4));}Console.Write(a);}

Lua，344个字符

a=string.rep("0",8)
t=io.read()
f={["!"]=function()local s="";for j=1,8 do s=s..(a:sub(j,j)=="0"and"1"or"0") end;return s end,[">"]=function() return "0"..a:sub(1,7) end,["<"]=function()return a:sub(2,8).."0"end,["@"]=function()return a:sub(5,8)..a:sub(1,4)end}
for i=1,#t do a=(f[t:sub(i,i)]or function()return a end)()end
print(tonumber(a,2))

受到@Beta Decay使用字符串累加器的启发，因为lua没有字节类型。可以通过使用更少的功能来打更多的高尔夫球。

R，194字节

b<-readline();A<-rep(0,8);s<-strsplit(b,"")[[1]];for(r in s){if(r=="!")A<-(A+1)%%2;if(r==">")A<-c(0,A)[1:length(A)];if(r=="<")A<-c(A,0)[-1];if(r=="@")A<-c(A[5:8],A[1:4])};print(sum(A*(2^(7:0))))

不打高尔夫球

b <- readline()
A <- rep(0, 8) 
s <- strsplit(b, "")[[1]]
for (r in s) {
    if (r == "!")
        A <- (A + 1) %% 2
    if (r == ">")
        A <- c(0, A)[1:length(A)]
    if (r == "<")
        A <- c(A, 0)[-1]
    if (r == "@")
        A <- c(A[5:8], A[1:4])
}
print(sum(A*(2^(7:0))))

RPL，170.5字节

输入应在级别1上作为字符串输入。

\<< DEC 8 STWS \-> S 
    \<< #0d 1 S SIZE 
        FOR I "!><@" S I DUP SUB POS 1 + { \<< \>> NOT SR SL \<< DUP #16d / SWAP #16d * + \>> } SWAP GET EVAL NEXT \>> 
\>>

K，57个字节

这是一个开始：

0{y+2*x}/(8#0){((~:;{-1_0,x};{1_ x,0};4!;{x})"!><@"?y)x}/

使用Kona测试：

  f:0{y+2*x}/(8#0){((~:;{-1_0,x};{1_ x,0};4!;{x})"!><@"?y)x}/
...
  f'("!";"!>>";"!<@";"!nop!&6*!")
255 63 239 255

我可能会在k5上做得更好，但这是一个复杂的权衡取舍，例如，将二进制转换为十进制一样容易2/，但是的行为?使处理默认情况下的指令查找变得更加困难。

PHP，189字节

<? $c='00000000';foreach(str_split($argv[1])as$a){$a=='!'&&$c=strtr($c,'01','10');$a=='<'&&$c=substr($c.'0',1);$a=='>'&&$c=substr('0'.$c,0,8);$a=='@'&&$c=substr($c.$c,4,8);}echo bindec($c);

不是因为它会赢得很多答案，而是为了练习

HPPPL，302个 294字节

#pragma mode(separator(.,;)integer(d8))EXPORT b()BEGIN print();local p,j,a;a:=#0d;INPUT({{p,[2]}});for j from 1 to dim(p)do c:=p(j);case if c==33 then a:=BITNOT(a)end if c==62 then a:=BITSR(a,1)end if c==60 then a:=BITSL(a,1)end if c==64 then a:=BITSL(a,4)+BITSR(a,4)end end;end;print(a*1);END;

取消高尔夫：

// make sure integers are unsigned 8 bit decimal numbers
#pragma mode( separator(.,;) integer(d8) ) 
EXPORT b()
BEGIN
  print();
  local p,j,a;
  a:=#0d;                         // set a to integer value 0
  INPUT({{p,[2]}});               // open input dialog treating input as string ( type [2])
  for j from 1 to dim(p) do
    c:=p(j);
    case
      if c==33 then a:=BITNOT(a) end             // !
      if c==62 then a:=BITSR(a,1) end            // >
      if c==60 then a:=BITSL(a,1) end            // <
      if c==64 then a:=BITSL(a,4)+BITSR(a,4) end // @
    end;
  end;
  print(a*1); // converts to proper output by promoting to non integer format
              // print(a) would result in
              // #239:8d for 239 if the default bit size is not set to 8 bits decimal
              // indicating an 8 bit unsigned decimal integer, or
              // #239d if the default bit size is already set to 8 bits decimal

END;

该答案可确保即使用户将模式设置为例如64位，HP Prime也会使用无符号的8位整数。如果将计算器手动设置为使用无符号的8位十进制整数，则pragma可以省略该命令。如果输出不需要严格遵循格式a*1，则末尾的可以简单地是a。将结果乘以1只会确保输出不跟随整数值的内部输出。print如果不需要在打印输出结果之前清除终端，也可以省略第4行中的命令。如果允许将程序作为字符串参数传递，则INPUT也可以省略该命令。

这是具有输入和正确输出的最短版本，没有pragma参数（如果默认情况下将计算器设置为Uint8：

243个字节：

EXPORT b()BEGIN local p,j,a;a:=#0d;INPUT({{p,[2]}});for j from 1 to dim(p)do c:=p(j);case if c=33 then a:=BITNOT(a)end if c=62 then a:=BITSR(a,1)end if c=60 then a:=BITSL(a,1)end if c=64 then a:=BITSL(a,4)+BITSR(a,4)end end;end;print(a*1);END;

Perl 6，96 89字节

{my $a=0;$a=(+^*,*+<1,*+>1,{$_+<4+$_+>4},{$_})["!<>@".index($_)//4]($a)%256 for .comb;$a}

旧解决方案：

{my $a=0;$a=(255-*,*+<1+&255,*+>1,{$_+&15+<4+$_+>4},{$_})["!<>@".index($_)//4]($a)for .comb;$a}

C＃，119个字节

i=>{var a=0;foreach(var c in i){if(c=='!')a=~a;if(c=='>')a>>=1;if(c=='<')a<<=1;if(c=='@')a=a<<4|a>>4;a&=255;}return a;}

我尝试过的其他版本，但需要更多字节：

Func<string,int>C=i=>{var a=0;foreach(var c in i){switch(c){case'!':a=~a;break;case'<':a<<=1;break;case'>':a>>=1;break;case'@':a=a<<4|a>>4;break;}a&=255;}return a;};

// This is, despite having the worst score, my personal favourite :D
Func<string,int>D=i=>{var f=new Dictionary<char,Func<int,int>>{{'!',q=>~q},{'<',q=>q<<1},{'>',q=>q>>1},{'@',q=>q<<4|q>>4}};var a=0;foreach(var c in i)if(f.ContainsKey(c))a=f[c](a)&255;return a;};

Python 2.7.3，104个字节

在字符串中要评估的代码看起来很脏，但是可以：D

a=0
for c in raw_input():a=eval({'!':'~a','<':'a<<1','>':'a>>1','@':'a<<4|a>>4'}.get(c,'a'))&255
print a

这是输出（实际上是输入..）

是的，它确实在RaspberryPi上运行:)