Yalnızca karakterleri içeren bir dizgede geçen bir program veya işlev yazın ^ve v(başka karakter olmayacağını varsayabilirsiniz). Soldan sağa okuma, bu dizenin bir Stack Exchange sorusunu veya cevabını ilk kez görüntülerken yapılan tek bir kullanıcının fare tıklaması sırasını temsil eder .

Her ^biri, yükseltme düğmesine vbir tıklamayı ve her biri, indirme düğmesine bir tıklamayı temsil eder . (Çalışma örnekleri için biraz sola bakın.)

Hiçbir oylama sınırlamasının geçerli olmadığını ve tüm tıklamaların doğru şekilde kaydedildiğini varsayalım .
Yazdır veya geri gönder:

• 1veya +1gönderinin sona erdirilmesi sona ererse.
• 0Gönderi sona ererse oy verilmez. ( -0ve +0geçerli değil)
• -1 Gönderi indirilmezse sona erer.

Gönderiler kullanıcıdan sıfır net oy ile başlar ve düğmeler net oylarını aşağıdaki gibi değiştirir:

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

Bayt cinsinden en kısa kod kazanır.

Test durumları:

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

iEh`^=:@)+M

Çevrimiçi deneyin . Bu bir sonraki güncellemede iyi çalışacak olsa da, sadece durumda 0.3.11 olarak listeledik.

açıklama

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

@İlk yinelemenin oylama sayısını ilklendirmek için ilk kullanımın yığının altından 0 aldığını unutmayın.

Dolu bir tabloyla göstermek için:

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 makine kodu, 24 bayt

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

Bu, bir dize alan ve 8 bitlik bir tamsayı döndüren hızlı arama çağrısı kuralını kullanan bir işlevdir.

32-bit modu için derlenmesi gereken aşağıdaki C programı ile test ettim.

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

^{44 çarpı hala normal 44 :(}

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

Toplam çalışan tutar s. for ofDizedeki her karakterin üzerinde yineleme yapmak için döngü kullanır ve sgeçerli karaktere ve önceki değere dayalı güncellemeler yapar .

Düzenlemeler: golfed ~s&&-1için !~s-1. sAksi durumda -1 ve -1 ise , bu ifade 0'a eşit olmalıdır. @Nderscore sayesinde 6 byte kurtarıldı.

İfade nasıl çalışır:

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

Dennis'in katkıda bulunduğu önemli iyileştirmeler içeren güncellenmiş sürüm:

0'jqf{-g_@=!*}

Çevrimiçi deneyin

Açıklama:

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 bayt

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

52 karakter ve 3 yeni satır.

Bu tercüman üzerinde test edilmiştir .

jEşit mesafede ^ve voldukça uzay tüketen Koşullamalar daha, sonunda aritmetik dönüşümleri yapmak için kullanılan böylece ASCII içinde.

brainfuck, 146 bayt

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

Bu program girişin her baytını alır ve sonuncusuyla karşılaştırır. Aynılarsa, girişi atar ve "0" ı "önceki giriş" olarak saklar, aksi takdirde normal şekilde kaydeder.

Son sonuç ise v, yazdırır -. Nihai sonuç sıfır değilse, boş bir hücreye 1 eklenir. Son olarak, bu hücreye 48 eklenir ve yazdırılır.

Javascript ES6, 91 48 karakter

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

Açıklama: ile undefinedbitiyor d.

Ölçek:

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

Cevap geçmişi:

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)

Güncelleme işleviyle yinelenir

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

Bu, mevcut oy sayımını xve yeni karakteri alır cve yeni oy sayımını çıkarır.

Fikir Python 2'nin kullanmaktır cmponun iki bağımsız değişken karşılaştırır ve verir işlevini -1, 0, 1için <, ==, >sırasıyla. İçteki cmp('u',c)verir -1için vve 1için ^; Aralarındaki herhangi bir karakter için yeterli 'u'. Dış biri daha sonra bu karşılaştırır xveren cmp(1,x)için ^ve cmp(-1,x)için vdoğru değerlere sahip olan.

Doğrudan yineleme 3 karakter uzunluğundaydı (52), ancak input()alıntılarla birlikte alınmasına izin verilirse kısa bir karakter olur (48) .

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

Bulduğum en iyi özyinelemeli işlev bir karakter daha uzun (50) oldu

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

Prolog, 159 152 bayt

Kod:

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

Kendiniz test edin:
Çevrimiçi Tercüman burada

Örnek

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

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

Düzenleme: r yan tümcelerini OR ile birleştirerek 7 bayt kurtardı.

CJam, 16 bayt

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

Bu olacak yazdırmadan sonra çökmesine 0 varsa,. Java tercümanı ile hata bastırılabilir. Bunu çevrimiçi olarak denerseniz , son çıktı satırından başka her şeyi yoksayın.

Nasıl çalışır

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 bayt

Hala bu kod golf şeyinde yeni.

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

EDIT: Yanlış davranış düzeltildi.
2 EDIT: Çok fazla bayt tıraş için teşekkürler @ MorganThrapp.

JavaScript (ES6), 64 59 58 52 bayt

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

Bu, sadece tekrarın son uzantısının (ya ^da birinin v) sonucunu etkilediği gözlemine dayanır .

6 baytlık golf oynadığı için Neil'e teşekkürler .

Haskell, 40 bayt

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

Scala, 75 bayt

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

Uygulanan işlev için test edin.

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

Çatal notasyonu olmayan tercümanlar için (GNU APL gibi), olacaktır {⍺×⍺≠⍵}/⌽0,2-'^ '⍳⍞(19). Bu muhtemelen olası çözümlerin en sıkıcı nedenidir çünkü doğrudan sorunun tanımından çalışır.

Ruby, 41 35 bayt

Regex. Sadece basılan son tuş ilginçtir, bu yüzden bunun çalışma uzunluğunu kontrol edin. Sonra karşılaştırmak "a"(ya da bunların arasında herhangi bir harf ^ve v) almak 1veya -1.

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

C # 6, 18 + 80 = 98 bayt

gerektirir:

using System.Linq;

Gerçek işlev:

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

Nasıl çalışır: Kod önce ^^veya sondan önce her şeyi kaldırır vv. Bu içerik alakalı değildir çünkü aynı düğmeye iki kez tıklamak oyunuzu her zaman iptal eder. Bunu bölerek bölerek ^^ve vvson maddeyi alarak yapar. Bu öğe boş bir dize ( .Length<1) ise, 0tüm oylamalar iptal edildiğinden işlev döner . Dize boş değilse, yalnızca orijinal dizenin son karakterine bakar: önceki tüm oyları geçersiz kılar. Karakter kodu 95'ten küçükse, 94 olacaktır ^, bu nedenle 1aksi takdirde döner -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 bayt

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

Burada dene.

açıklama

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)

N.Sonunda hiç olmadığını unutmayın . Çünkü onun baştan sarılmasına izin verdim. Giriş boş olduğunda, son taksit tamsayı olarak çıkar ve program durur.

Pyth, 13 bayt

ut+Jq\^H>JGzZ

Mathematica, 60 bayt

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

Şekil Komut Dosyası , 26 bayt

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

Nasıl woks:

"^"$     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 bayt, string yöntemi yok, aşırı 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;

Gerçekten önce gelen hak ediyor

using System.Linq;

Kullanma fikri var x<95?1:-1yerine x=='^'?1:-1gelen ProgramFOX cevabı

Tesadüfler:

• Çaldığım çimdik 95 ile karşılaştırmayı kullanıyor - bahsedilen ifadeyi kullanarak use ifadesi hariç bayt sayısı
• Toplam bayt sayısının hane toplamı, romen rakamı olarak yazılan toplam bayt sayısının hane sayısına eşittir.

C: 67 66 Bayt

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

179 bay

Son derece saf bir çözüm.

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 bayt

40 bayt, artı 1 -p

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

/(.)\1*$/;giriş dizesini regex ile karşılaştırır /(.)\1*$/, yani bir kaç kez tekrarlanan tek bir karakterle bitip bitmediğini görür.

Eğer öyleyse, $&tüm tekrar dizesi ve $1karakter; Aksi halde (yani giriş dizesi boş), bu iki değişken boş dizgedir.

$1=~v?-1:1$1regex vile karşılaştırır ve eşleşirse −1, aksi takdirde 1 döndürür.

Ve bunu ± 1 (length$&)%2ile $&modulo 2'nin uzunluğu ile çarpın .

05AB1E , 14 12 11 bayt

Îvy'^QDŠ‹+<

Port SP3000 @ 'ın Gol> <> cevap .

NOT: @Grimy, 05AB1E için daha kısa bir 8 bayt alternatif gönderdi , bu yüzden onu oyladığınızdan emin olun!

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

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

㤮öÓÆ.±

Çevrimiçi deneyin!

Aynı uzunluktaki alternatif çözümler: u㤮öÓÆ(, 㤮ögÓÆ(.

CJam, 27 24 bayt

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

Çevrimiçi deneyin .

Dennis'in cevabından tek aldığım şey g(işaret işlevi).

Ruby, 43

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

9-i/11^(94) veya v(118) ' in ascii kodları verildiğinde, 1 veya -1 olarak değerlendirilir.

Test programında:

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

g=gets.chomp
puts f[g]