Ecrivez un programme ou une fonction qui prend une chaîne contenant uniquement les caractères ^et v(vous pouvez supposer qu'il n'y aura pas d'autres caractères). Lisez de gauche à droite cette chaîne représente la séquence de clics de souris effectués par un seul utilisateur lors de la consultation d'une question ou d'une réponse Stack Exchange pour la première fois.

Chaque ^représente un clic de upvote bouton et tous vreprésente un clic de downvote bouton. (Pour des exemples de travail, regardez légèrement à gauche.)

Supposons qu'aucune limitation de vote ne soit en vigueur, de sorte que tous les clics sont correctement enregistrés.
Imprimer ou retourner:

• 1ou +1si le poste finit par être voté.
• 0si le poste finit par ne pas être voté. ( -0et +0ne sont pas valides)
• -1 si le poste finit par être voté.

Les messages commencent par zéro vote net de l'utilisateur et les boutons permettent de modifier les votes nets comme suit:

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

Le code le plus court en octets gagne.

Cas de 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 octets

iEh`^=:@)+M

Essayez-le en ligne . Même si cela fonctionnera correctement dans la prochaine mise à jour, je l’ai répertorié comme 0.3.11 au cas où.

Explication

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

Notez que la première utilisation de @tire un 0 du bas de la pile pour initialiser le nombre de votes pour la première itération

Pour illustrer avec un tableau complet:

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

code machine x86, 24 octets

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

Il s'agit d'une fonction utilisant la convention d'appel fastcall, qui prend une chaîne et renvoie un entier de 8 bits.

Je l'ai testé avec le programme C suivant, qui doit être compilé pour le mode 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 octets

^{44 barré est encore régulier 44 :(}

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

Garde un total cumulé en s. Utilise for ofloop pour parcourir chaque caractère de la chaîne et se met à jour en sfonction du caractère actuel et de la valeur précédente.

Edits: Golfé ~s&&-1à !~s-1. Cette expression doit être égale à 0 si ségal à -1 et -1 sinon. Sauvegardé 6 octets grâce à @nderscore.

Comment fonctionne l'expression:

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

Version mise à jour avec des améliorations significatives apportées par Dennis:

0'jqf{-g_@=!*}

Essayez-le en ligne

Explication:

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 octets

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

52 caractères et 3 nouvelles lignes.

Testé sur cet interprète .

Il jest équidistant de ^et ven ascii, il est donc utilisé à la fin pour effectuer des conversions arithmétiques, plutôt que des conditionnelles prenant beaucoup de place.

brainfuck, 146 octets

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

Ce programme prend chaque octet d'entrée et le compare au dernier. S'ils sont identiques, il supprime l'entrée et stocke "0" comme "entrée précédente", sinon il la sauvegarde normalement.

Si le résultat final est v, il est imprimé -. Si le résultat final était différent de zéro, 1 est ajouté à une cellule vide. Enfin, 48 sont ajoutés à cette cellule et celle-ci est imprimée.

Javascript ES6, 91 48 caractères

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

Explication: undefinedse termine par d.

Tester:

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

Réponse historique:

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)

Itère avec la fonction de mise à jour

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

cela prend le nombre actuel de votes xet le nouveau personnage cet génère le nouveau nombre de votes.

L'idée est d'utiliser la cmpfonction de Python 2 , qui compare ses deux arguments et donne -1, 0, 1pour <, ==, >respectivement. L'intérieur cmp('u',c)donne -1pour vet 1pour ^; n'importe quel caractère entre eux suffit pour 'u'. L'extérieur compare ensuite cela à x, qui donne cmp(1,x)pour ^et cmp(-1,x)pour v, qui ont les bonnes valeurs.

L'itération directe était plus longue de 3 caractères (52), mais aurait un caractère trop court (48) si l'utilisation input()de guillemets était autorisée.

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

La meilleure fonction récursive que j'ai trouvée était un caractère plus long (50)

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

Prolog, 159 152 octets

Code:

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

Testez-le vous-même:
Interprète en ligne ici

Exemple

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

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

Edit: 7 octets enregistrés en unifiant les clauses r avec OR.

CJam, 16 octets

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

Cela plantera après avoir imprimé 0 , le cas échéant. L'erreur peut être supprimée avec l'interpréteur Java. Si vous essayez ceci en ligne , ignorez tout sauf la dernière ligne de sortie.

Comment ça fonctionne

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 octets

Encore un peu nouveau dans cette affaire de golf de code.

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

EDIT: Correction du comportement incorrect.
EDIT 2: Merci @MorganThrapp pour avoir réduit le nombre d'octets.

JavaScript (ES6), 64 59 58 52 octets

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

Ceci est basé sur l'observation que seule la dernière partie de la répétition (de l'un ^ou de l'autre v) affecte le résultat.

Merci à Neil d' avoir joué 6 octets au golf.

Haskell, 40 octets

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

Scala, 75 octets

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

Test de la fonction implémentée.

  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 ans

(⊣×≠)/⌽0,2-'^ '⍳⍞

Pour les interprètes sans notation fork (comme GNU APL), ce serait {⍺×⍺≠⍵}/⌽0,2-'^ '⍳⍞(19). C’est probablement la solution la plus ennuyeuse car elle découle directement de la définition du problème.

Ruby, 41 35 octets

Regex. Seul le dernier bouton enfoncé est intéressant, alors vérifiez la durée de cette opération. Puis comparez-le à "a"(ou à toute lettre entre ^et v) pour obtenir 1ou -1.

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

C # 6, 18 + 80 = 98 octets

A besoin:

using System.Linq;

Fonction réelle:

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

Comment ça marche: le code supprime tout avant le dernier ^^ou vv. Ce contenu n'est pas pertinent car cliquer deux fois sur le même bouton annulera toujours votre vote. Elle le fait en divisant le ^^et vvet en prenant le dernier élément. Si cet élément est une chaîne vide ( .Length<1), la fonction retourne 0car tous les votes ont été annulés. Si la chaîne n'est pas vide, il se contente de regarder le dernier caractère de la chaîne d'origine: il remplacera tous les votes précédents. Si le code de caractère est inférieur à 95, il sera alors 94 ^, ainsi, il retourne 1sinon -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 octets

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

Essayez ici.

Explication

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)

Notez qu'il n'y a pas N.à la fin. C'est parce que je l'ai laissé au début. Lorsque l'entrée est vide, le décompte final est généré sous forme d'entier et le programme s'arrête.

Pyth, 13 octets

ut+Jq\^H>JGzZ

Mathematica, 60 octets

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

Script de forme , 26 octets

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

Comment ça se passe:

"^"$     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 octets, aucune méthode de chaîne, LINQ excessif

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

Mérite vraiment d'être précédé de

using System.Linq;

Vous avez eu l'idée d'utiliser la réponse de ProgramFOXx<95?1:-1 au lieu dex=='^'?1:-1

Coïncidences:

• Le tweak que j’ai volé se sert de la comparaison à 95 - le nombre d’octets excluant la déclaration using, en utilisant ledit tweak
• La somme des chiffres du nombre total d'octets est égale au nombre de chiffres du nombre total d'octets écrit en chiffres romains.

C: 67 66 octets

joué au golf:

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

Go, 179 octets

Une solution extrêmement naïve.

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 octets

40 octets, plus 1 pour -p

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

/(.)\1*$/;compare la chaîne d'entrée à l'expression régulière /(.)\1*$/, c'est-à-dire qu'elle se termine par un seul caractère répété un nombre ≥1 fois.

Si c'est le cas, $&est la chaîne de répétition entière et $1est le caractère; sinon (c’est-à-dire que la chaîne en entrée est vide), ces deux variables sont la chaîne vide.

$1=~v?-1:1se compare $1à l'expression régulière vet renvoie -1 si elle correspond et 1 sinon.

Et multipliez ce ± 1 par (length$&)%2la longueur de $&modulo 2.

05AB1E , 14 12 11 octets

Îvy'^QDŠ‹+<

Port de @ Sp3000 's Gol> <> répondre .

NOTE: @Grimy a déjà posté une alternative plus courte de 8 octets pour 05AB1E , assurez-vous donc de lui donner son vote!

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

㤮öÓÆ.±

Essayez-le en ligne!

Solutions alternatives avec la même longueur: u㤮öÓÆ(, 㤮ögÓÆ(.

CJam, 27 24 octets

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

Essayez-le en ligne .

Tout ce que j'ai retenu de la réponse de Dennis est g(fonction de signe).

Ruby, 43 ans

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

9-i/11évalue à 1 ou -1 lorsque les codes ascii de ^(94) ou v(118) sont spécifiés

Dans le programme de test:

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

g=gets.chomp
puts f[g]