(ad acta) Datenbankdarstellung für Mischkultur (Kleingarten)

[uname]

Bei Gemüseanbau würde ich Schädlingsvermeidung als gute Voraussetzung für Ernteerfolg wichtig nehmen, Erhalt der Bodenqualität, Verzicht auf zusätzliche Arbeit und/oder Chemie auch.

Dazu gibt es ein schönes Video von mathspacewien. Dort wird z. B. erklärt nach welchen Formeln sich die Populationen von Hasen und Füchsen entwickeln. Ist bzgl. Schädlingen und nützlichen Tieren / Chemie wohl ähnlich. Die Natur versucht sich im Gleichgewicht zu halten und alles folgt mathematischen Formeln. Sehr interessant.

[michaa7]

(1) Zeige welche Pflanzen gut (+) oder schlecht (-) mit einer gegeben Pflanze harmonieren.
(2) Zeige welcher der mit der gegebenen Pflanze gut harmonierenden Pflanzen untereinander schlecht harmonieren.

Beispiel1
A,B,+ (harmonieren)
B,C,+ (harmonieren)
(keine Aussage zu A,C,)

Lösung: A,B,C bilden eine gute, brauchbare, konflikfreie Mischkultur.

Meiner Meinung nach stellt das Beispiel einen Widerspruch zur den Fragen (1) und (2) dar.

Nein, ist es nicht.

Und lass es dir einfach gesagt sein: Wenn du meine Info so missverstehst wie du sie zu verstehen glaubst dann bitte nimm deinen Förmchen und such dir nen anderen Sandkasten.

Und wenn du jetzt beleidigt bist dann ist mir das nicht Wurscht, aber ich nehme es in Kauf.

Käsekunden vs. Schweinebraten:
Daher mag ich das Debianforum so. Ich finde es gut, wenn auch mal ganz andere Ansätze verfolgt werden.

Jaja, du weißt was, also willst du es beitragen auch wenn's zur Sache nichts beiträgt.

[Huo]

Spezifikation:
Es gibt positive und negative paarbeziehungen.
An die Liste diese Beziehungen sollen zwei gestaffelte Abfragen durchgeführt werden können:
(1) Zeige welche Pflanzen gut (+) oder schlecht (-) mit einer gegeben Pflanze harmonieren.
(2) Zeige welche der mit der gegebenen Pflanze gut harmonierenden Pflanzen untereinander schlecht harmonieren.
(Zusatzoption zu (2): Möglichkeit eine oder mehrere Pflanzen aus der zweiten Abfrage auszuschließen.)
[...]
Für alle anderen Pflanzen gilt: ungenannt/egal/neutral/nicht-mischkultur-relevant/fallen-hinten-runter.

zu (1): Okay, damit werden zur gegebenen Ausgangspflanze die Pflanzenpaarungen ohne Aussage ("neutral", "ungenannt") ausgeschlossen. Das war jedenfalls mir bisher nicht klar.

zu (2): Ist auch klar.

Nach Entfernen der in (2) ermittelten schlecht miteinander harmonierenden Pflanzen aus (1(+)) erhält man dann so was die größtmögliche Mischkultur zur gegebenen Ausgangspflanze [*]. Bei dieser Ausfilterung fallen allerdings – anders als in (1) – die "neutralen" Pflanzenpaarungen gerade NICHT hinten runter. Darin liegt eine gewisse Inkonsistenz, wenn auch kein logischer Widerspruch: Die Ausgangspflanze darf in keiner neutralen Beziehung zu anderen Pflanzen der Mischkultur stehen, diese untereinander jedoch schon.

EDIT: Ups, so einfach ist das mit dem Entfernen nicht. Schon bei einem Beispiel mit sechs Pflanzen beginnt es unübersichtlich zu werden:

(1) Welche Pflanzen harmonieren mit A?
A,B +
A,C +
A,D +
A,E +
A,F +

(2) Welche mit A harmonierenden Pflanzen vertragen sich untereinander schlecht?
B,C -
B,E -
C,D -
C,F -
E,F -

Wer sieht ohne weiteres, dass [A, B, D, F] und [A, C, E] die konfliktfreien Mischkulturen sind? Diese Tüftelei sollte einem das Skript doch auch abnehmen, oder?

[dasebastian]

Dafür hatte ich im ersten JSON-Beispiel den "hunger" vorgesehen.

Eine Frage, der Schwachzehrer hat nicht nur wenig Bedarf, sondern könnte schonmal auf einen nährstoffarmen Boden angewiesen sein? Bei Kartoffel und Bohne geht es, weil wenig Konkurrenz da ist und die Bohne den Boden verträgt?

Kartoffel ist nicht auf nährstoffarmen Boden angewiesen, gedeiht aber auch darauf und reagiert auf frischen Kompost schlecht (Schorf). Die Bohne verträgt schlechten Boden nicht nur, sondern kann ihn aufwerten (Leguminose, Anreicherung Stickstoff).

... aber so eindeutig scheint mir das nicht, "Gute Nachbarschaft" könnten ja in Richtung Symbiose gehen.
Und dann gibt es noch nützliche Pflanzen welche Schädlinge abhalten etc., die würde ich vielleicht (dann anders als im Besipiel unten ohne Doppelnennung) extra berücksichtigen?

Du bist ziemlich gut im Verständnis, finde ich super!

[michaa7]

war Quark

[michaa7]

zu (1): Okay, damit werden zur gegebenen Ausgangspflanze die Pflanzenpaarungen ohne Aussage ("neutral", "ungenannt") ausgeschlossen. Das war jedenfalls mir bisher nicht klar.

