From Newsgroup: comp.lang.lisp

The question is about so-called "bellied"
numbers, defined as 4-digit integers for which the sum of the two
"middle" digits is smaller than the sum of the two outer digits. So 1265
is bellied, while 4247 is not.

[ He means the sum of middle digits is larger. ]

This checking part is easy:

(defun bellied-number-p (n)
(> (+ (mod (truncate n 10) 10) (mod (truncate n 100) 10))
(+ (mod n 10) (truncate n 1000))))

Now the task is to find the longest, uninterrupted sequence of bellied numbers within all 4-digit number, hence from 1000 to 9999. And this is
where I terribly screwed up:

While the following code does the job,

(let ((max-length 0)
(current-length 0)
(last-bellied-number 0))
(dotimes (m 9000)
(let ((n (+ 1000 m)))
(if (bellied-number-p n)
(incf current-length)
(progn
(when (> current-length max-length)
(setf max-length current-length)
(setf last-bellied-number (1- n)))
(setf current-length 0)))))
(print (format t "~&Longest sequence of ~a bellied numbers ends at ~a."
max-length last-bellied-number)))

TXR Lisp.

Having defined:

(defun bellied-p (num)

Wouldn't it be more understandable and less cryptic
to name the funcion "bellied?" instead of "bellied-p"?
Again we see that those who are or who have been
CL cultists have no desire for clarity or elegance.

(let ((d (digits num)))
(and (= 4 (len d))
(< (+ [d 0] [d 3])
(+ [d 1] [d 2])))))

We casually do this at the prompt:

1> [find-max [partition-by bellied-p (range 1000 9999)] :
[iff [chain car bellied-p] len (ret 0)]]
(1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932
1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945
1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958
1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971
1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984
1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997
1998 1999)

Gauche Scheme

(define (bellied? n . xs)
(if (= 0 n)
(let-values (((a b c d) (apply values xs)))
(> (+ b c) (+ a d)))
(apply bellied? (div n 10) (mod n 10) xs)))

(let1 runs '()
(do ((i 1000 (+ 1 i))
(found #f))
((> i 9999))
(if (bellied? i)
(unless found (set! found i))
(when found
(push! runs (list found (- i found)))
(set! found #f))))
(car (sort runs > cadr)))

===>
(1920 80)

The longest run begins with 1920 and has a length of 80.
--
[T]he problem is that lispniks are as cultish as any other devout group and basically fall down frothing at the mouth if they see [heterodoxy].
--- Kenny Tilton
The good news is, it's not Lisp that sucks, but Common Lisp. --- Paul Graham --- Synchronet 3.21a-Linux NewsLink 1.2