---

Hallo,

ich hätte mal nee Frage zu den Befehl SORT!

Also ich lese aus einer CSV-Datei eine Liste wie folgt ein!

CSV-Datei bzw. 'Outfile'
10 \tab h \tab 7
20 \tab F \tab 8
16 \tab J \tab 6
30 \tab k \tab 9
110 \tab k \tab 6

Code:

---

(with-open-file (instream outfile)
(loop for line = (read-line instream nil)
while line do
(push (sd-string-split line #\tab) liste_eintraege)
) ;loop
) ;with-open-file

---

Jetzt sortiere ich diese nach dem ersten Eintrag wie folgt und erhalte folgendes:

Code:

---

(setq liste_eintraege (sort liste_eintraege #'string-lessp :key #'car))

---

10 h 7
110 k 6
16 j 8
20 F 8
30 k 9

Fehler -> ich Sortiere nach String!!!

Frage 1: Gibt es ein Befehl der beim sortieren den Wert als Zahl behandelt? In etwa so?

Code:

---

(setq liste_eintraege (sort liste_eintraege #'> :key #'(READ-FROM-STRING car))

---

Frage 2: Wie kann ich den zweiten Wert abfragen? Habs so Versucht:

Code:

---

(setq liste_eintraege (sort liste_eintraege #'string-lessp :key #'caar))

---

Habe mir schon nee Version gebastelt wo ich mittels PUSH und READ-FROM-STRING die Werte
nach vorn hole und anschließend sortiere und wieder und wieder!

Code:

---

;;; Passungsliste sortieren ;;;
;;; Liste nach Toleranzgrad sortieren ;;;
(dolist (item liste_eintraege)
(push (push (read-from-string (sd-string-trim (nth 2 item))) item) temp_eintraege)
)
(setq liste_eintraege temp_eintraege)
(setq liste_eintraege (sort liste_eintraege #'> :key #'car)) ;Einträge sortieren
(setq temp_eintraege nil)

;;; Liste nach Toleranz sortieren ;;;
(dolist (item liste_eintraege)
(push (push (sd-string-trim (nth 2 item)) item) temp_eintraege)
)
(setq liste_eintraege temp_eintraege)
(setq liste_eintraege (nreverse (sort liste_eintraege #'string-lessp :key #'car))) ;Einträge sortieren

(setq temp_eintraege nil)

;;; Liste nach Nennwert sortieren ;;;
(dolist (item liste_eintraege)
(push (push (read-from-string (sd-string-replace (nth 2 item) "," ".")) item) temp_eintraege)
)
(setq liste_eintraege temp_eintraege)
(setq liste_eintraege (sort liste_eintraege #'< :key #'car)) ;Einträge sortieren

---

Das schein mir aber seh Aufwendig, funzt aber!!!

KURZ: Gibt es ein Möglichkeit das in Kürze hinzubekommen?

Code:

---

(setq liste_eintraege (sort liste_eintraege #'> :key #'(READ-FROM-STRING nth 2))
(setq liste_eintraege (nreverse (sort liste_eintraege #'string-lessp :key #'nth 1)))
(setq liste_eintraege (sort liste_eintraege #'< :key #'(READ-FROM-STRING nth 0))

---

Gruß Michael

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Zitat:

---

Original erstellt von MiBr:
ich hätte mal nee Frage zu den Befehl SORT!

---

Code:

---

(setq mylist '(
              ("10" "h" "7")
              ("20" "F" "8")
              ("16" "J" "6")
              ("30" "k" "9")
              ("110" "k" "6")
              ))

---

Wenn du statt display nen print machst sieht man besser was was ist (also hier: alles strings)

Also du hast eine list of lists of Strings

Wäre evtl besser die Zahlen als Zahlen zu lesen direkt nach dem Einlesen, aber mal egal.

Code:

---

(setq mysorted-liste (sort mylist '< :key #'(lambda (a) (setq a (read-from-string (car a)))
                                                        (if (numberp a) a -999))
                                      ))

---

Und hier komme ich jetzt etwas in grübln:

Code:

---

(setq liste_eintraege (sort liste_eintraege #'> :key #'(READ-FROM-STRING nth 2))
(setq liste_eintraege (nreverse (sort liste_eintraege #'string-lessp :key #'nth 1)))
(setq liste_eintraege (sort liste_eintraege #'< :key #'(READ-FROM-STRING nth 0))

---

Soll das heissen du willst die Liste nach allen kriterien sortieren?

Dann schreibe dir eine eigenen Funktion die "my-less" darstellt.  Könntest du als Lambda machen ..  sieht dann aber übel aus.

Code:

---

(setq mysorted-list (sort mylist '(lambda (a b) (cond ...
                                                  ((and (numberp (read-from-string (third a)))
                                                        (numberp (read-from-string (third b)))
                                                        (< (read-from-string (third a))
                                                            (read-from-string (third b))
                                                            ))
                                                      T)
                                                    ((and (equal (third a)(third b))
                                                          (string< (second a) (second b))
                                                          )
                                                      T)
                                                    ((and (equal (second a)(second b))
                                                      ....

---

Übersichtlicher

Code:

---

(defun my-less (a b) .. )
(setq mysorted-list (sort mylist 'my-less))

---

jeder Einzelvergleich hat 3 mögliche Ergebnisse
* kleiner oder
* größer oder
* GLEICH .. und in dem Fall machst du den Verleich für das nächst niedere Argument.

Im code siehst du dann relativ viele read-from-string und numberp Aufrufe. Deswegen mein Hinweis das möglichst früh zu machen.

-----------------
Wenn du zuerst den equal machst, wird es vielleicht etwas reinfacher,
im Code steht dann allerdings der unwichtigste Fall am Anfang.
Vorteil ist, das der (equal) unabhängig vom Datentype funktioniert (im Gegensatz zu < oder string< )

Im ersten Ansatz könntest du dich auch drauf verlassen das das erste und dritte element eben eine Zahl ist.
(mapcar #'(lambda (one-list) (list (read-from-string (first one-list))
                                  (second one-list)
                                  (read-from-string (third one-list))))
              orginal-list)

------------------
● Firefox ESR ● Java Forum Stuttgart JUGS ● OSD Hilfeseite (de) / help page (en) ● NotePad++ ● BuFDi ●

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo Wolfgang,

Zitat:

---

Wäre evtl besser die Zahlen als Zahlen zu lesen direkt nach dem Einlesen, aber mal egal.

---

Das sehe ich eigentlich auch so! Aber wenn ich die Zahlen in die Zeichnung eintrage, kommt es vor das
die gerundet erscheinen -> 6 = 5.9999999999. Da weiß ich nicht mit umzugehen und von daher habe ich es
lieber bei den STRINGS belassen!

Zitat:

---

Soll das heissen du willst die Liste nach allen kriterien sortieren?

---

Ja! Ich möcht die Zeilen nach folgendem Gewichtung sortieren:
Gewichtung: Nennmaß -> Toleranzfeldlage -> Toleranzgrad
Beispiel:
90 h9
90 h7
90 e9
90 e8
70 h8
70 h7
70 e9

Zitat:

---

Im code siehst du dann relativ viele read-from-string und numberp Aufrufe. Deswegen mein Hinweis das möglichst früh zu machen.

---

Ich schieße jetzt im Vorfeld auf alles in der Liste, so dass ich sicher bin, dass da nur Zahlen als STRINGs horhanden sind.
So mit sortiere ich jetzt so:

Code:

---

;;; Liste nach Toleranzgrad sortieren ;;;
(setq liste_eintraege (sort liste_eintraege '< :key #'(lambda (a) (setq a (read-from-string (third a))) a)))
;;; Liste nach Toleranzfeldlage sortieren ;;;
(setq liste_eintraege (sort liste_eintraege #'string-lessp :key #'(lambda (a) (setq a (second a)) a)))
;;; Liste nach Nennmaß sortieren ;;;
(setq liste_eintraege (sort liste_eintraege '< :key #'(lambda (a) (setq a (read-from-string (first a))) a)))

---

Das funktioniert super mit dem LAMBDA! DANKE dafür!!!

Von daher wäre es so für mich gut lesbar und vom Code auch relativ überschaubar!

Das mit dem MAPCAR verstehe ich so, das ich das mit in dem SORT bringen soll? Allerding muss ich ja zweimal nach '< und
einmal nach #'string-lessp sortieren! Auch den Ansatz mit EQUAL versteh ich nicht  ! , sry schlechter Schüler  .

Also mir gefällt es so schon sehr gut -> DANKE WOLFGANG!!!

Gruß Michael

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Zitat:

---

Original erstellt von MiBr:
Ich schieße jetzt im Vorfeld auf alles in der Liste, so dass ich sicher bin, dass da nur Zahlen als STRINGs horhanden sind.
So mit sortiere ich jetzt so:

---

Deine Lambda Ausdrücke sind noch zu kompliziert.

den setq darin habe ich nur gemacht damit ich noch einen numberp aufrufen kann ohne erneut read-from-string-etc nutzen zu müssen.

Einfacher:

Code:

---

;;; Liste nach Toleranzgrad sortieren ;;;
(setq liste_eintraege (sort liste_eintraege '< :key #'(lambda (a) (read-from-string (third a))) ))
;;; Liste nach Toleranzfeldlage sortieren ;;;
(setq liste_eintraege (sort liste_eintraege #'string-lessp :key #'second ))
;;; Liste nach Nennmaß sortieren ;;;
(setq liste_eintraege (sort liste_eintraege '< :key #'(lambda (a) (read-from-string (first a))) ))

---

string-lessp kannte ich gar nicht. Finde ich aber umständlicher zu schreiben als string< .

Der Rest in den üblichen Abendstunden... 🕥

------------------
● Firefox ESR ● Java Forum Stuttgart JUGS ● OSD Hilfeseite (de) / help page (en) ● NotePad++ ● BuFDi ●

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

cadde_92__001024_sort3.png

Wie erzähl ich's meinem Rinde, ähm Kinde.

• Papa kommt von der Obstwiese, eine Kiste Äpfel unterm Arm. 
  
• "Kind komm her geschwind, sortier doch mal die Äpfel. Der Größe nach."
  
• Kind fängt an.
  
• 3 Minuten später kommt Kind mit 2 Äpfeln auf den Vater zu: 'die sind gleich gross, was soll ich denn jetzt machen?'
  
• Vater: "Der, der mehr rot ist ist besser" ,  Kind: 'okay, also der rote vor dem grünen'
  
• Kind sortiert weiter.
  
• 4 Minuten später kommt Kind mit 2 Äpfeln auf den Vater zu: 'die sind gleich gross und beide hell grün, was soll ich denn jetzt machen?'
  
• Vater überlegt. "Hmm. Also besser sind die mit weniger Druckstellen, weil die werden nicht so schnell faul."
  
• Kind: 'okay, also weniger Dellen sind besser'
  
• So sortiert Kind nun die ganze Kiste.

• Wir haben eine Reihe von Objekten mit je drei Eigenschaften: Größe, Farbe + Dellen
  
• Das Problem ist also eher die Gleichheit. Denn dann müssen wir uns was neues einfallen lassen.
  

Giessen wir das in pseudo LISP:

Schlimmer wäre es so:

Code:

---

  (if (not (= a1.size a2.size))
    (< a1.size a2.size)
    ;; else size compare
    (if (not (= a1.color a2.color))
    ....
      )
    )

---

Weil ein if-not-then-else ..  ist SAU doof zu lesen. Auch wenn man dazu tendiert. Programmatisch ist es einfacher zu erst auf Gleichheit zu prüfen.

Ein verschachteltes if-then-else ist aber immer unschön.  Nehmen wir besser eine Condition.

================================================================================
Der Punkt ist der folgende:

sei die Eingabe List mal nur:

• 70 h8
• 70 h7
• 70 e9

wenn du dann so sortierst:

Code:

---

(setq liste_eintraege (sort liste_eintraege '< :key #'(lambda (a) (read-from-string (first a))) ))

---

kann folgendes rauskommen

• 70 h8
• 70 h7
• 70 e9

oder

• 70 e9
• 70 h8
• 70 h7

oder

• 70 e9
• 70 h7
• 70 h8

oder

• 70 h7
• 70 e9
• 70 h8

oder oder oder.  alle (vier) sind bezüglicher der zuvor genannten Sortierung richtig!!!

Wie der Sort die Elemente BEI GLEICHEIT anordnet hängt von der Implementiertung vom Sort ab. Das ist nicht definiert.

------------------
● Firefox ESR ● Java Forum Stuttgart JUGS ● OSD Hilfeseite (de) / help page (en) ● NotePad++ ● BuFDi ●

[Diese Nachricht wurde von der_Wolfgang am 06. Dez. 2022 editiert.]

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo Wolfgang,

zu den leckeren Äpfeln:

Das Kind sortiert die Äpfel
als erstes nach Dellen,
dann alle schön der Reihe nach der roten Farbe
und anschließend diese nach der Größe sortiert.
Dann hat das kleine Mädchen gute arbeit geleistet
und sich den Apfel von ganz oben verdient!

Und mir scheint die Implementiertung von Sort so zu arbeiten!

Beispiel:

Original Liste
((70 h 8) (70 e 9) (90 e 8) (70 h 7) (90 e 7) (70 e 8))

Sortiert nach Toleranzgrad (third)
((70 h 7) (90 e 7) (70 h 8) (90 e 8) (70 e 8) (70 e 9))

Sortiert nach Toleranzfeldlage (second)
((90 e 7) (90 e 8) (70 e 8) (70 e 9) (70 h 7) (70 h 8))

Sortiert nach Nennmaß (first)
((70 e 8) (70 e 9) (70 h 7) (70 h 8) (90 e 7) (90 e 8))

Die SORT macht das wie gesagt richtig, aber Du hast recht das ich mich da auf die
Abarbeitung/Reihenfolge verlasse.

Von daher werde ich versuchen die COND-Variante mal auszuarbeiten. Leider komme
ich kurzfritig nicht dazu!

Wie immer Danke für deine Hilfe!

Gruß Michael

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo, ich konnte die Finger mal wieder nicht still halten!

Aufruf:

Code:

---

(setq liste_eintraege (sort liste_eintraege 'better_sort))

---

Cond sortier Funktion:

Code:

---

(defun better_sort (a1 a2)
  (cond ((and (= (read-from-string (first a1) (read-from-string (first a2)))) (string= (second a1) (second a2)) )
            (< (read-from-string (third a1)) (read-from-string (third a2))))
        ((= (read-from-string (first a1) (read-from-string (first a2))))
            (string-lessp (second a1) (second a2)))
        (t(< (read-from-string (first a1)) (read-from-string (first a2))))
  )
)

---

Irgendwie funzt das nicht wie gewünscht:

Aus Original Liste
((70 h 8)
(70 k 9)
(90 e 7)
(70 h 7)
(90 k 8)
(70 e 8))

wird sortiert oder auch nicht
((90 e 7)
(70 e 8)
(70 h 7)
(70 h 8)
(90 k 8)
(70 k 9))

Habe dann die einzelnen Sortierungen laufen lassen, alleine gehtŽs! Also nach:

Code:

---

(< (read-from-string (third a1)) (read-from-string (third a2)))

---

oder

Code:

---

(string-lessp (second a1) (second a2))

---

oder

Zitat:

---

(< (read-from-string (first a1)) (read-from-string (first a2)))

---

Dann habe ich es so ausprobiert:
Aufrufe:

Code:

---

(setq liste_eintraege (sort liste_eintraege 'better_sort_third))
(setq liste_eintraege (sort liste_eintraege 'better_sort_second))
(setq liste_eintraege (sort liste_eintraege 'better_sort_first))

---

Cond sortier Funktionen:

Code:

---

(defun better_sort_first (a1 a2)
(< (read-from-string (first a1)) (read-from-string (first a2)))
)
(defun better_sort_second (a1 a2)
(string< (second a1) (second a2))
)
(defun better_sort_third (a1 a2)
(< (read-from-string (third a1)) (read-from-string (third a2)))
)

---

Ergebnis wie gewünscht:
((70 e 8)
(70 h 7)
(70 h 8)
(70 k 9)
(90 e 7)
(90 k 8))

Aber das ist ja eigentlich, das selbe wie die drei SORT Aufrufe mittels LAMBDA!

Gruß Michael

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hast du mal deine better_sort getraced? Da würdest du wohl schnell paar Fälle finden, wo es auffällt, das die Funktion nicht so funktioniert wie gedacht.

Oder eben mal von Hand aufrufen:

Code:

---

(better_sort (nth 7 liste_eintraege) (nth 12 liste_eintraege))

---

usw.

risiko ist

Code:

---

(= (read-from-string (first a1) (read-from-string (first a2))))

---

Zahlen auf GLEICHHEIT .. 

warum nicht

Code:

---

(equal (first a1) (first a2))

---

oder eben

Code:

---

(sd-num-equal-p (read-from-string (first a1) (read-from-string (first a2))

---

Aber mal egal ..  geht ja nur noch um die Lernkurve. .

------------------
● Firefox ESR ● Java Forum Stuttgart JUGS ● OSD Hilfeseite (de) / help page (en) ● NotePad++ ● BuFDi ●

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo Wolfgang,

das mit den Zahlen auf GLEICHHEIT.. war dann wohl das Problem!!!
Da hätte ich wahrscheinlich alles vergleichen können (equal/string=) nur die Zahl
auf Gleichheit nicht.      Dumm gelaufen 

Jetzt sortiert die Funktion wunderbar! Danke nochmals für deine Mühe und Zeit!

Gruß Michael

[Diese Nachricht wurde von MiBr am 08. Dez. 2022 editiert.]

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Zitat:

---

Original erstellt von MiBr:
das mit den Zahlen auf GLEICHHEIT.. war dann wohl das Problem!!!

Danke nochmals für deine Mühe und Zeit!

---

Gerne. Du stellst ja auch oft gescheite / interessante Fragen.... und bist auch in der Lage meine Antworten zu lesen. 

------------------
● Firefox ESR ● Java Forum Stuttgart JUGS ● OSD Hilfeseite (de) / help page (en) ● NotePad++ ● BuFDi ●

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo,

dann hätte ich noch nee Frage! Ob die gescheit is weiß ich noch nicht!

Ich Versuche immer meine lisp-Funktionen in dem 'sd-dialog bzw. dort in den ':local-functions
zu lassen! Ich kann mir zwar Vorstellen das niemand nee Funktion 'better_sort' schreibt und
diese müsste ja auch noch in meinem Package sein! Aber sei es drum.

Aber so einfach funzt das hier scheinbar nicht!
Versuch:
:local-functions
(better_sort (a1 a2)
    (cond ....)
)
Aufruf:
(sort liste_eintraege (better_sort))

Fehlermeldung -> Er braucht zwei Eingaben!

Geht das in diesem Fall nicht mit einer Lokalen Funktion?

Gruß Michael

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

cadde-92-001024b.lsp

Code:

---

(sort liste_eintraege (better_sort))

---

Das passt aber so doch auch gar nie nicht zu der Definition deiner Local-Function!!
Du rufst doch hier deine Funktion better_sort einmal auf und das ganz ohne Parameter. So kann das schon gar nicht funktionieren.

Wenn denn dann wäre es so:

Code:

---

(sort liste_eintraege 'better_sort)

---

Aber das führt zu einem verständlichen LISP-Fehler: The function MIBR::BETTER_SORT is undefined.

BTW: den Text der Fehlermeldungen kann man als TEXT selektieren und als TEXT via copy and paste in Nachfragen 1:1 einfügen.

Also solche 'Funktionen für sort (und auch remove-duplicates, remove-if*, delete-if*, mapcar, mapcan, etc. pp)) als richtige Defuns definieren.
Grosser Vorteil: man kann die tracen und kann sie einfacher wieder verwenden

Anbei meine Test dialog für deine Frage.  Ich muss mich da halt auch manchmal rantasten.

Fazit: machn nen 'ordentliches'  defun. Das kann dann auch nicht am API vorbei auf irgendwelche (lokale) dialog variablen zurückgreifen (Stichwort: sauberer source code)

------------------
● Firefox ESR ● Java Forum Stuttgart JUGS ● OSD Hilfeseite (de) / help page (en) ● NotePad++ ● BuFDi ●

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo Wolfgang,

Code:

---

Fazit: machn nen 'ordentliches'  defun. Das kann dann auch nicht am API vorbei auf irgendwelche (lokale) dialog variablen zurückgreifen (Stichwort: sauberer source code)

---

Defun ist halt was 'Neues für Mich'! Da höre ich aber gern auf deinen Rat.

DANKE auch für deinen Test-Dialog! Habe daraus auch wieder was gelernt und ein paar Prog-Schnipsel in anderen Lisp geändert (MAPCAR/DELETE-IF)!

Von daher wie immer Besten Dank!

Michael

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP