У футболі асоціацій (також відомий як футбол), реалізація пенальті - це другий захід, який може бути застосований у матчі, який не може закінчитися внічию, після додаткового часу (тобто футбол, який проводиться в овертаймі).

Під час пенальті головний арбітр кидає монету, щоб визначити, з якого мети відбувається перестрілка, а потім кидає іншу монету, щоб визначити, яка команда починає першим. Однак єдиним, що має відношення до цього виклику, є те, що відбувається тоді, описане нижче.

Кожна команда має 5 штрафних санкцій на старті, а штрафний бал - 0-0. Якщо в будь-який момент решти штрафних санкцій команди недостатньо, щоб змінити команду-переможницю, перестрілка припиняється.

Якщо немає пенальті, але бали обох команд рівні, обом командам надається додатковий штраф. Це повторюється, поки бали не рівні.

Після припинення перестрілки команда з найбільшою кількістю штрафних балів виграє гру.

Виклик

Ваша задача полягає в тому, що ви маєте два списки Aі Bпредставляєте, які пенальті команда А та команда В забили відповідно, щоб визначити, чи є вони дійсними пенальті. Відстріл є дійсним, якщо стан, представлений вводом, може бути досягнутий, незалежно від того, чи може бути визначена команда-переможець. Зауважте, що вам, можливо, доведеться протестувати для обох сценаріїв (команда А, старт, команда B, старт), оскільки, якщо стан, описаний у вході, доступний принаймні для одного сценарію, введення є дійсним. Якщо довжина списків різна, команда, представлена ​​більш довгим, починається спочатку (у неї може бути лише один елемент більше, ніж інший, і команда коротшого списку не може починатись, оскільки тоді команда більш тривалого списку стрілятиме два штрафи поспіль, оскільки коротший список буде передчасно вичерпаний).

Детальні приклади

Ви можете перейти до розділу Правила нижче, це лише для вирішення проблеми.

Припустимо, ви отримуєте цю передачу як вхідну, де -означає, що жоден гол не був забитий і Xозначає, що гол був забитий (недійсний):

Team A: - X X X X
Team B: - - - - X

Assuming team A starts first:

Team A: - (0 - 0) (max possible score 4 - 5)
Team B: - (0 - 0) (max possible score 4 - 4)
Team A: X (1 - 0) (max possible score 4 - 4)
Team B: - (1 - 0) (max possible score 4 - 3)
Team A: X (2 - 0) (max possible score 4 - 3)
Team B: - (2 - 0) (max possible score 4 - 2)
Team A: X (3 - 0) (max possible score 4 - 2)
Team A already has a higher score than B could ever have, but the input hasn't
ended yet, so it's invalid if team A is first.

Assuming team B starts first:

Team B: - (0 - 0) (max possible score 5 - 4)
Team A: - (0 - 0) (max possible score 4 - 4)
Team B: - (0 - 0) (max possible score 4 - 3)
Team A: X (1 - 0) (max possible score 4 - 3)
Team B: - (1 - 0) (max possible score 4 - 2)
Team A: X (2 - 0) (max possible score 4 - 2)
Team B: - (2 - 0) (max possible score 4 - 1)
Team A already has a higher score than B could ever have, but the input hasn't
ended yet, so it's invalid if team B stars first.

The input is invalid no matter which team starts first, so it's considered
invalid.

Навпаки, ось вагомий приклад:

Team A: X X X
Team B: - - -

Assuming team A starts first:

Team A: X (1 - 0) (max possible score 5 - 5)
Team B: - (1 - 0) (max possible score 5 - 4)
Team A: X (2 - 0) (max possible score 5 - 4)
Team B: - (2 - 0) (max possible score 5 - 3)
Team A: X (3 - 0) (max possible score 5 - 3)
Team B: - (3 - 0) (max possible score 5 - 2)
It can be determined that team A wins, however the input has ended, so it's
valid if team A starts first. Therefore, the input is valid.

