flashpixx

Ich würde raten zu authentifizieren und nur einem authentifizierten User das Senden zu erlauben. Ich betreibe ein Postfix für 5 Domains und mehreren Usern. Jeder User bekommt eine Mailadresse mit Passwort und der User X kann dann nur unter seiner hinterlegten Mailadresse senden, d.h. User X kann nicht mit Adresse von User Y senden. Die Daten (User & Passwort) liegen in einer mySQL Datenbank auf die Postfix zugreift. Systemuser wie www o.ä. werden dann mit gesonderten Adressen versehen. Letztendlich funktioniert das dann über die Regeln: reject_sender_login_mismatch und permit_sasl_authenticated,

Du wirst hier keine fertige Lösung für Deinen Quellcode bekommen. Du hast den Hinweis bekommen, dass JOpenPane entsprechende Methoden bietet, um ein Icon zu setzen. Die Grundtechniken der Sprache musst Du beherrschen und verstanden haben: Galileo Computing :: Java ist auch eine Insel – 2.7 Methoden einer Klasse

Wenn Du jetzt mit der Aufgabe schon fertig bist, dann gehe jetzt zu Deinem Chef, bespreche mit ihm Dein Ergebnis und versuche eben das ganze noch etwas zu verfeinern / verbessern.

Du musst den JDBC in den Classpath hinzufügen

Der Weg ist das Ziel...... *scnr*

Auch wenn ich gerne hier zu den Leuten gehöre die aus der Mathematik argumentieren, gebe ich Dir aber recht, sofern es um "Standard-Software" geht, ist meistens die gesunde Menschenverstand besser, als das ganze zu formalisieren. Oft reicht einmal die Überlegung "wie muss das für meinen Nutzer einfach gestaltet werden" und "wie setzt man das dann noch in guten Code um". Oft ist ein klarer und einfacherer Weg die beste Lösung Ja, in manchen Bereichen stimmt das. Ich würde hier ggf auch mal hochperformante Datenbanken / Optimierungen hinzuzählen ebenso wie mathematische Algorithmen. Aber bis Du an diesem Punkt ankommst, wird es noch dauern.

Wie schon Crash schrieb, die ausgehenden Pakete werden wohl geblockt.

Die Vereinfachung ist optional um den Rechenaufwand zu verringern. Ansonsten nimmt man eine Schleife und iteriert, entweder so lange bis Konvergenz eintritt oder der Zahlenbereich nicht mehr genau auflöst oder eben bis zu einem festen n. Letztendlich ist das aber mathematisch betrachtet eine Reihe.

Das kannte ich nicht, ich hätte es via Trigger gelöst, da ich eher mit OpenSources Systemen wie mySQL und Postgresql arbeite.

Warum eine Prozedur? Wenn Du protokollieren willst, wann sich der Datensatz zuletzt geändert hat würde man bei einem On-Update bzw On-Create das Feld direkt via Trigger setzen

Ich hatte von einer Rekursion komplett abgeraten. Man kann die genannte Summe mathematisch (!) so vereinfachen, dass man daraus eine Folge machen kann und zu einem n mit relativ wenig Rechenaufwand das n+1 Element errechnen kann. Das ganze algorithmisch umzusetzen ist der nachfolgende Schritt und man kann dies komplett mit Schleifen realisieren, wobei man eben diese sehr einfach gestalten kann, wenn man zuerst mathematisch vereinfacht hat

Von einer Rekursion für eine einfache Potenzfunktion rate ich ab, denn alleine der Overhead für Rücksprung auf dem Stack rechtfertigt das nicht. Zusätzlich kann man eine Potenz durch eine simple Bedingung eliminieren. Durch etwas geschickte Umformung kann man die Summenfunktion, inkl. des Faktors und der Potenz zerlegen, so dass man die gesamte Funktion für ein n und ein n+1 schnell berechnen kann Benutze generell bitte die Codetags

Nein diese Aussage ist falsch XSL Transformation

Und was ist jetzt genau der Fehler?

