この課題では、私が作成した単純な言語のインタープリターを作成します。この言語は、1バイトのアキュムレーターAに基づいています。プログラムの開始時、A =0。これらは言語の指示です。

!：反転

この命令は、単にアキュムレータのすべてのビットを反転します。すべてのゼロが1になり、すべてのゼロがゼロになります。シンプル！

>：右シフト

この命令は、Aのすべてのビットを1つ右にシフトします。左端のビットはゼロになり、右端のビットは破棄されます。

<：左シフト

この命令は、Aのすべてのビットを1桁左にシフトします。右端のビットはゼロになり、左端のビットは破棄されます。

@：ナイブルを交換

この命令は、Aの上位4ビットを下位4ビットと交換します。たとえば、Aが01101010で実行する場合、Aは次のよう@になります10100110。

 ____________________
 |                  |
0110 1010    1010 0110
      |_______|

それがすべての指示です！シンプルでしょ？

ルール

• プログラムは、最初に入力を1回受け入れる必要があります。これはコード行になります。これはインタラクティブなインタープリターではありません！入力を1回だけ受け入れることができ、その行が実行された後に開始にループバックする必要はありません。
• プログラムは、上記の入力を評価する必要があります。上記以外の文字はすべて無視されます。
• プログラムは、アキュムレータの最終値を10進数で出力する必要があります。
• 有効なプログラミング言語の通常の規則が適用されます。
• 標準の抜け穴は許可されていません。
• これはcode-golfであり、最小バイトカウントが優先されます。

以下は、提出物をテストするための小さなプログラムです。矢印の前にコードがあり、その後に予想される結果があります。

• ! -> 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）の値がゼロになり、プログラムが終了するように、取得した値をインクリメントしています。

（理想的なリンク）

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)

できる限り短い。プログラムを入力として受け取る匿名関数を定義します。

• では、JS は32ビットの数値を考慮するため!、を取ります。x XOR 255~x
• の場合<、x2 で乗算し、結果をmod 256にします。
• の場合>、真にx1ビットのビットを右にシフトします。
• のために@、床x/16に追加しx%16*16ます。

reduceバイトを保存するための使用を提案してくれた@vihanに感謝します。

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および読み取りをSystem.in直接行うことにより、45（!!）文字をゴルフしました。ラムダ式がなくなったので、Java 8は不要になったことに注意してください！単にJava 1で十分です！

@bmarksのおかげで、クラス(default)（publicキーワードを削除）を作成して7文字をゴルフ

それらのすべての長いIntegerクラス操作をビット反転で回すことにより、120（!!!!!!!）文字をゴルフしました255 - a。今、それははるかに短いです！

シフトを乗算と除算に変換し、whileステートメントからブレースを削除しa、mainメソッド内でローカルにすることにより、15（！）文字をゴルフしました。

Ungolfed 9 =（charsは、左シフトで左端のバイトが破棄されないという問題のためです。したがって、私はこれを行いmod (256)ますmod。私のニブル交換は最後の4ビットと最後から2番目のニブルを交換し、and (&)他のすべてのビットを切り捨てますが、元の数が256未満の場合、反転プログラムは問題を引き起こしません。

@Geobitsのおかげで、ステートメントを多くの3項ステートメントに変換し、さらに文字をintに変換してリテラルを短縮することで、31 35文字のゴルフをしswitchました。

&240ニブルスワップで不必要なものを削除することで7文字をゴルフしました（(a&240)>>4にa>>4変換(a&15)<<4しa<<4&240ます。最後の変更では、1文字しかゴルフしませんでした。

不要除去することによって、1つの文字をGolfed =にするa /= 2ため、a = a /= 2と等価ですa = a / 2。

に回して2文字をゴルフprintlnしましたprint。

偶然を削除して2文字をゴルフa=したa=255-a（a=a=255-aと同等a=255-a）

に変わることによって1つのcharをゴルフa<<4&240したa%16<<4。

三項声明の外側に角かっこを追加して実行することで1文字をゴルフしました%256。そう%16すれば、ニブルスワップの左シフト部分では不要になります。括弧は2文字を追加し、%163文字を保存します。

変化させることにより、3つの文字をGolfed classにinterfaceし、除去publicするJava 8の静的インターフェース方法の機能を使用。@TheNumberOneに感謝（コメントはありませんが、「Javaでのゴルフのヒント」で答えを見つけてください）

さび、121 115バイト

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の驚くほど短い。事実以外の他の非常に興味深い何もない私は今日より優先順位のルールを学んだ知っていた-who (a>>b)|cと同じですかa>>b|c？

変更することで、バイト削り取らn>>=1にn/=2。ただし、算術オーバーフローはRustではパニック（クラッシュ）であるため、乗算でも同じことはできません。

HP 41C / CV / CX（？バイト、42ステップ）

純粋に笑いのために、ここではHP 41C / CV / CX計算機用です。（拡張機能モジュール、またはATOX機能の41CXが必要です。）残念ながら、計算機はプログラムサイズをバイト単位で報告しません。

プログラムをAlphaレジスタに配置します。これは入力する方法がないため、少し注意が必要です。または、キーボードから直接（@を追加するには、それぞれASCIIコード33および64のXTOAを使用します）。

ステップ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バージョンとの違いは、このバージョンでは、入力を繰り返し処理する際に無効な命令を無視しないことです。代わりに、一致しない場合では-1なくPythonが返す傾向があるという事実を利用し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ビットレジスタによって乗算と同じで256国防省
2で整数除算と同じで「>」
「@」とは、（最後の4ビットシフトa%16（4ビット）*16）および最初の4ビット（）を追加しa/16ます。

EDIT（恥知らずなコピーを読む）
Pythonで他の答えを見た（ベータ崩壊による）。辞書を使用してスイッチケースをシミュレートするために、本当に効果的な方法を使用します。それを使って書くことができます

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

おかげで、ベータ崩壊。

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バイト

編集：ショート、ありがとう@ジャクベ

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ニブルの16進数値であり、.byteバイトに整数に変換します。Byteの.string属性が既にバイトの符号なし表現を使用しているのは幸運です。Ceylonはフォールスルーのない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型を1バイトに制限するために使用されます。

ジュリア、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バイト、デニスのおかげで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);}

ルア、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}/

コナを使用してテスト：

  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でもっとうまくできるかもしれませんが、複雑な一連のトレードオフです-たとえば、バイナリを10進数に変換するのは簡単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ビット10進整数を使用するように手動で設定されている場合、pragmaコマンドは省略できます。出力が厳密に形式に従う必要がない場合a*1、最後に単にを指定できますa。結果に1を掛けると、出力が整数値の内部出力に追従しないことが保証されます。print結果を出力する前に端末をクリアする必要がない場合は、4行目のコマンドも省略できます。プログラムを文字列引数として渡すことが許可INPUTされている場合、コマンドも省略できます。

これは、プラグマ引数なしの入力と適切な出力を備えた最短バージョンです（デフォルトで電卓が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バイト

評価される文字列にコードがあるのはかなり汚そうに見えますが、動作します

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で実行されています:)