Gut! Das ist nun klar.

...
Nach Entfernen der in (2) ermittelten schlecht miteinander harmonierenden Pflanzen aus (1(+)) erhält man dann so was die größtmögliche Mischkultur zur gegebenen Ausgangspflanze [*]. Bei dieser Ausfilterung fallen allerdings – anders als in (1) – die "neutralen" Pflanzenpaarungen gerade NICHT hinten runter.

Das ist richtig.

Darin liegt eine gewisse Inkonsistenz, wenn auch kein logischer Widerspruch:

Richtig. Und diesen Unterschied zwischen (1) und (2) hätte ich erkennen und klar machen müssen.

Die Ausgangspflanze darf in keiner neutralen Beziehung zu anderen Pflanzen der Mischkultur stehen, diese untereinander jedoch schon.

In der hier formulierten Strenge ist das datenverarbeitungstechnisch richtig weil es für das Gesamtergebnis mit Hinblick auf die Ausgangspflanze so sinnvoll und notwendig ist. In der Praxis ist Neutralität (keine Vor- oder Nachteile) gegenüber der Ausgangspflanze einfach nebensächlich oder unwichtig (kein Verbot) und daher nicht Teil der Fragestellung in (1). Aber Neutralität zwischen zwei Pflanzen in (2) steht eben ihren positiven Wirkungen gegenüber der Ausgangspflanze nicht im Weg. Und das ist worauf die beiden Fragen insgesamt abzielen.

EDIT: Ups, so einfach ist das mit dem Entfernen nicht. Schon bei einem Beispiel mit sechs Pflanzen beginnt es unübersichtlich zu werden:

(1) Welche Pflanzen harmonieren mit A?
A,B +
A,C +
A,D +
A,E +
A,F +

(2) Welche mit A harmonierenden Pflanzen vertragen sich untereinander schlecht?
B,C -
B,E -
C,D -
C,F -
E,F -

Wer sieht ohne weiteres, dass [A, B, D, F] und [A, C, E] die konfliktfreien Mischkulturen sind? Diese Tüftelei sollte einem das Skript doch auch abnehmen, oder?

Richtig. Daher sollte man als (2b) einzelne oder mehrere Pflanzen ausschließen können.

Diese Beispiel ist in soweit (für mich) ein bisschen irreführend weil nicht klar ist wie der Ablauf funktioniert. (1) ist einfach, aber wie du von (1) nach (2) kommst verstehe ich nicht, es sei denn dass du das einfach niedergeschrieben hast ohne dich zunächst um die Funktion von (1) nach (2) zu kümmern.

Die scripttechnische Abfolge sähe vielleicht aus:

Datenbank: beziehung.txt
--------
A,B +
A,C +
A,D +
A,E +
A,F +
B,C -
B,E -
C,D -
C,F -
E,F -
und
viele
weitere
Einträge.
---------

Der Nutzer will eine Mischkultur mit/um "A" anlegen.

Code: Alles auswählen

script +A beziehung.txt; 

Teilergebnis(1):

Code: Alles auswählen

 "A":[B,C,D,E,F] ?;

Nur auf Basis dieses Zwischenergebnises weiß das Script wonach es mit (2) suchen soll. Das Script müsste nun also alle möglichen Paare aus B,C,D,E,F, bilden und in der Datenbank nachsehen welche Paare mit einem "-" assoziiert sind. Wird ein solches Paar gefunden werden (zunächst) beide Elemente aus der Ergebnisliste(1) gelöscht.
In deinem (extremen, das ist ok) Beispiel bliebe (zunächst) nichts übrig. Es gäbe ein Ergebnis das so aussähe: Ergebnis(2):

Code: Alles auswählen

 "A": [ ] [B,C -,B,E -,C,D -,C,F -,E,F -] ;

Nun kann sich der User Überlegen welche Pflanze er rausschmeißt (wobei das Teilergebnis(1) natürlich gleich bleibt): Deinem Beispiel entnehme ich dass es nicht reicht eine Pflanze rauszuschmeißen, weil das Endergebnis auf Grund zu vieler "-" in jedem Fall nahezu das gleiche wäre:

Code: Alles auswählen

script +A beziehung.txt -B ;

Ergebnis(2b):

Code: Alles auswählen

 "A": [ ] [C,D -,C,F -,E,F -] ;

Also zwei Pflanzen raus:

Code: Alles auswählen

script +A beziehung.txt -B -C;

Führt laut deinem Beispiel zu einem sehr dünnen Ergebnis:
Ergebnis(2c):

Code: Alles auswählen

"A": [D] [E,F -] ;

Also nächster Versuch:

Code: Alles auswählen

script +A beziehung.txt -C -E;

Ergebnis(2c):

Code: Alles auswählen

"A": [A, B, D, F]  [ ];

Schaut ganz gut aus.

und man könnte noch weiter probieren und würde dann deine zweite Lösung finden ...

Es wäre also nicht notwendig sofort zu einem gültigen Endergebnis, oder gar zu allen möglichen Endergebnissen zu kommen, aber es wäre hilfreich und schön die Konflikte zu sehen weil der Nutzer auf dieser Basis den nächsten Durchlauf anpassen kann.
Wenn es aber scripttechisch einfache ist die unbrauchbaren Ergebnisse zu eliminieren und nur gültigen Endergebnisse anzuzeigen spräche wenig dagegen.
Hm, wenn das script die sinnvollen Lösungen anzeigen würde wäre das nicht schlecht. Sonst muß man mit dem Script genausoviel basteln wie mit einer Tabelle

Das wäre in etwa der gewünschte Ablauf in der Nutzung des Scripts.

