이것은 두 사람 (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)

펄 5, 56 80 72 65 53 바이트

첫 번째 위치에서 X 또는 Y를 처리하고 두 번째로 A 또는 B를 처리하려면 +26 바이트입니다. 출력은 11이 비어 있으면 (펄의 거짓 값) 그렇지 않으면 출력됩니다.

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

자바 (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하고 >= 1A가 이기면 양의 정수 ( <= -1), B가이기거나 음수 인 경우 음의 정수 ( )를 출력합니다 0.

@ OlivierGrégoire 덕분에 -18 바이트 .

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

설명:

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)

하스켈, 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경우를 반환 합니다 .AFalse

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

우리는 추가 입력 다운 목록 재귀 길에 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 2s입력 목록의 두 번째 요소입니다 ( x!!1). rem s 2지도 1및 -1자체, 다른 모든 값 0. 수정 투표는 무시 l어쨌든 [*]와 X또는 Y이 수정 투표의 경우 바로 이웃을 얻는다. 전체 합계가 양수이면 A승리합니다.

[*] [1]Haskell의 게으름으로 인해 두 번째 요소에 대한 액세스가 평가되지 않기 때문에 싱글 톤 목록이 작동 과 같은 수정 투표 를합니다. [2]오류와 같은 입력은 오류와 함께 실패하지만 고려할 필요는 없습니다.

자바 스크립트 (ES6),  78 75  73 바이트

의 정수 배열로 입력을받습니다.$0$$1$$2$$4$$8$ = X 받습니다.

반환 반환합니다$false$$true$ 2 후보의 승리 경우.

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하고 <= -1A가 이기면 음수 ( >= 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표.

자바 스크립트 (Node.js) , 42 바이트

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

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

Shaggy 덕분에 1 바이트를 절약하십시오.

• N = 0, A = -1, B = 1, X = 2, Y = -2 인 정수 배열로 입력;
• 출력 1 = 거짓, 2 = Truthy

파이썬 삼 2, 125 121 117 바이트

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

탭 들여 쓰기 사용

입력 : int'A'= 1, 'B'= 0, 'X'= 4, 'N'= 3, 'Y'=-1 인 s 목록이므로 "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] 문자열을 필요한 입력 형식으로 변환합니다.

온라인으로 사용해 볼 수 있습니다! (제안 해주신 Jonathan Frech에게 감사드립니다)

펄 5, 54 바이트

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

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

용도 A대 A, B대 B, N대 N, \0대한 X및 \3Y에 대해 (마지막 두 문자 제어 문자이다). 트릭은 A비트 xor가 \3같고 B그 반대도 마찬가지입니다.

자바 스크립트 (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)

영업에 주어진 형식의 문자열에 취하고 반환 (1)가 후보 1 원, 경우 (2) 그렇지 않으면 (내가 그것을 인정합니다, 심지어 바이어스하고 있습니다).

파이썬 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로 줄였습니다.