Это проблема, в которой два человека, 1 и 2, баллотируются на должность. Люди определенно голосуют определенным образом в мире 1 и 2, что может позволить кандидатам выяснить результаты до выборов.

ПРИМЕЧАНИЕ: это не относится к каким-либо внешним выборам или другим политическим событиям.

Два человека баллотируются на должность. Мы назовем этих людей 1 и 2. Поскольку они оба хотят знать, победят ли они на выборах, они решают использовать свои знания людей и некоторый код, чтобы выяснить, каков будет результат. Из-за желания минимизировать государственные расходы, код должен быть максимально коротким.

Ваша задача: учитывая ряд людей, основываясь на том, как они голосуют, выведите, кто победит на выборах.

В веселом и захватывающем мире 1 и 2 есть пять видов людей:

• A: люди, которые обязательно проголосуют за 1.
• B: люди, которые обязательно проголосуют за 2.
• X: люди, которые будут голосовать за того, за кого проголосует человек слева. Если слева от них нет никого, они голосуют за того, за кого будет голосовать тот, кто справа. Если неясно, за кого голосует человек, за которого они имеют право, они не голосуют.
• Y: люди будут голосовать против человека слева от себя. Если слева от них нет людей, они голосуют против тех, кто находится справа от них. Если неясно, за кого голосует человек, за которого они имеют право, они не голосуют.
• N: люди, которые не голосуют.

Это оценивается слева направо.

Пример:

Для ясности, кто бы ни был «оценен», строчными буквами.

Input: `XXAYAN`
        xX      Votes for whoever their friend is voting for. Their friend has not decided yet, so it is unclear, so they do not vote.
        Xx      Person to left is voting "none" so votes "none."
          a     Votes for 1
          Ay    Since person on left is voting for 1, votes for 2.
            a   Votes for 1
             n  Does not vote

Финальный опрос:

• 2 человек проголосовали за 1

• 1 человек проголосовали за 2

• 3 человека не проголосовали

1 имеет наибольшее количество голосов, поэтому 1 выигрывает!

Тестовые случаи:

Вы можете использовать другие символы или значения в качестве ввода и вывода, если они различны. (Например: цифры вместо букв, разные буквы, строчные буквы, истина / ложь или положительный / отрицательный (для вывода) и т. Д.)

Input -> Output

"AAAA" -> 1
"BBBB" -> 2
"BBAXY" -> 2
"BAXYBNXBAYXBN" -> 2
"XXAYAN" -> 1
"AAAABXXXX" -> 2
"AXNXXXXAYB" -> 1
"NANNY" -> 1
"XA" -> 1
"YAB" -> 2
"XY" -> anything (do not need to handle test cases with no victor)
"AB" -> anything (do not need to handle test cases with no victor)

Perl 5, 56 80 72 65 53 байта

+26 байтов, чтобы обработать регистр X или Y в первой позиции и A или B во второй. вывод - 1если 1 выигрывает пустое (ложное значение в perl) в противном случае.

s/^X(.)/$1$1/,s/A\KX|B\KY|^Y(?=B)/A/|s/B\KX|A\KY|^Y(?=A)/B/&&redo;$_=y/A//>y/B//

TIO

используя Pи Sвместо того , чтобы Xи Yпозволяет использовать XOR операции на персонажах, позволит сэкономить еще несколько байт

s/(?|^(P|S)(?=(A|B))|(A|B)\K(P|S))/P^$1^$2/e&&redo;$_=y/A//>y/B//

использует группу сброса ветви (?|.. |.. ), так что $1 $2ссылка на соответствующую группу в ветви. Использование \0и \3вместо XиY

$_=s/^\W(?=(\w))|(\w)\K\W/$1.$2^$&/e?redo:y/A//>y/B//

72 байта

65 байт

53 байта

Java 8, 153 141 135 131 129 байт

a->{int l=a.length,t,r=0,i=-1;for(;++i<l;r+=(t=a[i]=a[i]>4?t<3?t^3:3:a[i]>3?t:a[i])>2?0:3-t*2)t=a[i>0?i-1:i<l-1?i+1:i];return r;}

Использует целочисленный массив в качестве входных данных A=1, B=2, N=3, X=4, Y=5и выводит положительное целое число ( >= 1), если побеждает A, отрицательное целое число ( <= -1), если побеждает B, или 0если это ничья.

-18 байт благодаря @ OlivierGrégoire .

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

Объяснение:

a->{                      // Method with int-array parameter and boolean return-type
  int l=a.length,         //  Length of the input-array
      t,                  //  Temp integer, uninitialized
      r=0,                //  Result-integer, starting at 0
  i=-1;for(;++i<l         //  Loop `i` in the range [0, l):
           ;              //    After every iteration:
            r+=           //     Increase the result by:
             (t=a[i]=     //       Change `i`'th item in the array to:
                 a[i]>4?  //        If the `i`'th item is a 5:
                  t<3?    //         If `t` is 1 or 2:
                   t^3    //          Use `t` Bitwise-XOR 3 to invert it
                          //          (1 becomes 2; 2 becomes 1)
                  :       //         Else (`t` is 3, 4, or 5 instead):
                   3      //          Set it to 3
                 :a[i]>3? //        Else-if the `i`'th item is a 4:
                  t       //         Set it to `t`
                 :        //        Else (the `i`'th item is a 1, 2 or 3):
                  a[i])   //         Leave it unchanged
             )>2?         //      And if this new `i`'th value is 3, 4, or 5:
              0           //       Leave the result the same by increasing it with 0
             :            //      Else (it's 1 or 2 instead):
              3-t*2;      //       Increase it by 3 minus two times the `i`'th value
                          //       (which is 1 for 1; and -1 for 2)
         t=               //   Set `t` to:
           a[i>0?         //    If `i` is not the first item:
              i-1         //     Set `t` to the previous (`i-1`'th) value
             :i<l-1?      //    Else-if `i` is not the last item:
              i+1         //     Set `t` to the next (`i+1`'th) value
             :            //    Else (`i` is the first or last item):
              i];         //     Set `t` to the current item itself
  return r;}              //  Return the result
                          //  (positive if A wins; negative if B wins; 0 if it's draw)

Haskell, 60 50 48 59 байт

l#(v:o)|v<2=v+v#o|n<-(3-v)*l=n+n#o
_#_=0
f x=rem(x!!1)2#x>0

Использует 1для A, -1для B, 0для N, 2для Xи 4для Y. Возвращает, Trueесли Aпобедит, иначе False.

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

На рекурсивном пути вниз по списку ввода мы добавляем 1за каждый голос за A, -1за каждый голос за Bи 0за "нет голосования". lпоследний голос, vследующий. Если v=1, -1или 0(или v<2) мы просто добавляем его к сумме. Если vэто «голосовать одинаково» ( Xв вызове, 2для моего решения) мы сохраняем и добавляем l( (3-2)*l= l). Если v«голосовать против» ( Yв задаче, 4для моего решения), мы сначала отрицаем l( (3-4)*l= -l), а затем добавляем его. Базовый случай - пустой список, с которого начинается сумма 0. Рекурсия начинается с lустановки rem s 2гдеsявляется вторым элементом списка ввода ( x!!1). rem s 2карты 1и -1для себя, все другие значения для 0. Фиксированные голоса игнорируют в lлюбом случае [*] и Xили Yполучают правильного соседа, если это правильный голос. Если общая сумма положительная, Aвыигрывает.

[*] это делает одноэлементные списки с фиксированными голосами похожими на [1]работу, потому что из-за лени Хаскелла доступ ко второму элементу никогда не оценивается. Входные данные, такие как [2]сбой с ошибкой, но не должны рассматриваться.

JavaScript (ES6),  78 75  73 байта

$0$$1$$2$$4$$8$

$false$$true$

a=>a.reduce((v,x,i)=>v+~~[,1,-1][p=x?x&3||~-x%7^(p&3||a[i+1]&3):0],p=0)<0

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

05AB1E , 34 33 32 30 байт

gFÐNè©2@iNx1.S-èDÄ2‹*D(‚®èNǝ]O

Использует целочисленный массив в качестве входных данных A=-1, B=1, N=0, X=2, Y=3и выводит отрицательное целое число ( <= -1), если побеждает A, положительное целое число ( >= 1), если побеждает B, или 0если это ничья.

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

Объяснение:

g             # Take the length of the (implicit) input-list
              #  i.e. [3,1,3,3,2,0,1] → 7
 F            # Loop `N` in the range [0, length):
  Ð           #  Triplicate the list at the top of the stack
              #  (which is the implicit input-list in the first iteration)
   Nè         #  Get the `N`'th item of the list
              #   i.e. [3,1,3,3,2,0,1] and `N`=0 → 3
              #   i.e. [-1,1,-1,3,2,0,1] and `N`=3 → 3
     ©        #  Store it in the register (without popping)
   2@i        #  If it's larger than or equal to 2 (so either 2 or 3):
      Nx      #   Push `N` and `N` doubled both to the stack
              #    i.e. `N`=0 → 0 and 0
              #    i.e. `N`=3 → 3 and 6
        1.S   #   Compare the double integer with 1 (-1 if N*2<1; 0 if N*2==1; 1 if N*2>1)
              #   (So this will be -1 in the first iteration, otherwise it will be 1)
              #    i.e. 0 → -1
              #    i.e. 6 → 1
           -è #   Subtract that from the index, and index it into the list
              #    i.e. `N`=0 and -1 → 1 (first item, so get the next index)
              #     → [3,1,3,3,2,0,1] and 1 → 1
              #    i.e. `N`=3 and 1 → 2 (fourth item, so get the previous index)
              #     → [-1,1,-1,3,2,0,1] and 2 → -1
      D       #   Duplicate that value
       Ä2‹    #   Check if that value is -1, 0, or 1 (abs(i) < 2) (truthy=1; falsey=0)
          *   #   And multiply that with the value
              #   (remains the same if truthy; or becomes 0 if falsey)
      D(‚     #   Pair it with its negative (-1 becomes [-1,1]; 1 becomes [1,-1])
         ®è   #   And index the `N`'th value (from the register) into it (with wraparound)
              #   (if it was a 2, it uses the unchanged (first) value of the pair;
              #    if it was a 3, it uses the negative (second) value of the pair)
              #     i.e. [1,-1] and 3 → -1
              #     i.e. [-1,1] and 3 → 1
      Nǝ      #   And replace the `N`'th value with this
              #    i.e. [3,1,3,3,2,0,1], `N`=0 and -1 → [-1,1,3,3,2,0,1]
              #    i.e. [-1,1,-1,3,2,0,1], `N`=3 and 1 → [-1,1,-1,1,2,0,1]
 ]            # Close both the if-statement and loop
  O           # Sum the modified list (which now only contains -1, 0, or 1)
              #  i.e. [-1,1,-1,1,1,0,1] → 2

