You can subscribe to this list here.
2000 
_{Jan}
(16) 
_{Feb}
(21) 
_{Mar}
(49) 
_{Apr}
(35) 
_{May}
(25) 
_{Jun}
(15) 
_{Jul}
(17) 
_{Aug}
(15) 
_{Sep}
(12) 
_{Oct}
(18) 
_{Nov}
(42) 
_{Dec}
(31) 

2001 
_{Jan}
(35) 
_{Feb}
(24) 
_{Mar}
(53) 
_{Apr}
(59) 
_{May}
(124) 
_{Jun}
(134) 
_{Jul}
(92) 
_{Aug}
(74) 
_{Sep}
(75) 
_{Oct}
(95) 
_{Nov}
(47) 
_{Dec}
(32) 
2002 
_{Jan}
(191) 
_{Feb}
(143) 
_{Mar}
(279) 
_{Apr}
(287) 
_{May}
(106) 
_{Jun}
(96) 
_{Jul}
(95) 
_{Aug}
(126) 
_{Sep}
(184) 
_{Oct}
(152) 
_{Nov}
(84) 
_{Dec}
(136) 
2003 
_{Jan}
(170) 
_{Feb}
(64) 
_{Mar}
(202) 
_{Apr}
(142) 
_{May}
(103) 
_{Jun}
(145) 
_{Jul}
(56) 
_{Aug}
(204) 
_{Sep}
(130) 
_{Oct}
(91) 
_{Nov}
(32) 
_{Dec}
(130) 
2004 
_{Jan}
(89) 
_{Feb}
(208) 
_{Mar}
(190) 
_{Apr}
(61) 
_{May}
(111) 
_{Jun}
(126) 
_{Jul}
(121) 
_{Aug}
(90) 
_{Sep}
(65) 
_{Oct}
(80) 
_{Nov}
(90) 
_{Dec}
(95) 
2005 
_{Jan}
(63) 
_{Feb}
(106) 
_{Mar}
(105) 
_{Apr}
(90) 
_{May}
(99) 
_{Jun}
(96) 
_{Jul}
(197) 
_{Aug}
(144) 
_{Sep}
(128) 
_{Oct}
(123) 
_{Nov}
(232) 
_{Dec}
(153) 
2006 
_{Jan}
(210) 
_{Feb}
(69) 
_{Mar}
(37) 
_{Apr}
(74) 
_{May}
(123) 
_{Jun}
(51) 
_{Jul}
(91) 
_{Aug}
(25) 
_{Sep}
(98) 
_{Oct}
(98) 
_{Nov}
(87) 
_{Dec}
(33) 
2007 
_{Jan}
(43) 
_{Feb}
(41) 
_{Mar}
(27) 
_{Apr}
(18) 
_{May}
(20) 
_{Jun}
(18) 
_{Jul}
(35) 
_{Aug}
(35) 
_{Sep}
(21) 
_{Oct}
(75) 
_{Nov}
(41) 
_{Dec}
(28) 
2008 
_{Jan}
(34) 
_{Feb}
(28) 
_{Mar}
(33) 
_{Apr}
(26) 
_{May}
(45) 
_{Jun}
(35) 
_{Jul}
(36) 
_{Aug}
(32) 
_{Sep}
(87) 
_{Oct}
(70) 
_{Nov}
(98) 
_{Dec}
(96) 
2009 
_{Jan}
(94) 
_{Feb}
(79) 
_{Mar}
(9) 
_{Apr}
(10) 
_{May}
(5) 
_{Jun}
(54) 
_{Jul}
(49) 
_{Aug}
(65) 
_{Sep}
(61) 
_{Oct}
(16) 
_{Nov}
(61) 
_{Dec}
(70) 
2010 
_{Jan}
(2) 
_{Feb}
(67) 
_{Mar}
(8) 
_{Apr}
(30) 
_{May}
(19) 
_{Jun}
(2) 
_{Jul}
(17) 
_{Aug}
(30) 
_{Sep}
(23) 
_{Oct}
(20) 
_{Nov}
(47) 
_{Dec}
(12) 
2011 
_{Jan}
(44) 
_{Feb}
(46) 
_{Mar}
(20) 
_{Apr}
(74) 
_{May}
(35) 
_{Jun}
(37) 
_{Jul}
(5) 
_{Aug}
(14) 
_{Sep}

_{Oct}
(8) 
_{Nov}
(6) 
_{Dec}
(1) 
2012 
_{Jan}
(18) 
_{Feb}
(12) 
_{Mar}
(22) 
_{Apr}
(6) 
_{May}
(16) 
_{Jun}
(17) 
_{Jul}
(10) 
_{Aug}
(13) 
_{Sep}
(2) 
_{Oct}
(8) 
_{Nov}
(10) 
_{Dec}
(1) 
2013 
_{Jan}
(19) 
_{Feb}
(14) 
_{Mar}
(12) 
_{Apr}
(3) 
_{May}
(33) 
_{Jun}
(12) 
_{Jul}
(20) 
_{Aug}
(5) 
_{Sep}
(5) 
_{Oct}
(17) 
_{Nov}
(15) 
_{Dec}
(4) 
2014 
_{Jan}
(8) 
_{Feb}
(4) 
_{Mar}
(17) 
_{Apr}

