이 도전에서 당신은 내가 만든 간단한 언어에 대한 통역을 작성합니다. 언어는 정확히 하나의 바이트 길이 인 단일 누산기 A를 기반으로합니다. 프로그램 시작시 A = 0입니다. 다음은 언어 지침입니다.

!: 반전

이 명령은 단순히 누산기의 모든 비트를 반전시킵니다. 모든 0은 1이되고 모든 0은 0이됩니다. 단순한!

>: 오른쪽으로 이동

이 명령은 A의 모든 비트를 오른쪽으로 한 자리 이동합니다. 가장 왼쪽 비트는 0이되고 가장 오른쪽 비트는 버려집니다.

<: 왼쪽으로 이동

이 명령은 A의 모든 비트를 왼쪽으로 한 자리 이동합니다. 가장 오른쪽 비트는 0이되고 가장 왼쪽 비트는 버려집니다.

@스왑 니 블스

이 명령어는 A의 상위 4 비트를 하위 4 비트로 교체합니다. A는 경우 예를 들어, 01101010당신이 실행 @, A는 것입니다 10100110:

 ____________________
 |                  |
0110 1010    1010 0110
      |_______|

모든 지시 사항입니다! 간단 하죠?

규칙

• 프로그램은 처음에 한 번 입력을 받아 들여야합니다 . 이것은 한 줄의 코드가 될 것입니다. 이것은 대화식 통역사 가 아닙니다 ! 입력은 한 번만 허용 할 수 있으며 해당 라인이 실행 된 후 시작으로 되돌아 갈 필요가 없습니다.
• 귀하의 프로그램은 상기 입력을 평가해야합니다. 위에서 언급하지 않은 모든 문자는 무시됩니다.
• 그런 다음 프로그램은 누산기의 최종 값을 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베이스 (10),베이스 (16)로 반전 한 변환 다시 변환 G축적된다.

나는 다른 모든 것을 무시하는 것에 대한 선을 놓쳤다. 이 문제가 해결되었습니다. 감사합니다, @Dennis.

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

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

기본적으로 이것은 중첩 된 삼항 표현식의 모음입니다. getchar()EOF (-1)의 결과 값이 0이고 프로그램이 종료되도록 얻은 값을 증가시키고 있습니다.

(아이디어 링크)

파이썬 3, 133 바이트

사전을 사용하여 파이썬에서 스위치 케이스 구문이 부족한 것을 보완합니다. 자세한 내용은 여기를 참조하십시오 .

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

자바 스크립트 (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 255JS의이 같은 ~고려할 것이라고 x32 비트 숫자를.
• 의 경우 2를 <곱하고 x결과 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#

자바 (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. 람다식이 사라 졌으므로 Java 8은 더 이상 필요하지 않습니다! 단지 Java 1이 할 것입니다!

@bmarks 덕분에 수업 (default)(삭제 된 public키워드) 을 만들어 7 문자 로 골프를 쳤습니다.

Integer비트를 뒤집는 긴 클래스 작업을 모두 돌려 120 (!!!!!!!)의 문자를 골랐 습니다 255 - a. 이제는 훨씬 짧습니다!

교대를 곱셈과 나눗셈으로 변환하고 while 문에서 중괄호를 제거 a하고 main메서드 내에서 로컬로 만들어서 15 (!) 자 골프를 쳤습니다 .

Ungolfed 9 = (왼쪽 시프트가 가장 왼쪽 바이트를 버리지 않는 문제로 인해 문자가 발생하므로 이제 그렇습니다 mod (256). 오른쪽 시프트는 결과 숫자를 이전보다 1 비트 더 짧게 만들므로 mod오른쪽 시프트 에서 사용할 필요가 없습니다 . 내 니블 스왑은 마지막 4 비트와 두 번째 마지막 니블을 바꾸고 and (&)다른 모든 비트를 자릅니다. 원래의 숫자가 256보다 작은 경우 내 반전 프로그램은 아무런 문제를 일으키지 않습니다.

@Geobits 덕분에 문을 많은 3 진 문으로 변환하고 문자를 정수로 변환하여 리터럴 을 줄임으로써 31 35 문자로 골프를 쳤습니다 switch.

&240니블 스왑에서 불필요 함을 제거하여 7 문자를 골프 로 전환 했습니다 ( (a&240)>>4로 a>>4변환하고로 변환 (a&15)<<4합니다 a<<4&240. 마지막 변경은 한 문자 만 골랐습니다.

불필요한 제거하여 1 개 문자 Golfed =하여 a /= 2때문에 a = a /= 2동일하다 a = a / 2.

(으)로 전환 println하여 2 자 골프 를했습니다 print.

실수로 제거하여 2 개의 골프를 쳤 a=습니다 a=255-a( a=a=255-a에 해당 a=255-a).

로 전환 a<<4&240하여 1 개의 문자가 골프를 쳤 습니다 a%16<<4.

삼항 진술의 외부에 괄호를 추가하고함으로써 1 문자 골프 %256. 그렇게 %16하면 니블 스왑의 왼쪽 시프트 부분에서 이가 불필요합니다. 대괄호는 2 개의 문자를 추가하고 %163 개의 문자를 저장합니다.

변경하여 3 개 문자를 Golfed class로 interface및 제거 public자바 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에게 짧습니다. 사실 이외의 다른 정말 흥미로운 아무것도 오늘보다 우선 순위 규칙을 배운 알고 누구 (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은 유효하지 않은 opcode를 무시하도록 허용합니다. 제거하여 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

파이썬 2, 79 바이트

나는 파이썬에서 이것 과 매우 비슷한 것을 일찍 깨달았다는 것을 깨달았다 . 이것은 내 Ruby 답변 의 포트 일뿐 이지만 현재로서는 가장 짧은 Python 답변입니다.

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하는 경향이 있다는 사실을 이용합니다 nil. 현재 값이 a결과 배열의 뒷면에 추가되어 모든 유효하지 않은 명령이 변경되지 않은 동일한 값에 매핑됩니다.

파이썬 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 MOD
(2)에 의해 정수 나눗셈과 동일 ">"
"@"수단 (마지막 4 비트 시프트 a%16(4 비트로) *16)를 추가하고 처음 4 비트 ( a/16)를 추가합니다 .

편집 (뻔뻔한 읽기)
파이썬에서 다른 대답을 보았습니다 (Beta decay). 사전을 사용하여 스위치 케이스를 시뮬레이션하는 효과적인 방법을 사용합니다. 그것을 사용하여 우리는 쓸 수 있습니다

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

감사합니다. 베타 붕괴.

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

파이썬 3, 127 바이트

편집 : shorting, 감사합니다 @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상기 니블 16 진 숫자 .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의 일반적인 용도에 너무 유용하지는 않습니다.

자바 스크립트, 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는 숫자 유형을 단일 바이트로 제한하는 데 사용됩니다.

줄리아, 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 바이트를 절약했습니다!

자바 스크립트 (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의 문자열 누산기 사용에서 영감을 얻었으며 루아에는 바이트 유형이 없습니다. 더 적은 기능을 사용하여 골프를 더 많이 쳤을 수 있습니다.

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 비트 10 진수를 사용하도록 계산기를 수동으로 설정 한 경우 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;

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

파이썬 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에서 실행됩니다 :)