写一个程序或函数，它仅包含字符的字符串^和v（你可以假设不会有其他字符）。从左至右读取此字符串表示单个用户在首次查看Stack Exchange问题或答案时进行的鼠标单击顺序。

每个^代表单击“ upvote”按钮，每个v代表单击“ downvote”按钮。（有关工作示例，请向左稍看。）

假设没有投票限制有效，因此所有点击均已正确注册。
打印或退回：

• 1或者+1该帖子最终被否决。
• 0如果帖子最终没有被投票。（-0并且+0无效）
• -1 如果帖子最终被否决。

帖子以用户的零净票数开头，按钮如下更改净票数：

Net Votes Before    Button Pressed    Net Votes After
1                   ^                 0
1                   v                 -1
0                   ^                 1
0                   v                 -1
-1                  ^                 1
-1                  v                 0

以字节为单位的最短代码获胜。

测试用例：

[empty string] -> 0
^^ -> 0
^v -> -1
^ -> 1
v -> -1
v^ -> 1
vv -> 0
^^^ -> 1
vvv -> -1
^^^^ -> 0
vvvv -> 0
^^^^^ -> 1
vvvvv -> -1
^^^^^^ -> 0
vvvvvv -> 0
^^v -> -1
^v^ -> 1
^vv -> 0
vv^ -> 1
v^v -> -1
v^^ -> 0
^vvv^^vv^vv^v^ -> 1
^vvv^^vv^vv^v^^ -> 0
^vvv^^vv^vv^v^^^ -> 1
^vvv^^vv^vv^v^^v -> -1
^vvv^^vv^vv^v^^vv -> 0
^vvv^^vv^vv^v^^vvv -> -1
^vvvvvvvvvvvv -> 0
^^vvvvvvvvvvvv -> 0
^^^vvvvvvvvvvvv -> 0
vvv^^^^^^^^^^^^ -> 0
vv^^^^^^^^^^^^ -> 0
v^^^^^^^^^^^^ -> 0

高尔> <> 0.3.11，13个 12 11字节

iEh`^=:@)+M

在线尝试。即使在下一个更新中可以正常工作，我还是将其列为0.3.11以防万一。

说明

i               Read char
 Eh             If EOF, halt and output top of stack as num
   `^=          Push 1 if char is ^, else 0
      :@        Dup and rotate, giving [is^ is^ votecount]
        )       Compare greater than, pushing 1 or 0 as appropriate
         +M     Add and subtract 1

请注意，第一次使用@从堆栈底部拉0来初始化第一次迭代的投票计数

为了说明完整的表格：

Votes before    Button    Is ^?    Compare <    Add     Subtract 1
     1            ^         1         0          1          0
     1            v         0         0          0         -1
     0            ^         1         1          2          1
     0            v         0         0          0         -1
    -1            ^         1         1          2          1
    -1            v         0         1          1          0

x86机器代码，24字节

31 C0 8A 11 84 D2 75 07 C0 E0 02 C0 F8 06 C3 41 38 C2 74 EC 88 D0 EB EA

这是一个使用快速调用调用约定的函数，该约定接受一个字符串并返回一个8位整数。

我使用以下C程序对其进行了测试，该程序必须针对32位模式进行编译。

#include <stdio.h>
#include <inttypes.h>

 __attribute__ ((aligned (16))) const unsigned char fun[] = {

    0x31,  //xor eax,eax
        0xC0,
    0x8A, //mov [ecx],dl
        1 | 2<<3,
    0x84, //test dl, dl
        0xC0 | 2<<3 | 2,
    0x75, // jnz
        7,
    0xC0, //shl al 2
        0xC0 | 4<<3,
        2,
    0xC0, //sar al 6
        0xC0 | 7<<3,
        6,
    0xC3, //ret
    0x41, //inc ecx
    0x38, //cmp al,dl
        0xC0 | 2,
    0x74, //je
        -20,
    0x88, //mov dl,al
        0xC0 | 2<<3,
    0xEB, //jmp
        -22,
};

