Schreiben Sie ein Programm oder eine Funktion, die eine Zeichenfolge enthält, die nur die Zeichen ^und enthält v(Sie können davon ausgehen, dass es keine anderen Zeichen gibt). Von links nach rechts gelesen repräsentiert diese Zeichenfolge die Abfolge der Mausklicks, die ein einzelner Benutzer beim erstmaligen Anzeigen einer Stapelaustausch- Frage oder -Antwort ausgeführt hat.

Jedes Symbol steht^ für einen Klick auf die Schaltfläche " Aufwärts" und jedes Symbolv für einen Klick auf die Schaltfläche " Abwärts" . (Arbeitsbeispiele finden Sie leicht links.)

Angenommen, es gelten keine Stimmrechtsbeschränkungen, sodass alle Klicks korrekt registriert werden.
Drucken oder zurücksenden:

• 1oder +1wenn der Beitrag am Ende hochgestuft wird.
• 0wenn der Beitrag nicht abgestimmt wird. ( -0und +0sind nicht gültig)
• -1 wenn der Beitrag abgelehnt wird.

Beiträge beginnen mit null Netto-Stimmen des Benutzers und die Schaltflächen ändern die Netto-Stimmen wie folgt:

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

Der kürzeste Code in Bytes gewinnt.

Testfälle:

[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

Probieren Sie es online aus . Auch wenn dies im nächsten Update gut funktionieren wird, habe ich es für alle Fälle als 0.3.11 aufgelistet.

Erläuterung

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

Beachten Sie, dass bei der ersten Verwendung von @eine 0 aus dem unteren Bereich des Stapels gezogen wird, um die Stimmenzahl für die erste Iteration zu initialisieren

Zur Veranschaulichung mit einer vollständigen Tabelle:

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

x86-Maschinencode, 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

Dies ist eine Funktion, die die Fastcall-Aufrufkonvention verwendet, die eine Zeichenfolge verwendet und eine 8-Bit-Ganzzahl zurückgibt.

Ich habe es mit dem folgenden C-Programm getestet, das für den 32-Bit-Modus kompiliert werden muss.

#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

^{Durchgestrichen 44 ist immer noch regulär 44 :(}

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

Hält eine laufende Summe in s. Mit der for ofSchleife wird jedes Zeichen in der Zeichenfolge durchlaufen und sbasierend auf dem aktuellen Zeichen und dem vorherigen Wert aktualisiert .

Bearbeitungen: Golf ~s&&-1zu !~s-1. Dieser Ausdruck muss 0 sein, wenn er s-1 ist, andernfalls -1. 6 Bytes dank @nderscore gespart.

So funktioniert der Ausdruck:

 ~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

Aktualisierte Version mit signifikanten Verbesserungen von Dennis:

0'jqf{-g_@=!*}

Probieren Sie es online aus

Erläuterung:

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 Zeichen und 3 neue Zeilen.

Auf diesem Interpreter getestet .

Das jist äquidistant von ^und vin Ascii, so dass es letztendlich verwendet wird, um arithmetische Umrechnungen durchzuführen, anstatt platzraubende Bedingungen.

Brainfuck, 146 Bytes

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

Dieses Programm nimmt jedes Byte der Eingabe und vergleicht es mit dem letzten. Wenn sie identisch sind, wird die Eingabe verworfen und "0" als "vorherige Eingabe" gespeichert, andernfalls wird sie normal gespeichert.

Wenn das Endergebnis lautet v, wird gedruckt -. Wenn das Endergebnis nicht Null war, wird 1 zu einer leeren Zelle hinzugefügt. Schließlich wird 48 zu dieser Zelle hinzugefügt und gedruckt.

Javascript ES6, 91 48 Zeichen

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

Erklärung: undefinedendet mit d.

Prüfung:

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

Antwortverlauf:

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)

Durchläuft die Update-Funktion

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

Das nimmt die aktuelle Stimmenzahl xund das neue Zeichen cund gibt die neue Stimmenzahl aus.

Die Idee ist, die cmpFunktion von Python 2 zu verwenden, die die beiden Argumente vergleicht und -1, 0, 1für das <, ==, >jeweilige Element gibt . Das Innere cmp('u',c)gibt -1für vund 1für ^; jedes Zeichen zwischen ihnen genügt für 'u'. Das Äußere vergleicht dann das mit x, was cmp(1,x)für ^und cmp(-1,x)für gibt v, welche die richtigen Werte haben.

Die direkte Iteration war 3 Zeichen länger (52), wäre jedoch ein Zeichen kürzer (48), wenn die Eingabe input()mit Anführungszeichen zulässig wäre.

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

Die beste rekursive Funktion, die ich gefunden habe, war ein Zeichen länger (50)

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

Prolog, 159 152 Bytes

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

Testen Sie es selbst:
Online-Dolmetscher hier

Beispiel

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

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

Bearbeiten: 7 Bytes durch Vereinheitlichen von r-Klauseln mit OR gespeichert.

CJam, 16 Bytes

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

Dies stürzt nach dem Drucken von 0 ggf. ab. Der Fehler kann mit dem Java-Interpreter unterdrückt werden. Wenn Sie dies online versuchen , ignorieren Sie alles außer der letzten Ausgabezeile.

Wie es funktioniert

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

Noch ein bisschen neu in dieser Code-Golf-Sache.

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

BEARBEITEN: Das falsche Verhalten wurde behoben. BEARBEITEN
2: Vielen Dank an @MorganThrapp, dass Sie viele Bytes gespart haben.

JavaScript (ES6), 64 59 58 52 Byte

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

Dies basiert auf der Beobachtung, dass nur der letzte Abschnitt der Wiederholung (von entweder ^oder v) das Ergebnis beeinflusst.

Vielen Dank an Neil für die 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}

