Фон

Розглянемо турнір із круглої робінкою, в якому кожен учасник грає одну гру проти кожного другого учасника. Нічия не має, тому в кожній грі є переможець та програв. Спортсмен є королем турніру, якщо для будь-якої іншої конкуруючої B , або бити B , або побив інший учасник C , який , в свою черги бити B . Можна показати, що кожен турнір має принаймні одного короля (хоча їх може бути декілька). У цьому виклику ваше завдання - знайти королів даного турніру.

Вхід і вихід

Ваша інформація - N × Nбулева матриця Tта, за бажанням, кількість N ≥ 2учасників. Кожен запис T[i][j]представляє результат гри між учасниками, iі jзначення 1 представляє виграш за iта 0 виграш за j. Зауважте, що T[i][j] == 1-T[j][i]якщо i != j. Діагональ Tскладається з 0s.

Вашим результатом повинен бути список королів на турнірі, який Tпредставляє, використовуючи індексацію на основі 0 або 1. Порядок королів не має значення, але дублікатів не повинно бути.

І вхід, і вихід можуть бути прийняті у будь-якому розумному форматі.

Правила та оцінка

Ви можете написати повну програму або функцію. Виграє найменший байт, а стандартні лазівки заборонені.

Тестові справи

У цих тестових випадках використовується індексація на основі 0. Для індексації на основі 1 збільшуйте кожне вихідне значення.

 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]

Матлаб, 36 35 29 байт

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

Давайте дізнаємось, чи iє королем. Потім для кожного jзначення T[i][j]==1 OR there is a k such that T[i][k] * T[k][l] == 1. Але другу умову також можна замінити sum_over_k(T[i][k] * T[k][l])>0, але це лише запис матриці T*T(якщо розглядати Tяк матрицю). ORПотім може бути переграний, додавши Tдо цього результату, тому ми просто повинні перевірити , якщо n-1значення рядка iз T*T+Tбільше нуля, щоб побачити чи iкороль. Це саме те, що робить моя функція.

(Це MATLAB, тому індекси базуються на 1).

Матриці MATLAB повинні бути закодовані крапками з комою як роздільники ліній:

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

Желе, 13 12 11 байт

a"€¹o/€oḅ1M

Результат 1-базований. Спробуйте в Інтернеті!

Крім того, використовуючи побітові оператори замість маніпулювання масивом:

×Ḅ|/€|ḄBS€M

Знову ж таки, результат на основі 1. Спробуйте в Інтернеті!

Фон

Для конкуруючої А , ми можемо знайти все B такий , що бити C биття B , приймаючи всі рядки , які відповідають C такою , що C бити . Якщо г на B - ^й вхід в C - ^й є 1 , ми отримуємо , що C бити B .

Якщо обчислити логічні АБО всіх відповідних записів вибраних стовпців, ми отримаємо одиночний вектор, який вказує, чи бити A по транзитивності чи ні. Нарешті, ORing отриманого вектора з відповідним рядком вхідної матриці дає булевим значенням A чи B , або транзитивністю, або безпосередньо.

Повторюючи це для кожного ряду, ми підраховуємо число 1 у кожному векторі, тому обчислюючи кількість учасників кожного A удару. Максимальні підрахунки відповідають королям турніру.

Як це працює

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.

Python, використовуючи numpy, 54 байти

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

Взяте в матричній матриці, виводить нумеровану рядкову матрицю індексів на основі 0.

Ще один спосіб думати про короля - як про змагання, за якого всі учасники перебувають у союзі короля, людей, яких король перемагає, і людей, яких вони б'ють. Іншими словами, для кожного учасника змагань є шлях довжиною не більше 2 від короля до них серед відношення «бит».

Матриця I + M + M*Mкодує числа шляхів 0, 1 або 2 кроків від кожного джерела до кожної цілі. Гравець є королем, якщо в їх ряду цієї матриці є лише позитивні записи. Оскільки 0 - це Falsey, allповідомляє нам, чи є ряд не нульовим. Ми застосовуємо це до кожного рядка і виводимо індекси ненульових результатів.

JavaScript (ES6), 83 байти

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

MATL , 12 10 9 байт

Xy+HY^!Af

Вхід: спочатку кількість учасників, а на окремому рядку матриця з рядками, розділеними крапками з комою. Результат 1-базований.

Наприклад, п'ятий тестовий випадок має вхід

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

і останній тестовий випадок має вхід

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]

Спробуйте в Інтернеті!

Пояснення

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

Javascript 136 131 121 112 байт

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

watchout тому, що вихід 1-індексований (збережено кілька байтів, не намагаючись відфільтрувати 0s проти помилок)