_{May}
(16) 
_{Jun}
(10) 
_{Jul}
(7) 
_{Aug}

_{Sep}
(1) 
_{Oct}
(25) 
_{Nov}
(6) 
_{Dec}
(1) 
2015 
_{Jan}
(1) 
_{Feb}
(3) 
_{Mar}
(9) 
_{Apr}
(1) 
_{May}
(8) 
_{Jun}

_{Jul}
(16) 
_{Aug}
(13) 
_{Sep}

_{Oct}
(44) 
_{Nov}
(1) 
_{Dec}

S  M  T  W  T  F  S 


1

2
(2) 
3
(1) 
4
(1) 
5
(3) 
6
(1) 
7
(3) 
8

9
(1) 
10
(1) 
11

12
(1) 
13
(1) 
14
(2) 
15
(2) 
16

17
(1) 
18
(1) 
19
(1) 
20

21
(1) 
22
(4) 
23
(5) 
24
(3) 
25

26
(1) 
27
(3) 
28
(1) 
29
(1) 
30

31
(2) 



From: Dave Roberts <dave@vy...>  20070122 17:58:55

lisp wrote: > Hi. I'm a newbie and I'm learning Scheme. Then you are definitely posting this to the *wrong* list. The clisp list is for the discussion of the CLISP Common Lisp *implementation*, not for Schemerelated questions or general Lisp newbie questions. If you have specific questions about CLISP, you are welcome to post them here. For your particular sorts of questions, comp.lang.scheme would be a much better place, although they will tend to get you to solve your own homework problems, rather than simply feeding you answers. You can find comp.lang.scheme on Google Groups.  Dave 
From: lisp <orianaparo@li...>  20070122 17:49:48

Hi. I'm a newbie and I'm learning Scheme. I'd like to know how I can perform a substitution in a list. I mean: I want to write a function that takes two arguments: a list where the atoms are 1character strings and a list of replacements (each describing a 1character string and its 1character replacement). It should yield the list whic results from performing the substitutions specified in the list pairs on the input list. E.g. substitute ((a (b c) d) a (f b)) ((a z) (b y)) returns the list ((z (y c) d) z (f y)) Thanks in advance. Ori  View this message in context: http://www.nabble.com/substitutiontf3059188.html#a8506074 Sent from the clisplist mailing list archive at Nabble.com. 
From: Pascal Bourguignon <pjb@in...>  20070122 13:10:19

Hans3 writes: > Im a LISP beginner and I would like some help. > I have 2 problems that might be easy for an advanced programmer: Since this is not specific to clisp, but to Common Lisp, a better forum would be news:comp.lang.lisp =20 > 1. A function which will interpolate the values of 2 lists in a number = of > steps, so '(1 1 1 1 1) and '(0.5 1 1.5 2 3) would become: > ( 1.000 1.000 1.000 1.000 1.000 > 0.875 1.000 1.125 1.250 1.500 > 0.750 1.000 1.250 1.500 2.000 > 0.625 1.000 1.375 1.750 2.500 > 0.500 1.000 1.500 2.000 3.000 ) >=20 > How do I make this? Good question. How do YOU do this? =20 You've got three parameters, a from list, a to list, and a number of steps. So you should write a function: (defun interpolate (fromlist tolist numberofsteps) ...) ; fill in the ellipsis. What did you do to get the above example result?=20 (or, if given by your teacher, how would YOU do it with:=20 (interpolate '(0 0 0 0) '(1 2 3 4) 6) ?) One hint: it would be easier/more natural to generate interpolations "line by line": (interpolate '(0 0) '(3 6) 4) > ((0 0) (1 2) (2 4) (3 6)) If you want the result under the form (0 0 1 2 2 4 3 6), you can always concatenate the resulting sublists in a final step. What we have here is a division of the problem in two easier parts. It's easy ton concatenate lists, and it's easy (or at least easier than the original problem) to generate the interpolations "line by line"). > 2. A function that returns a list containing integers between sets of l= ower > and upper boundaries. For example: function 20 26 23 28 would return: > (20 21 22 23 24 25 26 27 28) > Any even number should be possible. Basically, the answer is the same;. How would YOU do it? How can you divide the problem in simplier subproblems? > 3. A random generator that chooses values form a list or a stackpile wi= thout > repeating any values until all have been used once. Idem. Do you really need to write a random generator (it's hard to do in computers). You could write a pseudorandom generator, but is it what's asked? (There is already a pseudo random generator function in Common Lisp). Perhaps what's asked is only to return the values from the stackpile in a random order? What we have here, is that you'd better know your programming language (and libraries), to be able to use existing operators to your purposes. (And also, becareful with specifications, they are often not precise enough and misleading). =20 > 4. A random generator that chooses values form a list or a stackpile wi= th a > specific weight. Example: (weight '(1 2 3) '(4 2 1)) means that 1 has a > weight of 4, 2 has a weight of 2 and 3 has a weight of 1, so 1 will be = twice > as much in a list that 2 and so on. Idem. =20 Hint: if you have a (pseudo) random generator giving integers between 0 and N1 inclusive in equiprobability, how do you map these integers to a set of N elements to keep the equiprobability? And would you map these N integers to another set of elements to get different probabilities? > I would grately appreciate if anyone could tell me how to do this, so I= can > figure out the rest I want to do. Please help me out! >=20 > Thanks, Hans =20 __Pascal Bourguignon__ http://www.informatimago.com/ READ THIS BEFORE OPENING PACKAGE: According to certain suggested versions of the Grand Unified Theory, the primary particles constituting this product may decay to nothingness within the next four hundred million years. 
From: Klaus Ebbe Grue <grue@di...>  20070122 09:13:21

