Generating all possible combinations of a timetable using an SQL Query - sql

Question

I have an awkward SQL Puzzle that has bested me.
I am trying to generate a list of possible configurations of student blocks so I can fit their course choices into a timetable. A list of possible qualifications and blocks for a student could be as the following:
Biology A
Biology C
Biology D
Biology E
Chemistry B
Chemistry C
Chemistry D
Chemistry E
Chemistry F
Computing D
Computing F
Tutorial A
Tutorial B
Tutorial E
A possible solution of blocks for a student could be
Biology D
Chemistry C
Computing F
Tutorial E
How would I query the above dataset to produce all possible combinations of lessons and blocks for a student? I could then pare down the list removing the ones that clash and choose one that works. I estimate that in this instance there will be about 120 combinations in total.
I could imagine that it would be some kind of cross join. I have tried all sorts of solutions using window functions and cross apply etc but they have all had some kind of flaw. They all tend to get tripped up because each student has a different number of courses and each course has a different number of blocks.
Cheers for any help you can offer! I can paste in the gnarled mess of a query I have if necessary too!
Alex

Answer 1

For a fixed number of qualifications, the answer is relatively simple - the CROSS JOIN option from the previous answers will work perfectly.
However, if the number of qualifications is unknown, or likely to change in the future, hard-coding four CROSS JOIN operations won't work. In this case, the answer gets more complicated.
For small numbers of rows, you could use a variation of this answer on DBA, which uses powers of two and bit comparisons to generate the combinations. However, this will be limited to a very small number of rows.
For larger numbers of rows, you can use a function to generate every combination of 'M' numbers from 'N' rows. You can then join this back to a ROW_NUMBER value computed on your source data to get the original row.
The function to generate the combinations could be written in TSQL, but it would make more sense to use SQLCLR if possible:
[SqlFunction(
DataAccess = DataAccessKind.None,
SystemDataAccess = SystemDataAccessKind.None,
IsDeterministic = true,
IsPrecise = true,
FillRowMethodName = "FillRow",
TableDefinition = "CombinationId bigint, Value int"
)]
public static IEnumerable Combinations(SqlInt32 TotalCount, SqlInt32 ItemsToPick)
{
if (TotalCount.IsNull || ItemsToPick.IsNull) yield break;
int totalCount = TotalCount.Value;
int itemsToPick = ItemsToPick.Value;
if (0 >= totalCount || 0 >= itemsToPick) yield break;
long combinationId = 1;
var result = new int[itemsToPick];
var stack = new Stack<int>();
stack.Push(0);
while (stack.Count > 0)
{
int index = stack.Count - 1;
int value = stack.Pop();
while (value < totalCount)
{
result[index++] = value++;
stack.Push(value);
if (index == itemsToPick)
{
for (int i = 0; i < result.Length; i++)
{
yield return new KeyValuePair<long, int>(
combinationId, result[i]);
}
combinationId++;
break;
}
}
}
}
public static void FillRow(object row, out long CombinationId, out int Value)
{
var pair = (KeyValuePair<long, int>)row;
CombinationId = pair.Key;
Value = pair.Value;
}
(Based on this function.)
Once the function is in place, generating the list of valid combinations is fairly easy:
DECLARE #Blocks TABLE
(
Qualification varchar(10) NOT NULL,
Block char(1) NOT NULL,
UNIQUE (Qualification, Block)
);
INSERT INTO #Blocks
VALUES
('Biology', 'A'),
('Biology', 'C'),
('Biology', 'D'),
('Biology', 'E'),
('Chemistry', 'B'),
('Chemistry', 'C'),
('Chemistry', 'D'),
('Chemistry', 'E'),
('Chemistry', 'F'),
('Computing', 'D'),
('Computing', 'F'),
('Tutorial', 'A'),
('Tutorial', 'B'),
('Tutorial', 'E')
;
DECLARE #Count int, #QualificationCount int;
SELECT
#Count = Count(1),
#QualificationCount = Count(DISTINCT Qualification)
FROM
#Blocks
;
WITH cteNumberedBlocks As
(
SELECT
ROW_NUMBER() OVER (ORDER BY Qualification, Block) - 1 As RowNumber,
Qualification,
Block
FROM
#Blocks
),
cteAllCombinations As
(
SELECT
C.CombinationId,
B.Qualification,
B.Block
FROM
dbo.Combinations(#Count, #QualificationCount) As C
INNER JOIN cteNumberedBlocks As B
ON B.RowNumber = C.Value
),
cteMatchingCombinations As
(
SELECT
CombinationId
FROM
cteAllCombinations
GROUP BY
CombinationId
HAVING
Count(DISTINCT Qualification) = #QualificationCount
And
Count(DISTINCT Block) = #QualificationCount
)
SELECT
DENSE_RANK() OVER(ORDER BY C.CombinationId) As CombinationNumber,
C.Qualification,
C.Block
FROM
cteAllCombinations As C
INNER JOIN cteMatchingCombinations As MC
ON MC.CombinationId = C.CombinationId
ORDER BY
CombinationNumber,
Qualification
;
This query will generate a list of 172 rows representing the 43 valid combinations:
1 Biology A
1 Chemistry B
1 Computing D
1 Tutorial E
2 Biology A
2 Chemistry B
2 Computing F
2 Tutorial E
...
In case you need the TSQL version of the Combinations function:
CREATE FUNCTION dbo.Combinations
(
#TotalCount int,
#ItemsToPick int
)
Returns #Result TABLE
(
CombinationId bigint NOT NULL,
ItemNumber int NOT NULL,
Unique (CombinationId, ItemNumber)
)
As
BEGIN
DECLARE #CombinationId bigint;
DECLARE #StackPointer int, #Index int, #Value int;
DECLARE #Stack TABLE
(
ID int NOT NULL Primary Key,
Value int NOT NULL
);
DECLARE #Temp TABLE
(
ID int NOT NULL Primary Key,
Value int NOT NULL Unique
);
SET #CombinationId = 1;
SET #StackPointer = 1;
INSERT INTO #Stack (ID, Value) VALUES (1, 0);
WHILE #StackPointer > 0
BEGIN
SET #Index = #StackPointer - 1;
DELETE FROM #Temp WHERE ID >= #Index;
-- Pop:
SELECT #Value = Value FROM #Stack WHERE ID = #StackPointer;
DELETE FROM #Stack WHERE ID = #StackPointer;
SET #StackPointer -= 1;
WHILE #Value < #TotalCount
BEGIN
INSERT INTO #Temp (ID, Value) VALUES (#Index, #Value);
SET #Index += 1;
SET #Value += 1;
-- Push:
SET #StackPointer += 1;
INSERT INTO #Stack (ID, Value) VALUES (#StackPointer, #Value);
If #Index = #ItemsToPick
BEGIN
INSERT INTO #Result (CombinationId, ItemNumber)
SELECT #CombinationId, Value
FROM #Temp;
SET #CombinationId += 1;
SET #Value = #TotalCount;
END;
END;
END;
Return;
END
It's virtually the same as the SQLCLR version, except for the fact that TSQL doesn't have stacks or arrays, so I've had to fake them with table variables.

Answer 2

One giant cross join?
select * from tablea,tableb,tablec,tabled
That will actually work for what you need, where tablea is the biology entries, b is chem, c is computing and d is tutorial. You can specify the joins a bit better:
select * from tablea cross join tableb cross join tablec cross join tabled.
Technically both statement are the same...this is all cross join so the comma version above is simpler, in more complicated queries, you'll want to use the second statement so you can be very explicit as to where you are cross joining vs inner/left joins.
You can replace the 'table' entries with a select union statement to give the values you are looking for in query form:
select * from
(select 'biology' as 'course','a' as 'class' union all select 'biology','c' union all select 'biology','d' union all select 'biology','e') a cross join
(select 'Chemistry' as 'course','b' as 'class' union all select 'Chemistry','c' union all select 'Chemistry','d' union all select 'Chemistry','e' union all select 'Chemistry','f') b cross join
(select 'Computing' as 'course','a' as 'class' union all select 'Computing','c') c cross join
(select 'Tutorial ' as 'course','a' as 'class' union all select 'Tutorial ','b' union all select 'Tutorial ','e') d
There is your 120 results (4*5*3*2)

Answer 3

Not really seeing the problem, but does this sqlFiddle work?

Answer 4

You should be able to do with a simple union, however each select of the union would have a filter on only one class type so you don't get
BIO, BIO, BIO, BIO, BIO
BIO, CHEM, BIO, BIO, BIO
etc...
select
b.course as BioCourse,
c.course as ChemCourse,
co.course as CompCourse,
t.course as Tutorial
from
YourTable b,
YourTable c,
YourTable co,
YourTable t
where
b.course like 'Biology%'
AND c.course like 'Chemistry%'
AND co.course like 'Computing%'
AND t.course like 'Tutorial%'

Answer 5

Lets use the paradigm where Table1 is Biology, Table2 is chemistry, Table3 is computing and Table4 is tutorial. Each table has 1 column and that is the possible blocks for that table or course. To get all possible combinations, we want to Cartesian Product all of the tables together and then filter the rows out that have duplicate letters.
Each column in the end result will represent their respective course. This means column 1 in the finished table will be the block letter for Biology which is Table1.
So the SQL for the answer would look something like this.
SELECT * FROM Table1,Table2,Table3,Table4
WHERE col1 != col2
AND col1 != col3
AND col1 != col4
AND col2 != col3
AND col2 != col4
AND col3 != col4;
Note: This is trivial to extend to the case where each table has 2 columns, the first is the subject and the 2nd is the block. Substitutions just need to be done in the where clause but if I ignore this case the code is much easier to follow along.
This is a little verbose but this works if each student must have a class from each of the tables and the max number of classes is 4 classes. This solution breaks down if a student doesnt have to have 4 classes.
The exact SQL needed may be a little different depending on what database your using. For example != could be <>.
Hope this helps!