Und das ist die Aufgabe vor der man steht wenn man eine Tabelle zu Hilfe nimmt . Genau das will ich bequemer. Danke für dein Beispiel.

[Huo]

Über die "Spezifikation" sind wir uns, glaube ich, jetzt einig.

Inzwischen habe ich mir allerdings einige Mischkulturtabellen im Netz angeschaut und empfinde sie – wie viele andere hier – als völlig ausreichend und praktikabel für den gärtnerischen Einsatz. Grund: Mit verschwindend geringen Ausnahmen gilt für die Verträglichkeitsbeziehungen zwischen Pflanzen stets eine Transitivitätseigenschaft: Enthält eine Tabelle etwa die Beziehungen A,B,+ und A,C,+, dann trifft so gut wie immer auch B,C,+ zu oder aber B,C ist neutral/undefiniert. Anders ausgedrückt: Praktisch jede Pflanze kann mit Fug und Recht behaupten: "Meine Freunde sind untereinander nicht verfeindet". Das bedeutet, dass es (mit verschwindend geringen Ausnahmen) vollauf genügt, die Zeile und/oder Spalte der Ausgangspflanze zu betrachten.

Als programmiertechnische Herausforderung bleibt das Problem trotzdem interessant. Allerdings irritiert es mich, wenn Mitdiskutanten unsanft aus dem "Sandkasten" geschubst werden, weshalb ich momentan nicht in der Stimmung bin, mir weitere Gedanken dazu zu machen.

[michaa7]

..."Meine Freunde sind untereinander nicht verfeindet". Das bedeutet, dass es (mit verschwindend geringen Ausnahmen) vollauf genügt, die Zeile und/oder Spalte der Ausgangspflanze zu betrachten.

Als programmiertechnische Herausforderung bleibt das Problem trotzdem interessant.

Ja, für mich war das von Anfang an eine Spielerei, die ich hoffte schnell mit ein paar Hinweisen mit LO-Calc lösen zu können. Ist wohl doch etwas aufwendiger ...

Allerdings irritiert es mich, wenn Mitdiskutanten unsanft aus dem "Sandkasten" geschubst werden, weshalb ich momentan nicht in der Stimmung bin, mir weitere Gedanken dazu zu machen.

Naja gut, das magst du so sehen.
Mir geht dieses "ich weiß was, ich weiß was" Geplapper, welches sich einen qQSD um Relevanz kümmert einfach nur auf den Senkel (vuglo: S***). Und ich halte es auch für eine gedankliche Fehlkonstruktion jedem Teilnehmer eine weitreichende Ausweitung der Anfangsproblematik zuzugestehen, dem Themenstarter abzuverlangen dass dieser dies zugestehen muss, und gleichzeitig bzw genau dadurch dem Themenstarter zu untersagen (es ihm krumm zu nehmen) wenn er auf Eingrenzung seines Themas drängt, insbesondere wenn dies in einem fortgeschrittenen Stadium des Threads geschieht.

Es war angenehm sich mit dir über die Grundfrage auszutauschen und war, auch wenn es zu keinem Ergebnis führt, interessant die Logik des Problems und eines möglichen Lösungswegs gemeinsam aufzudröseln.

Ich würde es begrüßen, wenn die Forensoftware es dem Themenstarter erlauben würde einzelne Beiträge/Teilnehmer innerhalb des "eigenen" Threads für alle sichtbar auszublenden/nicht automatisch aufzuklappen (und eben nicht nur einzelne Teilnehmer global und nur für einen selbst). Das mag im ersten Augenblick verletzend wirken, wäre aber, wenn man es mal mit gebremstem Schaum betrachtet, einfach ein *wirksames* Feed-back des Fragestellers zu *seinem* Anliegen.

Vielleicht genügte es auch, wenn das Moderatorenteam diese Frage mal kurz untereinander bespricht und sich die Frage beantwortet ob man es einem Fragestellenden nicht zugestehen sollte/müsste (und dies hätte dann Konsequenzen wen ein Moderator wie und warum ermahnt) den eigenen Thread verbal zu steuern, ob man einem Themanstarter nicht wirklich ein "s" bei "seinem Anliegen" zugestehen muss.

@ Meilo:
Ich wollte dich nicht abwatschen. Und es wäre schön wenn meine diesbezügliche Erwiderung im Thread bei dir etwas positiv angekommen wäre ...

Thema/Faden "ad acta" gelegt.

[curt123]

Mir geht dieses "ich weiß was, ich weiß was" Geplapper, welches sich einen qQSD um Relevanz kümmert einfach nur auf den Senkel (vuglo: S***). Und ich halte es auch für eine gedankliche Fehlkonstruktion jedem Teilnehmer eine weitreichende Ausweitung der Anfangsproblematik zuzugestehen, dem Themenstart abzuverlangen dass dieser dies zugestehen muss, und gleichzeitig bzw genau dadurch dem Themenstarter zu untersagen (es ihm krumm zu nehmen) wenn er auf Eingrenzung seines Themas drängt, insbesondere wenn dies in einem fortgeschrittenen Stadium des Threads geschieht.
//
Ich würde es begrüßen, wenn die Forensoftware es dem Themenstarter erlauben würde einzelne Beiträge/Teilnehmer innerhalb des "eigenen" Threads sichtbar auszublenden (und eben nicht nur einzelne Teilnehmer global). Das mag im ersten Augenblick verletzend wirken, wäre aber, wenn man es mal mit gebremstem Schaum betrachtet, einfach ein *wirksames* Feed-back des Fragestellers.