Сетчатка 0.8.2 , 70 байт

AY
AB
BY
BA
}`(A|B)X
$1$1
^X(A|B)|^Y[AB]
$1$1
+`N|X|Y|AB|BA

.+|(?<=B)

Попробуйте онлайн! Ссылка включает в себя тестовые случаи. Выходы0 на галстук. Объяснение:

AY
AB
BY
BA

Справиться Y избирателям с правом людей с определенными голосами.

}`(A|B)X
$1$1

Обращайтесь к Xизбирателям справа от людей с определенными голосами, а затем возвращайтесь к началу, пока все возможное YиX голоса не могут быть решены.

^X(A|B)|^Y[AB]
$1$1

Обработка первоначального Xизбирателя рядом с решенным голосованием, а также начальногоY избирателя рядом с решенным голосованием. Поскольку этот избиратель будет голосовать против принятого решения, в этом случае мы можем просто удалить оба голоса.

+`N|X|Y|AB|BA

Удалите все оставшиеся не проголосовавшие или не определились голоса, и отмените все пары противостоящих решительных голосов. Повторяйте, пока все возможные голоса не будут отменены. В случае ничьей ничего не останется, в противном случае все оставшиеся голоса будут одного типа.

.+|(?<=B)

Выведите, 1если есть какие-либо голоса, но 2если они являются Bголосами.

JavaScript (Node.js) , 42 байта

s=>s.map(c=>x+=l=c%2|l*c/2,l=s[x=1]%2)|x>1

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

Сэкономьте 1 байт, благодаря Shaggy.

• Ввести в виде целочисленного массива, где N = 0, A = -1, B = 1, X = 2, Y = -2;
• Выход 1 = Ложь, 2 = Истина

питон 3 2, 125 121 117 байт

(Спасибо Джонатану Фреху)

def f(x):
    for i,v in enumerate(x):n=x[i-(i>0)];x[i]=(v>3)*n+abs(n-1)*(v<0)+x[i]*(0<v<4)
    print x.count(1)>x.count(0)

Использование отступа табуляции

Вход: список int s, где «A» = 1, «B» = 0, «X» = 4, «N» = 3, «Y» = - 1, поэтому «AAAA» - это [1, 1, 1, 1]«XXAYAN»[4, 4, 1, -1, 1, 3] .

[{'A': 1, 'B': 0, 'X': 4, 'N': 3, 'Y': -1}[c] for c in s] преобразует строки в нужный формат ввода.

Вы можете попробовать это онлайн! (Спасибо Джонатану Фреху за предложение)

Perl 5, 54 байта

s/^\W(?=(\w))|(\w)\K\W/$1^$2^$&/e&&redo;$_=y/A//>y/B//

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

Используется Aдля A, Bдля B, Nдля N, \0для Xи \3для Y (последние два - буквенные контрольные символы). Хитрость в том, что Aбит-xor \3равно B, и наоборот.

Javascript (ES6) - 133 байта

a=>(i=($=_=>'AB'.search(_)+1)(a[1],o=0),[...a].map(v=>(r=['NAB','NBA']['XY'.search(x)],p=r?r[i]:v,i=$(p),o+='NA'.search(p))),o>0?1:2)

Принимает строку с форматом, заданным в OP, и возвращает 1, если кандидат 1 победил, и 2 в противном случае (я признаю это, я даже предвзятый).

Python 2 , 95 73 байта

lambda(v):sum([l for l in[2*int(v[1]/2)]for i in v for l in[i*l**(i%2)]])

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

• Ввести в виде целочисленного массива, где N = 0, A = -2, B = 2, X = 1, Y = -1;
• Выход отрицательный = A, 0 = ничья, положительный = B
• Если первый вход X или Y, то 2 * int (v [1] / 2) отображает второй на себя или 0

Исправление ошибки требовало добавления дополнительных байтов, но преобразование в лямбду благодаря @Stephen уменьшило его до 95