Ah, dann hatte ich das anders verstanden, ich hatte es so gelesen, dass bei "Mona", "Tom" es heißt, dass die Aufgabe von "Mona" und "Tom" bearbeitet wird und nun noch weitere Mitarbeiter gefunden werden sollen Das sollte das gewünschte liefern: function aufgabenbacktrack( $personen, $aufgaben, $index = 0, $loesung = array()) { if ($index >= count($aufgaben)) { print_r($loesung); return true; } $lpersonen = $personen; foreach($lpersonen as $name => $val) { if ($val <= 0) continue; if (in_array($name, $aufgaben[$index])) { $lloesung = $loesung; array_push($lloesung, $name); $lpersonen[$name]--; if (aufgabenbacktrack($lpersonen, $aufgaben, $index+1, $lloesung)) return true; } } return false; } $schueler = array( "Peter" => 2, "Klaus" => 1, "Nina" => 2, "Sara" => 3, "Christian" => 1, "Joachim" => 3, "Robert" => 2 ); $aufgaben = array( array("Peter", "Klaus"), array("Nina", "Peter"), array("Sara", "Nina", "Klaus"), array("Sara", "Nina"), array("Robert", "Joachim", "Nina"), array("Klaus", "Peter", "Nina", "Joachim") ); aufgabenbacktrack($schueler, $aufgaben); [/php]

Da fehlt aber noch ein Abbruchkriterium, denn Du weißt aus der ersten Datei, wie viele Aufgaben jeder maximal bearbeiten darf, aus der zweiten Datei weißt Du, wer schon die Aufgabe bearbeitet, aber wann ist die Aufgabe beendet. Als Bsp: 3, Tom 2, Lisa 3, Mona 4, Tim wenn nun in der ersten Zeile der Aufgaben steht: Tom, Lisa => Mona, Tim wenn die zweite Zeile so aussieht, ergibt sich => dann Lisa, Mona => Tom, Tim d.h. jede Zeile Deiner Aufgaben würde mit allen Namen aufgefüllt werden, sofern jeder noch Aufgaben machen darf. Du hättest somit für jede Aufgabenzeile immer alle möglichen Namen stehen. Du bräuchtest somit in der Aufgabenlist eine Information, wann die Aufgabe als "erfüllt" gilt z.B. wenn immer 4 Leute daran mitarbeiten o.ä. So wie ich den das verstehe besagt die Zeile in der Aufgabendatei, wer schon an der Aufgabe arbeitet. Ich sehe das jetzt so, dass Du eben eine Belegung von allen Aufgaben finden sollst, so dass alle Aufgaben bearbeitet werden und keiner seine maximale Anzahl überschreitet. Ist das so richtig !?

Ich will noch anmerken das OpenGL in einer VM durchaus auch Probleme machen kann, sofern es eben nicht durch die Virtualisierung unterstützt wird. Compilieren und Linken sollte auf jeden Fall funktionieren, aber mit der Ausführung könnten Probleme auftreten

Noch einmal der Hinweis: Dein Code ist undokumentiert, noch sind Deine Ausgaben in irgendeiner Form verständlich. Ändere es so ab, dass es verständlich, wenn Du möchtest, dass man Dir hilft. Als weiterer Punkt nehme ich Deine Aufgabenstellung: Daraus folgt, dass für jeden Schüler ein individuelles Limit an Aufgaben existiert und eine Liste von Aufgaben existiert, die Auf die Schüler verteilt werden muss. Es existiert somit keine Einschränkung, dass bestimmte Aufgaben auf bestimmte Schüler verteilt werden müssen o.ä. Wie Du den Hinweis umsetzen willst, hast Du bisher nicht beantwortet. Du hast sogar gesagt, dass der Vorschlag von mir, dass im Mittel jeder gleich viele Aufgaben bearbeiten soll, nicht umgesetzt werden muss. Somit kann ich die genannte Aussage auf <= reduzieren. Dieser Code: $schueler = array( "Peter" => array("max" => 2, "aufgaben" => array()), "Klaus" => array("max" => 5, "aufgaben" => array()), "Nina" => array("max" => 4, "aufgaben" => array()), "Sara" => array("max" => 3, "aufgaben" => array()) ); $aufgaben = array( "Tafel putzen", "Kreide holen", "Bücher holen", "aufräumen", "aufpassen", "Bücher wegräumen", "Klassenzimmer putzen", "Klassenbuch führen", "Kinder betreuen", "Labor aufräumen", "Hausaufgaben machen", "Referat halten", "Test schreiben", "Pausenaufsicht", "Fenster putzen", "Musik spielen", "Essen austeilen" ); while ( (!empty($schueler)) && (!empty($aufgaben)) ) { foreach(array_keys($schueler) as $name) { array_push($schueler[$name]["aufgaben"], array_pop($aufgaben)); if (empty($aufgaben)) break; } foreach ($schueler as $name => $val) if ($val["max"] == count($val["aufgaben"])) { echo "=> ".$name." <=\n"; print_r($schueler[$name]); echo "\n\n"; unset($schueler[$name]); } } echo "Schüler, die das Maximum der Aufgaben nicht erreicht haben:\n"; print_r($schueler); echo "\n\nnicht vergebene Aufgaben:\n"; print_r($aufgaben); [/PHP] liefert genau eine Lösung für Dein Problem. Woher in Deinem Code auf einmal irgendwelche "Partnerbeziehungen" kommen, ist aus der Aufgabenstellung heraus nicht ersichtlich. Die Aussage lässt genau die Aussage zu, dass man eben eine Anzahl an Aufgaben hat, wobei die Einschränkung existiert, dass jede Aufgabe genau einmal bearbeitet werden soll. Liefere entweder weitere Einschränkungen, die zur Lösung relevant sind, ansonsten ist der Code von mir eine Lösung im Rahmen der Aufgabenstellung

