Viết chương trình hoặc hàm chỉ có một chuỗi chứa các ký tự ^và v(bạn có thể cho rằng sẽ không có ký tự nào khác). Đọc từ trái sang phải chuỗi này biểu thị chuỗi lần nhấp chuột của một người dùng được thực hiện trong khi xem câu hỏi hoặc câu trả lời Stack Exchange lần đầu tiên.

Mỗi ^đại diện cho một lần nhấp của nút upvote và mỗi lần vđại diện cho một lần nhấp vào nút downvote . (Đối với các ví dụ làm việc trông hơi trái.)

Giả sử rằng không có giới hạn bỏ phiếu nào có hiệu lực để tất cả các lần nhấp được đăng ký chính xác.
In hoặc trả lại:

• 1hoặc +1nếu bài đăng kết thúc được nâng cấp.
• 0nếu bài đăng kết thúc không được bình chọn. ( -0và +0không hợp lệ)
• -1 nếu bài viết kết thúc bị hạ cấp.

Bài viết bắt đầu với số phiếu không từ người dùng và các nút thay đổi số phiếu ròng như sau:

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

Mã ngắn nhất tính bằng byte thắng.

Các trường hợp thử nghiệm:

[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

Gol> <> 0.3.11 , 13 12 11 byte

iEh`^=:@)+M

Hãy thử trực tuyến . Mặc dù điều này sẽ hoạt động tốt trong bản cập nhật tiếp theo, tôi đã liệt kê nó là 0.3.11 chỉ trong trường hợp.

Giải trình

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

Lưu ý rằng lần sử dụng đầu tiên @kéo 0 từ dưới cùng của ngăn xếp để khởi tạo số phiếu bầu cho lần lặp đầu tiên

Để minh họa với một bảng đầy đủ:

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

Mã máy x86, 24 byte

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

Đây là một hàm sử dụng quy ước gọi fastcall, lấy một chuỗi và trả về một số nguyên 8 bit.

Tôi đã thử nghiệm nó với chương trình C sau, phải được biên dịch cho chế độ 32 bit.

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

^{Vượt qua 44 vẫn là thường xuyên 44 :(}

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

Giữ một tổng số chạy trong s. Sử dụng for ofvòng lặp để lặp lại qua từng ký tự trong chuỗi và cập nhật sdựa trên ký tự hiện tại và giá trị trước đó.

Chỉnh sửa: Golfed ~s&&-1tới !~s-1. Biểu thức này phải bằng 0 nếu sbằng -1 và -1 khác. Đã lưu 6 byte nhờ @nderscore.

Cách thức hoạt động của biểu thức:

 ~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 byte

Phiên bản cập nhật với những cải tiến đáng kể được đóng góp bởi Dennis:

0'jqf{-g_@=!*}

Dùng thử trực tuyến

Giải trình:

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 byte

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

52 ký tự và 3 dòng mới.

Đã thử nghiệm trên thông dịch viên này .

Tương jđương từ ^và vtrong ascii vì vậy cuối cùng nó được sử dụng để thực hiện chuyển đổi số học, thay vì sử dụng không gian có điều kiện.

Brainfuck, 146 byte

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

Chương trình này lấy từng byte đầu vào và so sánh nó với cái cuối cùng. Nếu chúng giống nhau, nó sẽ ném đầu vào đi và lưu "0" làm "đầu vào trước", nếu không, nó sẽ lưu nó bình thường.

Nếu kết quả cuối cùng là v, nó in -. Nếu kết quả cuối cùng là khác không, 1 được thêm vào một ô trống. Cuối cùng, 48 được thêm vào ô đó và nó được in.

Javascript ES6, 91 48 ký tự

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

Giải thích: undefinedkết thúc bởi d.

Kiểm tra:

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

Trả lời lịch sử:

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

Con trăn 2, 49

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

Lặp lại thông qua chức năng cập nhật

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

lấy số phiếu hiện tại xvà ký tự mới cvà đưa ra số phiếu mới.

Ý tưởng là để sử dụng Python 2 của cmpchức năng, trong đó so sánh hai args của nó và đưa ra -1, 0, 1cho <, ==, >tương ứng. Một bên cmp('u',c)cho -1cho vvà 1cho ^; bất kỳ nhân vật giữa họ đủ cho 'u'. Cái bên ngoài sau đó so sánh rằng x, cái cmp(1,x)cho ^và cmp(-1,x)cho v, có giá trị đúng.

Lặp lại trực tiếp dài hơn 3 ký tự (52), tuy nhiên sẽ là một ký tự ngắn (48) nếu input()cho phép lấy dấu ngoặc kép.

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

Hàm đệ quy tốt nhất tôi tìm thấy là một char dài hơn (50)

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

Prolog, 159 152 byte

Mã số:

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

Tự kiểm tra:
Phiên dịch trực tuyến tại đây

Ví dụ

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

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

Chỉnh sửa: Đã lưu 7 byte bằng cách thống nhất các mệnh đề r với OR.

CJam, 16 byte

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

Điều này sẽ sụp đổ sau khi in 0 , nếu có. Lỗi có thể được loại bỏ bằng trình thông dịch Java. Nếu bạn thử trực tuyến này , bỏ qua mọi thứ trừ dòng đầu ra cuối cùng.

Làm thế nào nó hoạt động

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, 177 159 72 byte

Vẫn còn mới với điều golf mã này.

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

EDIT: Đã sửa lỗi hành vi không chính xác.
EDIT 2: Cảm ơn @MorganThrapp đã loại bỏ rất nhiều byte.

JavaScript (ES6), 64 59 58 52 byte

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

Điều này dựa trên quan sát rằng chỉ có sự kéo dài cuối cùng của sự lặp lại (của một trong hai ^hoặc v) ảnh hưởng đến kết quả.

Cảm ơn Neil vì đã chơi golf 6 byte.

Haskell, 40 byte

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

Scala, 75 byte

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

Kiểm tra chức năng thực hiện.

  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-'^ '⍳⍞

Đối với các thông dịch viên không có ký hiệu ngã ba (như GNU APL), nó sẽ là {⍺×⍺≠⍵}/⌽0,2-'^ '⍳⍞(19). Đây có lẽ là giải pháp nhàm chán nhất có thể bởi vì nó hoạt động trực tiếp từ định nghĩa của vấn đề.

Ruby, 41 35 byte

Regex. Chỉ nhấn nút cuối cùng là thú vị, vì vậy hãy kiểm tra độ dài của nó. Sau đó so sánh nó với "a"(hoặc bất kỳ chữ cái nào giữa ^và v) để có được 1hoặc -1.

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

C # 6, 18 + 80 = 98 byte

Đòi hỏi:

using System.Linq;

Chức năng thực tế:

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

Cách thức hoạt động: mã đầu tiên loại bỏ mọi thứ trước khi cuối cùng ^^hoặc vv. Nội dung đó không liên quan vì nhấp vào cùng một nút hai lần sẽ luôn hủy bỏ phiếu bầu của bạn. Nó làm điều này bằng cách phân chia trên ^^và vvvà lấy mục cuối cùng. Nếu mục này là một chuỗi rỗng ( .Length<1), thì hàm sẽ trả về 0vì tất cả biểu quyết đã bị hủy. Nếu chuỗi nó không trống, thì nó chỉ nhìn vào char cuối cùng của chuỗi gốc: nó sẽ ghi đè tất cả các phiếu bầu trước đó. Nếu mã char nhỏ hơn 95, thì nó sẽ là 94 ^, vì vậy nó sẽ trả về 1, nếu không -1.

Con trăn 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]

Chồn 0,11 , 28 22 byte

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

Hãy thử nó ở đây.

Giải trình

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)

Lưu ý rằng không có N.ở cuối. Đó là bởi vì tôi để nó quấn quanh đầu. Khi đầu vào trống, kiểm đếm cuối cùng là đầu ra dưới dạng số nguyên và chương trình dừng lại.

Bình thường, 13 byte

ut+Jq\^H>JGzZ

Toán học, 60 byte

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

Tập lệnh Shape , 26 byte

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

Làm thế nào nó woks:

"^"$     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 byte, không có phương thức chuỗi, LINQ quá mức

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

Thực sự xứng đáng được đi trước

using System.Linq;

Có ý tưởng sử dụng x<95?1:-1thay vì x=='^'?1:-1từ câu trả lời của ProgramFOX

Sự trùng hợp:

• Tinh chỉnh tôi đã đánh cắp sử dụng so sánh với 95 - số byte không bao gồm câu lệnh sử dụng, sử dụng tinh chỉnh đã nói
• Tổng các chữ số của tổng số byte bằng số chữ số của tổng số byte được viết dưới dạng số la mã

C: 67 66 byte

đánh gôn

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

vô dụng:

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

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

Đi, 179 byte

Một giải pháp cực kỳ ngây thơ.

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

Ung dung:

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 byte

40 byte, cộng thêm 1 cho -p

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

/(.)\1*$/;so sánh chuỗi đầu vào với regex /(.)\1*$/, tức là xem liệu nó kết thúc bằng một ký tự lặp lại một số số number1 lần.

Nếu vậy, $&là toàn bộ chuỗi lặp lại và $1là ký tự; mặt khác (tức là chuỗi đầu vào trống), hai biến đó là chuỗi rỗng.

$1=~v?-1:1so sánh $1với regex vvà trả về −1 nếu nó khớp và 1 nếu không.

Và nhân số đó với 1 (length$&)%2, độ dài của $&modulo 2.

05AB1E , 14 12 11 byte

Îvy'^QDŠ‹+<

Cổng của @ Sp3000 's Gol> <> trả lời .

LƯU Ý: @Grimy đã đăng một thay thế 8 byte ngắn hơn cho 05AB1E , vì vậy hãy đảm bảo nâng cấp anh ấy!

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

Î            # 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 byte

㤮öÓÆ.±

Hãy thử trực tuyến!

Giải pháp thay thế với chiều dài tương tự: u㤮öÓÆ(, 㤮ögÓÆ(.

CJam, 27 24 byte

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

Hãy thử trực tuyến .

Tất cả những gì tôi lấy từ câu trả lời của Dennis là g(chức năng ký hiệu).

Ruby, 43

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

9-i/11ước tính thành 1 hoặc -1 khi được cung cấp mã ascii của ^(94) hoặc v(118)

Trong chương trình thử nghiệm:

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

g=gets.chomp
puts f[g]