Come fan di una squadra di calcio di successo moderatamente ^alto , verso la fine della stagione mi chiedo spesso se la mia squadra del cuore abbia ancora qualche possibilità teorica di diventare campione. Il tuo compito in questa sfida è rispondere a quella domanda per me.

Ingresso

Riceverai tre input: la tabella corrente, l'elenco delle partite rimanenti e la posizione attuale della squadra a cui siamo interessati.

Ingresso 1: La tabella corrente , una sequenza di numeri sono stati il I numero di -esimo sono i punti ottenuti dal team mi finora. Ad esempio, l'input [93, 86, 78, 76, 75]codifica la seguente tabella (solo l'ultima colonna è importante):

Input 2 : le partite rimanenti , una sequenza di tuple in cui ciascuna tupla ( i , j ) rappresenta una partita rimanente tra la squadra i e j . Nell'esempio sopra, un secondo input di [(1,2), (4,3), (2,3), (3,2), (1,2)]significherebbe che le rimanenti corrispondenze sono:

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

Input 3: l' attuale posizione della squadra a cui siamo interessati. Ad esempio, un input 2per l'esempio sopra significherebbe che vorremmo sapere se il Tottenham può ancora diventare campione.

Produzione

Per ogni corrispondenza rimanente del modulo ( i , j ), ci sono tre possibili esiti:

• La squadra i vince: la squadra i ottiene 3 punti , la squadra j ottiene 0 punti
• La squadra j vince: la squadra i ottiene 0 punti , la squadra j ottiene 3 punti
• Draw: Squadra i e j sia ottenere 1 punto

Devi ottenere un valore veritiero se ci sono dei risultati per tutte le partite rimanenti in modo tale che alla fine nessun'altra squadra abbia più punti di quelli specificati nel 3 ° input. Altrimenti, genera un valore errato.

Esempio : considerare l'input esemplare della sezione precedente:

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

Se la squadra 2vince tutte le partite rimanenti (ovvero (1,2), (2,3), (3,2), (1,2)), ottiene 4 * 3 = 12 punti aggiuntivi; nessuna delle altre squadre ottiene punti da queste partite. Diciamo che l'altra partita rimanente (cioè (4,3)) è un pareggio. Quindi i punteggi finali sarebbero:

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

Ciò significa che abbiamo già trovato alcuni risultati per le partite rimanenti in modo tale che nessun'altra squadra abbia più punti della squadra 2, quindi l'output per questo input deve essere veritiero.

Dettagli

• Si può presumere che il primo input sia una sequenza ordinata, cioè per i < j , la i -esima voce è uguale o maggiore della j -esima voce. Il primo input può essere preso come un elenco, una stringa o simili.
• Puoi prendere il secondo input come una stringa, un elenco di tuple o simili. In alternativa, puoi prenderlo come un array bidimensionale in acui a[i][j]è il numero di voci del modulo (i,j)nell'elenco delle corrispondenze rimanenti. Ad esempio, a[1][2] = 2, a[2][3] = 1, a[3][2] = 1, a[4][3] = 1 corrisponde a [(1,2), (4,3), (2,3), (3,2), (1,2)].
• Per il secondo e il terzo input, puoi assumere 0-indicizzazione invece di 1-indicizzazione.
• Puoi prendere i tre ingressi in qualsiasi ordine.

Si prega di specificare l'esatto formato di input scelto nella risposta.

_{Nodo laterale : il problema alla base di questa sfida è stato dimostrato essere NP-completo in "L' eliminazione del calcio è difficile da decidere in base alla regola dei 3 punti ". È interessante notare che se vengono assegnati solo due punti per una vittoria, il problema diventa risolvibile in tempi polinomiali.}

Casi test

Tutti i casi di test sono nel formato Input1, Input2, Input3.

Truthy:

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

Vincitore

Questo è code-golf , quindi vince la risposta corretta più breve (in byte). Il vincitore verrà scelto una settimana dopo la pubblicazione della prima risposta corretta.

Haskell (Lambdabot) , 84 byte

Grazie a @bartavelle per avermi salvato un byte.

Senza Lambdabot, aggiungi 20 byte per import Control.Lenspiù una nuova riga.

La funzione accetta i suoi argomenti nello stesso ordine descritto nell'OP, indicizzato 0. Il suo secondo argomento (l'elenco dei matchup rimanenti) è un elenco semplice di indici (ad es. [1,2,4,1]Corrisponde a [(Team 1 vs Team 2), (Team 4 vs Team 1)]).

Le regole sono un po 'vaghe sul fatto che ciò sia permesso o meno. Se non è consentito, la funzione può accettare input nel formato fornito dagli esempi: un elenco di tuple. In tal caso, aggiungere 2 byte al punteggio di questa soluzione, a causa della sostituzione a:b:rcon (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

Spiegazione:

La prima riga definisce una funzione !di infissione di tre variabili, di tipo (!) :: Int -> Int -> [Int] -> [Int], che incrementa il valore in corrispondenza di un determinato indice in un elenco. Poiché, spesso, il codice è più facile da capire delle parole (e poiché la sintassi di Haskell può essere strana), ecco una traduzione di Python:

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

La seconda riga definisce un'altra funzione infix ?, anche di tre variabili (input challenge). Lo riscriverò più facilmente qui:

(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

Questa è un'implementazione ricorsiva della ricerca esaustiva. Ricorre sull'elenco delle partite rimanenti, ramificando i tre possibili risultati, quindi, una volta che l'elenco è vuoto, controlla se il nostro team ha il numero massimo di punti. Ancora in Python (non idiomatico), questo è:

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

Provalo online!

^* Purtroppo, TiO non supporta Lens, quindi questo link in realtà non verrà eseguito.

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;

La funzione restituisce 0 per un risultato falso e più di 0 per un risultato veritiero.

L'intero frammento:

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

Controllalo online!

Python 2, 242 221 byte

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

Provalo online!

Dopo un primo passaggio con il pensiero di base del golf. Accetta input con indicizzazione basata su 0 ; i casi di test in TIO si adattano a questo tramite la funzione F.

L' product([0,1,2],repeat=len(m))iterazione valuta i possibili esiti su pareggio / vincita / sconfitta per ogni partita a meno che il team di interesse (TOI) non faccia parte della partita (in cui si presume sempre che il TOI vinca).

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

Accetta l'input del punteggio come array ( [93,86,78,76,75]), i giochi in arrivo come array di array a 2 valori ( [[0,1],[3,2],[1,2],[2,1],[0,1]]) e l'indice di squadra come numero intero ( 1). Tutto è indicizzato 0.

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}