Making combinations recursively - recursion

Question

I have a layer structure that is something like this:
1.1
1.2
2.1
3.1
3.2
4.1
5.1
I want to output all possible combinations for every item but not including items with higher order than themselves, the order is the first number, so for example:
5.1 will have the following combinations:
(4.1, 3.1, 2.1, 1.1)
(4.1, 3.1, 2.1, 1.2)
(4.1, 3.2, 2.1, 1.1)
(4.1, 3.2, 2.1, 1.2)
And 4.1 will have:
(3.1, 2.1, 1.1)
(3.1, 2.1, 1.2)
(3.2, 2.1, 1.1)
(3.2, 2.1, 1.2)
I want to do it with recursive function, I have tried something but it does not work like it should, here it is in pseudo code.
I start with the layer order and go down till it gets to the layers with order of 1.
function recursion (layer)
if layer.order > 1 do
for iterationLayer in allLayers do
if iterationLayer.order == (layer.order - 1) do
print iterationLayer.name
recursion iterationLayer
else
end of combination
This code gives me something like this for 4.1 case
(3.1, 2.1, 1.1)
(1.2)
(3.2, 2.1, 1.1)
(1.2)
Its like this because when the recursion reach the last for loop it tracks back from the bottom to the top, does anyone have solution for this?

Answer 1

Pseudo code:
function recursionMain(level)
for iterationLayer in allLayers where (layer.level == level)
recursion (iterationLayer, new list)
function recursion(currentLayer, currentLayerList)
remainingLevelsList = get the distinct list of levels left to visit
if remainingLevelsList not empty
lowestRemamingLevel = get the lowest number from remainigLevelsList
for iterationLayer in allLayers where (layer.level == lowestRemainingLevel)
recursion (iterationLayer, currentLayerList + currentLayer)
else
print the list(combination) / end of combination
This is working sample in C#:
static void GetCombinationsR(int level)
{
foreach (Layer layer in layers.Where(l => l.Level == level))
{
GetCombinationsR(layer, new List<Layer>());
}
}
static void GetCombinationsR(Layer layer, List<Layer> currentLayers)
{
// Declaring new list so we don't loose the list of previous layers in currentLayers
List<Layer> currentLayers2 = new List<Layer>();
currentLayers2 = currentLayers2.Union(currentLayers).ToList();
currentLayers2.Add(layer);
// Getting the list of remaining levels because we are not certain
// if level 1 is the lowest or if some levels are skipped
List<int> remainingLevels = layers.Select(l => l.Level).Where(l => l < layer.Level).ToList();
if (remainingLevels.Count() > 0)
{
int firstLowerLevel = remainingLevels.OrderByDescending(l => l).First();
foreach (Layer layerByValue in layers.Where(l => l.Level == firstLowerLevel).ToArray())
{
GetCombinationsR(layerByValue, currentLayers2);
}
}
else
{
PrintResultList(currentLayers2);
}
}
static void PrintResultList(List<Layer> resultList)
{
StringBuilder sb = new StringBuilder();
foreach (Layer layer in resultList)
{
sb.Append(layer.Level).Append(": ").Append(layer.Value).Append(" -> ");
}
sb = sb.Remove(sb.Length - 4, 4);
Console.WriteLine(sb.ToString());
}

Answer 2

Perhaps you need something like this:
function recursion (layer, combination)
if layer = 0
print combination
else
for (i = 0; i < layer.itemcount; i++)
recursion(layer - 1, combination + layer.item[i])
recursion(layer-1, empty[])
Delphi example (not optimal, we can search faster and break loop early)
var
A: TArray<string>;
procedure recursion (layer: Integer; combination: string);
var
i: integer;
begin
if layer = 0 then
Memo1.Lines.Add(combination)
else
for i := 0 to High(A) do
if A[i][1] = IntToStr(layer) then //primitive check of layer
recursion(layer - 1, combination + A[i] + ', ')
end;
begin
A := ['1.1','1.2','2.1','3.1','3.2','4.1','5.1'];
recursion(4, '');
generates
4.1, 3.1, 2.1, 1.1,
4.1, 3.1, 2.1, 1.2,
4.1, 3.2, 2.1, 1.1,
4.1, 3.2, 2.1, 1.2,