Bu mücadelede, yaptığım basit bir dil için bir tercüman yazacaksınız. Dil, tam olarak bir bayt uzunluğunda olan tek bir akümülatör A'ya dayanmaktadır. Bir programın başında, A = 0'dır. Bunlar dil talimatlarıdır:

!: Ters çevirme

Bu talimat, akümülatörün her bir ucunu basitçe tersine çevirir. Her sıfır bir olur ve her biri sıfır olur. Basit!

>: Sağa Kaydır

Bu komut A'daki her biti sağa kaydırır. En soldaki bit sıfır olur ve en sağdaki bit atılır.

<: Sola kay

Bu komut A'daki her biti sola kaydırır. En sağdaki bit sıfır olur ve en soldaki bit atılır.

@: Değişen Nybbles

Bu komut, A'nın ilk dört bitini, alt dört bit ile değiştirir. Örneğin, A ise 01101010ve siz yürütüyorsanız @, A olacaktır 10100110:

 ____________________
 |                  |
0110 1010    1010 0110
      |_______|

Tüm talimatlar bu! Basit değil mi?

kurallar

• Programınız başlangıçta bir kez girişi kabul etmelidir . Bu bir kod satırı olacaktır. Bu etkileşimli bir tercüman değil ! Girdiyi yalnızca bir kez kabul edebilirsiniz ve bu satır yürütüldüğünde başa geri dönmeniz gerekmez.
• Programınız sözü geçen girişi değerlendirmelidir. Yukarıda belirtilmeyen her karakter göz ardı edilir.
• Ardından programınız akümülatörün nihai değerini, ondalık olarak yazdıracaktır.
• Geçerli programlama dilleri için olağan kurallar geçerlidir.
• Standart boşluklara izin verilmez.
• Bu kod golf , en küçük bayt sayısı kazanıyor.

Gönderilerinizi test etmek için bazı küçük programlar. Ok koddan önce, beklenen sonuçtan sonra:

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

Keyfini çıkarın!

Pyth, 36 35 bayt

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

Test koşum

Akümülatörün iç gösterimi bir tamsayıdır. Bu tamsayı, her bir yinelemede istenildiği gibi 256 ile modlanmıştır. Gerçekleştirilen işlemlerdir -G-1, G/2, G*2ve Gtaban 10, tabanın 16, ters ve dönüştürülmüş geri dönüştürülür Gakümülatör.

Her şeyi görmezden gelme hakkındaki çizgiyi kaçırdım. Bu düzeltildi. Teşekkürler, @Dennis.

C, 96

ASCII (veya uyumlu) girişi varsayarak:

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

tidier:

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

Temelde sadece iç içe geçmiş üçlü ifadeler topluluğu. getchar()Bir EOF (-1) sıfır değerine neden olacak ve programın çıkacağı şekilde elde edilen değeri arttırıyorum.

(ideone bağlantısı)

Python 3, 133 bayt

Python'da switch-case sözdizimi eksikliğini telafi etmek için bir sözlük kullanır. Daha fazlasını burada görün .

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

Biriktirici, sonunda bir taban 10 numarasına dönüştürülmüş bir dizedir.

Örnek G / Ç:

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

Javascript (ES6), 80 91 90 bayt

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

Olabildiğince kısa. Programı giriş olarak alan adsız bir işlevi tanımlar.

• Çünkü !, x XOR 255JS’ler 32 bitlik bir sayı ~düşünür x.
• Çünkü <, x2 ile çarpar ve sonuç mod 256'yı alır.
• Çünkü >, x1 bit bitlerini gerçekten sağa kaydırır.
• İçin @zeminler x/16ve ekler x%16*16.

reduceBir bayt kurtarmak için kullanımını öneren @vihan için teşekkürler .

CJam, 37 bayt

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

CJam tercümanında çevrimiçi olarak deneyin .

Nasıl çalışır

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 karakter

Vay canına, bu bir sürü golf oynuyor! Bana öneride bulunan herkese teşekkürler! Çok takdir ediyorum!

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

Golfed 31 (!) Byte, uzun takma Integer.???yöntemlerin aksine bit takas işlemleri ile nibble takas alanını optimize ederek .

Golf 72 (!!!!) karakterlerini takas etmek için yarattığı gereksiz dizgiyi kaldırarak. Öncekinden çok daha iyi !?

Kullanarak kaldırma java.util.Scannerve okuma yoluyla Golf (45) karakterleriSystem.inDoğrudan . Şimdi lambda ifadesinin gittiğini, Java 8'in artık gerekli olmadığını unutmayın! Sadece sadece Java 1 yapar!

Sınıflandırılarak golf oynadı 7 karakter (default)(kaldırıldı)public@Bmarks sayesinde anahtar kelime ) golf oynatan

Golf 120 (!!!!!!!) karakterleri bu Integersaygısız sınıftaki tüm işlemleri çevirerek bit sayıyor 255 - a. Şimdi bu çok daha kısa!

Vardiyaları çarpma ve bölmeye dönüştürerek, parantezi while deyiminden çıkartarak ave mainyöntem içinde yerelleştirerek 15 (!) Karakter golf oynadı .

Ungolfed 9 = (sol vardiyada en soldaki baytı atmayacak bir sorun nedeniyle karakterler. Bu nedenle şimdi yapıyorum mod (256). Sağ vardiya, elde edilen sayıyı öncekinden biraz daha kısaltacaktır, bu yüzden modsağ vardiyada kullanmaya gerek yoktur . Uç değiştirmem, son 4 bit ve ikinci bit ucun yerini alacak ve and (&)diğer tüm bitleri kesecek, orijinal sayı 256'dan küçükse, inversiyon programım herhangi bir soruna neden olmaz.

Golfed 31 dönüştürerek @Geobits 35 karakter sayesinde switchüçlü tabloların bir sürü açıklama ve ayrıca ints için karakter dönüştürme, değişmezleri kısaltılması.

Gereksiz kaldırarak 7 karakter golfed &240(yarım bayt takas (a&240)>>4için a>>4ve dönüştürme (a&15)<<4içina<<4&240 . Geçen değişiklik, yalnızca olsa bir karakter golfed.

Gereksiz kaldırarak 1 kömürü golfed =in a /= 2, çünkü a = a /= 2eşdeğerdir a = a / 2.

Çevirerek 2 karakter golfed printlniçin print.

RASTLANTISAL kaldırarak 2 karakter golfed a=içinde a=255-a( a=a=255-aeşdeğerdir a=255-a)

Golf oynayarak 1 karakter a<<4&240haline getirin a%16<<4.

Üçlü ifadenin dışına parantez ekleyerek ve yaparak 1 char Golfed %256. Bu şekilde, %16uçlu takasın sola kayma kısmında gereksizdir. Parantezler 2 karakter ekler ve %163 karakter kazandırır.

Değiştirerek 3 karakter golfed classiçin interfaceve kaldırma publicJava 8'in statik arayüz yöntemi özelliğini kullanarak. @TheNumberOne sayesinde (yorum yok, ancak "Java'da golf için ipuçları" konulu cevabını bulun)

Pas, 121 115 bayt

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}

Örnek çalışma:

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

Ungolfed:

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 için şaşırtıcı derecede kısa. Bugün daha öncelikli kurallar öğrendiğim gerçeğinden başka gerçekten ilginç bir şey yok - kim bilir (a>>b)|caynıydı a>>b|c?

Değiştirerek bir bayt tıraş n>>=1için n/=2; ancak, aynı çarpma işlemi ile yapılamaz, çünkü aritmetik taşma, Rust'ta panik (çarpışma) şeklindedir.

HP 41C / CV / CX (? Bayt, 42 adım)

Tamamen kıkırdamalar için, burada HP 41C / CV / CX hesap makinesi içindir. (Genişletilmiş Fonksiyonlar modülünü veya ATOX fonksiyonu için 41CX'i gerektirir.) Hesap makinesi maalesef program boyutlarını bayt cinsinden bildirmiyor.

Programınızı, giriş yapmanın bir yolu olmadığından, biraz aldatıcı olan Alpha yazmacına yerleştirin! veya @ doğrudan klavyeden (eklemek için sırasıyla ASCII kodları 33 ve 64 ile XTOA kullanın).

Adım 08 ve 10, geçersiz kodları yok saymaya izin verir; 2 adımı kaydetmek için bunları kaldırın, ancak program geçersiz girdiyle kilitlenecek.

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 bayt

Daha önce Python'da buna benzer bir şey yaptığımı anladım . Bu sadece Ruby cevabımın bir limanı , ancak şu an itibariyle şu anda en kısa Python cevabı: 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 versiyonundan fark, bunun girdi üzerinde yineleme yaparken geçersiz talimatları göz ardı etmemesidir. Bunun yerine, Python'un eşleşme olmadığı zaman -1yerine geri dönme eğiliminde olmasından yararlanırım nil- Geçerli değer asonuç dizisinin arkasına eklenir, böylece geçersiz tüm talimatlar aynı, aynı değere eşlenir.

Python 3, 124 94 93 bayt

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'ten çıkarmakla aynıdır.
"<", 2 ile çarpmakla aynıdır. Ancak 8 bit kayıt, mod 256 anlamına gelir.
">", 2 ile tam sayı bölünmesiyle aynıdır.
"@", son 4 bit ( a%16) 'i 4 bit (" *16) ve ilk dört bitin ( a/16) eklenmesi .

EDIT (utanmaz kopyalamayı okuyun)
Diğer cevabı python olarak gördüm (Beta bozunmasıyla). Sözlük kullanarak geçiş durumlarını simüle etmek için gerçekten etkili bir yol kullanır. Bunu kullanarak yazabiliriz

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

Teşekkürler, Beta Çürüğü.

Haskell, 89 bayt

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

Kullanım örneği: f "!>>"->63

Pas, 111 bayt

@ Doorknob'un cevabı hakkında yapılan bir yorumdan daha fazlası var ancak henüz yeni bir hesap oluşturduğum için yorum için herhangi bir temsilcim yok.

Biri Rust çözümünden 10 byte'ı aşağıdaki gibi tıraş edebilir:

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 bayt

Düzenleme: kısa, teşekkürler @Jakube

Edit2: düzeltme, teşekkürler @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)

Seylan, 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);}