Ich würde wohl die englische Onlinedokumentation verwenden bzw. ein Training absolvieren MySQL :: MySQL Training and Certification

Ich kann mit Deinen Listen nicht anfangen, bitte benutze eine Darstellung, die leicht (!), schnell (!) zu lesen und verständlich (!) ist. Nur weil es nicht läuft bedeutet das nicht, dass das Verfahren nicht funktioniert, ich würde hier auf Deine Implementierung tippen, dass diese fehlerhaft ist. Das Verfahren konvergiert, denn die Aufgabenmenge wird sofern die Schülerliste nicht leer ist kleiner, bis sie entsprechend leer ist, ebenso die Schülerliste, denn sobald ein Schüler seine maximale Anzahl an Aufgaben erreicht wird er aus der Liste entfernt. Abbruchkritieren sind eben eine leere Schülerliste oder eine leere Aufgabenliste. Bei dem Verfahren werden zuerst die Schüler aus der Liste entfernt, die max. eine Aufgabe erhalten, dann die, die zwei erhalten etc. Der Fall, dass ein Schüler max keine Aufgaben (==0) erhalten darf, muss entsprechend vorher beachtet werden. Der Fall, dass Schüler keine Aufgaben erhalten tritt nur dann auf, wenn die Aufgabenanzahl < als Anzahl der Schüler ist. Andernfalls erhält jeder Schüler mind. eine Aufgabe. Es kann nicht garantiert werden, dass jeder Schüler seine maximale Anzahl an Aufgaben erhält, denn es war nur gefordert <= Anzahl Aufgaben. Wenn eben nicht genügend Aufgaben vorhanden sind, dann kann das eben niemals eintreten. Weiterhin garantiert ist, dass jeder Schüler genau eine Aufgabe bekommt, es treten keine Duplikate auf. D.h. der Algorithmus liefert ein von Dir gefordertes Ergebnis

Dein Code sieht etwas aus wie PHP, da ist die Laufzeit schon relevant, weil der Interpreter, wenn sie eine vorgegebene Grenze überschreitet, einfach das Script abbricht. Wieso muss eine Aufgabe zurück !? Du verteilst nach Deiner Aussage nur die Aufgaben, wann sie zurück kommen, war nicht gefordert. Du kannst keine "uneindeutigen" Fälle produzieren, denn wenn Du so vorgehst, wie in meinem letzten Post beschrieben, wird jede Aufgabe genau einmal an einen Schüler zu gewiesen (Duplikate sind ausgeschlossen) Im Pseudocode: while Aufgabenliste nicht leer und Schülerliste nicht leer { for each s in Schülerliste { hole Aufgabe a aus Aufgabenliste und entferne diese Aufgabe aus der Liste Schüler s erhält Aufgabe a if Aufgabenliste leer break } for each s in Schülerliste if Schüler s hat Maximum an Aufgaben erreicht || Aufgabenliste leer { Schüler s mit seinen Aufgaben anzeigen entferne Schüler s aus Schülerliste } } Ich sehe hier nicht, warum Du ein Backtracking brauchst, denn diese Du hast keine Abhängigkeit, die ggf rückgängig gemacht werden muss. Du Zuordnungen sind immer eindeutig möglich. Ein Backtracking wäre nur nötig, wenn eine Aufgabe an mehrere Schüler ausgegeben wird und einer sie beendet, wobei man dann eben auch alle anderen, die die Aufgabe erhalten haben, benachrichtigen muss. Wobei ein echtes Backtracking braucht man da nicht wirklich. Backtracking brauchst Du nur, wenn Du zu Beginn nicht weißt, ob die Lösung zum Erfolg führt. In diesem Fall geht man alle Möglichkeiten durch und die Lösungen die eben keinen Erfolg liefern kann man während der Berechnung abbrechen.