Test auf implementierte Funktion.

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

Für Interpreter ohne Fork-Notation (wie GNU APL) wäre es {⍺×⍺≠⍵}/⌽0,2-'^ '⍳⍞(19). Dies ist wahrscheinlich die langweiligste mögliche Lösung, da sie direkt aus der Definition des Problems hervorgeht.

Ruby, 41-35 Bytes

Regex. Nur der zuletzt gedrückte Knopf ist interessant, prüfen Sie also die Lauflänge. Vergleichen Sie es dann mit "a"(oder einem Buchstaben zwischen ^und v), um 1oder zu erhalten -1.

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

C # 6, 18 + 80 = 98 Bytes

Benötigt:

using System.Linq;

Tatsächliche Funktion:

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

So funktioniert es: Der Code entfernt zuerst alles vor dem letzten ^^oder vv. Dieser Inhalt ist nicht relevant, da ein zweimaliger Klick auf denselben Button Ihre Abstimmung immer storniert. Es tut dies durch die Spaltung auf ^^und vvund das letzte Element nehmen. Wenn dieses Element eine leere Zeichenfolge ( .Length<1) ist, wird die Funktion zurückgegeben, 0da alle Abstimmungen abgebrochen wurden. Wenn die Zeichenfolge nicht leer ist, wird nur das letzte Zeichen der ursprünglichen Zeichenfolge angezeigt: Alle vorherigen Stimmen werden überschrieben. Wenn der Zeichencode kleiner als 95 ist, dann wird es 94 sein ^, so gibt es 1, anders -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=,*!

Probieren Sie es hier aus.

Erläuterung

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)

Beachten Sie, dass es N.am Ende keine gibt . Das liegt daran, dass ich es am Anfang herumlaufen lassen habe. Wenn die Eingabe leer ist, wird die endgültige Zählung als Ganzzahl ausgegeben und das Programm angehalten.

Pyth, 13 Bytes

ut+Jq\^H>JGzZ

Mathematica, 60 Bytes

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

Formskript , 26 Byte

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

Wie es funktioniert:

"^"$     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, keine Zeichenfolgemethoden, übermäßige 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;

Wirklich verdient, vorausgegangen zu werden

using System.Linq;

Ich hatte die Idee, x<95?1:-1anstelle x=='^'?1:-1von ProgramFOX die Antwort zu verwenden

Zufälle:

• Der von mir gestohlene Tweak nutzt den Vergleich mit 95 - die Anzahl der Bytes ohne die using-Anweisung, die diesen Tweak verwendet
• Die Summe der Ziffern der Gesamtanzahl der Bytes entspricht der Anzahl der Ziffern der Gesamtanzahl der Bytes, die als römische Zahl geschrieben wurden

C: 67 66 Bytes

Golf gespielt:

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

Los, 179 Bytes

Eine extrem naive Lösung.

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 plus 1 für -p

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

/(.)\1*$/;vergleicht den eingegebenen String mit dem regulären Ausdruck /(.)\1*$/, dh prüft, ob er mit einem einzelnen Zeichen endet, das einige Male ≥ 1 wiederholt wird.

Wenn ja, $&ist dies die gesamte Wiederholungszeichenfolge und $1das Zeichen. Andernfalls (dh die Eingabezeichenfolge ist leer) sind diese beiden Variablen die leere Zeichenfolge.

$1=~v?-1:1vergleicht $1mit dem regulären Ausdruck vund gibt -1 zurück, wenn er übereinstimmt, und 1, wenn er nicht übereinstimmt.

Und multiplizieren Sie diese ± 1 mit (length$&)%2der Länge von $&Modulo 2.

05AB1E , 14 12 11 Bytes

Îvy'^QDŠ‹+<

Port von @ Sp3000 's Gol> <> Antwort .

HINWEIS : @Grimy hat bereits eine kürzere 8-Byte-Alternative für 05AB1E veröffentlicht. Stellen Sie also sicher, dass Sie ihn unterstützen!

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

㤮öÓÆ.±

Probieren Sie es online!

Alternative Lösungen mit der gleichen Länge: u㤮öÓÆ(, 㤮ögÓÆ(.

CJam, 27 24 Bytes

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

Probieren Sie es online .

Alles, was ich Dennis 'Antwort entnommen habe, ist g(Vorzeichenfunktion).

Rubin, 43

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

9-i/11wird mit den ASCII-Codes ^(94) oder v(118) zu 1 oder -1 bewertet

Im Testprogramm:

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

g=gets.chomp
puts f[g]