Ich sehe, so wie ich das Thema präsent habe, hier keinen nennenswerten Drift.
Danke bei der Gelegenheit an @uname für den Link und @dasebastian fürs Lob! Wenn sich da oder woanders ein neues Thema weiter entwickelt hätte, hätte man den Thread notfalls noch teilen können - aber so scheint da kein Bedarf. Und wenn man dann noch bedenkt, dass das Thema hier als "Smalltalk" und nicht unter "Softwareentwicklung ... Scripting" läuft.

Aber selbst unter "Scripting", woanders natürlich auch, finde ich einen entsprechende Toleranz für alle Beteligten vorteilhaft.
Wenn jemand seinen PC nicht starten kann und dringend Hilfe benötigt, ist eine schnelle Lösung nötig. Ansonsten aber, in weniger akuten Situationen, gibt es ja noch Dinge wie Hermeneutik. Ausserdem entstehen bei "Redundanz" weitere Sichtweisen und Blickwinkel, was selbst bei eindeutigerer Ausgangs-Situation usw. und ohne große Erkenntnissprünge immer noch auch eher vorteilhaft sein dürfte.

auch wenn es zu keinem Ergebnis führt, interessant die Logik des Problems und eines möglichen Lösungswegs gemeinsam aufzudröseln.

Also wegen der fehlenden Notwendigkeit einer solchen Lösung, etwa wegen zu seltener Wechselunverträglichkeiten der jeweiligen Pflanzengruppen?

Ansonsten: Ich würde die Daten nach wie vor nicht so weit atomisieren, wenn das später doch nicht als relationale db mit SQL o.ä. abgefragt werden kann. Aber da unterschätze ich vielleicht die Möglichkeiten oder die Fähigkeiten mir unbekannter Phyton-Module für eine schnelle Lösung mit der 2er-Liste.

Ich würde es begrüßen, wenn die Forensoftware es dem Themenstarter erlauben würde einzelne Beiträge/Teilnehmer innerhalb des "eigenen" Threads sichtbar auszublenden (und eben nicht nur einzelne Teilnehmer global). Das mag im ersten Augenblick verletzend wirken, wäre aber, wenn man es mal mit gebremstem Schaum betrachtet, einfach ein *wirksames* Feed-back des Fragestellers.

Klar. Und dann noch betreutes Denken, dann klappt das schon. Es finden sich (hier im Forum) mitunter m.E. weniger wichtige Beiträge wie "nach 1000 Beiträgen fragst du noch so etwas?", ok. Je nach Kontext mag das dann unterschiedlich gut ankommen. Die meisten Beiträge sind nicht der jeweiligen Eitelkeit geschuldet, sondern fundiert und zielorientiert (und auch keine Lohnarbeit). Und wo die Kommunikation nicht klappt, kann man ja versuchen etwas zu ändern, nachfragen, ergänzen usw..

[michaa7]

... du redest dir das einfach nach deinen Wünschen schön.

[dasebastian]

Oder du dir schlecht.

In diesem Thread hat tatsächlich jeder (sogar ich, der dir auf die Nerven gegangen ist) versucht, etwas konstruktiv beizutragen.

Nur weil man die Komplexizität eines Problems nicht sehen will, heisst es nicht, dass die Lösung einfach ist.

[Huo]

Nun habe ich zu meiner eigenen Erquickung doch ein einfaches Python-Skript geschrieben. Als Einkleidung habe ich statt der Planung von Mischkulturen die Erstellung von Gästelisten gewählt: Jemand möchte Freunde und Freundinnen zu einer Party einladen, auf der alle Gäste untereinander harmonieren. Prinzipiell kann das Skript natürlich auch für die Kombination von Pflanzen verwendet werden .

Damit myparty.py 41869 richtig funktioniert, müssen zwei Voraussetzungen erfüllt sein:

(1) Die Python-Bibliothek networkx muss installiert sein (Debian-Paket python3-networkx; alternativ per pip).

(2) Alle Freundes- und Feindespaare müssen in zwei getrennten Textdateien friends.csv und enemies.csv hinterlegt sein. In beide Dateien wird pro Zeile jeweils ein Namenspaar in der Form Anna,Ben eingetragen. Zwischen zwei Personen braucht nicht zwingend eine Freundschaft oder Feindschaft zu bestehen; "neutrale" Beziehungen sind erlaubt und werden nicht in die beiden Dateien aufgenommen.

Aufgerufen wird das Skript mit dem Namen der Gastgeberin oder des Gastgebers als Parameter. Beispiel:

Code: Alles auswählen

$ myparty.py Anna
Freunde von Anna:
Ben, Doris, Finn, Katrin, Paul, Sophie

Darunter harmonieren nicht:
['Ben', 'Katrin']
['Ben', 'Paul']
['Doris', 'Katrin']
['Finn', 'Katrin']
['Finn', 'Paul']
['Katrin', 'Sophie']

Mögliche Gästelisten:
['Katrin', 'Paul']
['Doris', 'Paul', 'Sophie']
['Ben', 'Doris', 'Finn', 'Sophie']

[chrbr]

Nun habe ich zu meiner eigenen Erquickung doch ein einfaches Python-Skript geschrieben.

So etwas ist das Beste was man überhaupt machen kann. Man beschäftigt sich mit einem interessanten Problem ohne Zeitdruck und lernt dabei hinzu. Von mir ausgegangen habe ich praktisch alles wieder mal gebraucht. Gerade im Beruf ist es sehr vorteilhaft bei neuen Projekten schnell eine Vorgehensweise aufzeigen zu können und bei Aufwandsabschätzungen nicht komplett verkehrt zu liegen. Und Spaß macht es als Hobby ja auch .