Ще один приклад, цього разу із додатковими штрафами:

Team A: X - X - - - X -
Team B: - X X - - - X X

Assuming team A starts first:

Team A: X (1 - 0) (max possible score 5 - 5)
Team B: - (1 - 0) (max possible score 5 - 4)
Team A: - (1 - 0) (max possible score 4 - 4)
Team B: X (1 - 1) (max possible score 4 - 4)
Team A: X (2 - 1) (max possible score 4 - 4)
Team B: X (2 - 2) (max possible score 4 - 4)
Team A: - (2 - 2) (max possible score 3 - 4)
Team B: - (2 - 2) (max possible score 3 - 3)
Team A: - (2 - 2) (max possible score 2 - 3)
Team B: - (2 - 2) (max possible score 2 - 2)
First 5 penalties result in a tie, so we move on to extra penalties.
Team A: -, Team B: - (2 - 2)
Team A: X, Team B: X (3 - 3)
Team A: -, Team B: X (3 - 4)
It can be determined that team B wins, however the input has ended, so it's
valid if team A starts first. Therefore, the input is valid.

Ось вагомий вклад, коли визначити переможця зарано:

Team A: X X - -
Team B: - X - X

Assuming team A starts first:

Team A: X (1 - 0) (max possible score 5 - 5)
Team B: - (1 - 0) (max possible score 5 - 4)
Team A: X (2 - 0) (max possible score 5 - 4)
Team B: X (2 - 1) (max possible score 5 - 4)
Team A: - (2 - 1) (max possible score 4 - 4)
Team B: - (2 - 1) (max possible score 4 - 3)
Team A: - (2 - 1) (max possible score 3 - 3)
Team B: X (2 - 2) (max possible score 3 - 3)
The input has ended before the winner can be determined, so it's valid if team A
starts first. Therefore, the input is valid.

Нарешті, ось подання, де довжини списків різняться:

Team A: - - -
Team B: X X - X

Since team B shot more penalties, it starts first:

Team B: X (0 - 1) (max possible score 5 - 5)
Team A: - (0 - 1) (max possible score 4 - 5)
Team B: X (0 - 2) (max possible score 4 - 5)
Team A: - (0 - 2) (max possible score 3 - 5)
Team B: - (0 - 2) (max possible score 3 - 4)
Team A: - (0 - 2) (max possible score 2 - 4)
Team B: X (0 - 3) (max possible score 2 - 4)
It can be determined that team B wins, however the input has ended, so it's
valid.

Правила

• Команда, яка стріляє першою, може бути або A, або B, ви не можете припустити, що завжди буде стріляти першою.
• Список буде або однакової довжини, або їх довжина буде відрізнятися на одиницю.
• Ви можете вибрати будь-які два чіткі та послідовні значення для відображення набраних / незакритих штрафних санкцій.
• Списки також можуть бути представлені у вигляді цілих чисел, перетворених з біективної бази 2, рядків або у вихідний формат списку вашої мови. Якщо обраний формат бієктивної бази 2, правила введення застосовуються до чисел, перетворених у біективну базу 2 (тобто цифри 1і 2можуть означати як забитий, так і незабарвлений або неполірований і набраний відповідно). Регулярні двійкові не дозволяються , оскільки не можна визначити наявність провідних нулів у призначеному бінарному поданні.
• Це код-гольф , тому найкоротше рішення виграє. Однак, будь ласка, не відмовляйтеся від відповідей, навіть якщо здається, що ваша мова не може "перемогти спеціалізовані".

Тестові справи

У цих тестових випадках засіб 0буде представляти мету, а тест 1- мета.

Формат:

[Team A], [Team B]

Дійсні входи:

