Chi è il re del torneo?

13

sfondo

Prendi in considerazione un torneo round robin, in cui ogni concorrente gioca una partita contro ogni altro concorrente. Non ci sono pareggi, quindi ogni partita ha un vincitore e un perdente. Un concorrente A è un re del torneo, se per ogni altro concorrente B , sia A sfiora B , o A sfiora altro concorrente C che a sua volta battuta B . Si può dimostrare che ogni torneo ha almeno un re (anche se possono essercene diversi). In questa sfida, il tuo compito è trovare i re di un determinato torneo.

Ingresso e uscita

Il tuo contributo è una N × Nmatrice booleana Te, facoltativamente, il numero N ≥ 2di concorrenti. Ogni voce T[i][j]rappresenta il risultato del gioco tra concorrenti ie j, con valore 1 che rappresenta una vittoria per ie 0 una vittoria per j. Si noti che T[i][j] == 1-T[j][i]se i != j. La diagonale di è Tcomposta da 0 secondi.

Il tuo risultato sarà l'elenco dei re del torneo che Trappresenta, usando l'indicizzazione basata su 0 o 1. L'ordine dei re è irrilevante, ma non dovrebbero esserci duplicati.

Sia l'input che l'output possono essere presi in qualsiasi formato ragionevole.

Regole e punteggio

È possibile scrivere un programma completo o una funzione. Vince il conteggio di byte più basso e non sono consentite scappatoie standard .

Casi test

Questi casi di test utilizzano l'indicizzazione basata su 0. Per l'indicizzazione basata su 1, incrementare ciascun valore di output.

 2 [[0,0],[1,0]] -> [1]
 3 [[0,1,0],[0,0,0],[1,1,0]] -> [2]
 3 [[0,1,0],[0,0,1],[1,0,0]] -> [0,1,2]
 4 [[0,1,1,1],[0,0,1,0],[0,0,0,0],[0,1,1,0]] -> [0]
 4 [[0,1,1,0],[0,0,1,0],[0,0,0,1],[1,1,0,0]] -> [0,2,3]
 5 [[0,1,0,0,1],[0,0,0,0,1],[1,1,0,0,0],[1,1,1,0,1],[0,0,1,0,0]] -> [3]
 5 [[0,1,0,1,0],[0,0,1,1,1],[1,0,0,0,0],[0,0,1,0,1],[1,0,1,0,0]] -> [0,1,4]
 5 [[0,0,0,0,0],[1,0,1,1,0],[1,0,0,0,1],[1,0,1,0,1],[1,1,0,0,0]] -> [1,3,4]
 6 [[0,0,0,0,0,0],[1,0,1,1,0,0],[1,0,0,1,1,0],[1,0,0,0,1,1],[1,1,0,0,0,1],[1,1,1,0,0,0]] -> [1,2,3,4,5]
 6 [[0,0,1,1,1,0],[1,0,0,1,1,1],[0,1,0,0,1,0],[0,0,1,0,0,1],[0,0,0,1,0,1],[1,0,1,0,0,0]] -> [0,1,2,3,5]
 6 [[0,1,1,0,0,1],[0,0,0,1,0,1],[0,1,0,1,1,0],[1,0,0,0,1,1],[1,1,0,0,0,0],[0,0,1,0,1,0]] -> [0,1,2,3,4,5]
 8 [[0,0,1,1,0,1,1,1],[1,0,1,0,1,1,0,0],[0,0,0,1,1,0,0,0],[0,1,0,0,0,1,0,0],[1,0,0,1,0,1,0,0],[0,0,1,0,0,0,1,0],[0,1,1,1,1,0,0,1],[0,1,1,1,1,1,0,0]] -> [0,1,4,6,7]