[NatureFriend]

Auf der Suche nach dem selbem Problem in der Mischkultur von Nutzpflanzen bin ich hier her gestoßen. Meine Idee ist es, wie ich es schon in einigen Beiträgen zuvor gelesen habe, eine Graph-Datenbank zu verwenden. Diese ist wie eine Mindmap zu verstehen. Jeder Knoten (Blase) ist eine Pflanze und jede Kante (Strich) gibt die Beziehung an. Ich habe leider noch nicht viel Erfahrung damit. Theoretisch könnte man damit die Beziehungen guter Nachbar und schlechter Nachbar abbilden. Dadurch sollte es möglich sein, schnell Ergebnisse auszuspucken, die folgende Probleme lösen:

Eine Tomate hat gute Nachbarn wie Buschbohne, Knoblauch, Kohl, ...
Der Kohl verträgt sich jedoch nicht mit Knoblauch, genauso wie die Bohnen.
Der Kohl verträgt sich jedoch gut mit Kartoffel.
Die Kartoffel verträgt sich aber wieder nicht gut mit der Tomate.
(Ich weiß nicht, ob diese Beispiele richtig sind )

Wenn man nun ein Beet aus mehreren Pflanzen zusammenstellen möchte, die sich alle möglichst gut vertragen, dann kommt man schnell an dieses Dilemma.

[Huo]

Meine Idee ist es, wie ich es schon in einigen Beiträgen zuvor gelesen habe, eine Graph-Datenbank zu verwenden. Diese ist wie eine Mindmap zu verstehen. Jeder Knoten (Blase) ist eine Pflanze und jede Kante (Strich) gibt die Beziehung an. [...] Theoretisch könnte man damit die Beziehungen guter Nachbar und schlechter Nachbar abbilden. Dadurch sollte es möglich sein, schnell Ergebnisse auszuspucken, die folgende Probleme lösen:

Mit Graphen beschäftigt sich ein eigenes Teilgebiet der Mathematik, die Graphentheorie. Mein Skript 41869 nutzt tatsächlich einen graphentheoretischen Ansatz in drei Schritten:
(1) Zuerst wird ein maximaler Graph generiert, der alle Freunde [guten Pflanzennachbarn] des Gastgebers [der Ausgangspflanze] als Knoten enthält, sowie sämtliche nur möglichen Kanten zwischen diesen Knoten.
(2) Im zweiten Schritt werden aus diesem Graphen genau die Kanten entfernt, die "verfeindete" Personen [schlechte Pflanzennachbarn] miteinander verbinden.
(3) Zuletzt werden die sogenannten Cliquen ermittelt: Das sind die Teilmengen des Graphen, in denen jeder Knoten [jede Pflanze] mit allen anderen verbunden ist. Diese Teilgraphen sind die gesuchten Gästelisten [Mischkulturen].

Auch wenn ich mit dem Party-Narrativ eine andere Einkleidung gewählt habe, genügt das Skript IMHO den Anforderungen des TO – außer dass es keine Funktion bietet, nachträglich einzelne Pflanzen aus dem Ergebnis auszuschließen. Eine solche Option ist m.E. aber unnötig, da die Entfernung von Pflanzen keine völlig neuen Kombinationen nach sich zöge, sondern nur die bereits gefundenen Mischkulturen um genau diese Pflanzen vermindern würde.

[GregorS]

... du redest dir das einfach nach deinen Wünschen schön.

Und Dir hat anscheinend noch nie jemand gesagt, dass Du ganz schön unfreundlich und egozentrisch rüberkommst.

Viel Spaß noch!

Gregor

[michaa7]

Es mag unfreundlich rüberkommen, aber Geplapper geht mir nun mal auf den Senkel. Und wenn du meine Charakterisierung als "Schönreden" für unfreundlich hältst was bleibt mir anderes übrig als zu sagen "so-be-it"?

[Huo]

@michaa7
Mein Python-Skript habe ich jetzt noch einmal der gärtnerischen Aufgabenstellung angepasst 41870. Galt die Party-Version vorrangig meiner eigenen Unterhaltung, verstehe ich diese Fassung als ernst gemeinten Lösungsversuch zu deinem eigentlichen Anliegen. Für Testzwecke füge ich sogar zwei Dateien friends.csv 41871 (= verträgliche Pflanzenpaare) und enemies.csv 41872 (= unverträgliche Pflanzenpaare; alles meiner Fantasie entsprungen ) bei. Nähere Infos über die Voraussetzungen der Anwendung findest du im Kommentarkopf des Skripts.

Deinen Unmut über den Verlauf unserer Diskussion kann ich wenigstens ansatzweise nachvollziehen. Jetzt wäre es aber vielleicht an der Zeit, dass du mein Skript einfach mal testest. Sollte es deinen Vorstellungen nicht entsprechen, käme ich mit deiner ehrlichen Rückmeldung gut klar. Für mich als Nichtgärtner war das Mischkulturenproblem in erster Linie eine reizvolle Knobelaufgabe und eine Anregung, länger nicht genutzte Python-Kenntnisse aufzufrischen. Dafür vielen Dank!

[curt123]

Mein Python-Skript habe ich jetzt noch einmal der gärtnerischen Aufgabenstellung angepasst 41870.

Hab den Code jetzt (zumal ohne größere Python-Erfahrung) nicht sehr ausführlich angeschaut - schaut für mich gut aus und für die Ausgangsfrage scheint es sehr gut zu passen.

Nach den import Anweisungen habe ich für meine Umgebung, um (z.B. in Spyder) erstmal ohne Parameter aufrufen zu können, ab Zeile 23 ergänzt:

