|
|
|
|
Nimm es. Selbst bauen lohnt sich nicht, jede Zeile Code die du nicht selber schreibst ist eine Zeile mehr die du nicht verkacken kannst.
Schreib halt eine requirements.txt und benutz pip.
|
|
|
|
|
|
|
List of lists konstruieren?
Initiale Elemente: Parent=None
Finde Elemente mit Parent=ID
Rekursiv für alle gefundenen Elemente
|
|
|
|
|
|
|
| Zitat von csde_rats
List of lists konstruieren?
Initiale Elemente: Parent=None
Finde Elemente mit Parent=ID
Rekursiv für alle gefundenen Elemente
| |
Dann rechne mal aus, wie häufig meine collection durch iteriert wird. Bei jeder Suche immerhin (im Worst case) einmal komplett
@Achsel: Ich bin bisher ohne Abhängigkeiten ausgekommen und fände es klasse, wenn das so bliebe. U.a. wegen Python3. Ich nehme lieber eine ineffiziente Lösung als ne extra App. Außerdem kann es nicht sooooo schwierig sein, den von mir beschriebenen simplen Fall zu implementieren.
/e: Es geht übrigens um Kommentare, die Antworten auf andere Kommentare sein können. Ich würde gerne nur eine DB Query haben und möglichst wenige Iterationen, da das bei jedem Seitenaufruf passieren wird.
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Oli am 31.03.2013 21:10]
|
|
|
|
|
|
Das "Finde bla" macht doch der SQL-Server? Dessen Problem! Zur Not halt einen Index auf die Parent-Spalte setzen. Du fässt hier ja auch jedes Element nur einmal an.
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von csde_rats am 31.03.2013 21:11]
|
|
|
|
|
|
| Zitat von csde_rats
Das "Finde bla" macht doch der SQL-Server? Dessen Problem! Zur Not halt einen Index auf die Parent-Spalte setzen. Du fässt hier ja auch jedes Element nur einmal an.
| |
Für jede Suche eine Query abschicken wäre ja noch schöner. Nehmen wir mal an, ich habe eine Collection/Liste/Whatever mit allen Einträgen wie oben beschrieben, und will die in einen directory tree schreiben. Oder so.
|
|
|
|
|
|
|
|
Code: |
def get_comment_tree(self):
class Node(object):
def __init__(self, obj):
self.obj = obj
self.children = list()
self.depth = -1
root = Node(None)
flat_lookup = {root.obj: root}
flat_result = []
for c in self.comments.filter(published=True):
node = Node(c)
flat_lookup[c.id] = node
flat_lookup[c.reply_id].children.append(node)
def traverse(root):
for node in root.children:
node.depth = root.depth + 1
flat_result.append(node)
traverse(node)
traverse(root)
return flat_result |
|
Nicht der Knaller an Effizienz, aber es funktioniert und ist schön schlank. O(N^2) wenn ich richtig rechne.
|
[Dieser Beitrag wurde 2 mal editiert; zum letzten Mal von Oli am 31.03.2013 23:03]
|
|
|
|
|
|
e/ Da du glaube ich mehr oder weniger das gleiche in Python implementiert hast ist der Post hier nur zur Freude und damit ich es nicht ganz ohne Grund wieder lösche .
Meine Lektion fürs nächste mal: Thread aktualisieren vorm implementieren.
----
Vielleicht verstehe ich falsch was du tun willst, aber du willst doch einen Baum bauen und den dann traversieren. Dazu erzeugst du eine Repräsentation (oder nimmst ne fertige) und machst dann ne Tiefensuche.
Ich habs hier mal mit Adjazenzlisten in Scala implementiert (e/ und mich bemüht es etwas lesbarer zu machen):
|
Code: |
object comments {
type key = Int
type entry = String
type tree = Map[key, List[key]]
type entries = Map[key, entry]
def build(comments: List[(key, entry, key)]): (tree, entries) = {
def insert(tree: tree, c: (key, entry, key)) = {
val (child, _, parent) = c
tree + (parent -> (child :: tree.getOrElse(parent, Nil)))
}
val tree = comments.foldLeft(Map[key, List[key]]())(insert)
val entries = (Map[key, entry]() /: comments) {
case (es, (key, entry, _)) => es + (key -> entry)
}
(tree, entries)
}
def dfs(tree: tree, entries: entries) {
def step(depth: Int, key: key) {
println("%s(%d, %s)" format ("-- " * depth, key, entries(key)))
tree.getOrElse(key, Nil).foreach(k => step(depth + 1, k))
}
tree.getOrElse(0, Nil).foreach(k => step(0, k))
}
val cs = List[(Int, String, Int)](
(1, "a", 0),
(2, "b", 1),
(3, "c", 1),
(4, "d", 2),
(5, "e", 0)
)
}
|
|
Erzeugt:
|
Code: |
/*
scala> val (t, e) = comments.build(comments.cs)
t: comments.tree = Map(0 -> List(5, 1), 1 -> List(3, 2), 2 -> List(4))
e: comments.entries = Map(5 -> e, 1 -> a, 2 -> b, 3 -> c, 4 -> d)
scala> comments.dfs(t, e)
(5, e)
(1, a)
-- (3, c)
-- (2, b)
-- -- (4, d)
*/
|
|
Build erzeugt aus deiner Liste mit zwei Iterationen die Baumstruktur (Map von key -> Liste von key) und die Metadaten (Map von key -> entry).
Dann macht es eine DFS.
Geht man mal von O(1) Maps aus, dann ist das alles in O(n) [Die DFS weil O(m) = O(n) hier].
|
[Dieser Beitrag wurde 5 mal editiert; zum letzten Mal von B0rG* am 31.03.2013 22:56]
|
|
|
|
|
|
Wenn ich bei dir auch nicht so ganz durchsteige, sieht nach dem gleichen Ansatz aus, den ich gewählt habe. Ich hab meine Lösung auch nochmal verschönert. Danke für den Aufwand!
Wieder ne Abhängigkeit gespart, mit ein paar Zeilen Code.
|
|
|
|
|
|
|
Ich muss doch mal mehr Python machen für solche Zwecke :/.
|
|
|
|
|
|
|
Schick oder? Und ein Trick ist besonders nett.
Ein Element ohne parent hat bei reply_id = None stehen. Um ifs zu sparen, hab ich dem root Element im Dictionary ({key: value}) also den Key "None" gegeben. So kann ich auch die parent-losen Elemente einfach in die children() vom root schreiben. Natürlich könnte man auch die .id und _id weg lassen und direkt Objekte in dem Baum speichern, aber ich bilder mir ein, dass das langsamer ist.
Eine andere Sache, die ich gerne nutze, ist:
|
Code: |
a = (object
.ich()
.bin()
.eine()
.method()
.chain()
) |
|
Ohne die äußeren () wirft das nen Fehler.
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Oli am 31.03.2013 23:14]
|
|
|
|
|
|
Alle Arbeit umsonst, ist in Django Admin schon vorhanden. -.- click Natürlich schön undokumentiert.
Devender als Aprilscherz?
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Oli am 01.04.2013 0:10]
|
|
|
|
|
|
Wieso schicken mir die Google Webmastertools ne E-Mail dass der Googlebot meine Seite nicht erreichen kann, mehrere Tage nachdem ich die Seite aus den Webmastertools entfernt hab? Ist das normal?
|
|
|
|
|
|
|
|
Code: |
class Spieler
{
string spielername;
byte spielernummer;
string spielerverein;
//Konstruktoren
public Spieler()
{
spielername = "Kein Name";
spielernummer = 0;
spielerverein = "Kein Verein";
}
public Spieler(string _sName, byte _sNummer, string _sVerein)
{
spielername = _sName;
spielernummer = _sNummer;
spielerverein = _sVerein;
}
//Methoden
public void ShowSpieler()
{
Console.WriteLine("Spielername: {0} || Spielernummer: {1} || Spielerverein: {2}", spielername, spielernummer, spielerverein);
}
//Properties
public string Name
{
get { return spielername; }
}
public string Verein
{
get { return spielerverein; }
}
public byte Nummer
{
get { return spielernummer; }
}
}
class ProfiSpieler : Spieler
{
double praemieProTor;
//Konstruktoren
public ProfiSpieler()
{
praemieProTor = 0.0;
}
public ProfiSpieler(double _praemieProTor):base(_sName,_sNummer,_sVerein)
{
praemieProTor = _praemieProTor;
}
} |
|
Momentan bin ich dabei C# zu lernen. Und versteh nicht warum mein Konstruktor mit Parameterliste der abgeleiteten Klasse (ProfiSpieler) nicht akzeptiert wird. Meine base Parameter sind "im aktuellen Kontext nicht verfügbar". Beide Klassen sind im selben Namespace deklariert.
Kann mir jemand sagen wo mein Fehler liegt?
|
|
|
|
|
|
|
Ich nehme an du möchtest, dass der ProfiSpieler-Konstruktor 4 Parameter nimmt?
public ProfiSpieler(string _sName, byte _sNummer, string _sVerein, double _praemieProTor):base(_sName,_sNummer,_sVerein)
Der :base(...) Part ist Syntax für den Aufruf des Konstruktors der Oberklasse, du kannst dir das vorstellen wie wenn das in der ersten Zeile des Bodys stehen würde. Du musst die Parameter also immernoch deklarieren.
e/ MSDN zu Konstruktoren.
|
[Dieser Beitrag wurde 2 mal editiert; zum letzten Mal von B0rG* am 02.04.2013 14:08]
|
|
|
|
|
|
| Zitat von B0rG*
Ich nehme an du möchtest, dass der ProfiSpieler-Konstruktor 4 Parameter nimmt?
public ProfiSpieler(string _sName, byte _sNummer, string _sVerein, double _praemieProTor):base(_sName,_sNummer,_sVerein)
Der :base(...) Part ist Syntax für den Aufruf des Konstruktors der Oberklasse, du kannst dir das vorstellen wie wenn das in der ersten Zeile des Bodys stehen würde. Du musst die Parameter also immernoch deklarieren.
e/ MSDN zu Konstruktoren.
| |
Ja richtig, er soll alle 4 Parameter nehmen.
Danke dir
|
|
|
|
|
|
|
Ich habe die Koordinaten der drei Vertices eines Dreiecks. Einer davon ist (0,0). Ich moechte jetzt zu einem Punkt P im Dreieck die baryzentrischen Koordinaten berechnen.
Geht das ohne mit den Teilflaechen zu arbeiten?
a*A+b*B+c*C=P
So funktioniert das ja normalerweise ohne Probleme wenn ich alle Koordinaten der Punkte habe. Da aber A = (0,0) ist, faellt mein a komplett raus.
|
|
|
|
|
|
|
Wo ist das Problem? Wenn das Dreieck nicht-entartet ist sind die durch die beiden anderen Ecken definierten Vektoren linear unabhängig, damit bekommst Du eine Linearkombination für P.
|
|
|
|
|
|
|
Weil ich mit den bary. Koordinaten gerne Farbwerte in den Ecken innerhalb des Dreieck interpolieren will. Und dann geht ja eine Ecke komplett flöten.
|
|
|
|
|
|
|
|
|
|
|
Bin doof. Hatte nen Rechenfehler drin.
Danke euch trotzdem!
|
|
|
|
|
|
|
Ne ganz banale Frage, die meines Wissens nach aber noch nie gestellt wurde:
Was ist eigentlich euer Lieblingsalgorithmus?
|
|
|
|
|
|
Ich mag einfache Sachen
|
Binäre Suche: Extrem einfach und sehr vielseitig und effizient
Timsort: Etwas komplex imho für einen Sortieralgo, dafür effizient und stabil
|
|
|
|
|
|
|
|
Code: |
INPUT: H = (h_1, \dots, h_s)
OUTPUT: Gröbnerbasis G = (g_1, \dots, g_t)
INIT: G := H
1. DO
2. G' := G
3. FOREACH p, q \in G', p \neq q
4. s = Rest(S(p, q), G)
5. IF s \neq 0 THEN G := G \cup \{s\}
6. NEXT
7. UNTIL G = G' |
|
http://de.wikipedia.org/wiki/Buchberger-Algorithmus
|
|
|
|
|
|
|
Mergesort - weil einfach, stabil, elegant und
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von AcidF!re am 03.04.2013 2:35]
|
|
|
|
|
|
| Zitat von Rufus
Ne ganz banale Frage, die meines Wissens nach aber noch nie gestellt wurde:
Was ist eigentlich euer Lieblingsalgorithmus?
| |
Die Identitätsabbildung.
Seit wann denkst du über Lieblingsalgorithmen nach? Entweder hattest du zu viel oder zu wenig Bier.
|
|
|
|
|
|
|
"wie berechne ich denn den kreisring eines kreisausschnittes, der weniger als die hälfte des kreises beträgt?"
Kennt da jemand ne Formel?
|
|
|
|
|
|
|
Ich wusste ja nichtmal was ein Kreisring ist ...
https://de.wikipedia.org/wiki/Kreisring
/und dann für die Fläche des Kreisrings eines Kreisausschnittes:
A = A_gesamt * Winkel/360
//ich zweifel gerade daran ob das so doof und einfach ist, irgendwie ... warum sollte es relevant sein ob das mehr oder weniger als die Hälfte des Kreises ist? Wenn ich mir den Kreisring anschaue, dann ist die Fläche einfach der Bruchteil den auch der Kreis im Vergleich zum Vollkreis hat.
|
[Dieser Beitrag wurde 2 mal editiert; zum letzten Mal von pinnback am 03.04.2013 12:17]
|
|
|
|
|
|
Vielleicht weil vorausgesetzt wird, dass der Leser Winkel über 180 nicht versteht und dann ganze Fläche - inverses segment rechnen soll.
Natürlich geht das aber schon so wie du das gesagt hast.
|
|
|
|
|
|
|
| Zitat von Oli
| Zitat von Rufus
Ne ganz banale Frage, die meines Wissens nach aber noch nie gestellt wurde:
Was ist eigentlich euer Lieblingsalgorithmus?
| |
Die Identitätsabbildung.
| |
Das ist ein Algorithmus?
|
|
|
|
|
|
|
| Zitat von csde_rats
Das ist ein Algorithmus?
| |
Wenn man "Algorithmus" als "turingberechenbare Funktion" auffasst, dann ist die Identität ein Algorithmus. Im Lambdakalkül z.b. darstellbar als .
Zum Thema: Ist jetzt net wirklich ein Algorithmus, aber dafür eine Datenstruktur, bei der ich mir wirklich dachte "hey, da muss man drauf kommen": Fibonacci-Heaps, die sich eigentlich nur um kleine Details von Binomial-Heaps unterscheiden und aber doch deutlich cooler sind.
|
|
|
|
|
|
Thema: pOT-lnformatiker, Mathematiker, Physiker XII ( Jetzt mit Primzahlen > 1024 ) |