Man kann halt naiv auch durch Reduktion arbeiten, das funktioniert aber nur, wenn keine weiteren Randbedingungen an der Aufgabenstellung existieren, also d.h. man hat nur die Bedingung jeder Schüler muss <= k Aufgaben bearbeiten. In diesem Fall verteilt man eben die Aufgaben so lange auf die Schüler, bis bei jedem / einigen das k erreicht ist, nachdem eine Aufgabe zugeteilt wurde, entfernt man sie aus der Liste, wenn ein Schüler das k erreicht entfernt man diese aus der Liste. Somit reduziert man die Aufgaben und die Schüler (siehe Association rule learning - Wikipedia, the free encyclopedia / frequent itemsets). Nachteil bei dieser Lösung ist aber, dass man eben keine weiteren komplexeren Randbedingungen leicht hinzufügen kann. Man würde eben bei diesem Vorgehen allen Schülern eine Aufgabe zuweisen, dann entfernt man alle Schüler, bei denen das k == 1 ist. Dann weist man eben wieder allen verbleibenden Schülern Aufgaben zu usw. Das ganze macht man so lange, bis entweder keine Aufgaben mehr da sind oder kein Schüler.

Okay, dann fällt raus, d.h. es wäre eben auch möglich, dass einer ganz viele Aufgaben bearbeitet und ein andere keine. Die Bedingung, dass das Limit jedes Schüler exakt erfüllt wird, ist nicht möglich, sofern Du nicht garantieren kannst, dass exakt so viele Aufgaben zur Verfügung stehen, wie alle Schüler zusammen bearbeiten sollen. Selbst wenn Du das garantieren kannst, muss die Lösung nicht eindeutig sein, denn sobald zwei Schüler gleich viele Aufgaben bearbeiten, wäre eine Permutation der Aufgaben immer noch eine gültige Lösung, d.h. Du hast hier eine Vielzahl von möglichen Lösungen. D.h. Du kannst es naiv machen und jede mögliche Lösung bestimmen und nimmst dann eine davon oder Du versuchst direkt eine gute Lösung zu bestimmen. Um alle Lösungen zu bestimmen und dann eine auszuwählen (vor allem ist dann die Frage, wie Du diese auswählst) wird eben nicht effizient möglich sein. Nein nicht direkt. Man kann das Problem als eine Abwandlung von Rucksackproblem auffassen. Eine Lösung mit Hilfe eines genetischen Algorithmus habe ich als Beispielcode hier implementiert http://flashpixx.de/svn/MachineLearning/developer/examples/geneticalgorithm/knapsack.cpp Die Grundannahme ist, dass jeder Schüler jede Aufgabe bearbeiten kann. Man nimmt dann eben n Schüler und verteilt erst einmal zufällig die Aufgaben auf diese. Danach bewertet man wie gut jeder Schüler ist (Fitnessfunktion), d.h. hier musst Du sicherstellen, dass eben wenn mehrere Schüler die gleiche Aufgabe bearbeiten, nur einer als "gut" bewertet wird. Ebenso muss hier bewertet werden, ob er eben seine maximale Anzahl an Aufgaben noch nicht erreicht hat etc., d.h. in diese Bewertungsfunktion müssen alle Bedingungen einfließen, die relevant sind. Anhand dieser Bewertung werden dann eine Anzahl an Schülern ausgewählt und eben rekombiniert, d.h. aus n Schülern werden k neue gemacht. Danach werden ggf noch einzelne Schüler mutiert, d.h. man weist ihnen zufällig Aufgaben zu. Dieses Verfahren iteriert man so lange, bis Konvergenz eintritt, d.h. bis eine Lösung gefunden wurde. Was in den meisten Fällen selbst bei großen Datenmengen in weniger als 100 Iterationen eintritt Nein die Zuweisung bezüglich des Quotienten (d.h. der aktuellen Lösungsanzahl) hat mit Heuristik nichts zu tun. Das Verfahren der genetischen Algorithmen ist eine Heuristik. Im Grunde wäre hier die Aussage, dass Schüler, die aktuell "wenig" oder "schlecht" gearbeitet haben, bevorzugt werden, eine weitere Aufgabe zu erhalten.

