Data update

Task/Sorting-algorithms-Merge-sort/EasyLang/sorting-algorithms-merge-sort.easy

@@ -1,4 +1,4 @@
-proc sort . d[] .
+proc sort &d[] .
    len tmp[] len d[]
    sz = 1
    while sz < len d[]
@@ -7,13 +7,9 @@ proc sort . d[] .
       while left < len d[]
          # merge
          mid = left + sz - 1
-         if mid > len d[]
-            mid = len d[]
-         .
+         if mid > len d[] : mid = len d[]
          right = mid + sz
-         if right > len d[]
-            right = len d[]
-         .
+         if right > len d[] : right = len d[]
          l = left
          r = mid + 1
          for i = left to right

Task/Sorting-algorithms-Merge-sort/REXX/sorting-algorithms-merge-sort-3.rexx

@@ -1,4 +1,8 @@
-Main:
+include Settings
+
+say 'MERGE SORT - 4 Mar 2025'
+say version
+say
 call Generate
 call Show
 call Mergesort 1,n
@@ -65,3 +69,5 @@ do i = b to e
    stem.i = work.i
 end
 return
+
+include Abend

Task/Sorting-algorithms-Merge-sort/ZED/sorting-algorithms-merge-sort.zed

@@ -3,35 +3,10 @@
 #true
 (003) "append" list1 list2
 
-(car) pair
+(cons) item list
 =========
 #true
-(002) "car" pair
-
-(cadr) pair
-=========
-#true
-(002) "cadr" pair
-
-(cdr) pair
-=========
-#true
-(002) "cdr" pair
-
-(cddr) pair
-=========
-#true
-(002) "cddr" pair
-
-(cons) one two
-=========
-#true
-(003) "cons" one two
-
-(list1a) item
-=========
-#true
-(002) "list" item
+(003) "cons" item list
 
 (map) function list
 =========
@@ -39,35 +14,35 @@
 (003) "map" function list
 
 (merge) comparator list1 list2
-CONTINUE WITH COLLECT ARGUMENT
+BRING IN COLLECT ARGUMENT
 #true
 (merge01) comparator list1 list2 nil
 
 (merge01) comparator list1 list2 collect
-LIST2 EXHAUSTED -> MERGED
+LIST2 EXHAUSTED
 (null?) list2
 (append) (reverse) collect list1
 
 (merge01) comparator list1 list2 collect
-LIST1 EXHAUSTED -> MERGED
+LIST1 EXHAUSTED
 (null?) list1
 (append) (reverse) collect list2
 
 (merge01) comparator list1 list2 collect
-TAKE FROM LIST2 (HANDLES ONE CASE)
-(003) comparator (car) list2 (car) list1
+COMPARATOR CHOOSES LIST2
+(003) comparator (1) list2 (1) list1
 (merge01) comparator
   list1
-  (cdr) list2
-  (cons) (car) list2 collect
+  (!) list2
+  (cons) (1) list2 collect
 
 (merge01) comparator list1 list2 collect
-TAKE FROM LIST1 (HANDLES TWO CASES)
+NOW TAKE FROM LIST1 (PRIORITY STABILITY)
 #true
 (merge01) comparator
-  (cdr) list1
+  (!) list1
   list2
-  (cons) (car) list1 collect
+  (cons) (1) list1 collect
 
 (null?) value
 =========
@@ -80,28 +55,47 @@ TAKE FROM LIST1 (HANDLES TWO CASES)
 (002) "reverse" list
 
 (sort) comparator jumble
-PREPARE JUMBLE AND PERFORM MERGE PASSES -> EXTRACT
+PREPARE JUMBLE AND PERFORM MERGE PASSES
 #true
-(car) (sort02) comparator (sort01) jumble
+(sort03) comparator (sort02) comparator (sort01) jumble
 
 (sort01) jumble
-PREPARED JUMBLE
+PREPARE JUMBLE
 #true
-(map) list1a jumble
+(map) "list" jumble
 
 (sort02) comparator jumble
-WHEN ZERO LISTS THEN NIL
+EMPTY JUMBLE
 (null?) jumble
 nil
 
 (sort02) comparator jumble
-WHEN ONE LIST THEN ALREADY SORTED
-(null?) (cdr) jumble
+ONE LIST JUMBLE
+(null?) (!) jumble
 jumble
 
 (sort02) comparator jumble
-REPEATEDLY MERGE ALONG LENGTH
+PERFORM MERGE PASS
 #true
-(sort02) comparator
-  (cons) (merge) comparator (car) jumble (cadr) jumble
-    (sort02) comparator (cddr) jumble
+(cons) (merge) comparator (1) jumble (1) (!) jumble
+  (sort02) comparator (!) (!) jumble
+
+(sort03) comparator jumble
+EMPTY JUMBLE
+(null?) jumble
+nil
+
+(sort03) comparator jumble
+ONE LIST JUMBLE
+(null?) (!) jumble
+(1) jumble
+
+(sort03) comparator jumble
+PERFORM MERGE PASS AND RESTART
+#true
+(sort03) comparator (sort02) comparator jumble
+
+(main)
+ENTRY POINT
+#true
+(002) "display" (sort) ">" (010) "list" 4 3 5 6 8 7 1 2 9