En tant que fan d'une équipe de football ^BE au plus modérément réussie, je me demande souvent vers la fin de la saison si mon équipe préférée a encore une chance théorique de devenir champion. Votre tâche dans ce défi est de répondre à cette question pour moi.

Contribution

Vous recevrez trois entrées: le tableau actuel, la liste des matchs restants et la position actuelle de l'équipe qui nous intéresse.

Entrée 1: Le tableau actuel , une séquence de nombres étaient le i- ème nombre sont les points gagnés par l'équipe i jusqu'à présent. Par exemple, l'entrée [93, 86, 78, 76, 75]code le tableau suivant (seule la dernière colonne est importante):

Entrée 2 : Les matchs restants , une séquence de tuples où chaque tuple ( i , j ) représente un match restant entre l'équipe i et j . Dans l'exemple ci-dessus, une deuxième entrée de [(1,2), (4,3), (2,3), (3,2), (1,2)]signifierait que les correspondances restantes sont:

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

Entrée 3: La position actuelle de l'équipe qui nous intéresse. Par exemple, une entrée de 2pour l'exemple ci-dessus signifierait que nous aimerions savoir si Tottenham peut toujours devenir champion.

Production

Pour chaque correspondance restante du formulaire ( i , j ), il y a trois résultats possibles:

• L'équipe i gagne: l'équipe i obtient 3 points , l'équipe j obtient 0 point
• L'équipe j gagne: l'équipe i obtient 0 point , l'équipe j obtient 3 points
• Match nul: les équipes i et j obtiennent 1 point

Vous devez produire une valeur véridique s'il y a un résultat pour tous les jeux restants de sorte qu'à la fin, aucune autre équipe n'ait plus de points que l'équipe spécifiée dans la 3ème entrée. Sinon, affichez une valeur fausse.

Exemple : Considérez l'apport exemplaire de la section ci-dessus:

Entrée 1 = [93, 86, 78, 76, 75], Entrée 2 = [(1,2), (4,3), (2,3), (3,2), (1,2)], Entrée 3 =2

Si l'équipe 2gagne tous ses matchs restants (c'est-à-dire (1,2), (2,3), (3,2), (1,2)), elle obtient 4 * 3 = 12 points supplémentaires; aucune des autres équipes n'obtient de points de ces matchs. Disons que l'autre match restant (ie (4,3)) est un match nul. Ensuite, les scores finaux seraient:

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

Cela signifie que nous avons déjà trouvé des résultats pour les matchs restants de sorte qu'aucune autre équipe n'a plus de points que l'équipe 2, donc la sortie pour cette entrée doit être véridique.

Détails

• Vous pouvez en déduire la première entrée à une séquence ordonnée, soit pour i < j , l' i entrée -ième est égale ou supérieure à la j entrée -ième. La première entrée peut être considérée comme une liste, une chaîne ou similaire.
• Vous pouvez prendre la deuxième entrée sous forme de chaîne, une liste de tuples ou similaires. Alternativement, vous pouvez le prendre comme un tableau à deux dimensions aoù a[i][j]est le nombre d'entrées du formulaire (i,j)dans la liste des correspondances restantes. Par exemple, a[1][2] = 2, a[2][3] = 1, a[3][2] = 1, a[4][3] = 1 correspond à [(1,2), (4,3), (2,3), (3,2), (1,2)].
• Pour les deuxième et troisième entrées, vous pouvez supposer une indexation 0 au lieu d'une indexation 1.
• Vous pouvez prendre les trois entrées dans n'importe quel ordre.

Veuillez spécifier le format de saisie exact que vous avez choisi dans votre réponse.

_{Noeud latéral : Le problème sous-jacent à ce défi s'est avéré être NP-complet dans "L' élimination du football est difficile à décider selon la règle des 3 points ". Fait intéressant, si seulement deux points sont accordés pour une victoire, le problème devient résoluble en temps polynomial.}

Cas de test

Tous les tests sont au format Input1, Input2, Input3.

Vérité:

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

Gagnant

Il s'agit de code-golf , donc la réponse correcte la plus courte (en octets) l'emporte. Le gagnant sera choisi une semaine après la publication de la première bonne réponse.

Haskell (Lambdabot) , 84 octets

Merci à @bartavelle de m'avoir sauvé un octet.

Sans Lambdabot, ajoutez 20 octets pour import Control.Lensplus une nouvelle ligne.

La fonction prend ses arguments dans le même ordre que celui décrit dans l'OP, indexé 0. Son deuxième argument (la liste des correspondances restantes) est une liste plate d'index (par exemple [1,2,4,1]correspond à [(Team 1 vs Team 2), (Team 4 vs Team 1)]).

Les règles sont un peu vagues quant à savoir si cela est autorisé ou non. Si ce n'est pas autorisé, la fonction peut prendre une entrée dans le format fourni par les exemples - une liste de tuples. Dans ce cas, ajoutez 2 octets au score de cette solution, en raison du remplacement a:b:rpar (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

Explication:

La première ligne définit une fonction infixe !de trois variables, de type (!) :: Int -> Int -> [Int] -> [Int], qui incrémente la valeur à un index donné dans une liste. Puisque, souvent, le code est plus facile à comprendre que les mots (et puisque la syntaxe Haskell peut être bizarre), voici une traduction Python:

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

La deuxième ligne définit une autre fonction d'infixe ?, également de trois variables (l'entrée challenge). Je vais le réécrire de façon plus lisible ici:

(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

Il s'agit d'une implémentation récursive d'une recherche exhaustive. Il revient sur la liste des matchs restants, se ramifiant sur les trois résultats possibles, puis, une fois la liste vide, vérifiant si notre équipe a le nombre maximum de points. Encore une fois en Python (non idiomatique), c'est:

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

Essayez-le en ligne!

^* Malheureusement, TiO ne prend pas en charge Lens, donc ce lien ne fonctionnera pas réellement.

Microsoft SQL Server, 792 octets

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;

La fonction retourne 0 pour un faux résultat et plus de 0 pour un vrai.

L'extrait entier:

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

Vérifiez-le en ligne!

Python 2, 242 221 octets

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

Essayez-le en ligne!

Après une première passe avec des notions de golf de base. Prend des entrées avec une indexation basée sur 0 ; les cas de test dans TIO s'ajustent pour cela via la fonction F.

L' product([0,1,2],repeat=len(m))itération évalue les résultats possibles sur égalité / victoire / perte pour chaque match, sauf si l'équipe d'intérêt (TOI) fait partie du match (dans lequel, la TOI est toujours supposée gagner).

JavaScript (ES6), 145 octets

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

Prend l'entrée de score sous forme de tableau ( [93,86,78,76,75]), les jeux à venir sous forme de tableau de tableaux à 2 valeurs ( [[0,1],[3,2],[1,2],[2,1],[0,1]]) et l'index de l'équipe sous forme d'entier ( 1). Tout est indexé 0.

Extrait de test

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}