Напишите программу или функцию, которая принимает строку, содержащую только символы ^и 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

Эта функция использует соглашение о вызовах fastcall, которое принимает строку и возвращает 8-разрядное целое число.

Я проверил это с помощью следующей программы на C, которая должна быть скомпилирована для 32-битного режима.

#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 байт

^{Вычеркнул 44, все еще регулярно 44 :(}

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

Сохраняет промежуточную сумму в s. Использует for ofцикл для перебора каждого символа в строке и обновления sна основе текущего символа и предыдущего значения.

Редактирует: Гольф ~s&&-1для !~s-1. Это выражение должно быть равно 0, если sравно -1 и -1 в противном случае. Сохранено 6 байт благодаря @nderscore.

Как работает выражение:

 ~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 байтов

Обновленная версия со значительными улучшениями, внесенными Денисом:

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в ascii, поэтому оно используется для выполнения арифметических преобразований в конце, а не занимающих много места условных выражений.

мозговой трах, 146 байт

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

Эта программа берет каждый байт ввода и сравнивает его с последним. Если они одинаковые, он выбрасывает ввод и сохраняет «0» как «предыдущий ввод», в противном случае он сохраняет его как обычно.

Если конечный результат есть v, он печатает -. Если конечный результат был ненулевым, 1 добавляется в пустую ячейку. Наконец, 48 добавляется к этой ячейке, и она печатается.

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

Python 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и выводит новый подсчет голосов.

Идея состоит в том, чтобы использовать cmpфункцию Python 2 , которая сравнивает два аргумента и дает -1, 0, 1для <, ==, >соответственно. Внутренний cmp('u',c)дает -1для vи 1для ^; любой символ между ними достаточно для 'u'. Внешний один сравнивает , что x, что дает cmp(1,x)для ^и cmp(-1,x)для v, которые имеют правильные значения.

Прямая итерация была на 3 символа длиннее (52), хотя была бы на 1 символ короткой (48), если input()было разрешено брать с кавычками.

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

Лучшая рекурсивная функция, которую я нашел, была на один символ длиннее (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

Изменить: 7 байтов сохранены путем объединения r-предложений с ИЛИ.

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.

Python 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 за сбрить много байтов.

JavaScript (ES6), 64 59 58 52 байта

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

Это основано на наблюдении, что только последний отрезок повторения (или ^или v) влияет на результат.

Спасибо Нейлу за игру в гольф с 6 байтами.

Haskell, 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 байт

Regex. Интересна только последняя нажатая кнопка, поэтому проверьте длину пробега. Затем сравните его с "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.

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]

Минколанг 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, используя указанный твик
• Сумма цифр общего количества байтов равна количеству цифр общего количества байтов, записанных в виде римской цифры

C: 67 66 байт

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

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

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 байт

40 байт, плюс 1 для -p

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

/(.)\1*$/;сравнивает входную строку с регулярным выражением /(.)\1*$/, т.е. видит, заканчивается ли она одним символом, повторяемым некоторое число ≥1 раз.

Если это так, то $&есть вся строка повторения и $1символ; в противном случае (т. е. входная строка пуста), эти две переменные являются пустой строкой.

$1=~v?-1:1сравнивает $1с регулярным выражением vи возвращает -1, если оно совпадает, и 1 в противном случае.

И умножьте это ± 1 (length$&)%2на длину по $&модулю 2.

05AB1E , 14 12 11 байт

Îvy'^QDŠ‹+<

Порт ответа @ Sp3000 's Gol> <> .

ПРИМЕЧАНИЕ: @Grimy уже опубликовал более короткую 8-байтовую альтернативу для 05AB1E , так что убедитесь, что проголосовали за него!

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

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

Попробуйте онлайн .

Все, что я взял от ответа Денниса, это g(знак функции).

Руби, 43

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

9-i/11оценивается в 1 или -1, если даны коды ASCII ^(94) или v(118)

В тестовой программе:

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

g=gets.chomp
puts f[g]