int main()
{
    __fastcall int8_t (*votesimulator)(char*) = fun;
    char* s[] = {
        "",
        "^^",
        "^v",
        "^",
        "v",
        "v^",
        "vv",
        "^^^",
        "vvv",
        "^^^^",
        "vvvv",
        "^^^^^",
        "vvvvv",
        "^^^^^^",
        "vvvvvv",
        "^^v",
        "^v^",
        "^vv",
        "vv^",
        "v^v",
        "v^^",
        "^vvv^^vv^vv^v^",
        "^vvv^^vv^vv^v^^",
        "^vvv^^vv^vv^v^^^",
        "^vvv^^vv^vv^v^^v",
        "^vvv^^vv^vv^v^^vv",
        "^vvv^^vv^vv^v^^vvv",
        "^vvvvvvvvvvvv",
        "^^vvvvvvvvvvvv",
        "^^^vvvvvvvvvvvv",
        "vvv^^^^^^^^^^^^",
        "vv^^^^^^^^^^^^",
        "v^^^^^^^^^^^^",
    };

    for(int i = 0; i < sizeof(s)/sizeof(*s); i++)
        printf("%d\n", votesimulator(s[i]));

    printf("\n%d\n", sizeof(fun));
    for(int i = 0; i < sizeof(fun); i++)
        printf("%02X ", fun[i]);
    return 0;
}

JavaScript（ES7），47 46 44 43 37 36字节

^{划掉44仍然是常规44 :(}

s=>[for(x of s)s=x<"v"?s!=1:!~s-1]|s

保持总计s。使用for of循环遍历字符串中的每个字符并s根据当前字符和先前的值进行更新。

编辑：Golfed ~s&&-1来!~s-1。如果s等于-1，则此表达式必须等于0，否则等于-1。@nderscore节省了6个字节。

表达式如何工作：

 ~s    // Bitwise inverse. ~s==0 only if s==-1
!      // Logical negate. Casts to boolean. Equivalent to s==-1
   -1  // Subtract. Casts to number so true-1 is 1-1 and false-1 is 0-1

CJam，18个 14字节

丹尼斯做出的重大改进的更新版本：

0'jqf{-g_@=!*}

在线尝试

说明：

0     Start value for running total.
'j    Push character between '^ and 'v for use in loop.
q     Get input.
f{    Apply block with argument to all input characters.
  -     Subtract character from 'j. This will give -12 for '^, 12 for 'v.
  g     Signum, to get 1 for '^, -1 for 'v, which is our increment value.
  _     Copy increment value.
  @     Bring running total to top.
  =     Compare. This will give 1 for the -1/-1 and 1/1 combinations where the new
        running total is 0. Otherwise, the new running total is the increment value.
  !     Negate to get 0 for the -1/-1 and 1/1 cases.
  *     Multiply result with increment value, to get new running total.
}     End block applied to input characters.

Befunge 93-55字节

vj#p01:>#<:1+|
>~:10g-|v:g25<
^p01"j"<1^   <
./*34-g0<@

52个字符和3个新行。

经过口译测试。

该j是等距^和v所以它用来做算术转换到了最后，而不是占用空间的条件语句以ASCII。

疯子，146字节

,[[>->+<<-]>[[-]>[<+>-]]>[-]<<[<],]----[>-----<--]--[>>+<<++++++]+>[<-]<[->>++.<++++[<------>-]]>[<+<<]----[>+++++<--]>[,+<]>>[<<]-[>+<-----]>---.

该程序获取输入的每个字节，并将其与最后一个字节进行比较。如果它们相同，则将输入丢弃，并将“ 0”存储为“先前输入”，否则通常将其保存。

如果最终结果是v，它将打印-。如果最终结果为非零，则将1添加到一个空单元格。最后，将48添加到该单元格并进行打印。

JavaScript的ES6，91 48个字符

s=>~~{'^':1,v:-1}[s.replace(/(.)\1/g).slice(-1)]

说明：undefined以结尾d。

测试：

` -> 0
^^ -> 0
^v -> -1
^ -> 1
v -> -1
v^ -> 1
vv -> 0
^^^ -> 1
vvv -> -1
^^^^ -> 0
vvvv -> 0
^^^^^ -> 1
vvvvv -> -1
^^^^^^ -> 0
vvvvvv -> 0
^^v -> -1
^v^ -> 1
^vv -> 0
vv^ -> 1
v^v -> -1
v^^ -> 0
^vvv^^vv^vv^v^ -> 1
^vvv^^vv^vv^v^^ -> 0
^vvv^^vv^vv^v^^^ -> 1
^vvv^^vv^vv^v^^v -> -1
^vvv^^vv^vv^v^^vv -> 0
^vvv^^vv^vv^v^^vvv -> -1
^vvvvvvvvvvvv -> 0
^^vvvvvvvvvvvv -> 0
^^^vvvvvvvvvvvv -> 0
vvv^^^^^^^^^^^^ -> 0
vv^^^^^^^^^^^^ -> 0
v^^^^^^^^^^^^ -> 0`
.split("\n").map(s => s.split(" -> "))
.every(([s,key]) => (s=>~~{'^':1,v:-1}[s.replace(/(.)\1/g).slice(-1)])(s)==key)

回答历史：

s=>({'':0,'^':1,v:-1}[s.replace(/^(.)\1(\1\1)*(?=.?$)|.*(.)(((?!\3).)\5)+/,"").substr(-1)])
s=>~~{'^':1,v:-1}[s.replace(/^(.)\1(\1\1)*(?=.?$)|.*(.)(((?!\3).)\5)+/,"").substr(-1)]
s=>~~{'^':1,v:-1}[s.replace(/^.*(.)(((?!\1).)\3)+|(.)\4(\4\4)*/,"").substr(-1)]
s=>~~{'^':1,v:-1}[s.replace(/^.*(.)(((?!\1).)\3)+|(.)\4(\4\4)*/,"").slice(-1)]
s=>~~{'^':1,v:-1}[s.replace(/.*(.)(((?!\1).)\3)+|(.)\4(\4\4)*/,"").slice(-1)]
s=>~~{'^':1,v:-1}[s.replace(/.*(.)(((?!\1).)\3)+|((.)\5)*/,"").slice(-1)]
s=>~~{'^':1,v:-1}[s.replace(/((.)\2)+/g,"!").slice(-1)]
s=>~~{'^':1,v:-1}[s.replace(/(.)\1/g,"!").slice(-1)]
s=>~~{'^':1,v:-1}[s.replace(/(.)\1/g,0).slice(-1)]
s=>~~{'^':1,v:-1}[s.replace(/(.)\1/g).slice(-1)]

