��p���� �����i�

for i := 0 to m do c[i] := 0;
for i := 0 to k do
     for j := 0 to l do
         c[i+j] := c[i+j] + a[i] * b[j];

(DEFUN LENGTH (lst)		(DEFUN GEN0 (n)
((NULL lst) 0)				((ZEROP n) NIL)
(+ 1 (LENGTH (CDR lst)))  )		(CONS 0 (GEN0 (- n 1)))  )

(DEFUN MAS (lst n)		(DEFUN CHANGE (lst n value)
((ZEROP n) (CAR lst))		((ZEROP n) (POP lst) (PUSH value lst))
(MAS (CDR lst) (- n 1))  )	(CONS (CAR lst) (CHANGE (CDR lst) (- n 1) value))

(DEFUN MULTPOL (lst1 lst2)
(SETQ k (LENGTH lst1) l (LENGTH lst2) lst3 (GEN0 (+ k l)))
(SETQ i 0)
(POP lst3)
(LOOP
  ((= i k) lst3)
  (SETQ j 0)
  (LOOP
   ((= j l))
   (SETQ lst3 (CHANGE lst3 (+ i j) (+ (MAS lst3 (+ i j)) (* (MAS lst1 i) (MAS lst2 j)))) )
   (INCQ j)   )
(INCQ i)  )  )

$ (MAKE-LIST 3 '(q w))	$ (MAKE-LIST 4)		$ (MAKE-LIST 3 5 '(2 3))
  ((q w)(q w)(q w))	(NIL NIL NIL NIL)	(5 5 5 2 3)

(DEFUN MAKE-LST (N OBJ LST)
((AND (INTEGERP N) (PLUSP N))
      (CONS OBJ (MAKE-LIST (SUB1 N) OBJ LST)) )
LST )

(DEFUN find_diff (x)
	((NULL (CDR x)) 1)
	(IF (/= (CAR x) (CADR x)) (+ 1 (find_diff (CDR x))) (find_diff (CDR x)))
)

(DEFUN find_num_n (n x)
(SETQ a (GEN0 n))
(LOOP
        ((NULL x))
        (SETQ a (CHANGE a (CAR x) (+ 1 (MAS a (CAR x)))))
        (SETQ x (CDR x))
) a )

             �=3, �=2
          ������i �����:
	          1,1,1
	          1,2
	          2,1
�i����i��:3.

(DEFUN FISHKA (n k)
        (F n k '(1))
)

(DEFUN F (n k lst)
(print lst)
((= (+ n 1) (LENGTH lst)) (CAR lst))
(SETQ l lst i 0 summa 0)
(LOOP
        ((OR (NULL l) (= i k)))
        (INCQ summa (CAR l))
        (POP l)
        (INCQ i)
        )
(F n k (CONS summa lst))
)

	f(m,n) = f(m-1,n) + f(m,n-1), n>0,m>0.
	f(m,0) = f(0,n) = 1, m>0, n>0.
	f(0,0) = 0.

�����i� ����i�

(DEFUN UNPACK (ATM)
((SYMBOLP ATM)   (������ ������i�, P - i���� ���� ����������� � ���������� 
                  ������i� ����� ATM) )
((NUMBERP ATM)   (������ ������i�, P - i���� ���� ����������� � ���� ����� ATM) ) )

$ (UNPACK 'abcde)	$ (UNPACK 216)	$ (SETQ *PRINT-BASE 16*)
(a b c d e)		(\2 \1 \6)	$ (UNPACK 216)
			 		(\0 \D \8)

(DEFUN PACK (LST)
((ATOM LST) "")
((SYMBOLP (CAR LST)) (������, P - i�'� ����� ���������� � P - i���i (CAR LST),
                                  ��������� � (PACK (CDR LST))) )
((NUMBERP (CAR LST)) (������, P - i�'� ����� ���������� � ���� � ����������� 
                                  �����������i (CAR LST), ��������� � (PACK (CDR LST))) )
(PACK (CDR LST)) )

$ (PACK '(a b c d e)		$ (PACK '(\7 \3 \1)	$ (PACK '(Q \7 \A \1))
abcde				|731|			Q7A1

$ (PACK '(23 56)		$ (PACK '("" 3 ||))
|2356|				\3

(DEFUN PACK* LST
(PACK LST) )

$ (PACK* 'a 'b 'c)		$ (PACK 4 'QW 'T)
ABC				|4QWT|

(DEFUN CHAR (atm n)		
((ATOM atm) (NTH n (UNPACK atm)) ) )

$ (CHAR 'ABCDE 3)	$ (CHAR 12345 0)	$ (CHAR 'qwe 8)
D			\1			NIL

(DEFUN SUBSTRING (atm n m)
	((AND (ATOM atm) (INTEGERP n))
	((MINUSP n) (SUBSTRING atm 0 m))
	(PACK (SUBLIST (UNPACK atm) n m))

$ (SUBSTRING 'ABCDEFG 2 4)	$ (SUBSTRING 'ABCDEFG 3)
CDE				DEFG
$ (SUBSTRING 123456 3)		$ (SUBSTRING 'ABCDEFG 0 3)
|456|				ABCD

$ (STRING= 'ABC 'ABC)	$ (STRING 'ABC 'ABC NIL)
T			T
$ (STRING= 'Abc 'AbC)	$ (STRING= 'Abc 'AbC NIL)
T			NIL
$ (STRING= |100| 100)	$ (STRING< 'ABC 'AZC) 
T			1    
$ (STRING< 'AZC 'ABC)	$ (STRING>= '123 '123)
NIL			3

$ (STRING-UPCASE "Lisp Is A Language")	$ (STRING-UPCASE '(a s d))
  |LISP IS A LANGUAGE|			NIL

$ (string-upcase |This is A TEXT|)	$ (string-downcase |This is A TEXT|)
|THIS IS A TEXT|			|this is a text|

$ (STRING-UPCASE 'i)			$ (STRING-DOWNCASE 'I)
I					\i

(DEFUN FINDSTRING (ATM1 ATM2 N)
((OR (NOT (ATOM ATM1)) (NOT (ATOM ATM2))) NIL)
((PLUSP N)
    ((NULL (FINDSTRING ATM1 (SUBLIST ATM2))) NIL)
    (+ N (FINDSTRING ATM1 (SUBLIST ATM2 N))) )
((���� ATM1 � �i������� ATM2)
    (�����i� ATM1, �� ��i� ���� ������ �����i������ � ATM2) ) )

$ (FINDSTRING 'BC 'ABCDEFG)	(FINDSTRING 'abc 'abdeabcde)
1				4

$ (DEFUN PRINT-LENGTH (atm)		
((ATOM atm) (LENGTH (UNPACK atm)))	

$ (PRINT-LENGTH 'Mulisp)
6

$ (PRINT-LENGTH -156)		$ (PRINT-LENGTH NIL)
4				3

(DEFUN symmax (atm)					$ (symmax 'a22eeerty)
((NOT (ATOM atm)) NIL)					(e . 3)
(SETQ lst (UNPACK atm) endel (ASCII 0) endct 0)		$ (symmax 'nil)
(LOOP							(n . 1)
  ((NULL lst))						$ (symmax 1222334)
  (SETQ el (CAR lst) ct 0)				(\2 . 3 )
  (LOOP
  ((NOT (EQL (CAR lst) el)))
  (POP lst)
  (INCQ ct) )
  (IF (> ct endct) (SETQ endct ct endel el)) )
(CONS endel endct) )

��������

$ (SETQ a '(1 2 3 4 5 6))	$ a
$ (SPLIT a)			(1 2 3)
(4 5 6)