Code: Alles auswählen

# test anfang hauptpflanze bzw parameter hier festlegen
sys.argv.extend(["Ananas"])

# test ende

Am Ende (ursprüngliche Zeile 77) ist per (reverse=True) auch einfach die umgekehrte Reihenfolge möglich, um die größte Gruppe zuerst zu erhalten:

Code: Alles auswählen

print(*sorted(mix_s, key=len, reverse=True), sep='\n')

[Huo]

Hab den Code jetzt (zumal ohne größere Python-Erfahrung) nicht sehr ausführlich angeschaut - schaut für mich gut aus und für die Ausgangsfrage scheint es sehr gut zu passen.

Danke fürs Drüberschaun! Um die Erwartungen nicht zu hoch zu schrauben, sollte ich noch erwähnen, dass ich keinen professionellen IT-Hintergrund habe, sondern als Hobby-Coder Autodidakt bin. Es ist also davon auszugehen, dass mein Skript in mancherlei Hinsicht verbesserungswürdig ist.

[michaa7]

@michaa7
... Sollte es deinen Vorstellungen nicht entsprechen, käme ich mit deiner ehrlichen Rückmeldung gut klar. Für mich als Nichtgärtner war das Mischkulturenproblem in erster Linie eine reizvolle Knobelaufgabe und eine Anregung, länger nicht genutzte Python-Kenntnisse aufzufrischen. Dafür vielen Dank!

Werde es die heute Abend anschauen. Genau, es ging um eine Art Knobelaufgabe. Die ich Anfangs eben selbst mit LO lösen wollte (und obwohl die praktische Anwendung der Anlaß war und der Herstellungsaufwand für eine entsprechende Anwendung deren Ergebnis vllt nur mangelhaft rechfertigt bestand/besteht der Reiz doch auch darin die Logik der Aufgabe auf den Punkt zu bringen). Es war mir eine Freude mich mit dir darüber auszutauschen. Ich habe immer noch ein bisschen im Hinterkopf ob man/ich das nicht irgendwie mit Wenn-Dann Formeln in LO hinbekommt. Das wäre reiner Spaß an der Knobelei! Jedenfalls sind die Einzelaufgaben nun formuliert.
friend und enemy paßt irgendwie sehr gut ... in viellerlei Hinsicht
Danke!

[curt123]

Es ist also davon auszugehen, dass mein Skript in mancherlei Hinsicht verbesserungswürdig ist.

Mag sein - ich hab da vielleicht nicht genug Routine um das verlässlich abzuschätzen. Einige Bezeichner sind vielleicht etwas kurz usw., ich hab da aber keinen Überblick was gerade und bei Python oder überhaupt Konvention oder guter Stil ist. haupt_pflanze, hauptPflanze? Heute mag ich eher "langweiligen" gut lesbaren Code als vor einigen Jahren, nicht zu lange Zeilen, genug Kommentare, bei komplexeren Geschichten mehr in Funktionen und/oder Bereiche auslagern.

Konkret würde ich die Parameterkontrolle vielleicht früher und getrennt vornehmen, wichtige Variablen evtl. am Anfang früher definieren (falls nötig noch kommentieren), auf die Schnelle:

Code: Alles auswählen

import sys
import networkx as nx

hauptpflanze = ""
friends = []
enemies = []

# hauptpflanze bzw parameter hier pruefen oder festlegen ggf abfragen
if len(sys.argv) == 2:
    hauptpflanze = sys.argv[1]
    
if hauptpflanze == "":
    while True:
        hauptpflanze = input("Name eingeben: ")
        if(hauptpflanze == "quit"):
            print("Abbruch durch Anwender")
            sys.exit(1)
        else:
            print("Eingabe beendet mit: ", hauptpflanze, "\n")
            break

# ...
 
# Check hauptpflanze
if not [i for i in friends if hauptpflanze in i]:

Eine Eingabemöglichkeit sollte aber vmtl. sowieso vorher ausserhalb der Datei erfolgen.

[dasebastian]

https://fryd.app/

[chrbr]

Zuerst hoffe ich mit diesem doch etwas überlangen Beitrag in dem viel diskutierten Thread keinen Unmut zu erregen. Falls es Michaa7 oder Huo lieber ist könnte man den Beitrag in einen neuen Thread auslagern oder komplett löschen. Ich möchte hier meine Erkenntnisse zusammenfassen. Dabei geht es nicht um die vielen Nebenkriegsschauplätze.

In diesem lang diskutierten Thread ging es um die Verträglichkeit verschiedener Pflanzen miteinander. Dabei haben die Pflanzen die Eigenschaft, dass sie mit einigen potentiellen Nachbarpflanzen gut auskommen und mit anderen überhaupt nicht. Die Frage des Autors bestand darin, ob und wie man einen Algorithmus erstellen oder nutzen könnte, aus einer Liste von Pflanzen und deren Verträglichkeit verschiedene Gruppen zusammen zu stellen, die untereinander keine Unverträglichkeiten zeigen.

Der User Huo erstellte im Laufe der Diskussionen ein Python Programm, das eine Liste von Pflanzen und eine Tabelle von Verträglichkeiten aufbereitete, mit dem Python Paket networkx verarbeitete und schliesslich eine Anzahl von Gruppen möglicher Pflanzen ohne Unverträglichkeiten ausgab.

