Đây là một thách thức trong đó hai người, 1 và 2, đang chạy cho văn phòng. Mọi người nhất định bỏ phiếu theo những cách nhất định trong thế giới 1 và 2, điều này có thể cho phép các ứng cử viên tìm ra kết quả trước cuộc bầu cử.

LƯU Ý: điều này không có nghĩa là đề cập đến bất kỳ cuộc bầu cử bên ngoài hoặc các sự kiện chính trị khác.

Hai người đang chạy cho văn phòng. Chúng tôi sẽ gọi những người này là 1 và 2. Vì cả hai đều muốn biết liệu họ sẽ giành chiến thắng trong cuộc bầu cử hay không, họ quyết định sử dụng kiến ​​thức về mọi người và một số mã để tìm hiểu kết quả sẽ ra sao. Do muốn giảm thiểu chi tiêu của chính phủ, mã cần phải ngắn nhất có thể.

Nhiệm vụ của bạn: Đưa ra một chuỗi người dựa trên cách họ bỏ phiếu, đầu ra ai là người chiến thắng trong cuộc bầu cử.

Có năm loại người trong thế giới vui vẻ và thú vị của 1 và 2:

• A: những người chắc chắn sẽ bỏ phiếu cho 1.
• B: những người chắc chắn sẽ bỏ phiếu cho 2.
• X: những người sẽ bỏ phiếu cho bất cứ ai bên trái của họ sẽ bỏ phiếu cho. Nếu không có người ở bên trái của họ, thì họ bỏ phiếu cho bất cứ ai mà người bên phải của họ sẽ bỏ phiếu. Nếu không rõ ai là người có quyền bầu cử cho họ, thì họ không bỏ phiếu.
• Y: mọi người sẽ bỏ phiếu ngược lại với người bên trái của họ. Nếu không có ai ở bên trái của họ, thì họ bỏ phiếu ngược lại với bất cứ ai ở bên phải của họ. Nếu không rõ ai là người có quyền bầu cử cho họ, thì họ không bỏ phiếu.
• N: những người không bỏ phiếu.

Điều này được đánh giá từ trái sang phải.

Thí dụ:

Bất cứ ai đang được "đánh giá" là chữ thường, cho rõ ràng.

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

Cuộc thăm dò cuối cùng:

• 2 người bình chọn cho 1

• 1 người bình chọn cho 2

• 3 người không bỏ phiếu

1 có nhiều phiếu bầu nhất, vì vậy 1 chiến thắng!

Các trường hợp thử nghiệm:

Bạn có thể sử dụng các ký tự hoặc giá trị khác làm đầu vào và đầu ra, miễn là chúng khác biệt. (Ví dụ: số thay vì chữ cái, chữ cái khác nhau, chữ thường, chữ thật / giả hoặc dương / âm (đối với đầu ra), v.v.)

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 byte

+26 byte để xử lý trường hợp X hoặc Y ở vị trí đầu tiên và A hoặc B ở vị trí thứ hai. đầu ra là 1nếu 1 thắng trống (giá trị sai trong perl) nếu không.

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

sử dụng Pvà Sthay vì Xvà Ycho phép sử dụng thao tác xor trên các ký tự, sẽ tiết kiệm thêm một số byte

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

sử dụng một nhóm thiết lập lại chi nhánh (?|.. |.. ), để $1 $2tham chiếu đến nhóm tương ứng trong chi nhánh. Sử dụng \0và \3thay vì XvàY

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

72 byte

65 byte

53 byte

Java 8, 153 141 135 131 129 byte

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

Sử dụng một mảng số nguyên làm đầu vào với A=1, B=2, N=3, X=4, Y=5và xuất ra một số nguyên dương ( >= 1) nếu A thắng, một số nguyên âm ( <= -1) nếu B thắng hoặc 0nếu đó là hòa.

-18 byte nhờ @ OlivierGrégoire .

Hãy thử trực tuyến.

Giải trình:

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 byte

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

Sử dụng 1cho A, -1cho B, 0cho N, 2cho Xvà 4cho Y. Trả về Truenếu Athắng, khác False.

Hãy thử trực tuyến!

Theo cách đệ quy xuống danh sách đầu vào, chúng tôi thêm 1cho mỗi phiếu bầu cho A, -1cho mọi phiếu bầu cho Bvà 0"không bỏ phiếu". llà phiếu bầu cuối cùng, vtiếp theo. Nếu v=1, -1hoặc 0(hoặc v<2) chúng ta chỉ cần thêm nó vào tổng. Nếu vlà "bỏ phiếu giống nhau" ( Xtrong thử thách, 2đối với giải pháp của tôi), chúng tôi giữ và thêm l( (3-2)*l= l). Nếu vlà "bỏ phiếu ngược lại" ( Ytrong thử thách, 4đối với giải pháp của tôi) trước tiên chúng ta phủ nhận l( (3-4)*l= -l) và sau đó thêm nó. Trường hợp cơ sở là danh sách trống bắt đầu tổng với 0. Đệ quy được bắt đầu với lthiết lập rem s 2ở đâuslà thành phần thứ hai của danh sách đầu vào ( x!!1). rem s 2bản đồ 1và -1chính nó, tất cả các giá trị khác 0. Sửa lỗi bỏ qua ldù sao [*] và Xhoặc Ynhận được hàng xóm phù hợp nếu đó là phiếu bầu sửa. Nếu tổng số là tích cực, Achiến thắng.

