Scrivi un programma o una funzione che accetta una stringa contenente solo i caratteri ^e v(puoi presumere che non ci saranno altri caratteri). Leggere da sinistra a destra questa stringa rappresenta la sequenza di clic del mouse un singolo utente fatta durante la visualizzazione di una pila di cambio domanda o una risposta per la prima volta.

Ogni ^rappresenta un clic del pulsante di votazione e ogni vrappresenta un clic del pulsante di votazione . (Per esempi di lavoro, guardare leggermente a sinistra.)

Supponiamo che non siano in vigore limiti di voto , quindi tutti i clic sono registrati correttamente.
Stampa o ritorna:

• 1o +1se il post finisce per essere votato.
• 0se il post finisce per non essere votato. ( -0e +0non sono validi)
• -1 se il post finisce per essere sottoposto a downgrade.

I post iniziano con zero voti netti dell'utente e i pulsanti cambiano i voti netti come segue:

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

Vince il codice più breve in byte.

Casi test:

[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

Provalo online . Anche se funzionerà bene nel prossimo aggiornamento, l'ho elencato come 0.3.11 per ogni evenienza.

Spiegazione

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

Si noti che il primo utilizzo di @estrae uno 0 dal fondo dello stack per inizializzare il conteggio dei voti per la prima iterazione

Per illustrare con una tabella 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

codice macchina 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

Questa è una funzione che utilizza la convenzione di chiamata fastcall, che accetta una stringa e restituisce un numero intero a 8 bit.

L'ho provato con il seguente programma C, che deve essere compilato per la modalità a 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

^{Cancellato 44 è ancora regolare 44 :(}

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

Mantiene un totale parziale in s. Utilizza il for ofciclo per scorrere su ogni carattere della stringa e si aggiorna in sbase al carattere corrente e al valore precedente.

Modifiche: golfato ~s&&-1a !~s-1. Questa espressione deve essere uguale a 0 se suguale a -1 e -1 altrimenti. 6 byte salvati grazie a @nderscore.

Come funziona l'espressione:

 ~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

Versione aggiornata con significativi miglioramenti apportati da Dennis:

0'jqf{-g_@=!*}

Provalo online

Spiegazione:

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 caratteri e 3 nuove righe.

Testato su questo interprete .

Il jè equidistante da ^e vin ASCII quindi è usato per fare conversioni aritmetiche, alla fine, piuttosto che consumare spazio condizionali.

Brainfuck, 146 byte

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

Questo programma prende ogni byte di input e lo confronta con l'ultimo. Se sono uguali, butta via l'input e memorizza "0" come "input precedente", altrimenti lo salva normalmente.

Se il risultato finale è v, stampa -. Se il risultato finale è stato diverso da zero, 1 viene aggiunto a una cella vuota. Infine, 48 viene aggiunto a quella cella e viene stampato.

Javascript ES6, 91 48 caratteri

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

Spiegazione: undefinedtermina con 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)

Cronologia delle risposte:

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)

Scorre la funzione di aggiornamento

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

che prende l'attuale conteggio dei voti xe il nuovo personaggio ce genera il nuovo conteggio dei voti.

L'idea è quella di utilizzare di Python 2 cmpfunzione, che mette a confronto le sue due args e dà -1, 0, 1per <, ==, >, rispettivamente. Quello interiore cmp('u',c)dà -1per ve 1per ^; qualsiasi personaggio tra loro è sufficiente 'u'. Quello esterno confronta quindi quello con x, che dà cmp(1,x)per ^e cmp(-1,x)per v, che hanno i giusti valori.

L'iterazione diretta era più lunga di 3 caratteri (52), anche se sarebbe stata una lettera corta di caratteri (48) se input()fosse consentito prendere una virgoletta.

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

La migliore funzione ricorsiva che ho trovato è stata un carattere più lungo (50)

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

Prolog, 159 152 byte

Codice:

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

Provalo tu stesso:
interprete online qui

Esempio

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

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

Modifica: salvato 7 byte unificando le clausole r con OR.

CJam, 16 byte

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

Questo si arresterà in modo anomalo dopo aver stampato 0 , se applicabile. L'errore può essere eliminato con l'interprete Java. Se lo provi online , ignora tutto tranne l'ultima riga di output.

Come funziona

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

Ancora un po 'nuovo a questo codice golf.

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

EDIT: corretto il comportamento errato.
EDIT 2: Grazie @MorganThrapp per aver rasato molti byte.

JavaScript (ES6), 64 59 58 52 byte

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

Questo si basa sull'osservazione che solo l'ultimo tratto della ripetizione (di uno ^o di entrambi v) influenza il risultato.

Grazie a Neil per il golf off 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}

Test per la funzione implementata.

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

Per gli interpreti senza notazione fork (come GNU APL), sarebbe {⍺×⍺≠⍵}/⌽0,2-'^ '⍳⍞(19). Questa è probabilmente la soluzione più noiosa possibile perché funziona direttamente dalla definizione del problema.

Rubino, 41 35 byte

Regex. È interessante solo l'ultimo pulsante premuto, quindi verificane la lunghezza. Quindi confrontalo con "a"(o qualsiasi lettera tra ^e v) per ottenere 1o -1.

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

C # 6, 18 + 80 = 98 byte

Richiede:

using System.Linq;

Funzione reale:

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

Come funziona: il codice rimuove tutto prima dell'ultimo ^^o vv. Tale contenuto non è pertinente perché facendo clic due volte sullo stesso pulsante si annulla sempre il voto. Lo fa dividendo su ^^e vve prendendo l'ultimo elemento. Se questo elemento è una stringa vuota ( .Length<1), la funzione ritorna 0perché tutte le votazioni sono state cancellate. Se la stringa non è vuota, osserva solo l'ultimo carattere della stringa originale: sostituirà tutti i voti precedenti. Se il codice char è inferiore a 95, sarà 94 ^, quindi restituisce 1, altrimenti -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 byte

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

Provalo qui.

Spiegazione

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)

Si noti che non c'è nessun N.alla fine. Questo perché l'ho lasciato avvolgere all'inizio. Quando l'input è vuoto, il conteggio finale viene emesso come numero intero e il programma si arresta.

Pyth, 13 byte

ut+Jq\^H>JGzZ

Mathematica, 60 byte

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

Shape Script , 26 byte

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

Come si sveglia:

"^"$     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, nessun metodo stringa, LINQ eccessivo

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

Merita davvero di essere preceduto da

using System.Linq;

Ha ottenuto l'idea di usare x<95?1:-1, invece di x=='^'?1:-1dalla risposta di ProgramFOX

coincidenze:

• Il tweak che ho rubato fa uso del confronto con 95 - il conteggio dei byte escludendo l'istruzione using, usando detto tweak
• La somma delle cifre del conteggio totale dei byte equivale al numero di cifre del conteggio totale dei byte scritto come numero romano

C: 67 66 byte

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++;
    }
}

Vai, 179 byte

Una soluzione estremamente 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)}

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 byte

40 byte, più 1 per -p

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

/(.)\1*$/;confronta la stringa di input con la regex /(.)\1*$/, cioè vede se termina con un singolo carattere ripetuto un numero ≥1 volte.

In tal caso, $&è l'intera stringa di ripetizione ed $1è il carattere; altrimenti (ovvero la stringa di input è vuota), queste due variabili sono la stringa vuota.

$1=~v?-1:1si confronta $1con regex ve restituisce −1 se corrisponde e 1 altrimenti.

E moltiplica quel ± 1 per (length$&)%2la lunghezza del $&modulo 2.

05AB1E , 14 12 11 byte

Îvy'^QDŠ‹+<

Porta della risposta Gol di @ Sp3000 > <> .

NOTA: @Grimy ha già pubblicato un'alternativa più corta di 8 byte per 05AB1E , quindi assicurati di votarlo!

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

㤮öÓÆ.±

Provalo online!

Soluzioni alternative con la stessa lunghezza: u㤮öÓÆ(, 㤮ögÓÆ(.

CJam, 27 24 byte

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

Provalo online .

Tutto quello che ho preso dalla risposta di Dennis è g(funzione segno).

Ruby, 43

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

9-i/11valuta 1 o -1 quando vengono dati i codici ASCII di ^(94) o v(118)

Nel programma di test:

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

g=gets.chomp
puts f[g]