Napisz program lub funkcję, która pobiera ciąg zawierający tylko znaki ^i v(możesz założyć, że nie będzie innych znaków). Ten ciąg znaków odczytywany od lewej do prawej reprezentuje sekwencję kliknięć myszą wykonanych przez jednego użytkownika podczas przeglądania pytania lub odpowiedzi Stack Exchange po raz pierwszy.

Każde ^oznacza kliknięcie przycisku głosowania , a każde voznacza kliknięcie przycisku głosowania . (Dla przykładów roboczych spójrz lekko w lewo.)

Załóżmy, że nie obowiązują żadne ograniczenia głosowania, więc wszystkie kliknięcia są rejestrowane poprawnie.
Wydrukuj lub zwróć:

• 1lub +1jeśli post zostanie ostatecznie oceniony.
• 0jeśli post nie zostanie poddany głosowaniu. ( -0i +0nie są ważne)
• -1 jeśli post zostanie ostatecznie odrzucony.

Wpisy zaczynają się od zerowej liczby głosów netto od użytkownika, a przyciski zmieniają liczbę głosów w następujący sposób:

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

Najkrótszy kod w bajtach wygrywa.

Przypadki testowe:

[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 bajtów

iEh`^=:@)+M

Wypróbuj online . Mimo że będzie to działać dobrze w następnej aktualizacji, na wszelki wypadek podałem ją jako 0.3.11.

Wyjaśnienie

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

Zauważ, że pierwsze użycie ciągu @ściąga 0 z dołu stosu, aby zainicjować liczenie głosów dla pierwszej iteracji

Aby zilustrować pełnym stołem:

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

kod maszynowy x86, 24 bajty

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

Jest to funkcja korzystająca z konwencji wywoływania fastcall, która pobiera ciąg znaków i zwraca 8-bitową liczbę całkowitą.

Przetestowałem go za pomocą następującego programu C, który musi zostać skompilowany dla trybu 32-bitowego.

#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 bajtów

^{Przekreślone 44 jest nadal regularne 44 :(}

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

Utrzymuje bieżącą sumę w s. Wykorzystuje for ofpętlę do iteracji każdego znaku w ciągu i aktualizuje w soparciu o bieżący znak i poprzednią wartość.

Edycje: Grał ~s&&-1w golfa !~s-1. To wyrażenie musi być równe 0, jeśli w sprzeciwnym razie będzie równe -1 i -1. Zaoszczędź 6 bajtów dzięki @nderscore.

Jak działa to wyrażenie:

 ~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 bajtów

Zaktualizowana wersja ze znacznymi ulepszeniami wniesionymi przez Dennisa:

0'jqf{-g_@=!*}

Wypróbuj online

Wyjaśnienie:

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 bajtów

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

52 znaki i 3 nowe linie.

Testowany na tym tłumaczu .

jJest w równej odległości od ^i vASCII więc jest używany do konwersji arytmetycznych w końcu, zamiast kosmicznych zużywających warunkowych.

pieprzenie mózgu, 146 bajtów

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

Ten program pobiera każdy bajt danych wejściowych i porównuje go z ostatnim. Jeśli są takie same, odrzuca dane wejściowe i zapisuje „0” jako „poprzednie dane wejściowe”, w przeciwnym razie zapisuje je normalnie.

Jeśli końcowy wynik jest v, drukuje się -. Jeśli końcowy wynik był niezerowy, 1 dodaje się do pustej komórki. Na koniec do tej komórki dodaje się 48 i drukuje.

JavaScript ES6, 91 48 znaków

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

Objaśnienie: undefinedkończy się na d.

Test:

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

Historia odpowiedzi:

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)

Iteruje za pomocą funkcji aktualizacji

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

, która pobiera bieżącą liczbę głosów xi nową postać ci generuje nową liczbę głosów.

Chodzi o to, aby użyć Python 2 w cmpfunkcję, która porównuje swoje dwa argumenty i daje -1, 0, 1do <, ==, >odpowiednio. Wewnętrzny cmp('u',c)daje -1za vi 1za ^; wystarczy każda postać między nimi 'u'. Zewnętrzny porównuje to z tym x, co daje cmp(1,x)za ^i cmp(-1,x)za v, które mają odpowiednie wartości.

Bezpośrednia iteracja była o 3 znaki dłuższa (52), choć byłaby krótsza o jeden znak (48), gdyby input()dozwolone było przyjmowanie cudzysłowów.

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

Najlepsza funkcja rekurencyjna, jaką znalazłem, była o jeden znak dłużej (50)

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

Prolog, 159 152 bajtów

Kod:

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

Sprawdź to sam:
Interpreter online tutaj

Przykład

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

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

Edycja: Zapisano 7 bajtów poprzez ujednolicenie klauzul r z OR.

CJam, 16 bajtów

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

Spowoduje to zawieszenie po wydrukowaniu 0 , jeśli dotyczy. Błąd można ukryć za pomocą interpretera Java. Jeśli spróbujesz tego online , zignoruj ​​wszystko oprócz ostatniego wiersza wyników.

Jak to działa

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 bajtów

Nadal trochę nowy w tej dziedzinie golfa.

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

EDYCJA: Naprawiono nieprawidłowe zachowanie.
EDYCJA 2: Dzięki @MorganThrapp za golenie dużej ilości bajtów.

JavaScript (ES6), 64 59 58 52 bajtów

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

Jest to oparte na spostrzeżeniu, że tylko ostatni odcinek powtórzenia (jednego ^lub jednego v) wpływa na wynik.

Dzięki Neil za grę w golfa z 6 bajtów.

Haskell, 40 bajtów

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

Scala, 75 bajtów

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

Test na zaimplementowaną funkcję.

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

Dla tłumaczy bez notacji widelca (jak GNU APL) byłoby to {⍺×⍺≠⍵}/⌽0,2-'^ '⍳⍞(19). Jest to prawdopodobnie najbardziej nudne z możliwych rozwiązań, ponieważ działa bezpośrednio od zdefiniowania problemu.

Rubin, 41 35 bajtów

Regex. Interesujący jest tylko ostatni naciśnięty przycisk, więc sprawdź jego długość. Następnie porównaj go z "a"(lub dowolną literą pomiędzy ^i v), aby uzyskać 1lub -1.

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

C # 6, 18 + 80 = 98 bajtów

Wymaga:

using System.Linq;

Rzeczywista funkcja:

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

Jak to działa: kod najpierw usuwa wszystko przed ostatnim ^^lub vv. Ta treść nie jest istotna, ponieważ dwukrotne kliknięcie tego samego przycisku zawsze anuluje Twój głos. Czyni to poprzez podział na ^^a vvi zrobieniu ostatniego elementu. Jeśli ten element jest pustym ciągiem ( .Length<1), funkcja zwraca, 0ponieważ całe głosowanie zostało anulowane. Jeśli ciąg nie jest pusty, to po prostu patrzy na ostatni znak oryginalnego ciągu: zastąpi wszystkie poprzednie głosy. Jeśli kod znaków jest mniejszy niż 95, wówczas będzie wynosił 94 ^, więc w 1przeciwnym razie zwraca -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 bajtów

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

Wypróbuj tutaj.

Wyjaśnienie

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)

Zauważ, że N.na końcu nie ma . To dlatego, że pozwoliłem temu zawinąć do początku. Gdy wejście jest puste, końcowy licznik jest wyprowadzany jako liczba całkowita, a program zatrzymuje się.

Pyth, 13 bajtów

ut+Jq\^H>JGzZ

Mathematica, 60 bajtów

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

Skrypt kształtu , 26 bajtów

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

Jak to działa:

"^"$     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 bajtów, brak metod łańcuchowych, nadmierne 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;

Naprawdę zasługuje na to, aby być poprzedzonym

using System.Linq;

Wpadł na pomysł wykorzystania x<95?1:-1zamiast x=='^'?1:-1z odpowiedzią ProgramFOX za

Koincydencje:

• Ulepszenie, które ukradłem, wykorzystuje porównanie z 95 - liczba bajtów z wyłączeniem instrukcji using, przy użyciu tego ulepszenia
• Suma cyfr całkowitej liczby bajtów jest równa liczbie cyfr całkowitej liczby bajtów zapisanych jako liczba rzymska

DO: 67 66 bajtów

grał w golfa:

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

bez golfa:

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

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

Idź, 179 bajtów

Skrajnie naiwne rozwiązanie.

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

Nie golfowany:

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 bajtów

40 bajtów plus 1 dla -p

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

/(.)\1*$/;porównuje ciąg wejściowy z wyrażeniem regularnym /(.)\1*$/, tzn. sprawdza, czy kończy się on pojedynczym znakiem powtarzanym pewną liczbę ≥1 razy.

Jeśli tak, $&to cały ciąg powtórzeń i $1znak; w przeciwnym razie (tzn. ciąg wejściowy jest pusty), te dwie zmienne są ciągiem pustym.

$1=~v?-1:1porównuje $1do wyrażenia regularnego vi zwraca -1, jeśli pasuje, a 1 w przeciwnym razie.

I pomnóż to ± 1 przez (length$&)%2długość $&modulo 2.

05AB1E , 14 12 11 bajtów

Îvy'^QDŠ‹+<

Port of @ Sp3000 's Gol> <> odpowiedz .

UWAGA: @Grimy opublikował już krótszą 8-bajtową alternatywę dla 05AB1E , więc upewnij się, że go głosujesz!

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

Î            # 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 bajtów

㤮öÓÆ.±

Wypróbuj online!

Alternatywne rozwiązania o tej samej długości: u㤮öÓÆ(, 㤮ögÓÆ(.

CJam, 27 24 bajtów

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

Wypróbuj online .

Wszystko, co wziąłem z odpowiedzi Dennisa, to g(funkcja znaku).

Ruby, 43

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

9-i/11ocenia na 1 lub -1, gdy podano kody ascii ^(94) lub v(118)

W programie testowym:

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

g=gets.chomp
puts f[g]