Die Liste von Pflanzen bestand aus 11 Arten von Ananas bis Papaya. Die Verträglichkeiten wurden in zwei csv Dateien beschrieben, und zwar enemies.csv und friends.csv. In den zwei Dateien wurde die Beziehung zweier Pflanzen beschrieben. Ein Eintrag in friends.csv bedeutete, dass sich die Pflanzen gut vertragen. Entsprechend bedeutete ein Eintrag in enemies.csv, dass die zwei Pflanzen sich nicht vertragen. Jede beliebige Kombination der Pflanzen aus der Liste der 11 Arten findet sich entweder in friends.csv oder enemies.csv wieder. Damit sind die Verträglichkeiten aller Kombinationen eindeutig definiert. Das Python Programm von Huo überprüft die Dateien auf Plausibilität und bricht die Verarbeitung ab, wenn in den Dateien etwas nicht konsistent ist.

Das Programm kann nun mit einem Parameter aufgerufen werden. Dieser Parameter ist die Hauptpflanze, die per Definition in jeder Gruppe von untereinander verträglichen Pflanzen Mitglied ist. Folgerichtig ist die Untermenge der Pflanzen, die überhaupt in Frage kommen in guter Verträglichkeit mit der Hauptfrucht. So reduzierte Huo die Anzahl der möglichen Kombinationen erheblich. Im Beispiel einer Hauptfrucht Ananas bleiben von den 11 Arten nur die 6 der mit der Ananas verträglichen Pflanzen übrig. Bei der Hauptfrucht Litschi bleiben nur 3 mit der Litschi verträglichen Pflanzen übrig.

Im Programm von Huo kommt nun das Python Paket networkx ins Spiel, in dem Algorithmen basierend auf der Graphentheorie implementiert sind. Zuerst wird eine Klasse Graph erzeugt. Eingangsdaten sind im Falle der Ananas eine Liste der verträglichen Nachbarn der Ananas. Hier sind es also 6 Elemente. In dem Graphen sind alle 6 Elemente in jeder Kombination miteinander verbunden. Hier sind es 15 Kombinationen. Darunter sind nun auch Kombinationen von Pflanzen, die sich nicht vertragen. Diese werden mit networkx entfernt. Es verbleiben im Graph nur Kombinationen untereinander verträglicher Pflanzen. Diese werden mit dem Befehl find_Cliques(G) in Gruppen zusammengefasst. Das ist aber auch die am schwierigsten zu lösende Aufgabe. Im Programm von Huo werden diese Cliques formatiert ausgegeben.

Im Fall dieses einfachen Szenarios mit den logischen Beziehungen verträglich oder unverträglich kann man auch anders herum das Problem lösen. Voraussetzung ist, dass man die Operationen von Einfügen und Entfernen in beliebiger Reihenfolge durchführen kann

Ausgangspunkt ist wieder die Liste der mit der Hauptfrucht verträglichen Pflanzen. Hier dient die Ananas als Beispiel. Dazu kommt eine Tabelle der mit der Hauptfrucht verträglichen Pflanzen, die sich aber untereinander nicht vertragen.

Code: Alles auswählen

Gute Nachbarn:
Baobab, Dattel, Feige, Kiwi, Litschi, Papaya

Darunter harmonieren nicht:
['Baobab', 'Kiwi']   (1)
['Baobab', 'Papaya'] (2)
['Dattel', 'Kiwi']   (3)
['Feige', 'Kiwi']    (4)
['Feige', 'Papaya']  (5)
['Kiwi', 'Litschi']  (6)

Der Algorithmus funktioniert nun wie folgt. Initial hat man eine Gruppe mit den mit der Hauptfrucht verträglichen Pflanzen. Nun wird der erste Konflikt dadurch beseitigt, in dem man aus der initialen Gruppe zwei Gruppen macht. Beide Gruppen entstehen aus der initialen Gruppe. Nur ist in der ersten Gruppe die erste Konfliktpflanze entfernt und bei der zweiten Gruppe die zweite Konfliktpflanze. Die zwei Gruppen entstehen im Beispiel nun so.

Code: Alles auswählen

Konflikt     | Ausgangsgruppe(n)                            | Nächste Gruppe(n)                     | Bemerkung
-------------|----------------------------------------------|---------------------------------------|----------------
Baobab, Kiwi | Baobab, Dattel, Feige, Kiwi, Litschi, Papaya | Dattel, Feige, Kiwi, Litschi, Papaya  | Baobab entfernt
             |                                              | Baobab, Dattel, Feige, Litschi, Papaya| Kiwi entfernt
-------------|----------------------------------------------|---------------------------------------|----------------

Die Ausgangsgruppe wird nicht mehr verwendet und entfernt. Nun werden die weiteren Konflikte suksessive abgebaut, und zwar für alle neuen Gruppen. Falls in einer Ausgangsgruppe keine Unverträglichkeit für den betrachteten Konfliktfall auftritt, so wird diese Gruppe unverändert übernommen. Sind zwei Ausgangsgruppen identisch, so kann man sie zusammenfassen beziehungsweise eine der identischen Gruppen entfernen. Es geht im Beispiel nun weiter.

Code: Alles auswählen

Konflikt        | Ausgangsgruppe(n)                      | Nächste Gruppe(n)              | Bemerkung
----------------| ---------------------------------------|--------------------------------|---------------
Baobab, Papaya  | Dattel, Feige, Kiwi, Litschi, Papaya   | unverändert                    | kein Konflikt
                |....................................... | .............................. | ...............
                | Baobab, Dattel, Feige, Litschi, Papaya | Dattel, Feige, Litschi, Papaya | Baobab entfernt
                |   "       "       "      "        "    | Baobab, Dattel, Feige, Litschi | Papaya entfernt