20 [[0,0,1,1,0,1,1,0,0,0,0,1,1,0,1,1,1,1,0,1],[1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1],[0,0,0,1,0,0,0,1,1,0,1,0,1,0,0,0,0,0,1,1],[0,0,0,0,1,1,1,1,1,1,1,1,0,0,1,0,0,1,1,1],[1,0,1,0,0,0,0,1,1,0,1,1,1,0,1,1,1,1,0,1],[0,1,1,0,1,0,1,1,1,1,1,0,1,1,1,0,1,1,0,1],[0,0,1,0,1,0,0,1,1,0,1,0,1,1,1,1,1,0,1,0],[1,0,0,0,0,0,0,0,1,0,1,1,1,1,0,0,1,1,1,0],[1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,1,1],[1,0,1,0,1,0,1,1,0,0,1,0,0,0,0,1,0,1,1,1],[1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,0,0,0],[0,1,1,0,0,1,1,0,0,1,0,0,1,1,1,1,1,0,1,1],[0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,1,0,1,1,1],[1,0,1,1,1,0,0,0,0,1,0,0,1,0,1,1,1,1,1,1],[0,0,1,0,0,0,0,1,0,1,1,0,0,0,0,1,1,0,0,1],[0,0,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,1],[0,0,1,1,0,0,0,0,0,1,1,0,1,0,0,1,0,0,1,1],[0,0,1,0,0,0,1,0,1,0,1,1,0,0,1,0,1,0,1,1],[1,0,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,1,0]] -> [0,1,3,4,5,7,8,11,15,17,18]
code-golf  array-manipulation 
— Zgarb
fonte
(Esistono limiti di tempo di esecuzione o di memoria?) Nevermind. Ho frainteso completamente le specifiche.
— Dennis,
@Dennis Nope. Finché il tuo programma funzionerebbe teoricamente con un tempo e una memoria illimitati, stai bene.
— Zgarb,
Giusto per chiarire: T [a] [b] è la stessa corrispondenza di T [b] [a] ma visto da un angolo opposto, quindi T [a] [b] ==! T [b] [a]
— edc65
@ edc65 Questa è una buona osservazione. L'ho modificato nella sfida.
— Zgarb,

Risposte:

9

Matlab, 36 35 29 byte

@(T,N)find(sum(T*T>-T,2)>N-2)

Scopriamo se iè un re. Quindi per ciascuno jil valore T[i][j]==1 OR there is a k such that T[i][k] * T[k][l] == 1. Ma la seconda condizione può anche essere sostituita da sum_over_k(T[i][k] * T[k][l])>0, ma questa è solo una voce della matrice T*T(se si considera Tuna matrice). Il ORpuò quindi essere riprodotto aggiungendo Ta quel risultato, quindi dobbiamo solo controllare se n-1i valori della riga idi T*T+Tsono maggiori di zero, per vedere se iè re. Questo è esattamente ciò che fa la mia funzione.

(Questo è MATLAB, quindi gli indici sono basati su 1).

Le matrici MATLAB devono essere codificate con punti e virgola come delimitatori di riga:

[[0,0,0,0,0];[1,0,1,1,0];[1,0,0,0,1];[1,0,1,0,1];[1,1,0,0,0]]
— flawr
fonte
Probabilmente puoi salvare qualche byte prendendo il numero di concorrenti come input, invece di farlosize(T,1)
— Luis Mendo,
7

Gelatina, 13 12 11 byte

a"€¹o/€oḅ1M

L'output è basato su 1. Provalo online!

In alternativa, usando operatori bit per bit invece di manipolazione di array:

×Ḅ|/€|ḄBS€M

Ancora una volta, l'output è basato su 1. Provalo online!

sfondo

Per concorrente A , possiamo vedere tutti B tale che A sfiora C battito B prendendo tutte le righe che corrispondono ad un C tale che C sfiora A . IFR il B esimo ingresso del C ° è 1 , si ha che C battito B .

Se calcoliamo gli OR logici di tutte le voci corrispondenti delle colonne selezionate, otteniamo un singolo vettore che indica se A battito B per transitività o meno. Infine, ORing il vettore risultante con la riga corrispondente della matrice di input fornisce ai booleani A il battito B , sia per transitività che direttamente.

Ripetendo questo per ogni riga, contiamo il numero di 1 in ciascun vettore, calcolando quindi la quantità di concorrenti ogni A battitoI conteggi massimi corrispondono ai re del torneo.

Come funziona

a"€¹o/€oḅ1M  Main link. Argument: M (matrix)

   ¹         Yield M.
  €          For each row of M:
