Como fã de um futebol de sucesso moderado, ^BE equipe, no final da temporada Muitas vezes me pergunto se o meu time favorito ainda tem alguma chance teórica deixou de se tornar campeão. Sua tarefa neste desafio é responder a essa pergunta para mim.

Entrada

Você receberá três entradas: a tabela atual, a lista de partidas restantes e a posição atual do time em que estamos interessados.

Entrada 1: A tabela atual , uma sequência de números, é o i- ésimo número dos pontos conquistados pela equipe i até o momento. Por exemplo, a entrada [93, 86, 78, 76, 75]codifica a tabela a seguir (apenas a última coluna é importante):

Entrada 2 : Os restantes jogos , uma sequência de tuplos onde cada tuplo ( i , j ) representa um fósforo remanescente entre equipa i e j . No exemplo acima, uma segunda entrada de [(1,2), (4,3), (2,3), (3,2), (1,2)]significaria que as correspondências restantes são:

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

Entrada 3: A posição atual da equipe na qual estamos interessados. Por exemplo, uma entrada de2 exemplo acima significaria que gostaríamos de saber se o Tottenham ainda pode ser campeão.

Resultado

Para cada correspondência restante do formulário ( i , j ), há três resultados possíveis:

• Equipe i ganha: Equipe i recebe 3 pontos , equipe j recebe 0 pontos
• A equipe j vence: a equipe i recebe 0 pontos , a equipe j recebe 3 pontos
• Draw: Equipe i e j tanto obter 1 ponto

Você deve gerar um valor verdadeiro se houver algum resultado para todos os jogos restantes, de modo que, no final, nenhuma outra equipe tenha mais pontos do que a equipe especificada na 3ª entrada. Caso contrário, imprima um valor falso.

Exemplo : considere a entrada exemplar da seção acima:

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

Se a equipe 2vencer todas as suas partidas restantes (ie (1,2), (2,3), (3,2), (1,2)), recebe 4 * 3 = 12 pontos adicionais; nenhuma das outras equipes ganha pontos nesses jogos. Digamos que a outra partida restante (ou seja (4,3)) seja um empate. Então a pontuação final seria:

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

Isso significa que já encontramos algum resultado para as partidas restantes, de modo que nenhuma outra equipe tenha mais pontos que a equipe 2, portanto, o resultado dessa entrada deve ser verdadeiro.

Detalhes

• Você pode assumir que a primeira entrada é uma sequência ordenada, ou seja, para i < j , a i- ésima entrada é igual ou maior que a j- ésima entrada. A primeira entrada pode ser tomada como uma lista, uma string ou algo semelhante.
• Você pode considerar a segunda entrada como uma string, uma lista de tuplas ou similares. Como alternativa, você pode tomá-lo como uma matriz bidimensional, aonde a[i][j]está o número de entradas do formulário (i,j)na lista de correspondências restantes. Por exemplo, a[1][2] = 2, a[2][3] = 1, a[3][2] = 1, a[4][3] = 1 corresponde a [(1,2), (4,3), (2,3), (3,2), (1,2)].
• Para a segunda e terceira entrada, você pode assumir a indexação 0 em vez da indexação 1.
• Você pode pegar as três entradas em qualquer ordem.

Especifique o formato exato de entrada que você escolheu na sua resposta.

_{Nó lateral : O problema subjacente a este desafio foi mostrado como NP-completo em "A eliminação do futebol é difícil de decidir sob a regra dos 3 pontos ". Curiosamente, se apenas dois pontos são concedidos por uma vitória, o problema se torna solucionável no tempo polinomial.}

Casos de teste

Todos os casos de teste estão no formato Input1, Input2, Input3.

Verdade:

• [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

Falsy:

• [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

Vencedora

Isso é código-golfe , então a resposta correta mais curta (em bytes) vence. O vencedor será escolhido uma semana após a publicação da primeira resposta correta.

Haskell (Lambdabot) , 84 bytes

Obrigado a @bartavelle por me salvar um byte.

Sem o Lambdabot, adicione 20 bytes para import Control.Lensmais uma nova linha.

A função recebe seus argumentos na mesma ordem descrita no OP, indexado em 0. Seu segundo argumento (a lista de correspondências restantes) é uma lista simples de índices (por exemplo, [1,2,4,1]corresponde a [(Team 1 vs Team 2), (Team 4 vs Team 1)]).

As regras são um pouco vagas sobre se isso é ou não permitido. Se não for permitido, a função pode receber entradas no formato fornecido pelos exemplos - uma lista de tuplas. Nesse caso, adicione 2 bytes à pontuação desta solução, devido à substituição a:b:rpor (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

Explicação:

A primeira linha define uma função infix !de três variáveis, do tipo (!) :: Int -> Int -> [Int] -> [Int], que incrementa o valor em um determinado índice em uma lista. Como, muitas vezes, o código é mais fácil de entender do que as palavras (e como a sintaxe de Haskell pode ser estranha), aqui está uma tradução do Python:

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

A segunda linha define outra função infix ?, também de três variáveis ​​(a entrada de desafio). Vou reescrevê-lo mais facilmente aqui:

(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

Esta é uma implementação recursiva de pesquisa exaustiva. Ele repete-se na lista de jogos restantes, ramificando-se nos três resultados possíveis e, depois que a lista estiver vazia, verificando se nossa equipe tem ou não o número máximo de pontos. Novamente no Python (não-idiomático), é o seguinte:

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

Experimente online!

^* Infelizmente, TiO não suporta Lens, de modo que este link não vai realmente funcionar.

Microsoft SQL Server, 792 bytes

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;

A função retorna 0 para um resultado falso e mais de 0 para um resultado verdadeiro.

Todo o trecho:

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

Verifique Online!

Python 2, 242 221 bytes

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

Experimente online!

Após um primeiro passe com o pensamento básico do golfe. Recebe entrada com indexação baseada em 0 ; casos de teste em TIO ajustar para este através da função F.

A product([0,1,2],repeat=len(m))iteração avalia os possíveis resultados sobre empate / vitória / derrota para cada partida, a menos que a equipe de interesse (TOI) faça parte da partida (na qual se presume que a TOI sempre vence).

JavaScript (ES6), 145 bytes

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

Leva a entrada de pontuação como uma matriz ( [93,86,78,76,75]), os próximos jogos como uma matriz de matrizes de 2 valores ( [[0,1],[3,2],[1,2],[2,1],[0,1]]) e o índice da equipe como um número inteiro ( 1). Tudo é indexado em 0.

Snippet de teste

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}