Python 2，49

lambda s:reduce(lambda x,c:cmp(cmp('u',c),x),s,0)

使用更新功能进行迭代

lambda x,c:cmp(cmp('u',c),x)

它采用当前的投票计数x和新字符c并输出新的投票计数。

我们的想法是使用Python 2的cmp功能，比较它有两个参数，并给出-1, 0, 1了<, ==, >分别。内层一个cmp('u',c)给出-1为v和1为^; 它们之间的任何字符都足以满足要求'u'。然后，外部的将其与进行比较，以x给出cmp(1,x)for ^和cmp(-1,x)for v，它们具有正确的值。

直接迭代的长度增加了3个字符（52个），但如果input()允许带引号的话，则将缩短一个字符（48个）。

x=0
for c in raw_input():x=cmp(cmp('u',c),x)
print x

我发现最好的递归函数是一个字符长（50）

f=lambda s:len(s)and cmp(cmp('u',s[-1]),f(s[:-1]))

Prolog，159152字节

码：

v(1,^,0).
v(1,v,-1).
v(0,^,1).
v(0,v,-1).
v(-1,^,1).
v(-1,v,0).
r(X,[H|T]):-T=[],v(X,H,Z),write(Z);v(X,H,Z),r(Z,T).
p(S):-atom_chars(S,L),r(0,L).

自己测试：此处
在线翻译示例

>p("^vvv^^vv^vv^v^^vvv").
-1

>p("^vvv^^vv^vv^v^")
1

编辑：通过与OR统一r子句，节省了7个字节。

CJam，16个字节

