Введение в программирование на Лиспе - ответы на тесты Интуит
Все ответы: За почти полувековую историю своего существования язык Лисп зарекомендовал себя как система с практически неограниченными возможностями символьного программирования. Лисп и его диалекты послужили основой широкого спектра прикладных разработок, оказавших существенное влияние на распространение информационных технологий.
label
return
(load 'имяфайла)
(eval (read))
eval
в базовом Лиспе – это: (cond)
(union)
(setq)
set,
где Alist
– ассоциативный список системы:(defun set (x y) (cons x y) Alist)
(defun set (x y) (eval '(cons x y) Alist) )
(defun set (x y) (assign x y Alist) )
ABC
(ABC)
(NIL ABC)
(Cons (A B С) 'B)
(Atom (Quote A B C))
(EQ (Atom (quote A)) (Atom '(Abc)))
(a1 a2 a3)
, где a1
– функция, a2
и a3
аргументы 'abcd
abcd
, где abcd
–переменная (v abcd)
, где v
и abcd
– переменные (cons (car x) (car y)):
x
и y
, затем в порядке следования выполнены операции cons, cdr и car
x
и результат (car x),
затем переменной y
и результат (car y),
а в конце будет выполнена операция cons с результатами (car x)
и (car y)
x
, затем переменной y
, а в конце будет выполнена операция cons с результатами (car x)
и (car y)
(union '(1 2 3) '(1 2 5))
будет получен (учесть порядок следования элементов итогового списка). Функция Union
имеет следующее определение:
(1 2 3 5)
(3 2 5 1)
(1 2 5 3)
(3 1 2 5)
(Cons 'a BC):
a
" не имеет значения BC
" не имеет значения (A)
(A . B)
'(A)
((lambda (x y) (cons x y)) 'A 'B):
X
и Y
X
связывается со значением A, Y
– с B, выполняется однократное вычисление безымянной функции, строящей пару (A . B)
Cons
при вызове функции subst,
имеющей определение
, со следующими аргументами (порядок следования x y z):
x- (1 2), y - (3 4), z - (1 2 3 4)
x- A, y - B, z – C
x- A, y - A, z - (A B C)
x- (1 2), y - A, z - (B A C D)
apply,
входящая в состав интерпретатора:apply
, к ее аргументам – то и другое представлено как данные Лиспа map-el
:
(map-el caddr '(1 2 3 4))
(map-el '(1 2 3 4))
(map-el '+ '(1 2 3 4))
(map-el '(1 2 3 4) #'caddr)
(map-el #'car '((1)(2)(3)(4)))
(Atom x)
(Eq x1 x2)
(Cond (x (cons 1 (cdr x)) ))
T
(rplacd (cdr x) (car x))
, где x
– список (a b c d)
, является верным:(b c d a)
(a b c a)
(a b a)
(a)
'L'
:Step
:((lambda (x) (cons (cdr x) (car x))) '(a b c))
()defun f(x y) (cons (cdr x) (car y ))
((lambda (x) (cons (cdr 'x) (car 'x))) '(a b c))
((defun (x) (cons (cdr x)) '(a b с))
(defun f (cons (cdr x) (car x )))
Cons
(в определении append) при вызове функции append,
имеющей определение
при интерпретации выражений с указанными ниже аргументами:
x – (car (A)), y – (car (1 2))
x – (cons 1 2), y – (1 2 2 3)
x – (car (quote (1 2))), y – (1 2 3)
TRUE
и FALSE
T
и Nil
(defun F(xl) (cond (xl (cons (* 2 (car xl) ) (F (cdr xl))))))
(defun F(xl) (map-el (lambda (x) (* 2 x) ) xl))
(defun F(xl) (map-comp (lambda (x) (* 2 x)) xl))
(intersection '(1 2 3) '(4 5 3))
является верным. Функция intersection
имеет следующее определение:
(1 2 3 4 5)
(1 2 4 5)
(3)
(Setq (get 'Атом) 'свойство)
(Setf (get 'Атом) 'свойство)
(Setf 'Атом 'свойство)
Step 3>
означает:(Step выражение)
(EQ (car '(A)) (cdr'(B)))
, если да, то какой ответ является верным:Nil
True
((lambda (x) (car (cons (cdr x) x))) '(1 2 3)):
x
со значением (1 2 3)
, вычисление головы списка, вычисление хвоста списка, соединение хвоста и остального списка, результат ((2 3) (1 2 3))
(car (cons (cdr x) x))
,подстановка в нее значения '(1 2 3)
(связывание с переменной x
), вычисление хвоста списка, консолидация со списком, вычисление головы итогового списка, результат (2 3)
x
со значением (1 2 3)
, вычисление хвоста списка, консолидация с исходным списком, вычисление головы итогового списка, результат (2 3)
(1 2 3)
(1 . (2 . 3))
(1 (2 3))
1
()
> a1
:a1
является именем функции a1
является именем переменной, не имеющей значения a1
является именем переменной, находящейся в ассоциативном списке _слово1_слово2_…_словоN
" слово1 слово2 слово3"
;слово1 слово2 слово3
(a b c d . e)
(a b .( c d) e)
(((a . b) . c) d . e)
(eval x)
'x
(defun f(x) x)
(lambda () x)
(symbol-function )
(symbol-value )
(symbol-plist)
Defun
содержит в порядке следования:(cdr '( a (b (c)) d)):
(b (c))
(d)
((b (c)) d)
"if (a=b) then print ('a равно b') else print ('a не равно b')"
на языке Лисп:(cond ((eq a b) (print "a равно b")) (T (print "a не равно b")))
(cond ((= a b) (print "a равно b")) (T (print "a не равно b")))
(cond ((= a b) print "a равно b") ("a не равно b"))
((lambda (x y) (car (cons x (cdr y)))) (a b 2) (2 3))
(defun f(x y z) (cons (cons x (cdr y)) z))
(defun F(x) ((lambda (y) (car y)) x) )
Nil
и (quote nil)
Nil
и True
(car a)
и '(car a)
(quote (Eq a))
и '(Eq a)
T
и Nil
("(abcd)")
abcd1234567890
'"abcd"
"(abcd)"
12345678910111213141516117abcd
(apply (f x y))
и (funcall f x y)
(apply (f x y))
и (funcall (f x y))
(eval '(f 'x 'y))
и (eval '(f x y))
(eval '(f x y))
и (funcall f 'x 'y)
(evcon x)
(defun f(x) (x))
(funcall (f x))
, где f(x)
определено с помощью (defun f(x) (x))
(apply (x ))
Cons
Eq
rplaca
Defun
(Cons 'a 'BC)
:((A . (B . C) ) . (D . (E . Nil))):
((A B . C) . (D E))
((A (B C)) (D E))
((A (B C)) (D . E))
(defun f(x) (f (caar x)))
(defun F(x) (cond (F (car x)) ((atom x) x) ))
(defun F(x) (cond (((atom x) x) (T (F (car x)) )) )
((QUOTE T) (QUOTE NIL))
второго (вложенного) Cond
функции Equal,
имеющей определение
при интерпретации выражений с указанными ниже аргументами:
(1 2)
и (1 0)
(a b)
и (a (d))
(a b)
и (c b)
(a b)
и (a c)
(cadr '((A) . B) )
(cadr '((A) B))
(car A)
(Caar '((A) B C))
map-comp
, аргументами которого выступают следующие функции и списки, является правильным:
(map-comp #'car '(1 2 3) '(1 2 4)), результат ( 1 2 3)
(map-comp #'cons '(1 2 3) '(1 (2 4))), результат ((1 . 1) (2 . 2) (3 . 4))
(map-comp #'cons '(1 2 3) '(1 (2 4) )), результат ((1 . 1) (2 2 4) (3))
(map-comp #'cons '(1) '(5 2)), результат (1 . (5 2))
(let ((a (cons x y))) a)
:"x"
и "y"
на список "a"
"a"
результата консолидации (cons x y)
Let
) повторяющегося подвыражения "(cons x y)"
на "a"
без воздействия на результат вычисления последующих форм (rplaca x (cddr x))
, где x
– список (a b c d)
, является правильным:((с d) b c d)
((b c d) a)
(b с d)
(a с d)
Error
Next
(caddr '(a b с))
(caaadr '(a (b c)))
(cdddr '(a b с))
(Abс)
Abc
A(1)2
member
, имеющей определение
при интерпретации выражений с указанными ниже аргументами:
x- (A B C), y - (A B C D),
результат Nil x – (A B C), y – (A B (C D)),
результат Nil x – (A (B)), y – (C (B) A),
результат T x – (A (B C)) y – (C A (B C) (A)),
результат T (lambda (y z) (map-el #'length (cons y z)))
(map-comp #'(lambda (y)(cons y y)) '(x) '(y))
(defun F(x y z) (map-comp #'* x (cons y z)))
(Nil e AL )
(T e AL )
(T (eval e AL ))
(grp '(1 2 (3)))
является верным. Функция (grp x)
имеет определение
(1 2 3)
(1 2 (3))
((1)(2)(3))
(1 (2 (3)))
(Cons '(A) Nil):
(A . Nil)
((Nil . Nil) . A)
((A))
(cons (cdr '(A B C)) (car '((D)))):
((car '(A B C)) (D))
( (B C) D)
(B C (D))
Assign,
имеющей определение
к следующим аргументам:
(map-el '#(car '(1 2 3)) '(1 2 3) '(4 5 6))
(defun f3 (xl) (map-el (lambda (x) (* x x )) 'xl))
(defun f(x y) (map-el #'(lambda (x1) (/ x1 y)) x))
(cons '(car '(A B) (car '(C D))))
:(A . C)
((car '(A B)) . C)
(pgrp '(1 2 3))
является верным. Функция (pgrp x)
имеет определение
((2 3))
(1 2 3)
(1 (2 (3)))
(CONS Nil 20)
(Nil)
(Nil . 20)
(Nil 20)
CONS
над двумя атомами является:((lambda (x y) (eq 'x 'y)) A 'A)
((lambda (z) (cons z 'x)) '(AB))
((lambda (x) (eq x 0)) (a b))
Cons
(входящей в состав определения sublis) при вызове функции sublis,
имеющей определение
при интерпретации выражений с указанными ниже аргументами:
al- ((C . A) (D . B)), y – (C D)
al- ((C . A) (D . B)), y – (C D)
al- ((C . A) (D . B)), y – (C D)
(car (eval (cdr '(a b c))))
(b с)
b
map-ap
, аргументами которого выступают следующие функции и списки, является правильным:
(map-ap #'cdr '((A B C) (A B (C))) ), результат (B C B C)
(map-ap #'* '(1 2 3)), результат (1 4 9)
(map-ap #'+1 '(10.0 7.0)), результат (11.0 8.0)
(1 2 3 4 5)
(1 . (2 3 . (4 5)))
(((1 . 2) . (3 . 4 . 5))
"(print выражение)"
и набрать в командной строке (load 'имяфайла) (eval (print(read)))
(let)
(intesection)
(print)
a
(car '(a b с))
car
clisp.exe –o filename
:(T Nil)
Nil
(Nil)
(NIL . NIL)
(Eq (A) (B))
(Atom (quote (A B C)))
(Cons '(a) ;(a b c))
(a 230 '3000)
, где a
– функция, 1 и 2 аргументы a
, где a
–имя функции a
, где a
–переменная (cond ((Atom 'a) 1) (T 0))
(car (cdr (cons x y))):
x
и y
, затем в порядке следования выполнены операции cons, cdr
и car
cons
, a затем в порядке следования к списку (x . y)
применены cdr
и car
. cons
, затем в порядке следования выполнены операция car
и cdr
. (union '(a b c) '(с a b))
будет получен (учесть порядок следования элементов итогового списка). Функция Union
имеет следующее определение:
(a b с)
(с a b)
(a b a b)
(a с b)
'i'
в списке 'x'
:(Cons a (quote BC)):
a
" не имеет значения BC
" не имеет значения (Atom)
(1 . 3)
Atom
((lambda (x) (cons x x)) 'A):
Lambda
X
связывается со значением A, выполняется однократное вычисление безымянной функции, строящей пару (A . A)
X
со следующими аргументами (порядок следования x y z):
x- (A B), y - (С), z - (A B D)
x- A, y - C, z - ((C) D)
x- Nil, y - A, z - (A B C)
x- T, y - T, z - (B A C)
apply,
входящая в состав интерпретатора:apply
, к ее аргументам – то и другое представлено как данные Лиспа map-el
:
(map-el caddr '(1 2 3 4))
(map-el #'+ '(1 2 3 4))
(map-el '+ '(1 2 3 4))
(map-el #'caddr '(1 2 3 4))
(defun f(x) (car x))
(Atom '(x y))
T
nil
(rplacd (car x) (cddr x))
, где x
– список (a b c d)
, является верным:(a с d)
(a b c a)
(a b a)
(a)
(cons 1 (cons 1 2))
:(Step (cons 1 (cons 1 2)))
(Step (cons 1 (cons 1 2)))
(Step (cons 1 (cons 1 2)))
(Nil . 1)
(1 T)
T . Nil
(ab123)
((lambda (x y) (cons (cdr y) (car x))) '(a b c) '(a))
((defun f(x) (cons (cdr x) (car x )) '(a b c)))
((defun (x y) (cons (cdr x)) '(a b с))
Cons
(в определении append) при вызове функции append,
имеющей определение
при интерпретации выражений с указанными ниже аргументами:
x – (A B C), y – (1 2)
x – (1 ((2))), y – (a b c)
x – (a (b) c), y – (a b c d)
T
и Nil
T
(defun F(xl) (cond (T (cons (- (car xl) (car xl) ) (F (cdr xl))))))
(defun F(xl) (cond ((Null xl) Nil) (T (cons (- (car xl) (car xl)) (F (cdr xl))))))
(defun F(xl) (map-el (lambda (x) 0 ) xl)
(intersection '(a b c) '(a b d))
является верным. Функция intersection
имеет следующее определение:
(d c)
(b a)
(a b)
(Setf (get 'Атом) 'свойство)
(Setf (get "Атом") свойство)
(Setf "Атом" 'свойство)
(EQ (car '(())) (cdr'(T . Nil)))
, если да, то какой ответ является верным:False
T
(defun f (x) (f (car x)))
(defun f (x) (cond ((Atom x) x)(T (f (car x)))))
(defun f (lambda (x) (cond (T ( * x (f (- x 1 ))) ) ) ))
(a . Nil)
(Nil . Nil)
(ab . (b1 . c2))
3 . Nil
> (a )
:(a)
есть недопустимая конструкция "abc_def_ghi"
'abc_def_ghi
" abc_def_ghi "
(a . b c d e)
(a . b .( c d e))
(((a . b) . c) d e)
(lambda () x)
;x
(lambda (x) x)
"x"
(symbol-function )
(symbol-value )
(symbol-plist)
Defun
(порядок следования аргументов должен быть показан правильно):(cdr '(( a b) c d)):
(с d)
(d)
(b c d)
"if ((a + b) = 3) then print (a) else print (b)"
на языке Лисп:(cond ((= (+ a b) 3) print a) (else print b))
(cond ((= (+ a b) 3) (print a)) (T (print b)))
(cond (( a + b) = 3) (print a)) (T (print b)))
(defun f(x y) (car (cons x (cdr y))))
((lambda (x,y) (car (cons x (cdr y)))) '(d c) '(d e))
(defun F(x,y) ((lambda (y) (car y)) x) )
(quote True)
и 'True
Nil
и (Nil Nil)
Nil
и (Quote Nil)
(car 'abc)
и (car abc)
(car 'abc)
и (car (quote abc))
("слово1 слово2 словоN")
слово1 слово2 словоN
;"слово1 слово2 словоN"
(слово1 слово2 словоN)
"(слово1 слово2 словоN)"
(eval f (x y))
и (apply (f x y))
(eval (f x y))
и (funcall f x y)
(eval '(f x y))
и (funcall f x y)
(eval '(f 'x 'y))
и (funcall f x y)
(x )
(append x)
(funcall x)
(defun f(x) (x))
Cond
rplacd
lambda
caddr
Cons 'a 'BC:
(A B (C) D)
(A . (B . (C . Nil) . D) )
(A . (B . ((C . Nil)) . D) )
(A . (B . ((C . Nil) . (D . Nil))))
(defun f(x) (f (cdr x)))
(defun F(x) (cond (F (cdr x)) ((atom x) x) ))
(defun F(x) (cond ((Null (cdr x)) (car x)) (T (F (cdr x)) )) )
((QUOTE T) (QUOTE NIL))
второго (вложенного) Cond
функции Equal,
имеющей определение
при интерпретации выражений с указанными ниже аргументами:
(a1 b1)
и (a1 b1)
(a (b))
и (с d)
(a b)
и ((c) (b))
(a1 b1)
и (a1 c1)
(cdar '((A) B) )
(cddr '(A . Nil))
(cddr '(A B . C))
(Caaadr '(A (B C)))
map-comp
, аргументами которого выступают следующие функции и списки, является правильным:
(map-comp #'* '(1 2 3) '((1 2) 4)), результат ((1 2) 8)
(map-comp #'/ '(1 2) '(2 2)), результат (1/2 1)
(map-comp #'+ '(1 2 3) '(1 2)), результат (2 4)
(map-comp #'/ '(1 2) '(2 2)), результат (0.5 .1.0)
(let ((a (car x)) (b (car y))) a b):
"a"
и "b"
на "(car x)"
и "(car y)"
Let
) повторяющихся подвыражений "(car x)"
и "(car y)"
на "a"
и "b"
" x"
и "y"
на "a"
и "b"
eval
(rplaca (cdr x) (car x))
, где x
– список (a b c d)
, является правильным:(b c d)
(b c d a)
(a a)
(a с d)
(caaaaaar '(a b с))
(caadr '(a (b c)))
(cdar '(a (b)))
(var A)
123A
A123
member,
имеющей определение
при интерпретации выражений с указанными ниже аргументами:
x- ((A) B C), y - (A B C D)
, результат T x – (B C D), y – (A (B C D))
, результат T x – ((A B)), y – (C A)
, результат T y – (A (B) C) y – (C (B) C A)
, результат T (quote Atom)
воспринимается интерпретатором как:(map-comp #'(lambda (x y) (* x y)) '(1 2) '(3 4))
(defun F(x y) (map-el #'* (cons x (cons y y))))
(map-el #'(lambda (y)(cons x y)) x))
(e AL )
(T e AL )
(Nil (eval e AL ))
(grp '(1 2 3 4))
является верным. Функция (grp x)
имеет определение
(1 2 3 4)
(1 2 3)
(1 (2 3))
(1 (2 (3)))
(Cons '(A) '(A)):
((A) A)
(A . (A))
(A . A)
(cons (car '(A B)) '((D))):
(A (D))
(A . ((D . Nil) . Nil))
(A D)
Assign,
имеющей описание
к следующим аргументам:
(map-comp #'car '((1)( 2)(3)) '((4) (5) (6)))
(defun f(x y) (map-comp #'(lambda (x1 y1) (* (car x1) (car y1))) x y))
(defun f(x y) (map-el #'(lambda (x1) (cons x1 y)) x))
(cons '(car '(A B)) '(car '(C D)))
:(A . C)
((car '(A B)) . (car '(B C)))
(pgrp '(1 2 3 4))
является верным. Функция (pgrp x)
имеет определение
(1 (2 3 4))
(1 2 3 4)
((2 3 4))
(CONS 20 'abc)
(abc . 20)
(20 . abc)
CDR
над списком является:((lambda (x) (atom 'x)) 1)
((lambda (z) (cons z x)) '(A) 'B))
((lambda (x y) (cons x 'a)) '(a b))
Cons
(входящей в состав определения sublis) при вызове функции sublis,
имеющей определение
при интерпретации выражений с указанными ниже аргументами:
al- ((A .1) (B . 2)), y – (C . 3)
al- ((A .1) (B . 2)), y – (C . 3)
al- ((A .1) (B . 2)), y – (C . 3)
(cddr (eval '(cdr '(a b c))))
(b с)
b
Nil
map-ap
, аргументами которого выступают следующие функции и списки, является правильным:
(map-ap #'cdr '((A B C)) ), результат (B C)
(map-ap #'cdr '(1 2 3)), результат ((2 3) (3) nil)
(map-ap #'car '(10.0 7.0)), результат (nil nil)
(1 2 3 . 4 5 )
(1 2 3 4 . (5))
(((1 . nil) . nil) 3 4 5)
(Let a 1)
(set a 1)
(setq a 1)
(load 'filename)
(eval (read 'filename))
(f 'x 3)
означает то, что:f
для двух аргументов 'x
и 3
, данные " x
" и "3
" подаются в функцию в качестве значений аргументов f,
аргументом которой является результат вызова функции x
с аргументом 3 (x y z 5)
(x y z)
(5 x y)
(y z 5)
clisp.exe @file.par
file.par
file.par
(Атом . Nil)
(Atom)
Atom
(Cons (Quote (A B С)) 'B)
(Atom Cons (Quote A B C))
(Eq 'A B)
(1 2 3)
(a b c)
, где a
– функция, b
и c
переменные a
, где a
– имя функции a
, где a
–переменная (quote a)
(f (cdr x))
, где f
– функция (defun f (y) (car y))
:f
в системе, получено значение переменной x
, затем вычислена функция (cdr x)
и (car y)
f
в системе, затем получено значение (cdr x)
и вычислена функция (car x)
(cdr x)
, затем поиск определения функции f
в системе, связь результата (cdr x)
с именем локальной переменной y
и вычисление (car y)
(union '(a b c) '(1 a a)),
функция union
имеет следующее определение:
(1 a b c)
(с a a b 1)
(b с 1 a a)
(a с b 1)
'i'
списка 'L'
:Lisp
(Lisp)
('Lisp)
(Lisp . Lisp)
(defun f(x)(cons x x)):
f
связывается с ее определением, и будет доступно далее при работе с интерпретатором f
связывается с ее определением и будет доступно только один раз после вычисления указанной формы f
связывается с ее определением, но данная форма не вычислима, т.к. не указано значение переменной x Cons
при вызове функции subst,
имеющей определение
со следующими аргументами (порядок следования x y z):
x- (A B), y - (С D), z - (A B C D)
x- A, y - B, z - C
x- (1 2), y - A, z - (A B C)
x- (1 2), y - A, z - (B A C D)
apply,
входящая в состав интерпретатора:(quote ..)
и '…
. apply
, к ее аргументам – то и другое представлено как данные Лиспа map-el
, аргументами которого выступают следующие функции и списки, является правильным:
(map-el #'car '(1 (2) 3)), результат - (1)
(map-el #'car '(1 (2) 3)), результат - (1 2)
(map-el #'cdr '(1 (2) 3)), результат - (2)
(map-el #'car '((1) (2 3))), результат - (1 2)
(map-el #'length '(1 (2) 3)), результат - (1 2)
(cond ((Eq x y) (print x)) (T (print y)) )
(Eq (x y))
(eval '(car x))
nil
(rplacd (cddr x) (car x))
, где x
– список (a b c d)
, является верным:(b c d a)
(a b c a)
(a b a)
(a)
Step --->
(выражение) означает:step
(())
(Nil . Nil)
A
('A 'B)
((defun (x , y) (cons (cdr x) y))
((lambda (x) (cons (cdr x) (car x))) '(a b c))
(defun f(x) (atom (car x )))
Cons
(в определении append) при вызове функции append,
имеющей определение
при интерпретации выражений с указанными ниже аргументами:
x – (cons A B), y – (car (1 2))
x – (cons 1 2), y – (2)
x – (cons (1 2)), y – (a b c d)
T
и Nil
(defun F(xl) (cond (xl (cons (* (car xl) (car xl) ) (F (cdr xl))))))
(defun F(xl) (cond ( (T (cons (* (car xl) (car xl)) (F (cdr xl))))))
(defun F(xl) (map-el (lambda (x) (* x x)) xl))
(intersection '(a b c) '(с a b))
является верным. Функция intersection
имеет следующее определение:
(a b с)
(с a b)
Nil
(Setq (get Атом) 'свойство)
(Setq Атом 'свойство)
(Setf (get 'Атом) 'свойство)
(eq '(Nil) (atom '(T)))
, и укажите причину, почему это так:'(nil)
это список T
, т.к. предикат atom выдаст значении Nil
T
, т.к. '(Nil)
и '(T)
являются атомами Nil
, т.к. форма (eq '(Nil) (atom '(T)))
сведется к вычислению (eq '(Nil) Nil)
Nil
, т.к. форма сведется к вычислению (EQ Nil T)
является верной:
{ (COND ((= N 0 ) 1 ) (T ( * N (Факториал (- N 1 ))) ) },
выделение параметров {n = 1},
немедленный выбор второй ветви cond {(T ( * N (Факториал (- N 1 ))) ) },
вычисление этого предиката и переход ко второму шагу рекурсии { (COND ((= N 0 ) 1 ) (T ( * N (Факториал (- N 1 ))) ) },
выделение параметров {n = 1},
перебор предикатов, вычитание единицы {N=N-1}
, вычисление первого предиката {((= N 0 ) 1 ), ответ 1}.
{ (COND ((= N 0 ) 1 ) (T ( * N (Факториал (- N 1 ))) ) },
выделение параметров {n = 1},
перебор предикатов, выбор первой ветви {((= N 0 ) 1 )}
, вычисление функции =, вычисление предиката (Nil 1),
т.е. переход ко второй ветви, выбор второй ветви cond {(T ( * N (Факториал (- N 1 ))) ) },
вычисление этого предиката и переход ко второму шагу рекурсии > abcdefg
:abcdefg
является именем переменной, не находящейся в ассоциативном списке abcdefg
является именем переменной, находящейся в ассоциативном списке "строка
'строка
"строка"
(a b c d e . nil)
(a b ( c d . e))
(((a . b) . c) d e)
(quote x)
'x
(lambda () x)
(defun f(x) x)
(symbol-function )
(symbol-value )
(function-symbol)
Defun
в порядке следования это:(cdr '( a (b c) d)):
(b c)
(a b c d)
((b c) d)
"if (a>b) then print (a) else print (b)"
на языке Лисп:(cond ((> a b) print a) (else print b))
(cond ((> a b) (print a)) (T (print b)))
(cond ((< a b) (print a)) ((> a b) (print b)))
(defun (x,y) (car (cons x (cdr y))))
((lambda (x y) (car (cons x (cdr y)))) '(1 2) '(2 3))
(defun F(x) ((lambda (y) (car y)) x) )
T
и 'T
Nil
и False
Nil
и (Quote Nil)
(Eq)
и '(Eq)
T
и True
("(abcd)")
"abcd"
(abcd)
12345678910111213141516117
(append f (x y))
и (funcall f (x y))
(apply f (x y))
и (funcall f x y)
(eval f (x y))
и (funcall f x y)
(eval '(f x y))
и (funcall f x y)
при учете, того, что (defun f(x y) (cons x y))
был вызван ранее (x )
(eval x AL)
, где AL
-ассоциативный список (lambda (x) (x) x)
(defun f(x) (x))
Cons
Eq
cdr
rplacd
(Cons 'a 'BC
:(A . B . C)
и (A B C)
соответственно:(A . B . C)
и (A (B C))
(A . (B . C))
и (A B C)
(A . (B . (C . Nil)))
и (A B C)
(defun f(x) (f (car x)))
(defun F(x) (cond (F (car x)) ((atom x) x) ))
(defun F(x) (cond (((atom x) x) (T (F (car x)) )) )
Cond
функции Equal,
имеющей определение
при интерпретации выражений с указанными ниже аргументами:
(a b)
и (c d)
(a (b))
и (с d)
(a b)
и (c b)
(a b)
и (a c)
(caar '((A) B) )
(car '(A))
(car 'A)
(Caar '(A B C))
map-comp
, аргументами которого выступают следующие функции и списки, является правильным:
(map-comp #'car '(1 2 3) '((1 2) 4)), результат ( 1 (1 2))
(map-comp #'cdr '(A B C) '(A B (C))), результат (B (C))
(map-comp #'* '(1 2 (3)) '(2 3 5)), результат (2 6 8)
(map-comp #'/ '(10.0 7.0) '(5 2)), результат (2 3.5)
Let
:eval
(rplaca '(e f) (car x))
, где x
– список (a b c d)
, является верным:(a e f)
(a b c d e f)
(a f)
(a b c d)
(a d e)
Next
Break
. 'e
списка ((a b cd) ((e f) g)):
(cadr 'выражение)
(caddr выражение)
(caaadr 'выражение)
(cdr (cdr (car (выражение))))
(car (car (car (cdr 'выражение))))
(A)
'A
Adcdefj
member,
имеющей определение
при интерпретации выражений с указанными ниже аргументами:
x- (A B C), y - (A B C D)
, результат T x – (A B C), y – (A B (C D))
, результат T x – (A (B)), y – (C (B) A)
, результат Nil y – (A (B) C) y – (C A (B) C A)
, результат T (lambda (x y z) (map-el #'length (cons x (cons y z))))
(defun F(x y z) (map-el #'* (cons x (cons y z))))
(map-el #'(lambda (y)(cons y y)) '(x))
(Nil e AL )
(T e AL )
(T (eval e AL ))
(grp '((1 2) 3))
является верным. Функция (grp x)
имеет определение
((1 2) 3)
((1 2) (3 nil))
((1)(2)(3)(nil))
(1 (2 (3)))
(Cons 'Nil '(A)):
(Nil . (Nil . A))
(Nil A)
(A . Nil)
(Nil . A)
(cons (car '(A B C)) 'D):
((car '(A B C)) D)
(A D)
((A) D)
(A . D)
Assign,
имеющей описание
к следующим аргументам:
(map-comp '#(car '(1 2 3)) '(1 2 3) '(4 5 6))
(defun f3 (xl) (map-el (lambda (x)(+ 10 (* x x x))) xl))
(defun f(x y) (map-el (lambda (x1 y1) (/ (car x1) (car y1)))))
(defun f(x y) (map-el (lambda (x y) (+ (car x) (car y)) x y)))
(funcall (cons 'car '('(C D)))):
C
(car '(C D))
(pgrp '((1 2) 3 4))
является верным. Функция (pgrp x)
имеет определение
((1 2) (3 4))
((1 2))
(( 3 4))
(CONS 10 12)
(10 . 12)
(22)
СAR
над списком является:((lambda (x y) (eq 'x 'y)) 'A 'A)
((lambda (z) (cons z 'x)) (AB))
((lambda (x y) (cons x 'a)) '(a b))
Cons
(входящей в состав определения sublis) при вызове функции sublis,
имеющей определение
при интерпретации выражений с указанными ниже аргументами:
al- ((C A) (D B))
, y – (C и D сидели на трубе) al- ((C A) (D B))
, y – (C и D сидели на трубе) al- ((C A) (D B))
, y – (C и D сидели на трубе) (cadr (eval '(cdr '(a b c))))
(b с)
(a)
c
(c)
map-ap
, аргументами которого выступают следующие функции и списки, является правильным:
(map-ap #'cdr '((A B C) (A B (C))) ), результат (B C B (C))
(map-ap #'* '(1 2 3)), результат (1 4 9)
(map-ap #'+ '(10.0 7.0)), результат (11.0 8.0)
((1) (2) (3 4) . (5))
(1 2 3 . (4 . nil) 5)
((1 . nil) (2. nil) (3 . nil) (4 . nil) (5 . nil) . nil)