update

Task/Self-referential-sequence/Aime/self-referential-sequence.aime

@@ -0,0 +1,100 @@
+text
+next(text s, integer show)
+{
+    integer l;
+    record v;
+    data d;
+    text u;
+
+    l = length(s);
+    while (l) {
+        integer e;
+
+        l -= 1;
+        e = 0;
+        u = insert("", 0, character(s, l));
+        r_g_integer(e, v, u);
+        r_f_integer(v, u, e + 1);
+    }
+
+    if (r_last(v, u)) {
+        do {
+            b_paste(d, -1, itoa(r_q_integer(v, u)));
+            b_paste(d, -1, u);
+        } while (r_less(v, u, u));
+    }
+
+    if (show) {
+        o_text(b_string(d));
+        o_newline();
+    }
+
+    return b_string(d);
+}
+
+integer
+depth(text s, integer i, record r)
+{
+    integer d;
+
+    d = 0;
+    r_g_integer(d, r, s);
+    if (d <= 0) {
+        i += 1;
+        if (d) {
+            d += i;
+        } else {
+            d = -i;
+        }
+        r_f_integer(r, s, d);
+        i = depth(next(s, 0), i, r);
+        d = r_q_integer(r, s);
+        if (d <= 0) {
+            d = i + 1;
+            r_r_integer(r, s, d);
+        }
+    }
+
+    return d;
+}
+
+integer
+main(void)
+{
+    integer d, e, i;
+    record r;
+    list l;
+
+    d = 0;
+    i = 1000000;
+    while (i) {
+        i -= 1;
+        e = depth(itoa(i), 0, r);
+        if (e == d) {
+            lb_p_integer(l, i);
+        } elif (d < e) {
+            d = e;
+            l_clear(l);
+            lb_p_integer(l, i);
+        }
+    }
+
+    o_text(cat3("longest length is ", itoa(d), "\n"));
+    while (l_length(l)) {
+        text s;
+
+        o_newline();
+        r_clear(r);
+        lf_e_integer(i, l);
+        o_integer(i);
+        o_newline();
+        e = d - 1;
+        s = itoa(i);
+        while (e) {
+            s = next(s, 1);
+            e -= 1;
+        }
+    }
+
+    return 0;
+}

Task/Self-referential-sequence/Racket/self-referential-sequence.rkt

@@ -0,0 +1,36 @@
+#lang racket
+
+(define (next s)
+  (define v (make-vector 10 0))
+  (for ([c s])
+    (define d (- (char->integer #\9) (char->integer c)))
+    (vector-set! v d (add1 (vector-ref v d))))
+  (string-append* (for/list ([x v] [i (in-range 9 -1 -1)] #:when (> x 0))
+                    (format "~a~a" x i))))
+
+(define (seq-of s)
+  (reverse (let loop ([ns (list s)])
+             (define n (next (car ns)))
+             (if (member n ns) ns (loop (cons n ns))))))
+
+(define (sort-string s)
+  (list->string (sort (string->list s) char>?)))
+
+(define-values [len nums seq]
+  (for/fold ([*len #f] [*nums #f] [*seq #f])
+            ([n (in-range 1000000 -1 -1)]) ; start at the high end
+    (define s (number->string n))
+    (define sorted (sort-string s))
+    (cond [(equal? s sorted)
+           (define seq (seq-of s))
+           (define len (length seq))
+           (cond [(or (not *len) (> len *len)) (values len (list s) seq)]
+                 [(= len *len) (values len (cons s *nums) seq)]
+                 [else (values *len *nums *seq)])]
+          ;; not sorted: see if it's a permutation of the best
+          [else (values
+                 *len
+                 (if (and *nums (member sorted *nums)) (cons s *nums) *nums)
+                 *seq)])))
+(printf "Numbers: ~a\nLength: ~a\n" (string-join nums ", ") len)
+(for ([n seq]) (printf "  ~a\n" n))