[], []
[0], [0]
[0], [1]
[1], [1]
[0], []
[1, 1, 1, 1], [0, 0, 1, 1]
[0, 1, 1, 1, 1], [0, 1, 1, 0]
[0, 0, 0, 0, 1], [0, 0, 0, 1, 0]
[0, 0, 0, 0, 1], [0, 0, 0, 1]
[1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1]
[0, 1, 1, 1, 1], [0, 1, 1, 0, 1]
[1, 1, 1], [0, 0, 0]
[1, 1, 1, 1], [0, 0, 1]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Недійсні входи:

[0, 1, 1, 1, 1], [0, 1, 1, 0, 0]
[0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 1, 0]
[0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 1]
[1, 1, 1, 0], [0, 0, 0]
[1, 1, 1, 1], [0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
[1, 0, 1, 0, 1], [0, 1, 0, 1, 0, 1]
[0, 0, 0, 0, 1], [0, 1, 1, 1, 0]

JavaScript (ES6),  117 112  109 байт

(a)(b)$1$$2$$0$$1$

a=>b=>!(g=(a,b,P=Q=i=5)=>(p=a[5-i])|(q=b[5-i])&&(--i<0?P-Q:P-Q>i|Q+q-P-p>i&p<2)|g(a,b,P+p,Q+=q))(a,b)|!g(b,a)

Спробуйте в Інтернеті!

Прокоментував

a => b =>                   // given a[] and b[]
  !(g = (                   // g is a recursive function taking:
      a,                    //   the results a[] of the team that plays first
      b,                    //   the results b[] of the team that plays second
      P =                   //   the cumulated goals P of the 1st team (relative value)
      Q =                   //   the cumulated goals Q of the 2nd team (relative value)
      i = 5                 //   a counter i
    ) =>                    // and returning a truthy value if something goes wrong
      (p = a[5 - i]) |      // if either the first team
      (q = b[5 - i]) && (   // or the second team is playing this round:
        --i < 0 ?           //   decrement i; if we've played more than 5 penalties:
          P - Q             //     do we already have a goal difference?
        :                   //   else:
          P - Q > i |       //     was the 1st team already guaranteed to win?
          Q + q - P - p > i //     or is the 2nd team now guaranteed to win
          & p < 2           //     while the 1st team failed its last attempt?
      ) |                   //
      g(                    //   do a recursive call:
        a, b,               //     pass a[] and b[] unchanged
        P + p,              //     update P
        Q += q              //     update Q
      )                     //   end of recursive call
  )(a, b) |                 // try g(a, b)
  !g(b, a)                  // try g(b, a); return 1 if at least one of them is falsy

Пітон 2 , 176 169 171 169 байт

-2 байти завдяки @Kevin Cruijssen

exec"h=lambda a,b,m:m-%s/2>abs(sum(a)-sum(b));f=lambda a,b:a[5#==b[5#and h(a[:5],b[:5],6)if %s>10else h(a,b,7)and h(a[#,b[#,6)".replace("#",":~-%s/2]")%(("len(a+b)",)*6)

Спробуйте в Інтернеті! (У тому числі деякі додаткові тестові випадки, не перелічені вище.)

Створює функцію, fяка бере два аргументи (два списки забитих / незакреплених пенальті) і повертається, Trueякщо бали можливо допустимі та Falseінше.

Часткове пояснення:

Перш за все, execпобудова - це лише спосіб зберегти кілька байтів, не повторюючи виразу len(a+b)більше одного разу. Вищевказаний фрагмент коду еквівалентний наступному:

Оновлення: нова та вдосконалена відповідь - це те саме число байтів із execхитрістю чи без неї , тому в інтересах простоти я її видалив.

Оновлення 2: Нова версія виправлених помилок включає ще більше стискання рядків за допомогою підстановки та exec. Так, я використовую %форматування та а .replaceв тому ж рядку. Код, наведений вище, еквівалентний:

h=lambda a,b,m:m-len(a+b)/2>abs(sum(a)-sum(b))
f=lambda a,b:a[5:(len(a+b)-1)/2]==b[5:~-len(a+b)/2]and h(a[:5],b[:5],6)if len(a+b)>10else h(a,b,7)and h(a[:(~-len(a+b)/2],b[:(len(a+b)-1)/2],6)

$<=5$not len(a+b)>10hm

Однак, щоб бути правильним набором балів, введення даних не повинно суворо тривати, але воно повинно бути продовженим до того, як буде зроблено останній удар. Ця умова еквівалентна твердженню, що вона повинна 1) тривати в останній раз, коли обидві сторони били ногами однакову кількість разів, і 2) в даний час знаходяться в межах двох пів-балів, щоб вони були безперервними - ось, де слід приймати остаточний аргумент h: h(a[:~-len(a+b)/2],b[:~-len(a+b)/2],6)умова тесту 1) та h(a,b,7)(що 7представляє додаткові два допустимих половини балів у запасі) умова 2).

