Escriba un programa o función que tome una cadena que solo contenga los caracteres ^y v(puede suponer que no habrá otros caracteres). Lea de izquierda a derecha esta cadena representa la secuencia de clics del mouse que un solo usuario realizó mientras veía una pregunta o respuesta de Stack Exchange por primera vez.

Cada ^representa un clic del botón de votación positiva y cada uno vrepresenta un clic del botón de votación negativa . (Para ejemplos de trabajo, mire ligeramente a la izquierda).

Suponga que no existen limitaciones de votación, por lo que todos los clics se registran correctamente.
Imprimir o devolver:

• 1o +1si la publicación termina siendo votada.
• 0si la publicación termina sin ser votada. ( -0y +0no son válidos)
• -1 si la publicación termina siendo rechazada.

Las publicaciones comienzan con cero votos netos del usuario y los botones cambian los votos netos de la siguiente manera:

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

El código más corto en bytes gana.

Casos de prueba:

[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

Pruébalo en línea . Aunque esto funcionará bien en la próxima actualización, lo he enumerado como 0.3.11 por si acaso.

Explicación

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

Tenga en cuenta que el primer uso de @tira un 0 desde la parte inferior de la pila para inicializar el recuento de votos para la primera iteración

Para ilustrar con una tabla 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 es una función que utiliza la convención de llamada fastcall, que toma una cadena y devuelve un entero de 8 bits.

Lo probé con el siguiente programa en C, que debe compilarse para el 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

^{Tachado 44 sigue siendo regular 44 :(}

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

Mantiene un total acumulado s. Utiliza el for ofbucle para iterar sobre cada carácter en la cadena y las actualizaciones sbasadas en el carácter actual y el valor anterior.

Ediciones: Golfed ~s&&-1a !~s-1. Esta expresión tiene que ser igual a 0 si ses igual a -1 y -1 en caso contrario. Guardado 6 bytes gracias a @nderscore.

Cómo funciona la expresión:

 ~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

Versión actualizada con mejoras significativas aportadas por Dennis:

0'jqf{-g_@=!*}

Pruébalo en línea

Explicación:

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 bytes

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

52 caracteres y 3 líneas nuevas.

Probado en este intérprete .

El jes equidistante de ^y ven ascii, por lo que se usa para hacer conversiones aritméticas al final, en lugar de condicionales que consumen espacio.

brainfuck, 146 bytes

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

Este programa toma cada byte de entrada y lo compara con el último. Si son iguales, tira la entrada y almacena "0" como la "entrada anterior", de lo contrario la guarda normalmente.

Si el resultado final es v, se imprime -. Si el resultado final fue distinto de cero, se agrega 1 a una celda vacía. Finalmente, se agrega 48 a esa celda y se imprime.

Javascript ES6, 91 48 caracteres

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

Explicación: undefinedtermina por d.

Prueba:

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

Historial de respuestas:

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

Pitón 2, 49

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

Se repite con la función de actualización

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

que toma el recuento de votos actual xy el nuevo personaje cy genera el nuevo recuento de votos.

La idea es utilizar Python 2 cmpfunción, que compara sus dos argumentos y da -1, 0, 1para <, ==, >respectivamente. El interior cmp('u',c)da -1por vy 1para ^; cualquier personaje entre ellos es suficiente 'u'. El externo luego compara eso con x, que da cmp(1,x)por ^y cmp(-1,x)para v, que tienen los valores correctos.

La iteración directa fue 3 caracteres más larga (52), aunque sería un carácter corto (48) si input()se permitiera tomar comillas con comillas.

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

La mejor función recursiva que encontré fue una char más larga (50)

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

Prolog, 159152 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).

Pruébelo usted mismo:
Intérprete en línea aquí

Ejemplo

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

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

Editar: Guardado 7 bytes al unificar las cláusulas r con OR.

CJam, 16 bytes

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

Esto se bloqueará después de imprimir 0 , si corresponde. El error se puede suprimir con el intérprete de Java. Si intenta esto en línea , ignore todo menos la última línea de salida.

Cómo 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, 177159 72 bytes

Todavía un poco nuevo en este código de golf.

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

EDITAR: se corrigió el comportamiento incorrecto.
EDIT 2: Gracias @MorganThrapp por eliminar muchos bytes.

JavaScript (ES6), 64 59 58 52 bytes

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

Esto se basa en la observación de que solo el último tramo de la repetición (de cualquiera ^o v) afecta el resultado.

Gracias a Neil por jugar golf en 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}

