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

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

Каждая команда имеет 5 штрафных очков, доступных на старте, и штрафной балл 0-0. Если в какой-то момент оставшихся штрафов команды недостаточно для смены победившей в настоящее время команды, перестрелка прекращается.

Если оставшихся штрафных очков нет, но очки обеих команд равны, обе команды получают дополнительный штраф. Это повторяется до тех пор, пока очки не будут равны.

После остановки перестрелки команда с наибольшим штрафным счетом побеждает в игре.

Вызов

Ваша задача состоит в том, чтобы, учитывая два списка Aи Bопределить, какие штрафные очки команда А и В забили соответственно, определить, представляют ли они действительный пенальти. Перестрелка действительна, если может быть достигнуто состояние, представленное входом, независимо от того, может ли быть определена команда-победитель. Обратите внимание, что вам, возможно, придется тестировать оба сценария (запуск команды A, запуск команды 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.

правила

• Команда, которая стреляет первой, может быть либо А, либо Б, вы не можете предполагать, что она всегда будет стрелять первой.
• Списки либо будут иметь одинаковую длину, либо их длины будут отличаться на один.
• Вы можете выбрать любые два отличных и непротиворечивых значения для представления штрафов / невыигранных штрафов.
• Списки также могут быть представлены в виде целых чисел, преобразованных из биективной базы 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

Python 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. Да, я использую %форматирование и a .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)>10), общее количество оставленных ударов должно быть больше или равно разнице в пол-очка между двумя командами. Когда одна команда выбила дополнительное время, по разным причинам из поля нужно вычесть пол-очка, так что это можно упростить, целочисленно разделив обе части уравнения на две. Это функция hв коде (с аргументом, mравным 6).

Однако, чтобы быть действительным набором баллов, ввод не обязательно должен быть строго продолжаемым, но он должен быть продолжаемым до того, как был сделан последний удар. Это условие равносильно тому, что оно должно: 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