0re`W=(2%*c'a--g

如果适用，将在打印0后崩溃。可以使用Java解释器抑制该错误。如果您在线尝试，请忽略输出的最后一行。

这个怎么运作

0                e# Push a 0 on the stack.
 r               e# Read a whitespace-separated token from STDIN.
  e`             e# Perform run-length encoding.
    W=           e# Select the last [repetitions character] pair.
                 e# This will fail for the empty string, so the
                 e# interpreter will print the stack's only element (0).
      (          e# Shift out the number of repetitions.
       2%        e# Compute its parity.
         *       e# Create a string, repeating the character 1 or 0 times.
          c      e# Cast to character.
                 e# This will fail for a zero-length string, so the
                 e# interpreter will print the stack's only element (0).
           'a-   e# Subtract the character 'a' from '^' or 'v'.
              -  e# Subtract the difference (integer) from 0.
               g e# Apply the sign function.

Python 2，177159 72字节

仍然对这个代码高尔夫事物有些陌生。

def v(s): 
 c=0 
 for i in s:c=((0,1)[c<1],(0,-1)[c>-1])[i=="^"] 
 return c

编辑：修复了不正确的行为。
编辑2：感谢@MorganThrapp削减了很多字节。

JavaScript（ES6），64 59 58 52字节

f=v=>(t=/\^*$|v*$/.exec(v)[0]).length*(t<'v'?1:-1)%2

这是基于以下观察结果，即（^或v）仅重复的最后一段会影响结果。

感谢Neil打高尔夫球6个字节。

Haskell，40个字节

1%'^'=0
_%'^'=1
1%_=-1
_%_=0
v=foldl(%)0

Scala，75个字节

def d(s:String)=s./:(0){case(1,94)|(-1,'v')=>0;case(_,94)=> 1;case _=> -1}

测试实现的功能。

  object Util {
        def d(s: String) = s./:(0) { 
    case (1, '^') | (-1, 'v') => 0
    case (_, '^') => 1
    case (_, _) => -1
  }      
      def main(s: Array[String]): Unit = {
        println("1 == " + d("^vvv^^vv^vv^v^^^"))
        println("1 == " + d("^vvv^^vv^vv^v^"))
        println("-1 == " + d("^vvv^^vv^vv^v^^vvv"))
        println("0 == " + d("^^^vvvvvvvvvvvv"))
        println("0 == " + d("vvv^^^^^^^^^^^^"))
      }
    }

APL，17

(⊣×≠)/⌽0,2-'^ '⍳⍞

对于没有分叉符号的解释器（例如GNU APL），它将是{⍺×⍺≠⍵}/⌽0,2-'^ '⍳⍞（19）。这可能是最无聊的解决方案，因为它直接根据问题的定义起作用。

Ruby，41 35字节

正则表达式。只有最后按下的按钮很有趣，因此请检查其运行长度。然后把它比作"a"（或之间的任何字母^和v）来获得1或-1。

->s{s[/(.?)\1*$/].size%2*(?a<=>$1)}

C＃6，18 + 80 = 98字节

要求：

using System.Linq;

实际功能：

int S(string v)=>v.Split(new[]{"^^","vv"},0).Last().Length<1?0:v.Last()<95?1:-1;

工作原理：代码首先删除last ^^或之前的所有内容vv。该内容无关紧要，因为单击同一按钮两次将始终取消您的投票。它通过对拆分做到这一点^^，并vv和采取的最后一个项目。如果该项目为空字符串（.Length<1），则该函数将返回，0因为所有表决都已取消。如果字符串不为空，则仅查看原始字符串的最后一个字符：它将覆盖所有先前的投票。如果char代码小于95，则它将为94 ^，因此它返回1，否则-1。

Python 2.7版，79 75 88

s=input()
print (0,(1,-1)[s[-1]=='v'])[len(s[s.rfind(('v^','^v')[s[-1]=='v'])+1:])%2!=0]

Minkolang 0.11，28 22个字节

0$I2&N."j"o-34*:dr=,*!

在这里尝试。

说明

0                         Push a 0 (running total)
 $I                       Push length of input
   2&N.                   Output as integer and stop if this is 0
       "j"                Push 106
          o               Take character from input (94 for ^, 118 for v)
                          <<so ^ becomes +12 and v becomes -12>>
           -              Subtract
            34*:          Divide by 12
                d         Duplicate top of stack
                 r        Reverse stack
                  =,      Push 0 if equal, 1 otherwise
                    *     Multiply
                          <<this handles two of the same vote in a row>>
                     !    Unconditional trampoline (jumps the 0 at the beginning)

请注意，N.结尾没有。那是因为我让它重新开始。当输入为空时，最后的提示输出为整数，程序停止。

Pyth，13个字节

ut+Jq\^H>JGzZ

Mathematica，60个字节

Mod[#,2]Sign@#&@Tr@Last@Split@StringCases[#,{"^"->1,_->-1}]&

形状脚本，26字节

"^"$"0>1@-"~"v"$"0<1-"~0@!

它如何运作：

"^"$     split input on '^'
"
  0>         Check if the number is more than 0 (1 if true, 0 if false).
  1@-        subtract the answer from one.
"~       Join it back together, with this string in place of '^'
"v"$     Split on 'v'
"        
  0<         Check if 0 is more than the number (1 if true, 0 if false).
  1-         subtract one from the results
"~       Join it back together, with this string in place of 'v'
0@       add a zero to the stack and place it under the string just built. 
!        run the string as code

C＃6，18 + 97 95 = 115个 113字节，没有字符串的方法，过度LINQ

int v(string s)=>(int)s.Reverse().TakeWhile((c,i)=>i<1||c==s[s.Length-i])?.Sum(x=>x<95?1:-1)%2;

确实值得在此之前

using System.Linq;

有了使用x<95?1:-1而不是x=='^'?1:-1来自ProgramFOX答案的想法

巧合：

• 我窃取的微调使用了与95的比较-字节数（不包括using语句），使用所述微调
• 总字节数的位数之和等于写为罗马数字的总字节数的位数

C： 67 66字节

打高尔夫球：

void f(char *v){int i=0,c,s=0;for(;v[i]!=0;i++){v[i]>94?s--:s++;}}

松散

void f (char *v)
{
    int i = 0, c, s = 0;

    for (;v[i]!=0;i++)
    {
        v[i] > 94 ? s-- : s++;
    }
}

Go，179个字节

一个非常幼稚的解决方案。

package main
import(."fmt"."strings")
func main(){a:=""
i:=0
Scanln(&a)
b:=Split(a,"")
for _,e:=range b{switch i{case 1:i--
case 0:if e=="^"{i++}else{i--}
case-1:i++}}
Println(i)}

取消高尔夫：

package main

import (
    ."fmt"
    ."strings"
)

func main() {
    a := ""
    i := 0
    Scanln(&a)
    b := Split(a, "")
    for _, e := range b {
        switch i {
        case 1:
            i--
        case 0:
            if e == "^" {
                i++
            } else {
                i--
            }
        case -1:
            i++
        }
    }
    Println(i)
}

Perl 5，41个字节

40个字节，外加1个 -p

/(.)\1*$/;$_=((length$&)%2)*($1=~v?-1:1)

/(.)\1*$/;将输入字符串与regex进行比较/(.)\1*$/，即查看是否以单个字符结束，重复次数≥1次。

如果是，$&则为整个重复字符串，并且$1为字符；否则（即输入字符串为空），这两个变量为空字符串。

$1=~v?-1:1与$1正则表达式比较，v如果匹配则返回-1，否则返回1。

并将±1乘以模2 (length$&)%2的长度$&。

05AB1E，14 12 11 字节

Îvy'^QDŠ‹+<

@ Sp3000的Gol> <>答案的端口。

注意：@Grimy已经为05AB1E发布了一个较短的8字节替代方案，因此请确保对他进行投票！

在线尝试或验证所有测试用例。

说明：

Î            # Push 0 (later mentioned as `r`) and the input-string
 v           # Loop over the characters of the input:
  y'^Q      '#  Does the current character equal "^"?
             #  (results in 1 for truthy; 0 for falsey - later mentioned as `b`)
      D      #  Duplicate this result `b`
       Š     #  Triple swap (`r`,`b`,`b`) to (`b`,`r`,`b`)
        ‹    #  Check if the boolean `b` is smaller than the result-integer `r`
             #  (again results in 1 for truthy; 0 for falsey)
         +   #  Add them together
          <  #  Decrease this by 1
             # (Implicitly output the result-integer `r` after the loop)

05AB1E，8个字节

㤮öÓÆ.±

在线尝试！

长度相同的替代解决方案：u㤮öÓÆ(，㤮ögÓÆ(。

CJam，27个 24字节

'^_]r+e`W=(2%\(i99-g@*W*

在线试用。

我从丹尼斯的答案中得到的只是g（符号函数）。

Ruby，43岁

->s{a=0
s.bytes{|i|b=9-i/11;a=a!=b ?b:0}
a}

9-i/11给定^（94）或v（118）的ASCII码时，计算结果为1或-1

在测试程序中：

f=->s{a=0
s.bytes{|i|b=9-i/11;a=a!=b ?b:0}
a}

g=gets.chomp
puts f[g]