biçimlendirilmiş:

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

#fve #f0uçlar için onaltılık sayılardır, .bytebir tamsayıyı bir bayta dönüştürür. Ben Byte'nın şanslı.string özniteliğinin zaten bir baytın işaretsiz gösterimini kullandığı için . Ceylon ayrıca, düşme olmadan bir switch deyimi içerir ve bir dize yinelenebilecek karakterlerin bir listesidir.

Ayrıca, bir takma ad alma özelliğini kullanarak bu uzun vardiya yöntemi adlarını azaltmaya çalıştım, ancak bu aslında 7 bayt oldu:

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

biçimlendirilmiş:

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

Bu yöntemlere biraz daha ihtiyaç duymamız durumunda faydalı olabilir.

Yakut, 81 73 bayt

Çok daha basit - değerlendirme yok! Girişteki her geçerli karakter için, her bir komutu değerlendirir ve uygun komutu dizini boyunca $&(girişteki geçerli karakter) bulur .

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

STATA, 197 bayt

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

Ungolfed

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

Çevrimiçi tercümanla çalışmaz ve ücretsiz olmayan varsayılan tercüman gerektirir. Bu, gerçek bit yönünde işlemlerle biraz daha kolay olurdu, ancak STATA'nın yaygın kullanımlarının çoğu için çok faydalı olduklarını sanmıyorum.

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)

İç içe üçlü operatörler talimatlara eşlenir.

BITWISE AND, Number türümüzü tek bir baytla sınırlamak için kullanılır.

Julia, 117 94 86 73 bayt

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)

Bu, bir dizgeyi kabul eden ve bir tamsayı döndüren adsız bir işlevdir. Aramak için değişkene atayın.

Ungolfed:

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

Dennis'e Sp3000 ve 13 sayesinde 8 bayt kaydedildi!

JavaScript (ES6), 76 81

Akümülatör değerini döndüren adsız bir işlev olarak

Bu, @daniero'nun süper zekice cevaplarının bir tasviridir.

Ek olarak: olabilir toplayıcının bir başlangıç değeri geçirir. Geçilmezse, başlangıç ​​değeri özel olarak 0'dır.

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

Aşağıdaki pasajı herhangi bir EcmaScript 6 tarayıcısında çalıştırmayı test edin (Firefox'ta test ettim)

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>

Kristal, 139 bayt

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 karakter

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

@ Deceta'nın bir akümülatör kullanmasından esinlenerek, lua türünün bayt türü olmadığını görün. Daha az sayıda fonksiyon kullanarak muhtemelen daha fazla golf oynayabilir.

R, 194 bayt

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

ungolfed

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 bayt

Giriş, seviye 1'de bir dize olarak girilmelidir.

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

Bu bir başlangıç:

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

Kona kullanılarak test edilmiştir:

  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'te daha iyisini yapabilirim, ancak karmaşık bir dizi haydut-örneğin, ikiliyi ondalık sayıya dönüştürmek kadar kolaydır 2/, ancak davranışı, ?talimat arama için varsayılan bir durumu ele almayı zorlaştırır.

PHP, 189 bayt

<? $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);

Birçok cevabı geçmeyecek, sadece pratik için olacak.

HPPPL , 302 294 bayt

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

Ungolfed:

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

Bu cevap, kullanıcı tarafından örneğin 64 bit olarak ayarlanmış olsa bile, HP Prime'ın işaretsiz 8 bit tam sayı kullanmasını sağlar. Hesap makinesi işaretsiz 8 bit ondalık sayılar kullanmak için el ile ayarlandıysa, pragmakomut atlanabilir. Çıktının formatı tam olarak izlemesi gerekmiyorsa a*1, sondaki basitçe olabilir a. Sonucu 1 ile çarpmak, çıktının tamsayı değerleri için dahili çıktının takip etmemesini sağlar. printTerminal sonucunu dışarı yazdırmadan önce temizlenmesi gerekir yoksa 4. satırdaki komut da atlanabilir. Programı bir dizge argümanı olarak geçirmeme izin verilirse, o zamanINPUT komut da ihmal edilebilir.

Bu, pragma bağımsız değişkeni olmadan giriş ve uygun çıkışa sahip en kısa sürümdür (hesap makinesi varsayılan olarak Uint8'e ayarlanmışsa:

243 bayt:

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 bayt

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

Eski çözüm:

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

C #, 119 bayt

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

Denediğim diğer sürümler, ancak daha fazla bayta ihtiyaç var:

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 bayt

Değerlendirilecek dizelerde kod olması oldukça kirli görünüyor, ancak çalışıyor: 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

İşte çıktı (ve aslında giriş ..)

Ve evet, gerçekten bir ahududu pisi üzerinde çalışıyor :)