Escreva um programa ou função que use uma string contendo apenas os caracteres ^e v(você pode assumir que não haverá outros caracteres). Ler da esquerda para a direita esta sequência representa a sequência de cliques do mouse feitos por um único usuário enquanto visualiza uma pergunta ou resposta do Stack Exchange pela primeira vez.

Every ^representa um clique no botão de votação positiva e every vrepresenta um clique do botão de votação negativa . (Para exemplos de trabalho, veja um pouco à esquerda.)

Suponha que nenhuma limitação de votação esteja em vigor; portanto, todos os cliques são registrados corretamente.
Imprimir ou devolver:

• 1ou +1se a postagem acabar sendo votada.
• 0se a postagem acabar não sendo votada. ( -0e +0não são válidos)
• -1 se a postagem acabar com voto negativo.

As postagens começam com zero voto líquido do usuário e os botões alteram o voto líquido da seguinte maneira:

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

O código mais curto em bytes vence.

Casos de teste:

[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 bytes

iEh`^=:@)+M

Experimente online . Mesmo que isso funcione bem na próxima atualização, listei como 0.3.11 por precaução.

Explicação

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

Observe que o primeiro uso de @puxa um 0 da parte inferior da pilha para inicializar a contagem de votos para a primeira iteração

Para ilustrar com uma tabela completa:

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

código de máquina x86, 24 bytes

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

Esta é uma função que utiliza a convenção de chamada de chamada rápida, que pega uma sequência e retorna um número inteiro de 8 bits.

Testei-o com o seguinte programa C, que deve ser compilado no modo de 32 bits.

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

^{Riscado 44 ainda é regular 44 :(}

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

Mantém um total em execução s. Usa um for ofloop para iterar sobre cada caractere na string e atualiza com sbase no caractere atual e no valor anterior.

Edições: jogou golfe ~s&&-1para !~s-1. Essa expressão deve ser igual a 0 se for sigual a -1 e -1 caso contrário. Economizou 6 bytes graças a @nderscore.

Como a expressão funciona:

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

Versão atualizada com melhorias significativas contribuídas por Dennis:

0'jqf{-g_@=!*}

Experimente online

Explicação:

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.

Baixar 93 - 55 bytes

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

52 caracteres e 3 novas linhas.

Testado neste intérprete .

O jé equidistante de ^e vem ascii, por isso é usado para fazer conversões aritméticas no final, em vez de condicionais que consomem espaço.

brainfuck, 146 bytes

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

Este programa pega cada byte de entrada e o compara com o último. Se forem iguais, ela joga a entrada fora e armazena "0" como a "entrada anterior", caso contrário, a salva normalmente.

Se o resultado final for v, ele será impresso -. Se o resultado final for diferente de zero, 1 será adicionado a uma célula vazia. Finalmente, 48 é adicionado a essa célula e é impresso.

Javascript ES6, 91 48 caracteres

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

Explicação: undefinedtermina em d.

Teste:

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

Histórico de respostas:

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)

Repete com a função de atualização

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

que pega a contagem atual de votos xe o novo caractere ce gera a nova contagem de votos.

A idéia é usar do Python 2 cmpfunção, que compara seus dois argumentos e dá -1, 0, 1para <, ==, >respectivamente. O interior cmp('u',c)dá -1para ve 1para ^; qualquer caractere entre eles basta 'u'. O externo então compara isso a x, que dá cmp(1,x)para ^e cmp(-1,x)para v, que tem os valores corretos.

A iteração direta foi de três caracteres a mais (52), mas seria um caractere curto (48) se input()permitir cotações.

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

A melhor função recursiva que encontrei foi um caractere a mais (50)

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

Prolog, 159 152 bytes

Código:

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

Teste você mesmo:
Intérprete online aqui

Exemplo

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

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

Editar: salvou 7 bytes unificando cláusulas r com OR.

CJam, 16 bytes

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

Isso falhará após a impressão de 0 , se aplicável. O erro pode ser suprimido com o interpretador Java. Se você tentar isso online , ignore tudo, exceto a última linha de saída.

Como funciona

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 bytes

Ainda meio novo nessa coisa do código de golfe.

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

EDIT: Corrigido o comportamento incorreto.
EDIT 2: Obrigado @MorganThrapp por cortar muitos bytes.

JavaScript (ES6), 64 59 58 52 bytes

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

Isso se baseia na observação de que apenas o último trecho da repetição (de um ^ou de v) afeta o resultado.

Agradecimentos a Neil por jogar fora 6 bytes.

Haskell, 40 bytes

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

Scala, 75 bytes

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

Teste para função implementada.

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

Para intérpretes sem notação de fork (como GNU APL), seria {⍺×⍺≠⍵}/⌽0,2-'^ '⍳⍞(19). Essa é provavelmente a mais chata das soluções possíveis, porque funciona diretamente a partir da definição do problema.

Ruby, 41 35 bytes

Regex. Somente o último botão pressionado é interessante, portanto verifique a duração disso. Em seguida, compare-o com "a"(ou qualquer letra entre ^e v) para obter 1ou -1.

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

C # 6, 18 + 80 = 98 bytes

Requer:

using System.Linq;

Função real:

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

Como funciona: o código primeiro remove tudo antes do último ^^ou vv. Esse conteúdo não é relevante porque clicar duas vezes no mesmo botão sempre cancelará seu voto. Ele faz isso através da divisão em ^^e vve tendo o último item. Se este item for uma string vazia ( .Length<1), a função retornará 0porque todas as votações foram canceladas. Se a string não estiver vazia, apenas o último caractere da string original: substituirá todos os votos anteriores. Se o código de caractere for menor que 95, será 94 e , caso contrário, ^retornará .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 bytes

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

Experimente aqui.

Explicação

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)

Observe que não há N.no final. Isso porque deixei envolver desde o início. Quando a entrada está vazia, a contagem final é emitida como número inteiro e o programa para.

Pitão, 13 bytes

ut+Jq\^H>JGzZ

Mathematica, 60 bytes

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

Script de forma , 26 bytes

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

Como funciona:

"^"$     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 bytes, sem métodos de cadeia, LINQ excessivo

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

Merece verdadeiramente ser precedido por

using System.Linq;

Teve a ideia de usar x<95?1:-1, em vez de x=='^'?1:-1partir a resposta de ProgramFOX

Coincidências:

• O ajuste que eu roubei faz uso da comparação com 95 - a contagem de bytes excluindo a instrução using, usando o referido ajuste
• A soma dos dígitos da contagem total de bytes é igual ao número de dígitos da contagem total de bytes, escrita como numeral romano

C: 67 66 bytes

golfed:

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

ungolfed:

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

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

Vá, 179 bytes

Uma solução extremamente ingênua.

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

Ungolfed:

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 bytes

40 bytes, mais 1 para -p

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

/(.)\1*$/;compara a sequência de entrada ao regex /(.)\1*$/, ou seja, vê se termina com um único caractere repetido algum número ≥1 de vezes.

Se sim, $&é toda a sequência de repetições e $1é o caractere; caso contrário (ou seja, a sequência de entrada está vazia), essas duas variáveis ​​são a sequência vazia.

$1=~v?-1:1compara $1com o regex ve retorna -1 se corresponder e 1 caso contrário.

E multiplique ± 1 por (length$&)%2, o comprimento do $&módulo 2.

05AB1E , 14 12 11 bytes

Îvy'^QDŠ‹+<

Porto da resposta Gol> <> do @ Sp3000 .

NOTA: O @Grimy já postou uma alternativa mais curta de 8 bytes para 05AB1E , portanto, faça um voto positivo!

Experimente online ou verifique todos os casos de teste .

Explicação:

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

㤮öÓÆ.±

Experimente online!

Soluções alternativas com o mesmo comprimento: u㤮öÓÆ(, 㤮ögÓÆ(.

CJam, 27 24 bytes

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

Experimente online .

Tudo o que tirei da resposta de Dennis é g(função de sinal).

Ruby, 43

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

9-i/11avalia como 1 ou -1 quando recebem os códigos ascii de ^(94) ou v(118)

No programa de teste:

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

g=gets.chomp
puts f[g]