시즌이 끝날 무렵 에 가장 성공한 축구 ^BE 팀 의 팬으로서 나는 종종 내가 좋아하는 팀이 여전히 챔피언이 될 이론적 기회가 있는지 궁금해합니다. 이 도전에서 당신의 임무는 저에게 그 질문에 대답하는 것입니다.

입력

현재 테이블, 남은 경기 목록 및 관심있는 팀의 현재 위치의 세 가지 입력을받습니다.

입력 1 : 현재 테이블 , 숫자의 순서가 있었다 내가 번째 숫자는 팀에 의해 얻은 점이다 나는 지금까지. 예를 들어, 입력 [93, 86, 78, 76, 75]은 다음 테이블을 인코딩합니다 (마지막 열만 중요 함).

입력 2 : 나머지 일치 , 각 튜플 ( i , j )이 팀 i 와 j 간의 나머지 일치 를 나타내는 일련의 튜플 . 위의 예에서 두 번째 입력은 [(1,2), (4,3), (2,3), (3,2), (1,2)]나머지 일치 항목이 다음을 의미합니다.

Chelsea vs Tottenham, Liverpool vs Man. City, Tottenham vs Man. City, Man. City vs Tottenham, Chelsea vs Tottenham

입력 3 : 우리가 관심있는 팀 의 현재 위치 . 예를 들어, 2위의 예를 입력 하면 Tottenham이 여전히 챔피언이 될 수 있는지 알고 싶습니다.

산출

양식 ( i , j ) 의 나머지 각 일치에 대해 세 가지 가능한 결과가 있습니다.

• 팀 내가 팀 : 승리 내가 도착 3 점을 팀, j는 얻을 수 0 점
• 팀 J 승리 : 팀 i 는 0 점을 얻 습니다. 팀 J 는 3 점을 얻습니다.
• 추첨 : 팀 i 와 j 모두 1 점을 얻습니다.

남은 모든 게임에 대해 어떤 결과가 나오면 결국 다른 팀이 세 번째 입력에 지정된 팀보다 더 많은 점수를 가지지 않도록 진실한 값을 출력해야합니다. 그렇지 않으면 거짓 값을 출력하십시오.

예 : 위 섹션의 예시 입력을 고려하십시오.

입력 1 = [93, 86, 78, 76, 75], 입력 2 = [(1,2), (4,3), (2,3), (3,2), (1,2)], 입력 3 =2

팀 2이 남은 경기에서 모두 이기면 (즉 (1,2), (2,3), (3,2), (1,2)) 4 * 3 = 12 추가 점수를 얻습니다. 다른 팀은이 경기에서 점수를 얻지 못합니다. 나머지 다른 경기 (즉 (4,3))가 무승부 라고 가정 해 봅시다 . 최종 점수는 다음과 같습니다.

 Team 1: 93, Team 2: 86 + 12 = 98, Team 3: 78 + 1 = 79, Team 4: 76 + 1 = 77, Team 5: 75

이것은 우리가 남은 경기에서 이미 다른 팀이 팀보다 더 많은 점수를 가지지 않는 결과를 찾았 음을 의미 2하므로이 입력의 결과는 진실해야합니다.

세부

• 첫 번째 입력이 순서가 지정된 순서라고 가정 할 수 있습니다. 즉 i < j 의 경우 i 번째 항목은 j 번째 항목 이상입니다. 제 1 입력은리스트, 문자열 등으로 받아 들여질 수있다.
• 두 번째 입력은 문자열, 튜플 목록 등으로 사용할 수 있습니다. 또는 나머지 일치 목록의 양식 항목 수인 2 차원 배열 a로 a[i][j]사용할 수 (i,j)있습니다. 예를 들어에 a[1][2] = 2, a[2][3] = 1, a[3][2] = 1, a[4][3] = 1 해당합니다 [(1,2), (4,3), (2,3), (3,2), (1,2)].
• 두 번째 및 세 번째 입력의 경우 1- 인덱싱 대신 0- 인덱싱을 가정 할 수 있습니다.
• 세 가지 입력을 순서에 상관없이 사용할 수 있습니다.

답변에서 선택한 정확한 입력 형식을 지정하십시오.