[*] điều này làm cho các danh sách đơn lẻ có phiếu bầu sửa chữa như [1]công việc, bởi vì sự lười biếng của Haskell đối với yếu tố thứ hai không bao giờ được đánh giá. Đầu vào như [2]lỗi với lỗi, nhưng không phải xem xét.

JavaScript (ES6),  78 75  73 byte

$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

Hãy thử trực tuyến!

05AB1E , 34 33 32 30 byte

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

Sử dụng một mảng số nguyên làm đầu vào với A=-1, B=1, N=0, X=2, Y=3và xuất ra một số nguyên âm ( <= -1) nếu A thắng, một số nguyên dương ( >= 1) nếu B thắng hoặc 0nếu đó là một trận hòa.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

Võng mạc 0.8.2 , 70 byte

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

.+|(?<=B)

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Đầu ra 0cho một tie. Giải trình:

AY
AB
BY
BA

Xử lý Ycử tri ở bên phải của người có phiếu quyết định.

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

Xử lý Xcử tri ở bên phải của những người có phiếu bầu quyết định, và sau đó lặp lại cho đến khi tất cả có thể Yvà Xphiếu bầu có thể được quyết định.

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

Xử lý một Xcử tri ban đầu bên cạnh một cuộc bỏ phiếu quyết định, và cũng là một Ycử tri ban đầu bên cạnh một cuộc bỏ phiếu quyết định. Vì cử tri này sẽ bỏ phiếu ngược lại với phiếu bầu đã quyết định, chúng tôi chỉ có thể xóa cả hai phiếu trong trường hợp này.

+`N|X|Y|AB|BA

Xóa mọi phiếu bầu còn lại hoặc phiếu không quyết định và hủy bỏ tất cả các cặp phiếu quyết định đối lập. Lặp lại cho đến khi tất cả các phiếu bầu có thể bị hủy bỏ. Trong trường hợp hòa, sẽ không còn gì, nếu không tất cả các phiếu còn lại sẽ cùng loại.

.+|(?<=B)

Đầu ra 1nếu có bất kỳ phiếu bầu nào, nhưng 2nếu chúng là Bphiếu bầu.

JavaScript (Node.js) , 42 byte

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

Hãy thử trực tuyến!

Tiết kiệm 1 byte, nhờ Shaggy.

• Nhập dưới dạng mảng số nguyên trong đó N = 0, A = -1, B = 1, X = 2, Y = -2;
• Đầu ra 1 = Falsy, 2 = Truthy

Con trăn 3 2, 125 121 117 byte

(Cảm ơn Jonathan Frech)

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)

Sử dụng thụt tab

Đầu vào: danh sách ints trong đó 'A' = 1, 'B' = 0, 'X' = 4, 'N' = 3, 'Y' = - 1, vì vậy "AAAA" là [1, 1, 1, 1]và "XXAYAN" [4, 4, 1, -1, 1, 3].

[{'A': 1, 'B': 0, 'X': 4, 'N': 3, 'Y': -1}[c] for c in s] sẽ chuyển đổi các chuỗi thành định dạng đầu vào cần thiết.

Bạn có thể dùng thử trực tuyến! (Cảm ơn Jonathan Frech đã gợi ý)

Perl 5, 54 byte

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

Hãy thử trực tuyến!

Sử dụng Acho A, Bcho B,N cho N, \0cho Xvà \3cho Y (hai cuối cùng là ký tự kiểm soát theo nghĩa đen). Bí quyết là Abitwise-xor \3bằng Bvà ngược lại.

Javascript (ES6) - 133 byte

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)

Tham gia vào một chuỗi với định dạng được đưa ra trong OP và trả về 1 nếu ứng viên 1 thắng và 2 nếu không (tôi sẽ thừa nhận, tôi thậm chí còn thiên vị).

Python 2 , 95 73 byte

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

Hãy thử trực tuyến!

• Nhập dưới dạng mảng số nguyên trong đó N = 0, A = -2, B = 2, X = 1, Y = -1;
• Đầu ra âm = A, 0 = vẽ, dương = B
• Nếu đầu vào đầu tiên là X hoặc Y, thì 2 * int (v [1] / 2) ánh xạ thứ hai sang chính nó hoặc 0

Sửa lỗi được yêu cầu có thêm byte, nhưng chuyển đổi sang lambda nhờ @Stephen đã giảm xuống còn 95