----------------| ---------------------------------------|--------------------------------|---------------
Dattel, Kiwi    | Dattel, Feige, Kiwi, Litschi, Papaya   | Feige, Kiwi, Litschi, Papaya   | Dattel entfernt
                |    "      "     "      "        "      | Dattel, Feige, Litschi, Papaya | Kiwi entfernt
                |....................................... | .............................. | ...............
                | Dattel, Feige, Litschi, Papaya         | unverändert                    | kein Konflikt
                | Baobab, Dattel, Feige, Litschi         | unverändert                    | kein Konflikt
----------------| ---------------------------------------|--------------------------------|---------------
Feige, Kiwi     | Feige, Kiwi, Litschi, Papaya           | Kiwi, Litschi, Papaya          | Feige entfernt
                |   "      "      "       "              | Feige, Litschi, Papaya         | Kiwi entfernt
                |....................................... | .............................. | ...............
                | Dattel, Feige, Litschi, Papaya         | unverändert aber doppelten     | kein Konflikt
                | Dattel, Feige, Litschi, Papaya         | unverändert Eintrag entfernt   | kein Konflikt
                |....................................... | .............................. | ...............
                | Baobab, Dattel, Feige, Litschi         | unverändert                    | kein Konflikt
----------------| ---------------------------------------|--------------------------------|---------------
Feige, Papaya   | Kiwi, Litschi, Papaya                  | unverändert                    | kein Konflikt
                |....................................... | .............................. | ...............
                | Feige, Litschi, Papaya                 | Litschi, Papaya                | Feige entfernt
                |   "      "        "                    | Feige, Litschi                 | Papaya entfernt
                |....................................... | .............................. | ...............
                | Dattel, Feige, Litschi, Papaya         | Dattel, Litschi, Papaya        | Feige entfernt
                |   "      "        "       "            | Dattel, Feige, Litschi         | Papaya entfernt
                |....................................... | .............................. | ...............
                | Baobab, Dattel, Feige, Litschi         | unverändert                    | kein Konflikt
----------------| ---------------------------------------|--------------------------------|---------------
Kiwi, Litschi   | Kiwi, Litschi, Papaya                  | Litschi, Papaya                | Kiwi entfernt
                |   "      "       "                     | Kiwi, Papaya                   | Litschi entfernt
                |....................................... | .............................. | ...............
                | Litschi, Papaya                        | unverändert                    | kein Konflikt
                | Feige, Litschi                         | unverändert                    | kein Konflikt
                | Dattel, Litschi, Papaya                | unverändert                    | kein Konflikt
                | Dattel, Feige, Litschi                 | unverändert                    | kein Konflikt
                | Baobab, Dattel, Feige, Litschi         | unverändert                    | kein Konflikt
----------------| ---------------------------------------|--------------------------------|---------------

Nun werden die Gruppen in Cliquen zusammengefasst. Dazu werden doppelte Einträge zu einem Eintrag zusammengefasst. Das gleiche gilt auch für Gruppen, die eine Teilmenge anderer Gruppen darstellen.

Code: Alles auswählen

Nummer | Gruppe                          | Reduktion auf Cliquen | Bemerkung
-------|---------------------------------|-----------------------|---------
    1  | Litschi, Papaya                 | Untergruppe von 5     | entfernt
    2  | Kiwi, Papaya                    |                       |          
    3  | Litschi, Papaya                 | Untergruppe von 5     | entfernt
    4  | Feige, Litschi                  | Untergruppe von 6     | entfernt
    5  | Dattel, Litschi, Papaya         |                       |         
    6  | Dattel, Feige, Litschi          | Untergruppe von 7     | entfernt
    7  | Baobab, Dattel, Feige, Litschi  |                       |         

Die resultierenden Cliquen sind zusammen mit der Hauptfrucht

Code: Alles auswählen

['Ananas', 'Kiwi', 'Papaya']
['Ananas', 'Dattel', 'Litschi', 'Papaya']
['Ananas', 'Baobab', 'Dattel', 'Feige', 'Litschi']

Das Ergebnis stimmt mit der Ausgabe des Programms von Huo überein. Nun habe ich selbst ein auf dem Skript von Huo basierendes Python Skript geschrieben. Das Skript von Huo habe ich nur so verändert, dass in der ersten Ausgabe eine Reihe von Minus Zeichen als Trennung ausgegeben wird. In der folgenden Zeile wird zusätzlich der Name der Hauptfrucht mit angezeigt. Mein Python Programm verwendet die selben Eingangs- und Ausgabe Funktionen wie das Skript von Huo. Damit kann man in einem kleinen Shellskript beide Programme für alle Arten aus den von Huo gelisteten Sortiment laufen lassen und die Ausgaben in Dateien umlenken. Ein Vergleich ergibt bis auf zum Teil unterschiedliche Reihenfolgen in den ermittelten Cliquen keine Unterschiede.

Ein Mathematiker könnte sehr wahrscheinlich eine Äquivalenz der zwei Methoden formal beweisen. Mein Skript muss ich noch ablegen. Der gezeigte Algorithmus sollte sich wie vom Threadstarter angeregt sogar in einer Tabellenkalkulation implementieren lassen. Vielen Dank an Michaa7 für die Anregung, an Huo für seine hervorragende Referenz Implementierung und an Heisenberg für seine Tips per PN zur uproblematischen Handhabung von Textblöcken, die in Monospace Fonts dargestellt werden sollen.

Viele Grüße,
Christoph --- das Skript lege ich noch ab.

[chrbr]

das Skript lege ich noch ab

Die Option für Beitrag ändern ist wohl abgelaufen. Macht nichts, dann liegt der Link eben hier. 41879