_{사이드 노드 :이 도전의 근본적인 문제는 " 축구 제거가 3 점 규칙에 따라 결정하기 어렵다 "에서 NP- 완전한 것으로 나타났습니다 . 흥미롭게도, 2 점만 이기면 다항식 시간에 문제를 해결할 수 있습니다.}

테스트 사례

모든 테스트 케이스는 형식으로되어 있습니다 Input1, Input2, Input3.

진실한 :

• [93, 86, 78, 76, 75], [(1,2), (4,3), (2,3), (3,2), (1,2)],2
• [50], [],1
• [10, 10, 10], [],3
• [15, 10, 8], [(2,3), (1,3), (1,3), (3,1), (2,1)],2

거짓 :

• [10, 9, 8], [],2
• [10, 9, 9], [(2,3), (3,2)],1
• [21, 12, 11], [(2,1), (1,2), (2,3), (1,3), (1,3), (3,1), (3,1)],2

우승자

이것은 code-golf 이므로 가장 짧은 정답 (바이트)이 이깁니다. 당첨자는 첫 정답이 게시 된 지 1 주일 후에 선정됩니다.

하스켈 (Lambdabot) , 84 바이트

바이트를 절약 해 주신 @bartavelle에게 감사드립니다.

Lambdabot이 없으면 개행에 20 바이트를 import Control.Lens추가하십시오.

이 함수는 0 인덱스의 OP에 설명 된 것과 동일한 순서로 인수를 취합니다. 두 번째 인수 (나머지 매치업 목록)는 단순한 인덱스 목록입니다 (예 :에 [1,2,4,1]해당 [(Team 1 vs Team 2), (Team 4 vs Team 1)]).

이것이 허용되는지 여부에 대한 규칙은 약간 모호합니다. 허용되지 않으면 함수는 예제에서 제공 한 형식 (튜플 목록)으로 입력을받을 수 있습니다. 이 경우, 인해 교체로,이 솔루션의 점수에 2 바이트를 추가 a:b:r로 (a,b):r.

(!)=(+~).element
(t?(a:b:r))s=any(t?r)[a!3$s,b!3$s,b!1$a!1$s]
(t?_)s=s!!t==maximum s

설명:

첫 번째 행은 !유형의 세 가지 변수 의 삽입 함수 를 정의하여 (!) :: Int -> Int -> [Int] -> [Int]목록의 지정된 색인에서 값을 증가시킵니다. 종종 코드가 단어보다 이해하기 쉬우므로 (하스켈 구문이 이상 할 수 있기 때문에) 다음은 파이썬 번역입니다.

def add(index, amount, items):
    items[index] += amount
    return items

두 번째 줄은 ?세 가지 변수 (도전 입력)의 또 다른 삽입 함수를 정의합니다 . 여기에서 더 읽기 쉽게 다시 작성하겠습니다.

(t ? a:b:r) s = any (t ? r) [a ! 3 $ s, b ! 3 $ s, (b ! 1 $ a) ! 1 $ s]
(t ? _) s = (s !! t) == maximum s

철저한 검색을 재귀 적으로 구현 한 것입니다. 남은 게임 목록에 대해 반복하여 세 가지 가능한 결과로 분기 한 다음 목록이 비어 있으면 팀에 최대 점수가 있는지 여부를 확인합니다. (비 아이디 오틱) 파이썬에서 다시 한 번 :

def can_still_win(standings, games_left, our_team):
    if games_left == []:
        return standings[our_team] == max(standings)
    team1, team2, other_games = games_left[0], games_left[1], games_left[2:]
    team1Wins, team2Wins, tie = standings.copy(), standings.copy(), standings.copy()
    team1Wins[team1] += 3
    team2Wins[team2] += 3
    tie[team1] += 1
    tie[team2] += 1
    return (can_still_win(team1Wins, other_games, our_team)
            or can_still_win(team2Wins, other_games, our_team)
            or can_still_win(tie, other_games, our_team))

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

^* 슬프게도 TiO는 Lens를 지원하지 않으므로이 링크는 실제로 실행되지 않습니다.

Microsoft SQL Server, 792 바이트

CREATE FUNCTION my.f(@s XML,@m XML,@ INT)RETURNS TABLE RETURN
WITH s AS(SELECT s.value('@p','INT')p FROM @s.nodes('S')s(s)),
m AS(SELECT m.value('@i','INT')i,m.value('@j','INT')j FROM @m.nodes('M')m(m)),
a AS(SELECT ROW_NUMBER()OVER(ORDER BY-p)t,p FROM s),
b AS(SELECT p+3*(SELECT COUNT(*)FROM m WHERE t IN(i,j))o FROM a WHERE t=@),
c AS(SELECT i,j,ROW_NUMBER()OVER(ORDER BY 1/0)k FROM m WHERE @ NOT IN(i,j)),
d AS(SELECT COUNT(*)u,POWER(3,COUNT(*))-1 v FROM c UNION ALL SELECT u,v-1 FROM d WHERE v>0),
e AS(SELECT v,u,v/3 q,v%3 r FROM d UNION ALL SELECT v,u-1,q/3,q%3 FROM e WHERE u>1),
f AS(SELECT v,p+SUM(IIF(t=i,r,(2-r))%3*3/2)s FROM a,c,e WHERE t IN(i,j)AND k=u GROUP BY v,t,p),
g AS(SELECT MAX(s)x FROM f GROUP BY v)SELECT SUM(IIF(o<ISNULL(x,p),0,1))f FROM a,(b OUTER APPLY g)WHERE t=1;

이 함수는 잘못된 결과에 대해 0을, 진실한 결과에 대해 0보다 큰 값을 반환합니다.

스 니펫 전체 :

SET NOCOUNT ON;
--USE tempdb;
USE rextester;
GO
IF SCHEMA_ID('my') IS NULL EXEC('CREATE SCHEMA my');
ELSE BEGIN
  IF OBJECT_ID('my.f', 'IF') IS NOT NULL DROP FUNCTION my.f;
  IF OBJECT_ID('my.s', 'U') IS NOT NULL DROP TABLE my.s;
  IF OBJECT_ID('my.m', 'U') IS NOT NULL DROP TABLE my.m;
  IF OBJECT_ID('my.c', 'U') IS NOT NULL DROP TABLE my.c;
END;
GO
CREATE TABLE my.c( -- Test cases
  c INT PRIMARY KEY CLUSTERED CHECK(c > 0), -- Test Case Id
  n INT CHECK(n > 0), -- Current position of the team of interest
);
CREATE TABLE my.s( -- Standings
  a INT FOREIGN KEY REFERENCES my.c(c) CHECK(a > 0), -- Test cAse Id
  p INT CHECK(p > 0) -- Team pts
);
CREATE TABLE my.m( -- Matches
  s INT FOREIGN KEY REFERENCES my.c(c) CHECK(s > 0), -- Test caSe Id
  i INT CHECK(i > 0), -- Team i
  j INT CHECK(j > 0), -- Team j
  CHECK(i != j)
);
GO
INSERT my.c(c, n) VALUES (1, 2), (2, 1), (3, 3), (4, 2), (5, 2), (6, 1), (7, 2);
INSERT my.s(a, p) VALUES (1, 93), (1, 86), (1, 78), (1, 76), (1, 75),
(2, 50), (3, 10), (3, 10), (3, 10), (4, 15), (4, 10), (4, 8),
(5, 10), (5, 9), (5, 8), (6, 10), (6, 9), (6, 9), (7, 21), (7, 12), (7, 11);
INSERT my.m(s, i, j) VALUES (1, 1, 2), (1, 4, 3), (1, 2, 3), (1, 3, 2), (1, 1, 2),
(4, 2, 3), (4, 1, 3), (4, 1, 3),(4, 3, 1), (4, 2, 1), (6, 2, 3), (6, 3, 2),
(7, 2, 1), (7, 1, 2), (7, 2, 3), (7, 1, 3), (7, 1, 3), (7, 3, 1), (7, 3, 1);
GO
CREATE FUNCTION my.f(@s XML,@m XML,@ INT)RETURNS TABLE RETURN
WITH s AS(SELECT s.value('@p','INT')p FROM @s.nodes('S')s(s)),
m AS(SELECT m.value('@i','INT')i,m.value('@j','INT')j FROM @m.nodes('M')m(m)),
a AS(SELECT ROW_NUMBER()OVER(ORDER BY-p)t,p FROM s),
b AS(SELECT p+3*(SELECT COUNT(*)FROM m WHERE t IN(i,j))o FROM a WHERE t=@),
c AS(SELECT i,j,ROW_NUMBER()OVER(ORDER BY 1/0)k FROM m WHERE @ NOT IN(i,j)),
d AS(SELECT COUNT(*)u,POWER(3,COUNT(*))-1 v FROM c UNION ALL SELECT u,v-1 FROM d WHERE v>0),
e AS(SELECT v,u,v/3 q,v%3 r FROM d UNION ALL SELECT v,u-1,q/3,q%3 FROM e WHERE u>1),
f AS(SELECT v,p+SUM(IIF(t=i,r,(2-r))%3*3/2)s FROM a,c,e WHERE t IN(i,j)AND k=u GROUP BY v,t,p),
g AS(SELECT MAX(s)x FROM f GROUP BY v)SELECT SUM(IIF(o<ISNULL(x,p),0,1))f FROM a,(b OUTER APPLY g)WHERE t=1;
GO
SELECT c, f
FROM my.c
OUTER APPLY(SELECT p FROM my.s S WHERE a = c FOR XML AUTO)S(s)
OUTER APPLY(SELECT i, j FROM my.m M WHERE s = c FOR XML AUTO)M(m)
OUTER APPLY my.f(s, m, n)
ORDER BY c
OPTION(MAXRECURSION 0);

온라인으로 확인하십시오!

파이썬 2, 242221 바이트

from itertools import*
def u(S,M,t,O):
 for m,o in zip(M,O):
  if t in m:S[t]+=3
  else:S[m[0]]+=(1,3,0)[o];S[m[1]]+=(1,0,3)[o]
 return S[t]>=max(S)
f=lambda s,m,t:any(u(s[:],m,t,O)for O in product([0,1,2],repeat=len(m)))

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

기본적인 골프 사고로 첫 패스 후. 0 기반 인덱싱으로 입력을 받습니다 . TIO의 테스트 사례는 기능을 통해이를 조정합니다 F.

그만큼 product([0,1,2],repeat=len(m))반복은 팀의이자 (TOI)를 제외하고 각각의 일치 넥타이 / 승리 / 손실을 통해 가능한 결과를 평가 (어떤에서 TOI는 항상 승리를 가정한다) 경기의 일부입니다.

자바 스크립트 (ES6), 145 바이트

(s,d,t,o=[],g=(c=s,i=0)=>d[i]?[3,,0,3,1,1].map((a,j)=>(j%=2,r=j?r:[...c],r[d[i][j]]+=a,g(r,i+1))):o.push(c))=>o.some(r=>r[t]==Math.max(...r),g())

점수 입력을 배열 ( [93,86,78,76,75])로, 다음 게임을 2 값 배열 ([[0,1],[3,2],[1,2],[2,1],[0,1]] )의 , 팀 색인을 정수 (1 ) . 모든 것은 0 인덱스입니다.

테스트 스 니펫

let f=
(s,d,t,o=[],g=(c=s,i=0)=>d[i]?[3,,0,3,1,1].map((a,j)=>(j%=2,r=j?r:[...c],r[d[i][j]]+=a,g(r,i+1))):o.push(c))=>o.some(r=>r[t]==Math.max(...r),g())

console.log("---Truthy---")
console.log(f([93, 86, 78, 76, 75], [[0,1], [3,2], [1,2], [2,1], [0,1]], 1))
console.log(f([50], [], 0))
console.log(f([10, 10, 10], [], 2))
console.log(f([15, 10, 8], [[1,2], [0,2], [0,2], [2,0], [1,0]], 1))
console.log("---Falsy---")
console.log(f([10, 9, 8], [], 1))
console.log(f([10, 9, 9], [[1,2],[2,1]], 0))
console.log(f([21, 12, 11], [[1,0], [0,1], [1,2], [0,2], [0,2], [2,0], [2,0]], 1))

.as-console-wrapper{max-height:100%!important}