Prueba de función 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 sin notación fork (como GNU APL), sería {⍺×⍺≠⍵}/⌽0,2-'^ '⍳⍞(19). Esta es probablemente la solución más aburrida posible porque funciona directamente desde la definición del problema.

Ruby, 41 35 bytes

Regex. Solo el último botón presionado es interesante, así que verifique la duración de la ejecución. Luego compárelo con "a"(o cualquier letra entre ^y v) para obtener 1o -1.

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

C # 6, 18 + 80 = 98 bytes

Requiere:

using System.Linq;

Función real:

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

Cómo funciona: el código primero elimina todo antes del último ^^o vv. Ese contenido no es relevante porque hacer clic en el mismo botón dos veces siempre cancelará su voto. Esto se hace mediante la división de ^^y vvy tomando el último elemento. Si este elemento es una cadena vacía ( .Length<1), la función vuelve 0porque toda la votación ha sido cancelada. Si la cadena no está vacía, solo mira el último carácter de la cadena original: anulará todos los votos anteriores. Si el código char es menor que 95, entonces será 94 ^, por lo que devuelve 1, de lo contrario -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=,*!

Pruébalo aquí.

Explicación

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)

Tenga en cuenta que no hay N.al final. Eso es porque lo dejé envolver hasta el principio. Cuando la entrada está vacía, la cuenta final se emite como un número entero y el programa se detiene.

Pyth, 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@!

Cómo 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, sin métodos de cadena, LINQ excesivo

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

Verdaderamente merece ser precedido por

using System.Linq;

Tuve la idea de usar en x<95?1:-1lugar de la respuestax=='^'?1:-1 de ProgramFOX

Coincidencias:

• El ajuste que robé hace uso de la comparación con 95: el recuento de bytes que excluye la declaración de uso, usando dicho ajuste
• La suma de los dígitos del recuento total de bytes es igual al número de dígitos del recuento total de bytes escrito como número romano

C: 67 66 bytes

golfizado:

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

sin golf:

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

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

Ir, 179 bytes

Una solución extremadamente ingenua.

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

Sin golf:

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, más 1 para -p

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

/(.)\1*$/;compara la cadena de entrada con la expresión regular /(.)\1*$/, es decir, ve si termina con un solo carácter repetido un número ≥1 de veces.

Si es así, $&es toda la cadena de repetición y $1es el personaje; de lo contrario (es decir, la cadena de entrada está vacía), esas dos variables son la cadena vacía.

$1=~v?-1:1se compara $1con la expresión regular vy devuelve −1 si coincide y 1 de lo contrario.

Y multiplique eso ± 1 por (length$&)%2la longitud del $&módulo 2.

05AB1E , 14 12 11 bytes

Îvy'^QDŠ‹+<

Puerto de la respuesta Gol> <> de @ Sp3000 .

NOTA: @Grimy ya publicó una alternativa más corta de 8 bytes para 05AB1E , ¡así que asegúrese de votarlo!

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

㤮öÓÆ.±

Pruébalo en línea!

Soluciones alternativas con la misma longitud: u㤮öÓÆ(, 㤮ögÓÆ(.

CJam, 27 24 bytes

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

Pruébalo en línea .

Todo lo que tomé de la respuesta de Dennis es g(función de signo).

Rubí, 43

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

9-i/11se evalúa a 1 o -1 cuando se le dan los códigos ascii de ^(94) o v(118)

En programa de prueba:

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

g=gets.chomp
puts f[g]