Hallo Forum, ich hoffe das ist das richtige Unterforum!

Also, ich muss für ein Projekt folgende Aufgabe übernehmen:

Grundlegendes: Es gibt ein Programm, dass Fragen stellt. Wenn man auf Antwort klickt, sieht man die Antwort, anschließend kann man bewerten wie schwierig man die Frage selbst gefunden hat, von 1-3, 1 ist leicht, 3 ist schwer.

So weit so gut, meine Aufgabe ist eine Funktion, die die Fragen einer Gruppe in einer bestimmten Reihenfolge kommen lässt. Die Funktion wird nach jeder Frage neu aufgerufen, und gibt nur die Fragennummer zurück. Abhängig ist die Reihenfolge von Bewertung und Auftreten, wobei das Auftreten am Ende des Quizes wieder auf 0 zurückgeht.

Also, einfaches Beispiel, es gibt 5 Fragen in der Gruppe.

es kommt Frage - wird bewertet mit

Frage 1 - schwer
Frage 2 - leicht
Frage 3 - mittel
dann wieder Frage 1 da vorhin mit schwer beantwortet
dann Frage 4 - leicht
Frage 5 - leicht
und dann nochmal Frage 3

oder so ähnlich, muss jetzt nicht genau so sein.

Meine Frage nun: Wie gehe ich das am besten an? Ich bekomme eine Datenbank übergeben, wo die einzelnen Fragen inklusive Antworten, Bewertungen und Auftreten dabei sind.

Bin für jede Hilfe dankbar, Grundlagen der Programmierung kann ich.

MFG Zoltamor

Hallo Zoltamor

du meinst sicherlich "Algorithmus" im Titel, oder?

Hoppla, natürlich

Habs schon ausgebessert. Vielleicht findet sich jetzt eher wer der mir helfen kann

MFG Zoltamor

Hallo Zoltamor,

ich hatte heute morgen nicht soviel Zeit, um deine Frage konkret zu lesen und zu beantworten.
Als Stichwort fällt mir da "Priority Queue" ein, d.h. anhand der Bewertung die Frage einsortieren (und evtl. einen Zufallswert zusätzlich noch zu nehmen, um ein bißchen Abwechslung zu schaffen). Sehe ich das richtig, daß leichte Fragen dann komplett aus der Liste rausfallen sollen, also nicht mehr nachgefragt werden?

Delphi hat doch so hübsche dynamische Arrays, ich würde da garnicht groß mit der Priority-Queue-Keule schwingen:

Am Anfang alle Fragen (nur die Nummern) in ein array of integer packen.

Mit dem Befehl random( Lenght(MeinArray) ) wählst du nun eine Frage aus.

Wird sie mit "leicht" bewertet, dann fliegt sie aus dem Array raus (Effizient: Das letzte Element des Arrays in die Lücke ziehen, Array eins kleiner machen).

Randomize nicht vergessen

Die Idee gefällt mir sehr gut, hab mir das selbst auch so ähnlich gedacht (unter zahlreichen anderen gescheiterten Versuchen )

Stellt sich nur die Frage, wie realisiere ich das alles in C#?

Ein Array erstellen, und die random Funktion drüber laufen lassen dürfte kein Problem sein.

Aber: wenn sie mit leicht bewertet ist --> Wie werfe ich sie dann raus und mache das Array kleiner?
Und vor allem: Schwere und Mittlere Fragen sollten ja nach einer gewissen Zeit nochmal auftauchen, wie kommt das da mit rein?

Danke schon Mal für die Hilfe!

MFG Zoltar

Hi,

das ist jetzt schon das zweite mal dass ich eine Delphi-spezifische Antwort gebe, es aber eigentlich um C# geht Bitte poste es dann im C#-Forum

Kurzes Googlen sagt mir nämlich: C# kann keine dynamischen Arrays, du kannst also das Array garnicht kleiner machen. Du müsstest also von Hand speichern, wieviele Einträge noch im Array sind (die letzten Elemente wären dann "leer"). Immer wenn du ein Element rausnimmst, dann machst du den Wert kleiner (Achtung, du musst das letzte wie im vorherigen Post nach vorne in die Lücke ziehen).

Die mittleren/schweren Fragen werden dann wieder gezogen, da sie ja noch im Array sind. Nur die leichten Fallen raus.

Xion hat folgendes geschrieben :

das ist jetzt schon das zweite mal dass ich eine Delphi-spezifische Antwort gebe, es aber eigentlich um C# geht Bitte poste es dann im C#-Forum

Diese Sparte ist Forenübergreifend

Wäre aber trotzdem nett, die Sprache vorher mit zu erwähnen, ja.

Hallo zusammen,

unter C# gibt es die generischen Container, z.B. List<T> bzw. Queue<T>.
Aber so wie ich die Aufgabenstellung verstehe, sollen die Fragen ja anfangs in einer bestimmten Reihenfolge erscheinen. Und dafür eignet sich nun mal eine PriorityQueue.
Eine generische Version davon gib es unter www.codeproject.com/...elp-of-heap-data-str

