Als Fan einer höchstens mäßig erfolgreichen Fußball- ^BE- Mannschaft frage ich mich gegen Ende der Saison oft, ob meine Lieblingsmannschaft noch theoretische Chancen hat, Meister zu werden. Ihre Aufgabe bei dieser Herausforderung ist es, diese Frage für mich zu beantworten.

Eingang

Sie erhalten drei Eingaben: die aktuelle Tabelle, die Liste der verbleibenden Spiele und die aktuelle Position der Mannschaft, an der wir interessiert sind.

Eingabe 1: Die aktuelle Tabelle , eine Folge von Zahlen, die die i- te Zahl sind, sind die Punkte, die Team i bisher gesammelt hat . Beispielsweise [93, 86, 78, 76, 75]codiert die Eingabe die folgende Tabelle (nur die letzte Spalte ist von Bedeutung):

Eingabe 2 : Die verbleibenden Übereinstimmungen , eine Folge von Tupeln, wobei jedes Tupel ( i , j ) für eine verbleibende Übereinstimmung zwischen Team i und j steht . Im obigen Beispiel würde eine zweite Eingabe von [(1,2), (4,3), (2,3), (3,2), (1,2)]bedeuten, dass die verbleibenden Übereinstimmungen sind:

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

Eingabe 3: Die aktuelle Position des Teams, an dem wir interessiert sind. Eine Eingabe 2für das obige Beispiel würde beispielsweise bedeuten, dass wir wissen möchten, ob Tottenham noch Champion werden kann.

Ausgabe

Für jede verbleibende Übereinstimmung der Form ( i , j ) gibt es drei mögliche Ergebnisse:

• Team i gewinnt: Team i erhält 3 Punkte , Team j erhält 0 Punkte
• Team j gewinnt: Team i erhält 0 Punkte , Team j erhält 3 Punkte
• Unentschieden: Team i und j erhalten beide 1 Punkt

Sie müssen einen Wahrheitswert ausgeben, wenn für alle verbleibenden Spiele ein Ergebnis vorliegt, sodass am Ende kein anderes Team mehr Punkte hat als das in der 3. Eingabe angegebene Team. Andernfalls geben Sie einen falschen Wert aus.

Beispiel : Betrachten Sie die beispielhafte Eingabe aus dem obigen Abschnitt:

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

Wenn das Team 2alle verbleibenden Spiele gewinnt (dh (1,2), (2,3), (3,2), (1,2)), erhält es 4 * 3 = 12 zusätzliche Punkte; Keines der anderen Teams erhält Punkte aus diesen Spielen. Nehmen wir an, das andere verbleibende Spiel (dh (4,3)) ist ein Unentschieden. Dann wären die Endergebnisse:

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

Dies bedeutet, dass wir für die verbleibenden Spiele bereits einige Ergebnisse erzielt haben 2, sodass kein anderes Team mehr Punkte als das Team hat. Daher muss die Ausgabe für diese Eingabe wahr sein.

Einzelheiten

• Sie können annehmen, dass die erste Eingabe eine geordnete Sequenz ist, dh für i < j ist der i- te Eintrag gleich oder größer als der j- te Eintrag. Die erste Eingabe kann als Liste, Zeichenfolge oder dergleichen verwendet werden.
• Sie können die zweite Eingabe als Zeichenfolge, Liste von Tupeln oder dergleichen verwenden. Alternativ können Sie es als zweidimensionales Array verwenden, awobei a[i][j]die Anzahl der Einträge des Formulars (i,j)in der Liste der verbleibenden Übereinstimmungen angegeben ist. Zum Beispiel a[1][2] = 2, a[2][3] = 1, a[3][2] = 1, a[4][3] = 1 entspricht [(1,2), (4,3), (2,3), (3,2), (1,2)].
• Für die zweite und dritte Eingabe können Sie eine 0-Indizierung anstelle einer 1-Indizierung annehmen.
• Sie können die drei Eingaben in beliebiger Reihenfolge vornehmen.

Bitte geben Sie das genaue Eingabeformat an, das Sie in Ihrer Antwort ausgewählt haben.

_{Seitenknoten : Das dieser Herausforderung zugrunde liegende Problem hat sich in " Fußball-Eliminierung ist nach der 3-Punkte-Regel schwer zu entscheiden " als NP-vollständig erwiesen . Interessanterweise wird das Problem in der Polynomzeit lösbar, wenn nur zwei Punkte für einen Sieg vergeben werden.}

Testfälle

Alle Testfälle im Format sind Input1, Input2, Input3.

Wahrheit:

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

Falsch:

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

Gewinner

Dies ist Code-Golf , daher gewinnt die kürzeste richtige Antwort (in Bytes). Der Gewinner wird eine Woche nach der ersten richtigen Antwort ausgewählt.

Haskell (Lambdabot) , 84 Bytes

Vielen Dank an @bartavelle für das Speichern eines Bytes.

Fügen Sie ohne Lambdabot 20 Bytes import Control.Lensplus eine neue Zeile hinzu.

Die Funktion nimmt ihre Argumente in der gleichen Reihenfolge wie im OP, 0-indiziert beschrieben. Das zweite Argument (die Liste der verbleibenden Übereinstimmungen) ist eine flache Liste von Indizes (z . B. [1,2,4,1]entspricht [(Team 1 vs Team 2), (Team 4 vs Team 1)]).

Die Regeln sind etwas vage, ob dies erlaubt ist oder nicht. Wenn dies nicht zulässig ist, kann die Funktion Eingaben in dem in den Beispielen angegebenen Format vornehmen - einer Liste von Tupeln. In diesem Fall fügen Sie 2 Bytes zu dieser Partitur-Lösung, wegen Ersatz a:b:rmit (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

Erläuterung:

Die erste Zeile definiert eine Infix-Funktion !aus drei Variablen vom Typ (!) :: Int -> Int -> [Int] -> [Int], die den Wert an einem bestimmten Index in einer Liste erhöht. Da Code häufig leichter zu verstehen ist als Wörter (und die Haskell-Syntax seltsam sein kann), ist hier eine Python-Übersetzung:

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

Die zweite Zeile definiert eine weitere Infix-Funktion ?, die ebenfalls aus drei Variablen besteht (die Challenge-Eingabe). Ich werde es hier besser lesbar umschreiben:

(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

Dies ist eine rekursive Implementierung einer umfassenden Suche. Es wird die Liste der verbleibenden Spiele wiederholt, wobei auf die drei möglichen Ergebnisse verzweigt wird. Sobald die Liste leer ist, wird überprüft, ob unser Team die maximale Anzahl von Punkten hat oder nicht. Auch in (nicht idiomatischem) Python ist dies:

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

Probieren Sie es online aus!

^* Leider unterstützt TiO Lens nicht, sodass dieser Link nicht ausgeführt wird.

Microsoft SQL Server, 792 Byte

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;

Die Funktion gibt 0 für ein falsches Ergebnis und mehr als 0 für ein wahres Ergebnis zurück.

Der ganze Ausschnitt:

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

Überprüfen Sie es 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)))

Probieren Sie es online aus!

Nach einem ersten Durchgang mit grundlegendem Golfdenken. Nimmt Eingaben mit 0-basierter Indizierung vor ; Testfälle in TIO passen dies über die Funktion an F.

Die product([0,1,2],repeat=len(m))Iteration bewertet die möglichen Ergebnisse über Unentschieden / Gewinn / Verlust für jedes Spiel, es sei denn, das interessierende Team (TOI) ist Teil des Spiels (bei dem immer davon ausgegangen wird, dass der TOI gewinnt).

JavaScript (ES6), 145 Byte

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

Nimmt die Score-Eingabe als Array ( [93,86,78,76,75]), die kommenden Spiele als Array von Arrays mit zwei Werten ( [[0,1],[3,2],[1,2],[2,1],[0,1]]) und den Teamindex als Ganzzahl ( 1). Alles ist 0-indiziert.

Test-Snippet

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}