Recursief alle mogelijkheden bepalen

[Snoeks]

Hoi allemaal,

Ik heb het volgende probleem:

Ik defnieer een struct QnA

struct QnA
        {          
            private string PLeftSide;
            private string PRightSide;
            
            public string LeftSide
            {
                get{return PLeftSide;}
                set{PLeftSide = value;}
            }
            public string RightSide
            {
                get{return PRightSide;}
                set{PRightSide = value;}
            }
        }

En deze plaats ik in een List

List<QnA> AnswerList = new List<QnA>();

Vervolgens vul ik deze met wat data:

QnA qna0 = new QnA();            
qna0.LeftSide= "Art7";
qna0.RightSide= "Art1";
AnswerList.Add(qna0);

QnA qna1 = new QnA();            
qna1.LeftSide= "Art6";
qna1.RightSide= "Art7";
AnswerList .Add(qna1);

QnA qna2= new QnA();            
qna2.LeftSide= "Art1";
qna2.RightSide= "Art6";
AnswerList.Add(qna2);

QnA qna3= new QnA();            
qna3.LeftSide= "Art6";
qna3.RightSide= "Art13";
AnswerList.Add(qna3);

QnA qna4= new QnA();            
qna4.LeftSide= "Art13";
qna4.RightSide= "Art7";
AnswerList.Add(qna4);

Vervolgens wil ik (recursief?!) alle mogelijk combinaties bepalen en wel voor het volgende:

Ik neem de eerste QnA als uitgangspunt --> LeftSide Art7 || RightSide Art1
Vervolgens moet ik per element in de List (afgezien van element met index 0, die is al gebruikt) kijken of de LeftSide gelijk is aan Art1 (RightSide van uitgangspunt).

Zo bouw ik stap voor stap een 'ketting' totdat beide uiteinden hetzelfde zijn. Let wel, een List item mag maar één keer worden gebruikt (om een oneindige loop te voorkomen).

In dit (eenvoudige) geval zouden de volgende twee 'kettingen' kunnen worden gemaakt:

qna0 (Art7||Art1), qna2 (Art1||Art6), qna1 (Art6||Art7)

en

qna0 (Art7||Art1), qna2 (Art1||Art6), qna3 (Art6||Art13), qna4(Art13||Art7)


***

Hoe pak ik het aan voor een AnswerList met 30 elementen om alle mogelijke kettingen af te leiden?
Daarbij, het kan voorkomen dat sommige elementen vaker voorkomen (bijv. 4 keer een QnA met (Art7||Art1).

Alvast dank voor iemand die wil meekijken!!!

 

[xxmart]

Ik ben een goede bui

[CPP]using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Windows.Forms;

namespace SandboxForm
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

private static void Form1Load(object sender, EventArgs e)
{
List<Qna> qnaOrderedList = new List<Qna>();
List<Qna> qnaList = new List<Qna>
{
new Qna {LeftSide = "Art7", RightSide = "Art1"},
new Qna {LeftSide = "Art6", RightSide = "Art7"},
new Qna {LeftSide = "Art1", RightSide = "Art6"},
new Qna {LeftSide = "Art6", RightSide = "Art13"},
new Qna {LeftSide = "Art13", RightSide = "Art7"}
};

//start met eerste obj
qnaOrderedList.Add(qnaList[0]);
Debug.WriteLine("LEFT: {0} -- RIGHT: {1}", qnaOrderedList[0].LeftSide, qnaOrderedList[0].RightSide);

int tryCount = 0;
while (qnaList.Where(q => !q.Used).Count() > 0 && tryCount < qnaList.Count)
{
Qna bla = qnaList.Where(q => !q.Used && q.LeftSide == qnaOrderedList[qnaOrderedList.Count - 1].RightSide).FirstOrDefault();
tryCount++;

if (bla != null)
{
qnaOrderedList.Add(bla);
Debug.WriteLine("LEFT: {0} -- RIGHT: {1}", qnaOrderedList[qnaOrderedList.Count - 1].LeftSide, qnaOrderedList[qnaOrderedList.Count - 1].RightSide);
bla.Used = true;
tryCount = 0;
}
}
}
}

public class Qna
{
public string LeftSide { get; set; }
public string RightSide { get; set; }
public bool Used { get; set; }
}
}
[/CPP]

 

[Snoeks]

Onwijs bedankt voor het meedenken!

Mooie code ook (ik heb nog veel te leren )

Wat me wel opvalt is dat deze code maar 1 resultaat heeft... Op zich natuurlijk helemaal correct, maar mijn probleem zit vooral in het vinden van alle mogelijkheden.

Dus voor gegeven set zijn volgens mij elk geval twee manieren om de 'ketting' te maken. Misschien als je nog een idee hebt, hoor ik dat heel graag.

Nogmaals dank!!!