Da die Laufzeit quasi egal ist, würde ich eine lineare Suche nach dem (wie auch immer gearteten) maximalen Element trotzdem bevorzugen .

Oh, tut mir Leid dass ich das nicht erwähnt habe, aber ja, es geht um C#!

Danke schon Mal für die vielen hilfreichen Antworten, nur so wirklich die Lösung hab ich leider noch immer nicht.

Die Fragen müssen nicht unbedingt in einer bestimmten Reihenfolge kommen, es geht nur darum, dass leicht bewertete dann nicht mehr kommen, mittlere noch 2 Mal und schwere noch 3 Mal, und halt innerhalb einer gewissen Zeit. Das ist das wichtige, und das, wo ich meine Probleme habe!

MFG Zoltamor

Es wäre gut, wenn du mal ganz klar aufschreibst, was der Algorithmus genau tun soll. Die Anforderung "leicht bewertete dann nicht mehr kommen, mittlere noch 2 Mal und schwere noch 3 Mal, und halt innerhalb einer gewissen Zeit" lässt sich aus deinem Beispiel nicht ableiten. Auch der Begriff "gewisse Zeit" sollte klar definiert werden, sollen Wiederholungsfragen erst gestellt werden, wenn alle Fragen einmal durch sind oder schon vorher?

Ok ich erklärs nochmal:

Also:

Ich muss ein Programm schreiben, dass eine Fragennummer ausgibt. Je nach Fragennummer wird dann eine Frage ausgegeben (eh klar)

Das Programm soll ermitteln, welche Frage die nächste sein soll, und zwar nach Bewertung (1=leicht, 2=mittel, 3=schwer) und auch Auftreten. Am besten wäre es so, ich mach Mal ein konkretes Beispiel:

In der Datenbank stehen 50 Fragen. Die erste Frage wird zufällig gewählt, angezeigt, und bewertet.

Wird sie mit leicht bewertet, kommt sie nicht mehr! Wird sie mit mittel bewertet, soll sie nach ein paar Fragen, sagen wir 8, wieder kommen. Wird sie mit schwer bewertet, soll sie nach 5 Fragen wieder kommen. Und dazwischen halt immer andere Fragen!

Zu Ende ist das Quiz wenn alle leichten Fragen 1 Mal, alle mittleren Fragen 2 Mal und alle schweren Fragen 3 Mal aufgetreten sind! Vor jedem Quizbeginn wird das Auftreten wieder auf 0 gesetzt.
Hoffe es ist jetz klar und bedanke mich Mal wieder für die Hilfe die bis jetzt schon kam!

MFG Zoltamor

Hallo Zoltamor,

du hast den Algorithmus ja jetzt schon genau aufgeschrieben.
Hierfür reicht wirklich eine einfache Liste (anstatt meiner vorgeschlagenen PriorityQueue).
1. List<int> erzeugen
2. alle Fragen (bzw. deren Nummer) in die Liste eintragen
3. Liste shuffeln (random)
4. Jeweils die erste Frage anzeigen (bis Liste leer ist)
4a. Bewertung durchführen:
- leicht: erste Frage entfernen
- mittel: Frage an Position 8 verschieben (bzw. zufällig in einem Bereich von 5-10)
- schwer: Frage an Position 5 verschieben (... von 3-7)

Einzige Frage ist noch, ob bisher bewertete Fragen nochmals neu bewertet werden sollen, oder ob sie dann automatisch aus der Liste gelöscht werden sollen? Im zweiten Fall müßtest du noch zusätzlich die Bewertung mitspeichern (z.B. in einem eigenen Array oder aber eine eigene Klasse mit Fragennummer und Bewertung anlegen und diese dann in der Liste verwenden).

Wobei ich deinen Satz "Zu Ende ist das Quiz wenn alle leichten Fragen 1 Mal, alle mittleren Fragen 2 Mal und alle schweren Fragen 3 Mal aufgetreten sind!" eher so deute, daß du dann die schwere Frage zweimal in die Liste zurückeintragen sollst (und es keine neue Bewertung geben soll).

Danke vielmals schon Mal, hat mir denke ich echt weitergeholfen!

Und nein, die Bewertung soll nach jeder Frage neu erfolgen, wodurch sich jetzt eventuell ein bisschen was ändern kann.

Und noch eine Frage, wo finde ich am besten erklärt (oder würde das hier wer machen? ) wie ich mit Listen arbeite? Weil die sind mir bisher völlig unbekannt.

MFG Zoltamor

Über ein letztes bisschen Hilfe mit Listen wäre ich wirklich dankbar, hab zwar auch schon gegoogelt aber so wirklich was brauchbares kann ich nicht finden..

Danke schonmal!!!

MFG Zoltar

LIST C# sagt mir www.dotnetperls.com/list

Ok vielen Dank, das sollte helfen!

MFG Zoltamor