a"           Take the logical AND of each entry of that row and the corr. row of M.
    o/€      Reduce each resulting matrix by logical OR.
       o     Take the logical OR of the entries of the resulting maxtrix and the
             corr. entries of M.
        ḅ1   Convert each row from base 1 to integer, i.e. sum its elements.
          M  Get all indices of maximal sums.

×Ḅ|/€|ḄBS€M  Main link. Argument: M (matrix)

 Ḅ           Convert each row of M from base 2 to integer. Result: R
×            Multiply the entries of each column of M by the corr. integer.
  |/€        Reduce each row fo the resulting matrix by bitwise OR.
     |Ḅ      Bitwise OR the results with R.
       BS€   Convert to binary and reduce by sum.
             This counts the number of set bits for each integer.
          M  Get all indices of maximal popcounts.
— Dennis
fonte
1
Sai, la gente continua a postare questi messaggi dicendo "byte" x, ma "ḅ" è davvero codificato in 1 byte in una codifica standard? Mi dispiace, ma trovo che questi linguaggi basati su stack iper-condensati non siano affatto interessanti perché è come imbrogliare assegnare ogni funzione immaginabile a un carattere unicode.
— MattPutnam,
2
@MattPutnam Jelly utilizza la propria codifica personalizzata. (Inoltre non è basato su stack)
— uno spaghetto del
2
@MattPutnam Ho avuto sentimenti simili, ma non togliono nulla al golf tradizionale. Nessuno guarda in basso le lingue tradizionali solo perché esistono, e diversamente dagli altri siti SE, questo non ha esattamente "questa risposta è oggettivamente migliore di quella risposta". Inoltre, anche se tecnicamente non sono vietati, non modificano il linguaggio per supportare una domanda (anche se, in realtà, possono realizzare una scorciatoia utile per domande future e renderla un'operazione).
— corsiKa
Perché questi algoritmi producono i re?
— xnor
@Dennis Vedo ora, la sua moltiplicazione della matrice fondamentalmente booleana fatta tramite logica o aritmetica di bit. La moltiplicazione della matrice effettiva non sarebbe più breve?
— xnor
2

Python utilizza numpy, 54 byte

import numpy
lambda M:(M**0+M+M*M).all(1).nonzero()[0]

Accetta una matrice numpy, genera una matrice di righe numpy di indici basati su 0.

Un altro modo di pensare a un re è come un concorrente per il quale tutti i concorrenti sono nell'unione del re, le persone che il re batte e le persone che quelle persone battono. In altre parole, per ogni concorrente, esiste un percorso di lunghezza al massimo 2 dal re a loro tra la relazione "beat".

La matrice I + M + M*Mcodifica il numero di percorsi di 0, 1 o 2 passi da ciascuna sorgente a ciascun target. Un giocatore è un re se la sua fila di questa matrice ha solo voci positive. Poiché 0 è Falsey, allci dice se una riga è tutta diversa da zero. Lo applichiamo a ciascuna riga e produciamo gli indici dei risultati diversi da zero.

— XNOR
fonte
Sembra esattamente il mio approccio, ma con un'interpretazione
— diversa
2

JavaScript (ES6), 83 byte

a=>a.map((b,i)=>b.every((c,j)=>c|i==j|b.some((d,k)=>d&a[k][j]))&&r.push(i),r=[])&&r
— Neil
fonte
Puoi salvare 1 con a => a.map ((b, i) => b.every ((c, j) => c | i == j | b.some ((d, k) => d & a [ k] [j])) && i + 1) .filter (a => a) ma significa che devi produrre 1-indicizzato, il che è un grosso problema
— Charlie Wynn,
2

MATL , 12 10 9 byte

Xy+HY^!Af

L'input è: prima il numero di concorrenti e su una riga separata una matrice con righe separate da punti e virgola. L'output è basato su 1.

Ad esempio, il quinto caso di test ha input

4
[0,1,1,0; 0,0,1,0; 0,0,0,1; 1,1,0,0]

e l'ultimo caso di test ha input

20
[0,0,1,1,0,1,1,0,0,0,0,1,1,0,1,1,1,1,0,1; 1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1; 0,0,0,1,0,0,0,1,1,0,1,0,1,0,0,0,0,0,1,1; 0,0,0,0,1,1,1,1,1,1,1,1,0,0,1,0,0,1,1,1; 1,0,1,0,0,0,0,1,1,0,1,1,1,0,1,1,1,1,0,1; 0,1,1,0,1,0,1,1,1,1,1,0,1,1,1,0,1,1,0,1; 0,0,1,0,1,0,0,1,1,0,1,0,1,1,1,1,1,0,1,0; 1,0,0,0,0,0,0,0,1,0,1,1,1,1,0,0,1,1,1,0; 1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,1,1; 1,0,1,0,1,0,1,1,0,0,1,0,0,0,0,1,0,1,1,1; 1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,0,0,0; 0,1,1,0,0,1,1,0,0,1,0,0,1,1,1,1,1,0,1,1; 0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,1,0,1,1,1; 1,0,1,1,1,0,0,0,0,1,0,0,1,0,1,1,1,1,1,1; 0,0,1,0,0,0,0,1,0,1,1,0,0,0,0,1,1,0,0,1; 0,0,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,1; 0,0,1,1,0,0,0,0,0,1,1,0,1,0,0,1,0,0,1,1; 0,0,1,0,0,0,1,0,1,0,1,1,0,0,1,0,1,0,1,1; 1,0,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0; 0,0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,1,0]

Provalo online!

Spiegazione

Xy    % Implicitly take input: number. Push identity matrix with that size
+     % Implicitly take input: matrix. Add to identity matrix
HY^   % Matrix square
!     % Transpose
A     % Row vector with true entries for columns that contain all nonzero values
f     % Indices of nonzero values
— Luis Mendo
fonte
1
MATL <Jelly \ m /
— flawr
1

Javascript 136 131 121 112 byte

(n,m)=>m.map((a,k)=>eval(a.map((o,i)=>o||eval(a.map((p,j)=>p&&m[j][i]).join`|`)).join`+`)>n-2&&k+1).filter(a=>a)

Chiama usando:

f=(n,m)=>m.map((a,k)=>eval(a.map((o,i)=>o||eval(a.map((p,j)=>p&&m[j][i]).join`|`)).join`+`)>n-2&&k+1).filter(a=>a)

f(20,[[0,0,1,1,0,1,1,0,0,0,0,1,1,0,1,1,1,1,0,1],
     [1,0,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1],
     [0,0,0,1,0,0,0,1,1,0,1,0,1,0,0,0,0,0,1,1],         
     [0,0,0,0,1,1,1,1,1,1,1,1,0,0,1,0,0,1,1,1],
     [1,0,1,0,0,0,0,1,1,0,1,1,1,0,1,1,1,1,0,1],         
     [0,1,1,0,1,0,1,1,1,1,1,0,1,1,1,0,1,1,0,1],
     [0,0,1,0,1,0,0,1,1,0,1,0,1,1,1,1,1,0,1,0],         
     [1,0,0,0,0,0,0,0,1,0,1,1,1,1,0,0,1,1,1,0],
     [1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,1,1],         
     [1,0,1,0,1,0,1,1,0,0,1,0,0,0,0,1,0,1,1,1],
     [1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,0,0,0],         
     [0,1,1,0,0,1,1,0,0,1,0,0,1,1,1,1,1,0,1,1],
     [0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,1,0,1,1,1],         
     [1,0,1,1,1,0,0,0,0,1,0,0,1,0,1,1,1,1,1,1],
     [0,0,1,0,0,0,0,1,0,1,1,0,0,0,0,1,1,0,0,1],         
     [0,0,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,1],
     [0,0,1,1,0,0,0,0,0,1,1,0,1,0,0,1,0,0,1,1],         
     [0,0,1,0,0,0,1,0,1,0,1,1,0,0,1,0,1,0,1,1],
     [1,0,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0],             
     [0,0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,1,0]])

attenzione perché l'output è 1 indicizzato (salvati alcuni byte non cercando di filtrare 0s contro i falsi)

— Charlie Wynn
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.