用位和字节编程


40

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

!:反转

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

>:右移

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

<:左移

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

@:交换Nybbles

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

 ____________________
 |                  |
0110 1010    1010 0110
      |_______|

这就是所有指示!简单吧?

规则

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

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

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

请享用!


我猜想! -> 255我们在这里每个字节要使用8位吗?这个问题不是很明确。
Toby Speight 2015年

3
@TobySpeight根据定义,一个字节为8位。
HyperNeutrino '16

Answers:


15

Pyth,36 35字节

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

测试线束

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

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


因此,-G-1短于~G在Pyth?我对此表示怀疑。
CalculatorFeline

有问题的代码实际上是t_G,这里_是否定和t-1。在Pyth中,~意味着完全不同的东西。
isaacg

我的意思是Python ~(按位非)
CalculatorFeline

@CalculatorFeline我的意思是在Pyth中没有具有这种效果的1个字符的函数,因此上面的代码(至少对于该操作而言)就已经足够了。
isaacg

13

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


1
我自己尝试了挑战,并且编写了几乎完全相同的代码。顺便说一句。向上移位时,您的程序不会掉位(输入:!<>应该为127而不是255)。要么将您定义achar,要么使用该行a&=255(并使用%u)来获得正确的效果。您也可以将否定时间缩短a^255~aa>>4&15也比您的短(a&240)/16
MarcDefiant 2015年

啊,好点。事实证明,在每次迭代中屏蔽掉低8位的效率更高。
吱吱作响的ossifrage

1
在这种情况下,您甚至可以使用格式字符串%u代替%hhu
MarcDefiant 2015年

1
我现在才看到它,但是您也可以使用a/16|a*16代替a/16|(a&15)*16。最前面的几位被删除&255
MarcDefiant 2015年

1
稍有改进:a*257/16比短一个字节a/16|a*16
Toby Speight 2015年

11

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

如果它是一个真正的互动翻译,它将是for i in sys.stdin::)
Zizouz212

4
@ Zizouz212我相信你是说它是交互式的;在我看来,它像是一个真正的翻译。;)
Alex A.

9

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保存字节。


您可以<用来节省大约4个字节。使用reduce 可能还会节省一些字节
Downgoat 2015年

1
@vihan您的意思<是代替==吗?如果是这样,那将是行不通的,因为无操作字符会错误地执行操作。我在以前的80字节解决方案中使用了它。
ETHproductions 2015年

您不是必须在PPCG上定义ES6粗箭头标准吗?
MayorMonty 2015年

@SpeedyNinja我不知道任何这样的标准,但是如果您可以向我指出有关该标准的帖子,我会修改我的答案。
ETHproductions's

8

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

的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)>>4a>>4并转换(a&15)<<4a<<4&240该最后变化仅golfed一个字符虽然。

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

通过转动Golfed 2个字符printlnprint

通过消除(等于)中的意外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高尔夫技巧”中找到了答案)


我认为课程不必是公开的。另外,我觉得,如果你做的,而不是一个int一个整数,你可以做a.parseInt,a.toString等代替的Integer.parseInt,Integer.toString等
bmarks

感谢您的第一个建议;我将删除所有Integer类方法。
HyperNeutrino

也许您可以执行while(((i = System.in.read())> 10)而不是!= 10来保存字节?
bmark

好主意,但是任何低于10的东西都会导致程序终止,所以我应该忽略其他字符,而不是让世界末日(或者至少是我的程序:)结束。也许没有低于10的有效ascii字符
。– HyperNeutrino 2015年

4
这是几乎从来不值得使用switch,而打高尔夫球。该case/ break只是太长。您应该能够通过将整个事情变成三元来节省一堆;像a=i=='!'?255-a:i==62?a/2:i=='<'?a*2%256:i=='@'?(a&240)>>4|(a&15)<<4:a;
Geobits,2015年

7

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中算术溢出是一种恐慌(即崩溃)。


2
优先的事情是有意义的,当你说服自己,>>就是那种像分工和|那种像加法。
林恩

6

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

6

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被附加到结果数组的后面,以便所有无效指令都映射到相同的,不变的值。


4

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衰变。


无论您执行什么操作,都必须减少mod 256权?那么,为什么不这样做结尾:a={"!":255-a,"<":a*2,">":a//2,"@":(a%16)<<4+a>>4}.get(i,a)%256。这会立即为您节省一个字节(因为您将a*2代替a<<1)...但是@daniero的回答还显示,如果您以此方式进行操作,则(a%16)<<4可以缩短为just a<<4,因为一旦乘法,任何16位或更大的位都将被消除。减少16并减少256模。不错!另外,您现在可以255-a-1-a...或更好的用Just 代替~a。这些建议总共可以为您节省9个字节。
mathmandan

3

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


3

锈,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}

我以为使用fold可以使时间更短(doc.rust-lang.org/std/iter/trait.Iterator.html#method.fold),但令人惊讶的是它更长了一点。
user4867444's

3

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)

也许这是因为Windows的换行了。那是加上两个字节。下次我将使用该字节计数器。:-) 谢谢。
uno20001 2015年

请注意,这不会在左移时丢弃最左边的位,因此应该在应该的时候!<给出510254
Rohcana 2015年

我希望现在可以了。对不起,这是我的第一个“高尔夫”挑战。
uno20001 2015年

3

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

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


3

红宝石, 81 73字节

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

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

1
那是天才。比任何其他方式都短得多。2由我投票!
edc65

您如何才能双重投票...?
HyperNeutrino 2015年

@JamesSmith他可能是指这和我的python答案 :)
daniero

@danerio我明白了。
HyperNeutrino 2015年

2

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的大多数常用用法并不太有用。


为什么在线解释器不起作用?
CalculatorFeline

2

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类型限制为一个字节。


2

朱莉娅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个字节!


2

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>


1

水晶,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

1

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

2
你不需要using System;或类似的东西来访问Console.ReadLineConsole.WriteSystem.前缀?
Alex A.

在我看来,您也不必byte为每个操作都强制转换,但我可能是错的。
Alex A.

1

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没有字节类型。可以通过使用更少的功能来打更多的高尔夫球。


1

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

所有代码<-都可以=在此处替换,从而将代码减少7个字节。此外,您也许可以if通过致电switch(如A=switch(r,"!"=(A+1)%%2, ...)
plannapus

结果b=readline();A=rep(0,8);s=strsplit(b,"")[[1]];for(r in s)A=switch(r,"!"=(A+1)%%2,">"=c(0,A)[1:length(A)],"<"=c(A,0)[-1],"@"=c(A[5:8],A[1:4]),A);print(sum(A*(2^(7:0))))是167个字节。
plannapus

1

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

1

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/,但是的行为?使处理默认情况下的指令查找变得更加困难。


1

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

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


1

HPPPL302个 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;

HPPPL输入命令

HPPPL输出到终端

该答案可确保即使用户将模式设置为例如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;

1

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}

1

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

1

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上运行:)

输出示例

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.