;; Hi, ;; Im a LISP beginner and I would like some help. ;; I have 2 problems that might be easy for an advanced programmer: ; I wonder whether or not clisplist@... is the right ; place to ask such questions. But I had a little spare time this morning, ; so here is a partial answer to question 2 and 3 in case you want to ; write your program in a doityourselfstyle (which I think is a good ; idea until you are no longer a LISP beginner). (inpackage "COMMONLISPUSER") ;; 2. A function that returns a list containing integers between sets of ;; lower and upper boundaries. For example: function 20 26 23 28 would ;; return: (20 21 22 23 24 25 26 27 28) ; (integerinterval m n) returns the list (m m+1 m+2 ... n) provided ; that m and n are integers and m <= n. (defun integerinterval (m n) (if (< n m) nil (cons m (integerinterval (+ m 1) n)))) ; (integerinterval1 m n) also returns the list (m m+1 m+2 ... n) ; provided that m and n are integers and m <= n. But it runs faster. (defun integerinterval1 (m n) (integerinterval2 m n nil)) ; (integerinterval2 m n result) returns the list (m m+1 m+2 ... n) ; prepended to the list 'result'. (defun integerinterval2 (m n result) (if (< n m) result (integerinterval2 m ( n 1) (cons n result)))) ; The function above is 'tail recursive' in the sense that the very ; last thing it does when (< n m) is false is that it calls *itself*. ; The integerinterval function is not tail recursive: the last thing ; it does when (< n m) is false is that it calls 'cons'. Tail recursive ; functions happen to be faster than other functions on most systems. ; (question2 s) returns a list with all integers between the smallest and ; largest element of the nonempty list s of integers. As an example, ; (question2 '(20 26 23 28)) returns (20 21 22 23 24 25 26 27 28) (defun question2 (s) (integerinterval1 (apply 'min s) (apply 'max s))) ; The function above uses (apply 'min s) to apply the minimum function to ; the list s to get the smallest element of the list. If you want to do ; that 'yourself' you can use (smallestelement s) instead: (defun smallestelement (s) (if (atom (cdr s)) (car s) (min (car s) (smallestelement (cdr s))))) ; The smallestelement function above is *not* tail recursive. One can make ; it tail recursive and thereby faster using the same trick as the one I ; used for integerinterval above. ;; 3. A random generator that chooses values form a list or a stackpile ;; without repeating any values until all have been used once. ; The following is *not* a solution to your problem. Rather, I solve ; the related problem of constructing a random permutation of the ; integers from m inclusive to n exclusive. Hopefully, you can adapt ; the code to suit your needs ; (randompermutation m n) returns a random permutation of the numbers ; m,m+1,m+2,...,n1 provided that m and n are integers and m < n. (defun randompermutation (m n) (format t "randompermutation ~s ~s~%" m n) (if (= m ( n 1)) (list m) (randompermutation1 m (floor (+ m n) 2) n))) ; (randompermutation1 m d n) returns a random permutation of the numbers ; m,m+1,m+2,...,n1 provided that m, n, and d are integers and m < d < n. (defun randompermutation1 (m d n) (format t "randompermutation ~s ~s ~s~%" m d n) (randommerge ( d m) (randompermutation m d) ( n d) (randompermutation d n))) ; (randommerge l1 s1 l2 s2) returns a random merge of the lists s1 and s2 ; provided that l1 is the length of s1 and l2 is the length of s2. When ; merging a short and a long list it picks with largest probability from ; the long list. To get all permutations with even probability it is ; important to pick with probability l1/(l1+l2) from the list of length l1. (defun randommerge (l1 s1 l2 s2) (format t "randommerge ~s ~s~%" l1 l2) (if (= l1 0) s2 (if (= l2 0) s1 (if (< (random (+ l1 l2)) l1) (cons (car s1) (randommerge ( l1 1) (cdr s1) l2 s2)) (cons (car s2) (randommerge ( l2 1) (cdr s2) l1 s1)))))) ; Cheers, ; Klaus 