Випадок, коли кожна команда б'є максимум п'ять разів, таким чином було врегульовано. (Пояснення буде продовжено для іншого випадку.)

Що стосується гольфінгу на низькому рівні, я сумніваюся, що занадто багато для гоління, але алгоритмічно це, можливо, можна зробити трохи простіше.

Желе , 62 54 49 байт

ṫ⁵Ṗm2¬Ạ
N§ỤḢƊ¦LÞṚZFĵ12R:2U_ṁḣ⁵ṫ-N<Ø.ẠaÇoL<3
ṚÇoÇ

Спробуйте в Інтернеті!

ṫ⁵Ṗm2¬Ạ # helper function to determine whether
        # even indices at or beyond 10 are zero
ṫ⁵      # tail - take every item from 10
  Ṗ     # remove last item
   m2   # take every second item
     ¬  # logical not, will return 1 for an empty list
      Ạ # all
# function to create cumulative score
# difference and check values
N§ỤḢƊ¦    # negate scores for team with lower score
          # (or one of them if both same score)
  LÞṚ     # sort by length, longest first
  ZF      # transpose lists and flatten
  Ä       # cumulative sum
  µ       # this cumulative score difference (CSD) 
          # now becomes left value
  12R:2U_ # subtract cumulative score difference from
          # 6,5,5,4,4,3,3,2,2,1
  ṁḣ⁵     # shorten to be no longer than 10 items
          # and no longer than CSD
  ṫ-N<Ø.Ạ # check last two values are greater than 0,-1
  aÇ      # check that helper function also TRUE
  oL<3    # handle very short scores
# main link that calls the above for scores in either order
ṚÇoÇ

Зверніть увагу, що код нижнього колонтитулу в tio - це лише обробка декількох тестових випадків та друку виходів проти входів.

Завдяки @EriktheOutgolfer за те, що виграли 8 байт

Perl 6 , 123 байти

{all map {@^b>@^a||[R,](map {abs(($+=$_)-++$ %2/2)>(5-++$ /2 max++$ %2)},flat roundrobin @a,-<<@b).skip.any},@^a,@^b,@b,@a}

Спробуйте в Інтернеті!

Повертає фальси для дійсних розстрілів, трити для недійсних.

Пояснення

# Check whether block returns true (invalid shoot-out) for arguments (a, b) and (b, a)
{all map {...},@^a,@^b,@b,@a}
# Return true (invalid) if array b is longer than a
@^b>@^a||
# Return true (invalid) if any except the last value is true (shoot-out stopped)
[R,](...).skip.any
# Map values from a and negated b, interleaved
map {...},flat roundrobin @a,-<<@b
# Shoot out stopped?
abs(($+=$_)-++$ %2/2)>(5-++$ /2 max++$ %2)
    #     # Accumulator
           #        # Subtract 0.5 for first team
                      #                  # Sequence 4.5 4 3.5 3 2.5 2 1.5 1 1 0 1 0 1 0