문자열 문자 만 포함 취하는 프로그램이나 기능을 작성 ^하고 v(당신이 다른 문자가 없을 것으로 가정 할 수 있습니다). 이 문자열을 왼쪽에서 오른쪽으로 읽으면 Stack Exchange 질문 또는 답변을 처음 보는 동안 단일 사용자가 마우스 클릭을 한 순서를 나타냅니다 .

모든이 ^의 클릭 대표 upvote에 버튼을 모든이 v의 클릭 나타냅니다 downvote의 버튼을 누릅니다. (작업 예제의 경우 약간 왼쪽을보십시오.)

투표 제한 이 적용되지 않아 모든 클릭이 올바르게 등록 되었다고 가정 합니다.
인쇄 또는 반품 :

• 1또는 +1게시물이 업 보팅 된 경우
• 0게시물이 투표되지 않는 경우. ( -0그리고 +0유효하지 않습니다)
• -1 게시물이 다운 보팅 된 경우

게시물은 사용자의 순 투표로 시작하며 버튼은 다음과 같이 순 투표를 변경합니다.

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

바이트 단위의 가장 짧은 코드가 이깁니다.

테스트 사례 :

[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 바이트

iEh`^=:@)+M

온라인으로 사용해보십시오 . 다음 업데이트에서는 제대로 작동하지만, 만일을 위해 0.3.11로 나열했습니다.

설명

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

첫 번째 사용은 @스택의 맨 아래에서 0 을 가져와 첫 번째 반복에 대한 투표 수를 초기화합니다.

전체 테이블로 설명하려면 다음을 수행하십시오.

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 기계 코드, 24 바이트

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

문자열을 가져와 8 비트 정수를 반환하는 fastcall 호출 규칙을 사용하는 함수입니다.

32 비트 모드로 컴파일 해야하는 다음 C 프로그램으로 테스트했습니다.

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

자바 스크립트 (ES7), 47 46 44 43 37 36 바이트

^{44를 넘어서도 여전히 규칙적인 44입니다 :(}

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

에 누적 합계를 유지합니다 s. 사용 for of문자열 및 업데이트의 각 문자를 반복하는 루프를 s현재 문자와 이전의 값을 기반으로.

편집 :로 골프 ~s&&-1를 쳤다 !~s-1. 이 표현식은 s-1과 같으면 0 이어야하고, 그렇지 않으면 -1이어야합니다. @nderscore 덕분에 6 바이트를 절약했습니다.

표현의 작동 방식 :

 ~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 바이트

Dennis가 크게 개선 한 업데이트 된 버전 :

0'jqf{-g_@=!*}

온라인으로 사용해보십시오

설명:

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 바이트

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

52 자 및 3 줄

이 인터프리터 에서 테스트되었습니다 .

은 j에서 같은 거리 ^와 v오히려 공간이 소요되는 조건문보다, 결국 산술 변환을 위해 사용되는, 그래서 아스키있다.

brainfuck, 146 바이트

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

이 프로그램은 각 바이트의 입력을 받아 마지막 바이트와 비교합니다. 동일하면 입력을 버리고 "0"을 "이전 입력"으로 저장하고, 그렇지 않으면 정상적으로 저장합니다.

최종 결과 v인 경우 인쇄 -됩니다. 최종 결과가 0이 아닌 경우 빈 셀에 1이 추가됩니다. 마지막으로 48이 해당 셀에 추가되고 인쇄됩니다.

자바 스크립트 ES6, 91 48 자

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

설명 :로 undefined끝납니다 d.

테스트:

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

답변 내역 :

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

파이썬 2, 49

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

업데이트 기능을 통해 반복

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

현재 투표 수 x와 새 캐릭터 를 가져 와서 c새 투표 수를 출력합니다.

아이디어는 파이썬 2의 사용하는 cmp두 개의 인수를 비교 제공 기능 -1, 0, 1을 위해 <, ==, >각각을. 내부 한 cmp('u',c)제공 -1을 위해 v그리고 1위해 ^; 그들 사이의 모든 문자는 충분합니다 'u'. 그런 다음 바깥 쪽은 그것을 올바른 값을 가진 for 와 for에 x제공하는 것과 비교 합니다.cmp(1,x)^cmp(-1,x)v

직접 반복은 3 자 이상 (52)이지만 input()따옴표로 묶는 것이 허용 되면 1 자 (48)가됩니다 .

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

내가 찾은 최고의 재귀 함수는 1 문자 더 길었습니다 (50)

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

프롤로그, 159 152 바이트

암호:

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

스스로를 테스트 :
온라인 통역 여기

예

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

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

편집 : OR로 r 절을 통합하여 7 바이트를 절약했습니다.

CJam, 16 바이트

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

해당되는 경우 0 을 인쇄 한 후 충돌 이 발생 합니다. Java 인터프리터로 오류를 억제 할 수 있습니다. 이 경우 이 온라인을 시도 , 출력의 마지막 줄하지만, 모든 것을 무시합니다.

작동 원리

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.

파이썬 2, 177 159 72 바이트

이 코드 골프에 익숙하지 않습니다.

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

편집 : 잘못된 동작을 수정했습니다.
편집 2 : 많은 바이트를 면도 해 주셔서 감사합니다 @MorganThrapp.

자바 스크립트 (ES6), 64 59 58 52 바이트

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

이것은 ( ^또는의 v) 반복의 마지막 스트레치 만이 결과에 영향을 미친다는 관찰에 근거합니다 .

6 바이트를 골라 낸 Neil 에게 감사 합니다.

하스켈, 40 바이트

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

스칼라, 75 바이트

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

구현 된 기능을 테스트하십시오.

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

GNU APL과 같은 포크 표기법이없는 통역사는 {⍺×⍺≠⍵}/⌽0,2-'^ '⍳⍞(19)입니다. 이것은 문제의 정의에서 직접 작동하기 때문에 아마도 가장 지루한 해결책 일 것입니다.

루비, 41 35 바이트

정규식. 마지막으로 누른 버튼 만 흥미 롭기 때문에 실행 길이를 확인하십시오. 그런 다음에 비교 "a"(또는 사이에 편지 ^와 v) 얻을 1또는 -1.

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

C # 6, 18 + 80 = 98 바이트

요구 사항 :

using System.Linq;

실제 기능 :

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

작동 방식 : 코드는 먼저 ^^또는 이전의 모든 것을 제거합니다 vv. 동일한 버튼을 두 번 클릭하면 항상 투표가 취소되므로 해당 내용은 관련이 없습니다. 그것은에 분할하여이 작업을 수행 ^^하고 vv마지막 항목을 복용. 이 항목이 빈 문자열 ( .Length<1)이면 0모든 투표가 취소되어 함수가 반환 됩니다. 문자열이 비어 있지 않으면 원래 문자열의 마지막 문자 만 확인합니다. 이전의 모든 투표를 무시합니다. 문자 코드가 95보다 작 으면 94 ^가되고 1, 그렇지 않으면를 반환합니다 -1.

파이썬 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 바이트

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

여기에서 시도하십시오.

설명

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.끝에는 없습니다 . 처음부터 마무리하기 때문입니다. 입력이 비어 있으면 최종 탈리가 정수로 출력되고 프로그램이 중지됩니다.

Pyth, 13 바이트

ut+Jq\^H>JGzZ

Mathematica, 60 바이트

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

모양 스크립트 , 26 바이트

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

깨우는 방법 :

"^"$     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 바이트, 스트링 방법 과도한 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;

참으로 앞에 올 가치가있다

using System.Linq;

사용하는 아이디어를 얻었다 x<95?1:-1대신 x=='^'?1:-1에서 ProgramFOX의 답변을

우연의 일치 :

• 내가 훔친 조정은 95를 비교하는 것을 사용합니다. – using 문을 제외한 바이트 수는 상기 조정을 사용합니다.
• 총 바이트 수의 자릿수는 로마 숫자로 작성된 총 바이트 수의 자릿수와 같습니다.

씨: 67 66 바이트

골프 :

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

언 골프 :

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

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

이동, 179 바이트

매우 순진 솔루션입니다.

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

언 골프 드 :

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

펄 5, 41 바이트

40 바이트 + 1 -p

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

/(.)\1*$/;입력 문자열을 정규식과 비교합니다 /(.)\1*$/. 즉, 문자가 ≥1 번 반복되는 단일 문자로 끝나는 지 확인합니다.

그렇다면 $&전체 반복 문자열이며 $1문자입니다. 그렇지 않으면 (즉, 입력 문자열이 비어있는 경우)이 두 변수는 빈 문자열입니다.

$1=~v?-1:1$1정규식 v과 비교 하여 일치하면 -1을, 그렇지 않으면 1을 반환합니다.

그리고 모듈러스 2 (length$&)%2의 길이에 ± 1을 곱합니다 $&.

05AB1E , 14 12 11 바이트

Îvy'^QDŠ‹+<

@ Sp3000 의 Gol> <> 답변 포트 .

참고 : @Grimy는 이미 05AB1E 에 대한 짧은 8 바이트 대안을 게시 했으므로 그를 찬성 해야합니다!

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

Î            # 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 바이트

㤮öÓÆ.±

온라인으로 사용해보십시오!

길이가 같은 대체 솔루션 : u㤮öÓÆ(, 㤮ögÓÆ(.

CJam, 27 24 바이트

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

온라인으로 사용해보십시오 .

Dennis의 답변에서 얻은 것은 g(sign function)입니다.

루비, 43

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

9-i/11^(94) 또는 v(118) 의 ASCII 코드가 주어지면 1 또는 -1로 평가

테스트 프로그램에서 :

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

g=gets.chomp
puts f[g]