Das ist doch schon etwas verständlicher. Ich formuliere das mal etwas abstrakter: D.h. Du hast für jeden Schüler eine maximale Anzahl an Aufgaben, die erreicht werden kann. Also ein Schüler S, hat k Aufgaben, d.h. sofern der Schüler <= k Aufgaben erledigt, ist das eine gültige Lösung D.h. Du hast hier n Aufgaben. Hier ist jetzt in der Formulierung nicht klar, ob hier eine Zuordnung von Aufgabe zu Schüler existiert, d.h. Du hast die Information, welche Aufgabe welcher Schüler erledigen soll. So wie ich das verstehe existiert hier nur eine Liste von Aufgaben Das Ziel ist also, die n Aufgaben so auf die Schüler zu verteilen, dass a) jeder <= k Aufgaben erledigt und jeder möglichst gleich viel zu tun hat und c) keine Aufgabe doppelt vergeben wird. Du hast somit im Grunde drei Constraints, die die Lösung einschränken und die zu beachten sind. Ich kann hier direkt sagen, dass eine Lösung, die durch das Bestimmen jeder möglichen Kombination berechnet wird, extrem schlecht funktionieren wird, weil mehrere gültige Lösungen existieren können. Außerdem bei einer Listengröße > 1000 Elemente wird das bestimmen der Lösungen extrem ineffizient funktionieren. Ich rate deshalb das ganze über ein heuristisches Verfahren zu lösen Genetischer Algorithmus Man kann das Problem als binäres Problem (Schüler S löst Aufgabe j und kein weiterer Schüler darf dann j lösen) aufbauen und dann über einen genetischen Algorithmus lösen, was durchaus zu einer recht guten Lösung führt. Eine Lösung wie "Probiere alle möglichen Kombinationen durch" wird hier zu extremer Laufzeit führen. Rein formal kann jeder Schüler jede Aufgabe lösen, so lange er eben sein Limit (maximale Anzahl an Aufgaben) noch nicht erreicht hat und nicht jemand anderes diese Aufgabe schon bearbeitet. Um nun möglichst die Aufgabe so zu verteilen, dass alle gleich viel erledigen muss man so etwas wie die "mittlere Aufgabenanzahl" bestimmen und eben bei jedem Schüler schauen, wie weit seine aktuelle Anzahl von dieser mittleren Anzahl abweicht. D.h. im Sinne des genetischen Algorithmus bestimmt man "wie gut die Verteilung der Aufgaben bei jedem Schüler ist" und dieses optimiert man nun.

Gib bitte einmal den Algorithmus (in Worten) an, wie die Listen kombiniert werden müssen. Denn auf Grund Deines Beispiels ist nicht klar, was und wie kombiniert werden muss. Bei Deinem Ergebnis jetzt schreibst Du hinter ein Element auf der zweiten Liste ein Element aus der ersten: AB => B B hat in Deiner ersten Liste eine 2 als Suffix, es scheint aber bei dem Ergebnis unerheblich zu sein, was dort angegeben ist, denn Deine Lösung erhält immer genau einen Buchstaben. Nur weil eine exakte Lösung existiert, kann durchaus das Problem auftreten, dass es sehr schwierig ist diese zu bestimmen. In vielen Fällen sind approximative / heuristische Verfahren nicht schlechter als kombinatorische. Weiterhin möchte ich Dir den Tip geben, dass Du nicht hier an einem Buchstabenbeispiel, das nicht unbedingt gut verständlich ist, das Problem bzw. Dein Ziel beschreibst, sondern das zugrunde liegende Problem, denn in den meisten Fällen kann man durch eine Änderung des Algorithmus (und Datenstruktur) das Problem oft effizienter lösen. Beschreibe also die Problemstellung, d.h. in Deinem Fall was ist das inhaltliche Problem mit den Listen