I have a database that stores how users were referred into the system like so:
| user_id | referrer_id |
| 3 | 2 |
| 4 | 3 |
| 5 | 3 |
| 6 | 4 |
| 7 | 4 |
| 8 | 5 |
| 9 | 5 |
| 10 | 6 |
| 11 | 10 |
| 12 | 10 |
and I would like to display a specific user's network, i.e., the user, the other users which s/he referred directly, and also other users referred by the direct referrals, in an array.
So far, I've been able to create a recursive function
// The actual get_downlines() function
function get_downlines($upline_id) {
// Init the UsersMatrix model
$um_model = model('UsersMatrix');
$um_model->select('user_id')->where('upline_id', $upline_id);
$downlines_check = $um_model->findAll(5);
$downlines = [];
if ( ! empty($downlines_check) ) {
foreach($downlines_check as $check) {
$downlines[] = $check->user_id;
}
}
return $downlines;
}
// User to check
$user = 3;
// The initial network array
$network_array['user_network'][0] = [
'id' => $user,
'text' => "user-$user"
];
// Get the user's network
function get_network($referrer, $network_array){
// This function basically runs a SELECT user_id FROM users WHERE referrer_id = $referrer_id
// and returns the user_ids in an array: get_downlines()
$downlines = get_downlines($referrer);
if (count($downlines) > 0){
// Loop through the downlines
foreach($downlines as $downline){
// Update the array
array_push($network_array['user_network'], [
'id' => $downline,
'text' => "user-$downline",
]);
// Check for the downlines of this user and inner levels
get_network($downline, $network_array);
}
}
// Return the network array
return $network_array;
}
With this, I expect that when I run the get_network(3, $network_array);, I should get an array like so:
Array
(
[user_network] => Array
(
[0] => Array
(
[id] => 3
[text] => user-3
),
[1] => Array
(
[id] => 4
[text] => user-4
),
[2] => Array
(
[id] => 5
[text] => user-5
),
[3] => Array
(
[id] => 6
[text] => user-6
),
[4] => Array
(
[id] => 7
[text] => user-7
),
[5] => Array
(
[id] => 8
[text] => user-8
),
[6] => Array
(
[id] => 9
[text] => user-9
),
[7] => Array
(
[id] => 10
[text] => user-10
)
)
)
instead, the page dies with a maximum execution time error. But if I use a user ID without an indirect referrer, it works well. E.g user id 10.
Where am I going wrong?
I have one multidimensional-array and i want to insert into my database, there is one issue if one entry in my database and same entry is on my multidimensional-array that value should not insert again in my database.
$activity[] = array('user_id'=> $_SESSION['user_id'], 'choosen_date' => $ch_date, 'distance' => $distance, 'pace' => $pace );
Array
(
[0] => Array
(
[user_id] => 1200
[choosen_date] => 2018-12-11
[distance] => 1.72
[pace] => 12.4812
)
[1] => Array
(
[user_id] => 1200
[choosen_date] => 2018-12-09
[distance] => 3.17
[pace] => 3.8736
)
[2] => Array
(
[user_id] => 1200
[choosen_date] => 2018-11-14
[distance] => 2.26
[pace] => 6.3504
)
[3] => Array
(
[user_id] => 1200
[choosen_date] => 2018-11-07
[distance] => 0.53
[pace] => 3.6576
)
)
And following is my database entry
----------------------------------------------------
| S.No | user Id | choose date | distance | Pace |
----------------------------------------------------
| 1 | 1200 | 2018-12-09 | 3.17 | 3.8736 |
----------------------------------------------------
| 2 | 1200 | 2018-12-11 | 2.17 | 5.67 |
----------------------------------------------------
so here, in database S.no 1 and array index 1 both are the same entry so I want to insert rest value into my database. So how can I insert?
I am assuming that you are using MySQL database, you can use INSERT IGNORE INTO
or INSERT ON DUPLICATE KEY UPDATE
If you want to do it through PHP then you can try this.
$i=0;
foreach($activity as $key=>$val)
{
$sn_check=mysqli_query($con,"SELECT id FROM table WHERE S.No='$i'");
if(mysqli_num_rows($sn_check)==0)
{
$user_id=$val[$i]['user_id']; //all other values can be catch like this.
$query_insert=mysqli_query($con,"INSERT QUERY");
}
$i++;
}
I am trying to navigate through a bunch of objects with links to other objects. I want to start with the lowest id number (the root object) and navigate through each of the objects based on connected links. Some of the object links will loop back to previous objects, so I want to make sure I look at each one only once otherwise I will get stuck in an infinite loop. I also want to be able to tell which objects cannot be accessed by navigating through the links beginning at the first link.
The tables in my database look like this:
Object Table:
+----+---------+
| id | title |
+----+---------+
| 1 | Apple |
| 3 | Carrot |
| 4 | Dill |
| 5 | Egg |
| 6 | Fred |
| 7 | Goat |
| 8 | Harry |
| 9 | Igloo |
| 10 | Jason |
| 11 | Klaus |
| 12 | Banana |
| 15 | Oyster1 |
| 16 | Oyster2 |
+----+---------+
Object_Links Table:
+----+---------+--------------+
| id | obj_id | obj_link_id |
+----+---------+--------------+
| 1 | 1 | 12 |
| 2 | 1 | 5 |
| 3 | 3 | 1 |
| 4 | 3 | 12 |
| 5 | 3 | 3 |
| 6 | 4 | 1 |
| 7 | 4 | 5 |
| 8 | 5 | 6 |
| 9 | 6 | 7 |
| 10 | 7 | 7 |
| 11 | 7 | 8 |
| 12 | 9 | 12 |
| 13 | 9 | 5 |
| 14 | 10 | 1 |
| 15 | 10 | 5 |
| 16 | 10 | 8 |
| 17 | 11 | 1 |
| 18 | 11 | 5 |
| 19 | 11 | 10 |
| 20 | 12 | 3 |
| 21 | 15 | 16 |
| 22 | 16 | 15 |
+----+---------+--------------+
So, from the table you can see that object 1 has links to both objects 12 and 5.
My SQL query looks like this:
select object.id, title, obj_link_id
from object
left join object_links ON object.id = object_links.object_id
order by object.id
which gives the table:
+----+---------+--------------+
| id | title | obj_link_id |
+----+---------+--------------+
| 1 | Apple | 12 |
| 1 | Apple | 5 |
| 3 | Carrot | 1 |
| 3 | Carrot | 12 |
| 3 | Carrot | 3 |
| 4 | Dill | 1 |
| 4 | Dill | 5 |
| 5 | Egg | 6 |
| 6 | Fred | 7 |
| 7 | Goat | 7 |
| 7 | Goat | 8 |
| 8 | Harry | NULL |
| 9 | Igloo | 12 |
| 9 | Igloo | 5 |
| 10 | Jason | 1 |
| 10 | Jason | 5 |
| 10 | Jason | 8 |
| 11 | Klaus | 1 |
| 11 | Klaus | 5 |
| 11 | Klaus | 10 |
| 12 | Banana | 3 |
| 15 | Oyster1 | 16 |
| 16 | Oyster2 | 15 |
+----+---------+--------------+
In PHP I am using:
$objects = $stmt->fetchAll(PDO::FETCH_CLASS);
I wasn't sure whether there was a better way to fetch these for my purposes so am open to suggestions.
A print_r($objects) yields:
Array
(
[0] => stdClass Object
(
[id] => 1
[title] => Apple
[obj_link_id] => 12
)
[1] => stdClass Object
(
[id] => 1
[title] => Apple
[obj_link_id] => 5
)
[2] => stdClass Object
(
[id] => 3
[title] => Carrot
[obj_link_id] => 1
)
[3] => stdClass Object
(
[id] => 3
[title] => Carrot
[obj_link_id] => 12
)
[4] => stdClass Object
(
[id] => 3
[title] => Carrot
[obj_link_id] => 3
)
[5] => stdClass Object
(
[id] => 4
[title] => Dill
[obj_link_id] => 1
)
[6] => stdClass Object
(
[id] => 4
[title] => Dill
[obj_link_id] => 5
)
[7] => stdClass Object
(
[id] => 5
[title] => Egg
[obj_link_id] => 6
)
[8] => stdClass Object
(
[id] => 6
[title] => Fred
[obj_link_id] => 7
)
[9] => stdClass Object
(
[id] => 7
[title] => Goat
[obj_link_id] => 7
)
[10] => stdClass Object
(
[id] => 7
[title] => Goat
[obj_link_id] => 8
)
[11] => stdClass Object
(
[id] => 8
[title] => Harry
[obj_link_id] =>
)
[12] => stdClass Object
(
[id] => 9
[title] => Igloo
[obj_link_id] => 12
)
[13] => stdClass Object
(
[id] => 9
[title] => Igloo
[obj_link_id] => 5
)
[14] => stdClass Object
(
[id] => 10
[title] => Jason
[obj_link_id] => 1
)
[15] => stdClass Object
(
[id] => 10
[title] => Jason
[obj_link_id] => 5
)
[16] => stdClass Object
(
[id] => 10
[title] => Jason
[obj_link_id] => 8
)
[17] => stdClass Object
(
[id] => 11
[title] => Klaus
[obj_link_id] => 1
)
[18] => stdClass Object
(
[id] => 11
[title] => Klaus
[obj_link_id] => 5
)
[19] => stdClass Object
(
[id] => 11
[title] => Klaus
[obj_link_id] => 10
)
[20] => stdClass Object
(
[id] => 12
[title] => Banana
[obj_link_id] => 3
)
[21] => stdClass Object
(
[id] => 15
[title] => Oyster1
[obj_link_id] => 16
)
[22] => stdClass Object
(
[id] => 16
[title] => Oyster2
[obj_link_id] => 15
)
)
Please note, that the number in the brackets is just the array index, not the object id number, so don't let the index throw you off.
I am trying to find a way to determine which are the linked and which are the unlinked objects. Based on the above scenario the objects should be separated as follows:
**Linked:**
Apple
Banana
Carrot
Egg
Fred
Goat
Harry
**Not Linked:**
Dill
Igloo
Jason
Klaus
Oyster1
Oyster2
My main question:
How can I create a loop in PHP to loop through a structure like this especially when each object can have multiple links? Ultimately I would like to produce two collections of objects, one containing the linked objects and one containing the unlinked objects. A sample collection might look like this:
stdClass Object
(
[LinkedElements] => stdClass Object
(
[1] => stdClass Object
(
[id] => 1
[name] => Apple
[link] => Array
(
[0] => 14
[1] => 5
)
)
[14] => stdClass Object
(
[id] => 14
[name] => Banana
[link] => Array
(
[0] => 3
)
)
[3] => stdClass Object
(
[id] => 3
[name] => Carrot
[link] => Array
(
[0] => 1
[1] => 14
[2] => 3
)
)
[5] => stdClass Object
(
[id] => 5
[name] => Egg
[link] => Array
(
[0] => 6
)
)
[6] => stdClass Object
(
[id] => 6
[name] => Fred
[link] => Array
(
[0] => 7
)
)
[7] => stdClass Object
(
[id] => 7
[name] => Goat
[link] => Array
(
[0] => 7
[1] => 8
)
)
[8] => stdClass Object
(
[id] => 8
[name] => Harry
)
)
[UnLinkedElements] => stdClass Object
(
[4] => stdClass Object
(
[id] => 4
[name] => Dill
[link] => Array
(
[0] => 1
[1] => 5
)
)
[9] => stdClass Object
(
[id] => 9
[name] => Igloo
[link] => Array
(
[0] => 14
[1] => 5
)
)
[10] => stdClass Object
(
[id] => 10
[name] => Jason
[link] => Array
(
[0] => 1
[1] => 5
[2] => 8
)
)
[11] => stdClass Object
(
[id] => 11
[name] => Klaus
[link] => Array
(
[0] => 1
[1] => 5
[2] => 10
)
)
[15] => stdClass Object
(
[id] => 15
[name] => Oyster1
[link] => Array
(
[0] => 16
)
)
[16] => stdClass Object
(
[id] => 16
[name] => Oyster2
[link] => Array
(
[0] => 15
)
)
)
)
Please note:
Navigation is done from object to link, not the other way around.
It is okay to have an object point to itself (as object 7 does).
The above sample structure (underneath my main question) is a suggestion only and I am open to other suggestions.
Disclaimer: This question is based on another question I previously asked.
In my original question I manually created the test objects, but I was not able to pull them out of my database in this fashion.
It's easier (IMHO) to deal with the data as two separate arrays. A set of objects and their links. Also, as the first part I convert the object to have the ID as the key, this allows me to use it directly rather than having to search for the ID each time.
Also to make the solution a lot simpler, I've created a flag in the object array as I visit it, so that when I try and reference it again, I can check if it's already been visited.
<?php
error_reporting ( E_ALL );
ini_set ( 'display_errors', 1 );
$objects =[[1,'apple'],
[3, 'Carrot'],
[4, 'Dill'],
[5, 'Egg '],
[6, 'Fred'],
[7, 'Goat'],
[8, 'Harry'],
[9, 'Igloo'],
[10, 'Jason'],
[11, 'Klaus'],
[12, 'Banana'],
[15, 'Oyster1'],
[16, 'Oyster2' ]];
$links =[[1,12],
[1,5],
[3,1],
[3,12],
[3,3],
[4,1],
[4,5],
[5,6],
[6,7],
[7,7],
[7,8],
[8,null],
[9,12],
[9,5],
[10,1],
[10,5],
[10,8],
[11,1],
[11,5],
[11,10],
[12,3],
[15,16],
[16,15 ]];
function buildTree ( $id, &$objects, $links ) {
foreach ( $links as $testNode ) {
if ( $testNode[0] == $id &&
$testNode[1] != $id &&
$testNode[1] != null &&
!isset($objects[$testNode[1]]['visited']) ) {
$objects[$testNode[1]]['visited'] = true;
buildTree ( $testNode[1], $objects, $links);
}
}
}
// Convert array to have the ID as key
$objects = array_combine(array_column($objects, 0), $objects);
// Fetch ID of first item
reset($objects);
$startID = key($objects);
// Mark as visited
$objects[$startID]['visited'] = true;
// Process
buildTree ( $startID, $objects, $links);
$linked = [];
$notLinked = [];
foreach ( $objects as $object) {
if ( isset($object['visited']) ) {
$linked[] = $object[1];
}
else {
$notLinked[] = $object[1];
}
}
echo "Linked...".PHP_EOL;
print_r($linked);
echo "Not linked...".PHP_EOL;
print_r($notLinked);
As you can see, the core is the recursive buildTree function. This uses &$objects as this means that all calls to the function will use the same array. As I want to build up all the uses of the items, this is important.
The condition in buildTree, checks to see if it's the node we want, it's not referring to the same node (waste of time looking any more), not null (not sure why you link to null, but again not worth looking any further) and that the node hasn't already been visited. If these conditions are OK, it marks the next node as visited and goes down into the next level.
The output is...
Linked...
Array
(
[0] => apple
[1] => Carrot
[2] => Egg
[3] => Fred
[4] => Goat
[5] => Harry
[6] => Banana
)
Not linked...
Array
(
[0] => Dill
[1] => Igloo
[2] => Jason
[3] => Klaus
[4] => Oyster1
[5] => Oyster2
)
This is a graph traversal problem. Starting from a node (root) you want to traverse the graph keeping track of each node visited along the way. Once the traversal is over, visited ones are connected. Breadth-first search can be done in this way:
//To form a graph fetch all objects from the database (sorted by id) and
//index them in a hash map
$objects = $stmt->fetchAll(PDO::FETCH_OBJ);
$nodes = [];
foreach ($objects as $object) {
$nodes[$object->id] = new Node($object);
}
//fetch all connections from the database and link the objects
$links = $stmt->fetchAll(PDO::FETCH_OBJ);
foreach ($links as $link) {
$nodes[$link->obj_id]->addLink($nodes[$link->obj_link_id]);
}
//let's assume root is the first node (sorted by id),
//traverse the graph starting from root
$root = reset($nodes);
$root->traverse();
//now if a node can be reached by the root it is marked as visited
$linked = [];
$notLinked = [];
foreach ($nodes as $node) {
if ($node->isVisited()) {
$linked[] = $node;
} else {
$notLinked[] = $node;
}
}
And the node class:
class Node
{
/**
* List of neighbor nodes.
*
* #var Node[]
*/
private $links = [];
/**
* id, title info
*
* #var array
*/
private $data = [];
/**
* To track visited nodes.
*
* #var bool
*/
private $visited = false;
/**
* Node constructor.
* #param array $data
*/
public function __construct($data)
{
$this->data = $data;
}
/**
* Add a link to this node.
*
* #param Node $node
* #return void
*/
public function addLink(Node $node)
{
$this->links[] = $node;
}
/**
* Traverse the graph in a Breadth-First-Search fashion marking
* every visited node.
* #return void
*/
public function traverse()
{
//initialize queue
$q = new SplQueue();
//add root to queue and mark as visited
$q->enqueue($this);
$this->visited = true;
while (!$q->isEmpty()) {
/** #var Node $cur */
$cur = $q->dequeue();
foreach ($cur->links as $link) {
//if link not visited already add it to queue and mark visited
if (!$link->visited) {
$link->visited = true;
$q->enqueue($link);
}
}
}
}
/**
* Checks if node has been visited.
*
* #return bool
*/
public function isVisited()
{
return $this->visited;
}
}
Let's say the "root" is obj_id 1.
Here's a somewhat brute force algorithm, but it takes advantage of SQL's liking of 'set' operations.
Insert into table1 the root (1)
Loop
Create table2 with all nodes linked to any node in table1
Exit if number of rows in table2 = num rows in table1
table1 := table2
Closer to SQL:
# Initialize:
CREATE TABLE table1 (
obj_id ...
PRIMARY KEY(obj_id)
)
SELECT 1; # assuming root is 1
start of loop:
CREATE TABLE table2 (
obj_id ...
PRIMARY KEY(obj_id)
)
SELECT DISTINCT obj_link_id
FROM table1
JOIN object_links USING(obj_id);
SELECT #fini := ( SELECT COUNT(*) FROM table1 ) =
( SELECT COUNT(*) FROM table2 ) # will give true/false
DROP TABLE table1;
RENAME TABLE table2 TO table1;
loop if #fini=0
The output is all the 'connected' ids. If you want the unconnected ones:
SELECT obj_id
FROM object_links
LEFT JOIN table1 USING(obj_id)
WHERE table1.obj_id IS NULL; # that is, missing from table1
Here is a pretty short way to get all linked IDs:
$pdo = new PDO('mysql:host=localhost;dbname=test_obj_link', 'testread', 'testread');
$links = $pdo
->query('select obj_id, obj_link_id from object_links')
->fetchAll(PDO::FETCH_GROUP|PDO::FETCH_COLUMN);
function getLinks($objId, $links, $indirectNodes = []) {
$directNodes = isset($links[$objId]) ? $links[$objId] : [];
foreach($directNodes as $linkedNode) {
if (!in_array($linkedNode, $indirectNodes)) {
$indirectNodes[] = $linkedNode;
$indirectNodes = array_unique(array_merge(
$indirectNodes,
getLinks($linkedNode, $links, $indirectNodes)
));
}
}
return $indirectNodes;
}
$linkedObjectIds = getLinks(1, $links);
fetchAll(PDO::FETCH_GROUP|PDO::FETCH_COLUMN) will return a structured array with links per object indexed by objectIDs which looks like:
$links = [
1 => ['5', '12'],
3 => ['1', '3', '12'],
4 => ['1', '5'],
5 => ['6'],
6 => ['7'],
7 => ['7', '8'],
9 => ['5', '12'],
10 => ['1', '5', '8'],
11 => ['1', '5', '10'],
12 => ['3'],
15 => ['16'],
16 => ['15'],
];
The getLinksfunction will "walk" the $links array recursively and merge all child arrays that are found on the way. Since PHP doesn't seem to have an array_union function - array_unique(array_merge(..)) is used instead.
The result:
$linkedObjectIds = array (
0 => '5',
1 => '6',
2 => '7',
3 => '8',
4 => '12',
10 => '3',
11 => '1',
)
Note that the indexes have no meaning here.
To get the corresponding objects you can do the following:
$objects = $pdo
->query('select id, title from object')
->fetchAll(PDO::FETCH_KEY_PAIR);
$linkedObjects = array_intersect_key($objects, array_flip($linkedObjectIds));
$notLinkedObjects = array_diff_key($objects, $linkedObjects);
The variables will contain:
$objects = array (
1 => 'Apple',
3 => 'Carrot',
4 => 'Dill',
5 => 'Egg',
6 => 'Fred',
7 => 'Goat',
8 => 'Harry',
9 => 'Igloo',
10 => 'Jason',
11 => 'Klaus',
12 => 'Banana',
15 => 'Oyster1',
16 => 'Oyster2',
);
$linkedObjects = array (
1 => 'Apple',
3 => 'Carrot',
5 => 'Egg',
6 => 'Fred',
7 => 'Goat',
8 => 'Harry',
12 => 'Banana',
);
$notLinkedObjects = array (
4 => 'Dill',
9 => 'Igloo',
10 => 'Jason',
11 => 'Klaus',
15 => 'Oyster1',
16 => 'Oyster2',
);
Demo: http://rextester.com/ZQQGE35352
Note that in_array() and array_unique() are probably slow, since they have to search in values, which are not sorted. This might lead to performance issues on some datasets. Assuming that PHP can search the keys faster, we could use array_key_exists() instead of in_array() and the array operator + (union by keys) instead of array_unique(array_merge()). And the code will even be a bit shorter:
function getLinks($objId, $links, $indirectNodes = []) {
$directNodes = isset($links[$objId]) ? $links[$objId] : [];
foreach($directNodes as $linkedNode) {
if (!array_key_exists($linkedNode, $indirectNodes)) {
$indirectNodes[$linkedNode] = 0;
$indirectNodes = $indirectNodes + getLinks($linkedNode, $links, $indirectNodes);
}
}
return $indirectNodes;
}
However - since the function now returns the needed result as keys, we would need to use array_keys() to extract them:
$linkedObjectIds = array_keys(getLinks(1, $links));
Demo: http://rextester.com/GHO7179
here is my table and I need to make a search function using codeigniter that will display the a list of items that contains my keywords order by most number of matched keywords and latest date added.
Ex. the two submitted keyword are yes, test
messages table
id | title | msg |date
---+-----------+-------------------+--------
1 | test1 | yes | 2016-06-01 // 2 match keywords
2 | yes1 | no | 2016-06-02 // 1 match keywords
3 | test2 | no | 2016-06-03 // 1 match keywords
4 | yes2 | yes yes yes | 2016-06-04 // 4 match keywords
5 | yesyes3 | yes yes yes yes | 2016-06-05 // 6 match keywords
now for expected output it will display:
array (
[0] => array (
[id] => 5
[title] => yesyes3
[msg] => yes yes yes yes
[date] => 2016-06-05
[match] => 6
)
[1] => array (
[id] => 4
[title] => yes2
[msg] => yes yes yes
[date] => 2016-06-04
[match] => 4
)
[2] => array (
[id] => 1
[title] => test1
[msg] => yes
[date] => 2016-06-01
[match] => 2
)
[3] => array (
[id] => 3
[title] => test2
[msg] => no
[date] => 2016-06-03
[match] => 1
)
[4] => array (
[id] => 2
[title] => yes1
[msg] => no
[date] => 2016-06-02
[match] => 1
)
)
Currently here are my current code and i'm not sure with these on how to make this search works
$match = array('yes','test');
$array = array('m.title' => $match, 'm.msg' => $match);
$this->db->select('m.*');
$this->db->from('messages m');
$this->db->like($array);
$this->db->order_by('m.date', 'DESC');
$query = $this->db->get();
Is there any php codeigniter code for this?
Thanks!
You will need to create a ORDER BY clause using search terms.
So the Full code
EDITED
$match = array('yes','test');
//$array = array('m.title' => $match, 'm.msg' => $match);//you do not need this
$orderbyString = "";
$likestr = "";
//first prepare an ORDER BY statement and like statement
foreach($match AS $value)
{
$orderbyString .= "IF(m.title LIKE '%".$value."%' OR m.msg LIKE '%".$value."%',1,0)+";
$likestr .= "m.title LIKE '%".$value."%' OR m.msg LIKE '%".$value."%' OR ";
}
$orderbyString = substr($orderbyString, 0, -1);
$likestr = substr($likestr, 0, -4);
$this->db->select('m.*, ('.$orderbyString.') as count_match');
$this->db->from('messages m');
$this->db->where($likestr." ORDER BY ".$orderbyString." DESC");
//$this->db->order_by($orderbyString, 'DESC');//removed this line
$query = $this->db->get();
$results = $query->result_array();//contains the desired result
This question already has answers here:
Transposing multidimensional arrays in PHP
(12 answers)
Chunk and transpose a flat array into rows with a specific number of columns
(3 answers)
Closed 5 months ago.
So I have a database with players names and their skill level.
It looks like this:
Id | Name | Level
1 | Peter | 24
2 | Andy | 23
...
24 | John | 1
The first player in the list with the highest level is the strongest one, and the last is the weakest.
I need to sort them in groups with 4 players, so if I have 24 people there will be 6 groups.
The way I need to sort it I call "zig-zag".
It goes like this:
Ag Bg Cg Dg Eg Fg
01 02 03 04 05 06
12 11 10 09 08 07
13 14 15 16 17 18
24 23 22 21 20 19
So the A group will consist of players: 1, 12, 13, 24.
B group of players: 2, 11, 14, 23.
C group of players: 3, 10, 15, 22 and so on.
It's easy to do it by hand, but how I could automate this sort with PHP language?
The groups should be array list (I think so) which could I easily put to the group tables in database.
The idea would be to:
Sort your starting data (or preferably, start with it sorted).
Split it into chunks, basically one per each of your rows.
Reverse the order of every other chunk.
Flip the matrix so you've got your groups - one per column instead of one per row.
Example:
// Basic sample data.
$players = range(1, 24);
// Sort them ascending if you need to.
sort($players);
// Make a matrix. 2d array with a column per group.
$matrix = array_chunk($players, ceil(count($players)/4));
// Reverse every other row.
for ($i = 0; $i < count($matrix); $i++) {
if ($i % 2) {
$matrix[$i] = array_reverse($matrix[$i]);
}
}
// Flip the matrix.
$groups = array_map(null, ...$matrix); // PHP 5.6 with the fancy splat operator.
//$groups = call_user_func_array('array_map', array_merge([null], $matrix)); // PHP < 5.6 - less fancy.
// The result is...
print_r($groups);
Output:
Array
(
[0] => Array
(
[0] => 1
[1] => 12
[2] => 13
[3] => 24
)
[1] => Array
(
[0] => 2
[1] => 11
[2] => 14
[3] => 23
)
[2] => Array
(
[0] => 3
[1] => 10
[2] => 15
[3] => 22
)
[3] => Array
(
[0] => 4
[1] => 9
[2] => 16
[3] => 21
)
[4] => Array
(
[0] => 5
[1] => 8
[2] => 17
[3] => 20
)
[5] => Array
(
[0] => 6
[1] => 7
[2] => 18
[3] => 19
)
)