recursief zoeken

Even uit de losse pols:

<?php

$ids = array_keys($data); //$data is die 2e tabel
$default_scores = array_fill_keys($ids,0); //standaard tegen niemand gespeeld

foreach($data as $id => $player){ //per speler gaan bekijken
  $scores = $player['tegenstanders'];
  unset($scores['totaal']);
  $scores = array_merge($default_scores,$scores); //nu voor iedereen een score
  asort($scores); //sorteren op score (minste vooraan)
  $opponents = array_keys($scores); //tegenstanders geordend
  $opponent = array_shift($opponents); //tegenstander met minste partijen

  //verder afhandelen/opslaan/enz

}

?>

Sorry snap het niet.
Wie speelt nu tegen wie?

$id speelt tegen $opponent

Dan moet je verderop wel controleren dat zowel $id als $opponent niet meer aan iemand anders gekoppeld kunnen worden (een lijstje met $fulfilled bijhouden, en daarvoor de $id's overslaan, en deze uit $opponents halen).

Of is het dan nog weer de bedoeling dat als A tegen B of C kan spelen (beiden nog nooit tegen gespeeld), maar D al wel tegen C heeft gespeeld, dat ie dan ook nog zo wijs is om A aan C te koppelen, zodat B dan tegen D kan?

Tof dat je elke tegenstander op 0 partijen plaats. Ik werkte met isset
Juist dat je Totaal verwijderd. Stond op verkeerde plaats.

oorspronkelijke data aangepast.

Je basis is ongeveer hetzelfde als ik had echter ik blijf vastlopen.
ik heb ofwel onvolledige data, niet alle spelers gevonden, of kom in een eindeloze lus.


<?php
$ids = array_keys($partijen);//partijen oorspronkelijke data
{
foreach($ids as $id) {//niemand speelt
$speelt[$id]=false;
}
$i=$j=0;
while ($i<count($ids)) {//loop door alle spelers
$id1=$ids[$i];
if(!$speelt[$id1]) {
$j=0;
while ($j<count($ids)) {//zoek tegestander
$id2=$ids[$j];
if(!$speelt[$id2]) {
if($id1!=$id2) {/niet tegen jezelf
if($partijen[$id1]['tegenstanders'][$id2]<=$verschilWZ) {// aantal parttijen < max toegelaten
$stappen[] = array($i,$j);//bewaar stappen om terug te keren indien lus niet volledig ok
$speelt[$id1]=$speelt[$id2]=true;//deze 2 spelers spelen nu wel
$borden[] = array($partijen[$id1],$partijen[$id2]);//bepaal bord. exact 2 spelers
if(alltrue($speelt)) {//eenvoudige lus welke kijkt of alle items in array true zijn
break 2;// spring uit de 2 lussen
}
break;//ga naar volgende speler
}
}
}
$j++;
}
$j=0;
}
if($i==(count($ids)-1)) {//net voor einde kijken alles OK
if(alltrue($speelt)) {
break;//OK dus uit lus
}else{
$a = end($stappen);// niet ok stap terug
$i=($a[0]-1);
$j=($a[1]+1);
$speelt[$ids[$a[0]]] = $speelt[$ids[$a[0]]] = false;//spelers apelen toch niet
array_pop($borden);//verwijder bord
}
}
$i++;
}
}
var_dump($borden);//wordt later opnieuw uitgewerkt :)
?>

Jan

Ik geloof niet dat ik de vraag begrijp, maar dat zal aan mij liggen.

In je voorbeeld zeg je "wit en zwart is het aantal keren met respectievelijke kleur gespeeld", en "het nummer bij tegenstanders is het aantal al keren tegen elkaar gespeeld".

Kijk ik naar Philippe, dan heeft hij 2x met wit gespeeld en 2x met zwart, dus 4x in totaal.
Maar als ik naar de tweede helft kijk, dan zie ik dat hij maar 3x heeft gespeeld, met ID's 115, 119, 126.

Hoe zit dat?

In de geleverde data staan enkel de spelers welke hun deelname bevestigd hebben. Ze kunnen dus ook tegen iemand anders gespeeld hebben. Totaal is i de berekening dus niet relevant maar wel nodig om te tonen in de browser.

De berekening start enkel als het aantal spelers paar is.

Ik heb in een testdatabase twee tabellen gemaakt die zouden moeten lijken op de tabellen in je eigen database:

-- SQL dump van testdatabase

CREATE TABLE `speler` (
  `id` int(10) UNSIGNED NOT NULL COMMENT 'ID',
  `naam` text NOT NULL COMMENT 'Naam',
  `punten` int(10) UNSIGNED NOT NULL DEFAULT 0 COMMENT 'Punten'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='Spelers';

INSERT INTO `speler` (`id`, `naam`, `punten`) VALUES
(115, 'Eddy', 2020),
(117, 'Freddy', 2028),
(119, 'Jan', 2016),
(122, 'Thomas', 2030),
(123, 'Yvonne', 1984),
(126, 'Jacques', 1920),
(147, 'Philippe', 2048),
(148, 'Pierre Matthys', 1922);

CREATE TABLE `wedstrijd` (
  `id` int(10) UNSIGNED NOT NULL COMMENT 'ID',
  `wit` int(10) UNSIGNED NOT NULL DEFAULT 0 COMMENT 'Wit',
  `zwart` int(10) UNSIGNED NOT NULL DEFAULT 0 COMMENT 'Zwart'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='Wedstrijden';

INSERT INTO `wedstrijd` (`id`, `wit`, `zwart`) VALUES
(1, 147, 115),
(2, 147, 126),
(3, 122, 115),
(4, 122, 126),
(5, 117, 119),
(6, 117, 148),
(7, 115, 123),
(8, 119, 147),
(9, 119, 148),
(10, 123, 119),
(11, 148, 123),
(12, 126, 117);

ALTER TABLE `speler`
  ADD PRIMARY KEY (`id`);

ALTER TABLE `wedstrijd`
  ADD PRIMARY KEY (`id`),
  ADD KEY `wedstrijd_speler_wit` (`wit`),
  ADD KEY `wedstrijd_speler_zwart` (`zwart`);

ALTER TABLE `speler`
  MODIFY `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT 'ID', AUTO_INCREMENT=149;

ALTER TABLE `wedstrijd`
  MODIFY `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT 'ID', AUTO_INCREMENT=13;

ALTER TABLE `wedstrijd`
  ADD CONSTRAINT `wedstrijd_speler_wit` FOREIGN KEY (`wit`) REFERENCES `speler` (`id`) ON UPDATE CASCADE,
  ADD CONSTRAINT `wedstrijd_speler_zwart` FOREIGN KEY (`zwart`) REFERENCES `speler` (`id`) ON UPDATE CASCADE;

Daarin kan je met een query een ranking maken van spelercombinaties die de minste wedstrijden hebben gespeeld:

WITH `geselecteerd` AS (
  SELECT 147 AS `id`
  UNION SELECT 122
  UNION SELECT 117
  UNION SELECT 115
  UNION SELECT 119
  UNION SELECT 123
  UNION SELECT 148
  UNION SELECT 126
)
SELECT DISTINCT
  LEAST(`speler`.`id`, `tegenstander`.`id`) AS `speler_id`,
  GREATEST(`speler`.`id`, `tegenstander`.`id`) AS `tegenstander_id`,
  COUNT(`wedstrijd`.`id`)
    OVER (PARTITION BY `speler`.`id`, `tegenstander`.`id`) AS `wedstrijden`
FROM `geselecteerd` AS `speler`
  JOIN `geselecteerd` AS `tegenstander`
    ON `speler`.`id` != `tegenstander`.`id`
  LEFT JOIN `wedstrijd`
    ON (`wedstrijd`.`wit` = `speler`.`id`
      AND `wedstrijd`.`zwart` = `tegenstander`.`id`)
    OR (`wedstrijd`.`wit` = `tegenstander`.`id`
      AND `wedstrijd`.`zwart` = `speler`.`id`)
ORDER BY `wedstrijden`;

Ik was begonnen met recursief zoeken in MySQL maar de mogelijkheden zijn beperkter dan in andere databases als PostgreSQL en het is toch nog even puzzelen. Misschien is het laatste stukje logica eenvoudiger te maken in PHP.

Overigens zijn er meer mensen die dit probleem hebben willen oplossen in SQL.

Bedankt maar ik heb nooit gezegd dat het in sql moest zijn :) Daarom had ik er ook een json van gemaakt.

sql loopt al vast op 1° woord. 'with'

Klopt, je zei "Eerst heb ik data. Komt normaal uit de database maar om hier te posten even json gebruikt." dus het is logischer om het dan maar meteen goed uit de database te halen. Waar heb je een database anders voor?

WITH is onderdeel van een CTE, MySQL loopt daarmee achter. Je moet minimaal MySQL 8 hebben, anders moet je de query op de ouderwetse manier herschrijven, en jezelf herhalen in het FROM statement (dat kan dan wel weer beter met PHP):

SELECT DISTINCT
  LEAST(`speler`.`id`, `tegenstander`.`id`) AS `speler_id`,
  GREATEST(`speler`.`id`, `tegenstander`.`id`) AS `tegenstander_id`,
  COUNT(`wedstrijd`.`id`)
    OVER (PARTITION BY `speler`.`id`, `tegenstander`.`id`) AS `wedstrijden`
FROM
  ( SELECT 147 AS `id`
    UNION SELECT 122
    UNION SELECT 117
    UNION SELECT 115
    UNION SELECT 119
    UNION SELECT 123
    UNION SELECT 148
    UNION SELECT 126
  ) AS `speler`
  JOIN
  ( SELECT 147 AS `id`
    UNION SELECT 122
    UNION SELECT 117
    UNION SELECT 115
    UNION SELECT 119
    UNION SELECT 123
    UNION SELECT 148
    UNION SELECT 126
  ) AS `tegenstander`
    ON `speler`.`id` != `tegenstander`.`id`
  LEFT JOIN `wedstrijd`
    ON (`wedstrijd`.`wit` = `speler`.`id`
      AND `wedstrijd`.`zwart` = `tegenstander`.`id`)
    OR (`wedstrijd`.`wit` = `tegenstander`.`id`
      AND `wedstrijd`.`zwart` = `speler`.`id`)
ORDER BY `wedstrijden`;