public ILejátszható[] Elsőelemre(LáncoltLista <ILejátszható> tartalom)
{
ListaElem <ILejátszható> aktualis = tartalom.Fej;
//6 stílust használok, ezáltal 6 elemű a tömbböm, amibe eltárolom az első elemre vonatkozó referenciákat.
string[] stilusok = new string[] { "Családias", "Mulatós", "Rock", "Elektronikus", "Romantikus", "Akció" };
int stilus_index = 0;
int db = stilusok.Length;
ILejátszható[] elsőelemekreRef = new ILejátszható[db];
int elsőre_index = 0;
while (stilus_index < db && aktualis != null)
{
if (aktualis.Következő == null && elsőelemekreRef[elsőre_index] == null)
{
stilus_index += 2;
aktualis = tartalom.Fej;
elsőelemekreRef[elsőre_index++] = aktualis.Érték;
}
else if (aktualis.Érték.Stílus == stilusok[stilus_index])
{
elsőelemekreRef[elsőre_index++] = aktualis.Érték;
stilus_index++;
}
aktualis = aktualis.Következő;
}
return(elsőelemekreRef);
}
public lista(LáncoltLista <ILejátszható> tartalom, string[] támogatott)
{
adatok.Add("Rock", new List <ILejátszható>());
foreach (ILejátszható i in t.Tartalom)
{
switch (i.Stílus)
{
case "Rock": adatok["Rock"].Add(i); break;
}
}
}
//Az elsőelemek megtalálása: egy int db változóba eltárolom a tartalom méretét, majd a egy tmp tömböt ezzel a mérettel inicializálok. Ebbe a tmp tömbbe kerülnek bele a referenciák.
//A megvalósítás:Először feltöltöm a tömböt a tartalom összes elemével, majd deklarálok egy index változót ami a legelső elemre mutat, és ezt is használom az if első vizsgálandó elemének indexelésére.
//Amíg a soron következő elemek stílusa azonos az elsővel, addig azokat törlöm, ha különböznek, akkor az index értéket fölülírom az i-vel így az az éppen aktuális elemre fog mutatni, aminek pont eltér a stílusa
//az eddig vizsgálttól. Ezután folytatódik a ciklus és vizsgálja, hogy a következő elem azonos-e az index-edik elem stílusával és ha igen, törli, ha nem átlépteti az indexet az aktuális elemre és így tovább.
public void TartalomÖsszeállítás(LáncoltLista <ILejátszható> tartalom)
{
int stilusDb = 0;
int támogatott_index = 0;
try
{
stilusDb = Db();
}
catch (TulnagyASzam e)
{
Console.WriteLine(e.Message);
TartalomÖsszeállítás(tartalom);
}
Console.WriteLine();
string[] támogatottStílusok = new string[stilusDb]; //meghívom a műfajra kiválogatott listán ami már csak azokat a műfajokat tartalmazza amiket a felhasz engedett
bool kilep = false;
while (kilep == false)
{
try
{
támogatottStílusok = TámogatottStílusok(stilusDb, támogatott_index);
kilep = true;
}
catch (NemLetezoStilus e)
{
Console.WriteLine(e.Message);
}
}
Console.WriteLine();
int műsorhossz = 0;
Dictionary <string, List <ILejátszható> > válogatottTartalom = Válogatás(tartalom, támogatottStílusok);
LáncoltLista <ILejátszható> osszefuzott = new LáncoltLista <ILejátszható>();
osszefuzott = ElejereOsszeFuzes(válogatottTartalom);
int meret = osszefuzott.Count();
int marker = 0;
ILejátszható[] eredmeny = new ILejátszható[meret];
//osszefuzott.BackTrack()
Console.WriteLine();
foreach (var item in osszefuzott)
{
Console.WriteLine(item);
}
}
public Dictionary <string, List <ILejátszható> > Válogatás(LáncoltLista <ILejátszható> tartalom, string[] támogatott)
{
Dictionary <string, List <ILejátszható> > adatok = new Dictionary <string, List <ILejátszható> >();
adatok.Add("Családias", new List <ILejátszható>());
adatok.Add("Mulatós", new List <ILejátszható>());
adatok.Add("Rock", new List <ILejátszható>());
adatok.Add("Elektronikus", new List <ILejátszható>());
adatok.Add("Romantikus", new List <ILejátszható>());
adatok.Add("Akció", new List <ILejátszható>());
for (int i = 0; i < támogatott.Count(); i++)
{
foreach (ILejátszható item in tartalom)
{
if (item.Stílus == támogatott[i])
{
adatok[támogatott[i]].Add(item);
}
}
}
return(adatok);
}
public LáncoltLista <ILejátszható> ElejereOsszeFuzes(Dictionary <string, List <ILejátszható> > válogatottTartalom)
{
//ListaElem<T> fej = válogatottTartalom.Values;
LáncoltLista <ILejátszható> osszefuzott = new LáncoltLista <ILejátszható>();
foreach (var item in válogatottTartalom)
{
if (item.Value.Count != 0)
{
for (int j = 0; j < item.Value.Count; j++)
{
osszefuzott.Beszuras(item.Value[j]);
}
}
}
//for (int i = 0; i < válogatottTartalom.Values.Count; i++)
//{
// if (válogatottTartalom.Keys != null)
// {
// Console.WriteLine("null");
// }
//}
return(osszefuzott);
}
public void Start(List <ILejátszható> input)
{
int length = input.Count;
LáncoltLista <ILejátszható> tartalom = new LáncoltLista <ILejátszható>();
for (int i = 0; i < length; i++)
{
tartalom.RendezettenBetesz(input[i]);
}
//A foreach működése: var értékek in tartalom
/*
* Első lépésként a tartalom "parancsra" meghívódik az IEnumerable<T> interface-t megvalósító LáncoltLista<T> osztály-ban a GetEnumerator() metódus, melynek egyetlen eleme a visszatérési értéke, a LáncoltListaEnumerátor<T> osztály, melynek
* bemenő paramétere a listánk feje.
* A LáncoltListaEnumerátor<T> megvalósítja az INumerator<T> interface-t ami miatt meg kell írni a Current, MoveNext, Reset metódusokat.
* A LáncoltListaEnumerátor<T> osztály tartalmaz két ListaElem<T> típusú elemet, az aktualis-t és az elso-t. A konstruktorban az elso-nek átadódik a teljes láncolt listánk, az aktualis értéke null.
* Második lépésként az in "parancsra" a MoveNext() metódus hívódik meg, ami első lépésként az aktualisnak átadja a teljes listánkat, majd újabb meghíváskor, már csak elementként lépteti a listát.
* Visszatérési értéke bool, jelzi hogy maradt e még elemünk a listában, ha ez hamis, leáll a foreach ciklus.
* Utolsó lépésben a var érték fut le, ami a Current() metódusból visszaadja az -aktualis- listaelem érték tulajdonságát.
*
* */
foreach (var érték in tartalom)
{
Console.WriteLine(érték); //Kiiratáskor a Film osztályban található ToString metódus fut le, mivel minden osztály tulajdonsága onnan olvasható ki.
}
Console.WriteLine();
Console.WriteLine();
ILejátszható[] elsőelemreReferencia = Elsőelemre(tartalom);
foreach (var item in elsőelemreReferencia)
{
Console.WriteLine(item);
}
TartalomÖsszeállítás(tartalom);
/*
*
* /*
* Backtrackhez:
* majd akkor
* mikor jön a BT
* ugye ott az van
* hogy a felhasználó megasszondja
* milyen stílusokat akar
* egyáltalán válogattatni
* te meg ez alapján a referencia tömböd alapján
* nem kell
* mindig elejéről végigmenned
* hanem rögtön odaugrasz
* és elkezded kiszedni adott stilust
* de ha balfasz felhasználó asszondja szeretne olyat, ami létezik mint stilus a rendszeredbe
* de nincs hozzárendelt film/zene
* akkor throw
* szal a BT
* lesz a try
* végére catch
* azt máris írhatod ki
* a megadott stílus nem létezik/stílusok közül egy nem létezik
*
*
*
* BT
* a lancolt lista egyik metodusa
* mivel minden lancolt lista-ban lehet keresni a megközés miatt
* mert úgy van felépítve a programom, hogy a láncolt listámban a bts működni fog
* mert csak olyan elemek lehetnek benne, amivel a bts működik
* 9 paraméteres BTS
* ebből 3 vagy 4 ref paraméterrel
* meghívom a műfajra kiválogatott listán
* ami már csak azokat a műfajokat tartalmazza
* amiket a felhasz engedett
* abban megnézi az első belefér-e az időbe
* ha igen, megnézi a másodikkal belefér-e az időbe
* ha valami belefér
* azt kimentem egy olyan lista node-ba
* aminek a tartalma az adott listaelem tartalmára mutat, a next része meg az előtte ellenőrzött
* listaelemére
* amennyiben találok egy optimális megoldás (az első megtalált mindig optimális lesz)
* (utána meg az előző optimálishoz hasonlít mindig)
* szal ha talál egy éppen legjobb megoldást
* akkor a mappoint listnode-okon
* visszaköveti
* milyen listaelemeken keresztül jutott el oda
* azok tartalmát egy tömbbe
* Eredmeny() metódusban
* feltölti
* ha a megtalált megoldás nem a legjobb
* tehát nem jobb mint az előző
* akkor
* semmit nem csinál, keres tovább
* csak akkor változtat az eredményen
* a tömbön
* ha jobb megoldást talál
* akkor viszont beállítgatja az eredmény tömböt megfelelően
* és a markert
* a marker egy olyan változó ami azt jelöli, hogy az eredmény tömbben
* meddig kell nézni
* a cuccot
* mert ha régen 7 elem volt a jó megoldás, de később 2 elem a legjobb
* akkor a maradék 5 elem már nem kell kiíratásnál
* amennyiben egy elem sem felel az egész tömb null referenceket fog tartalmazni
* annyi, hogy kell egy ilyen konstruktor a Node-od nak, amit a láncolt listára használsz még:
* public ListNode(ListNode<T> next)
* {
* tartalom = default(T);
* this.next = next;
* }
* meg a T tartalom tulajdonságot
* írhatóvá is kell tenni
* és ezzel megoldható a visszakeresése a megoldásnak
* node - vizsgált listelem
* szint - az aktuális választás szintje, az az index ahanyadik kiválasztott lehetséges elem
* remaining - maradék idő, ami hátra van, hogy elérjem a műsoridőt
* cost - ár
* eredmeny - az eredménytömb, melybe az éppen legjobb megoldásokat beállítom
* ref int pool - az éppen aktuális legjobb megoldás és műsoridő közti eltérés
* ref int totalcost - az éppen aktuális legjobb megoldás ára
* ref int marker - az éppen aktuális legjobb megoldás utolsó elemét mutatja meg az eredmény tömbben
* (azért kell, mert ha előtte 5 elem volt a legjobb, most meg csak kettő, akkor az első 2 elemet átállítom a tömbben, de tudnom kell, hogy csak az első kettőt kell figyelembe vennem a további feldolgozásnál)
* before - az előző szinten vizsgált elemre mutató referencia, hogy vissza tudjam követni milyen elemeken keresztül találtam legjobb megoldásokat
*
* a bts-em
* a this helyett
* nálad
* a ref totalcost
* llenne
* a te verziodban
* **/
}
public OptimálisTartalomÖsszeállító(LáncoltLista <ILejátszható> tartalom)
{
this.tartalom = tartalom;
}
