(defun F (L)

 (if L

  (let

   ((elem (car L)))

   (mapcar '+

    (if (atom elem)

     (cond

      ((minusp elem) (list 1 0 0))

      ((zerop elem) (list 0 1 0))

      ((plusp elem) (list 0 0 1))

      (T (list 0 0 0)))

     (F elem))

    (F (cdr L))))

  (list 0 0 0)))

«...отказывается работать...» - какие симптомы?

(F '(1 (-4 0 5) 3 0 (-1 4))) возвращает (2 2 4)
(F '(1 2 3 (1 2) -1 0)) возвращает (1 1 5)

Можно, но скучно

(defun F (L)

 (mapcar

 '(lambda (p) (F0 L p))

 '(minusp zerop plusp)))

(defun F0 (L P)

 (if L

  (+

   (if (atom (car L))

    (if (funcall P (car L)) 1 0)

    (F0 (car L) P))

   (F0 (cdr L) P))

  0))

С моей точки зрения, в списке ((a11 a12 ... a1n) (a21 a22 ... a2m) ... (ak1 ak2 ... akp)) элементы (a11 a12 ... a1n), (a21 a22 ... a2m) ... (ak1 ak2 ... akp) и есть именно подсписки.
Оба варианта пригодны для такого списка (как и для любого другого).

и ещё такой вопрос... мне если честно уже даже стыдно спрашивать.. просто нам необходимо сделать работу по определенному образцу, поэтому я собственно и спрашивал как сделать через отдельные функции.. примерно так:

(defun Positive(number)

(cond

	((> number 0) number)

	(t 0)

))

 

(defun PositiveSumm (list)

(cond

	((NULL list) 0)

	((ATOM (CAR list))

		(+ (Positive(CAR list))			(PositiveSumm (CDR list))

		)

)

	(T (+ (PositiveSumm (CAR list))

				(PositiveSumm (CDR list))

				)

		)

))

 

(defun Negative(number)

(cond

	((< number 0) number)

	(t 0)

))

 

(defun NegativeSumm(list)

(cond

	((NULL list) 0)

	((ATOM (CAR list))

		(+ (Negative(CAR list))			(NegativeSumm (CDR list))

			)

		)

	(T (+ (NegativeSumm (CAR list))			(NegativeSumm (CDR list))

				)

		)

))

 

(defun Null(number)

(cond

	((= number 0) number)

	(t 0)

))

 

(defun NullSumm(list)

(cond

	((NULL list) 0)

	((ATOM (CAR list))

		(+ (Null(CAR list))			(NullSumm (CDR list))

			)

		)

	(T (+ (NullSumm (CAR list))			(NullSumm (CDR list))

))))

 

(defun NullPositiveNegativeSumm(list)

	(list (PositiveSumm list)

		(NegativeSumm list)

		(NullSumm list)

	))

что мне нужно изменить в функциях NegativeSumm, PositiveSumm, NullSumm, чтобы он считал не сумму, а количество?

Цитата

---

VH :
Количества отрицательных, положительных и нулевых элементов функция (F) <в обоих вариантах> находит.
Величины b и c - это суммы элементов "по строкам" и "по столбцам"?

---

Если честно я не уверен, потому что постановка задачи не совсем понятна для меня... но исходя из логики - да, это суммы элементов по строкам и столбцам... Но это ещё необходимо уточнить... я не могу сказать уверенно... я надеюсь в ближайшее время уточню..
Судя по всему просто либо я недопонял задачу либо, преподаватель просто не ясно обьяснил

Если эти величины b и c, не используются в задаче, то получается что вторая задача ничем не отличается от первой, как вы уже сказали...


Но пока, что вы можете сказать по первой задаче? что я выше написал? как можно преобразовать?
просто у нас действительно придираются к таким вещам
И ещё раз СПАСИБО Вам за Вашу отзывчивость!

Вот так над нами издеваются...
Мало того что задачи ставят невнятно, так ещё и реализовывать заставляют так, что запутаться как пить дать... Вот собственно и опять я немного в недоумении...
Но, да ладно... буду разбираться ещё обращусь к Вам за помощью, если Вы не против


Что то я никак не пойму, что Вы в последнем сообшении написали, и как это применить к моей задаче..?

Прошу прощения за мою глупость, это значит я что то не правильно делаю... компилируется он хорошо, но вот когда пытаюсь запустить, выдает ошибку снова... можете проверить пожалуйста?

(defun Positive (number)

 

 (if (> number 0) 1 0))

 

(defun Positive (number)

 

 (cond

 

  ((> number 0) 1)

 

  (T 0)))

 

(defun Negative (number)

 

 (if (< number 0) 1 0))

 

(defun Negative (number)

 

 (cond

 

  ((> number 0) 1)

 

  (T 0)))

 

(defun PositiveNegative(list)

	(list (Positive list)

		(Negative list)

	)

)

CL-USER 13 > (POSITIVENEGATIVE '(1 2 3 -1 -2 0))

Error: In > of ((1 2 3 -1 -2 0) 0) arguments should be of type REAL.
1 (continue) Return a value to use.
2 Supply a new first argument.
3 (abort) Return to level 0.
4 Return to top loop level 0.

Type :b for backtrace or :c <option number> to proceed.
Type :bug-form "<subject>" for a bug report template or :? for other options.


что это значит и как это исправить? метод научного тыка не помог... пробовал

Или нужно как то иначе прописать эту последнюю функцию?)

Цитата

---

VH :
В сообщении #5173 два ВАРИАНТА функции (Positive).
В определении Вашей функции (PositiveNegative) следует выполнять вызовы функций (PositiveSumm) и (NegativeSumm).

---

Да, Вы правы... это моя ошибка по не внимательности, или по не знанию...
Огромное Вам человеческое СПАСИБО за помощь!

По поводу второй части задания, я к Вам обращусь попозже, если Вы не против конечно?

Количества элементов "по столбцам":

(defun F (L)

 ((lambda (trim)

   (if trim

    (cons

     (F0 (mapcar #'car trim))

     (F (mapcar #'cdr trim)))))

  (remove nil L)))

(defun F0 (L)

 (if L

  ((lambda (elem)

    (mapcar #'+

     (cond

      ((minusp elem) (list 0 0 1))

      ((zerop elem)  (list 0 1 0))

      ((plusp elem)  (list 1 0 0))

      (T (list 0 0 0)))

     (F0 (cdr L))))

   (car L))

  (list 0 0 0)))

Добрый день!

У меня снова возникла проблема с этим заданием... скажите я что то не так делаю?


CL-USER 17 > (F0 '((1 2 3) (0 1 0) (-1 -1 0)))

Error: In MINUSP of ((1 2 3)) arguments should be of type REAL.



И вопрос... можно ли каким то более простым языком написать эти функции? используя скажем, только какие то базовые знания?

Подскажите пожалуйста что не так... и ещё раз спасибо за помощь!

Извините меня за мою глупость или непонимание...

Мне кажется что мы с Вами просто не допоняли друг друга, или я просто не понимаю как правильно вызывать эти функции...

Давайте разберемся... Задача состоит в следующем:

У нас дан список-"матрица", состоящий из n-ного количества подсписков (как на картинке в сообщении выше), которые в свою очередь могут состоять только из атомов!.
Нам необходимо посчитать кол-во положительных, отрицательных и нулевых элементов, в каждой строке "матрицы" (получается в каждом подсписке), и в каждом столбце "матрицы".
В результате у нас должно получится два списка:
1. Список для строк - состоящий из подсписков (каждый подсписок соответствует одной строке)
2. Список для столбцов - состоящий также, из подсписков (каждый подсписок соответствует одному столбцу)

На примере это выглядит примерно следующим образом:

(( 1 2 -1 0 3)
(-1 0 -3 2)
( 2 1 0 -1)
(0 -1 2))

В данном случае:
По строкам: b1=(3 1 1), b2=(1 1 2), b3=(2 1 1), b4=(1 1 1), общий ответ список ((3 1 1) (1 1 2) (2 1 1) (1 1 1))
По столбцам: c1=(2 1 1), c2=(2 1 1), c3=(1 1 2), c4=(1 1 1), c5=(1 0 0), общий ответ список ((2 1 1) (2 1 1) (1 1 2) (1 1 1) (1 0 0))

В конечном результате, должно получится два списка как показано выше...

((3 1 1) (1 1 2) (2 1 1) (1 1 1))
((2 1 1) (2 1 1) (1 1 2) (1 1 1) (1 0 0))



Или я просто не правильно понял как нужно вызывать эту функцию, и это привело к недопониманию между нами...
Потому как, если допустим я ввожу
(F0 '(1 2 3
0 1 0
0 -1 -1))

Он считает полностью всё... и выдает следующий результат (4 3 2)

Простите меня за нервотрепку, просто мне действительно необходимо разобраться, что к чему и как...

И да, вы правы, скорее всего не стоит ничего "упрощать" (что в конечном итоге может все наоборот усложнить)...

Да, действительно, теперь всё встало на свои места
Я наверное просто запутался в трех деревьях как говорится....

Спасибо Вам огромное за Вашу отзывчивость и помощь!
Вы мне действительно безумно помогли... буквально жизнь спасли!

З.Ы. О нервотрепке я говорил к тому, что меня бы на Вашем месте наверно уже достало бы вдалбливать кому то, что и как работает и что по чем... да ещё при этом и делать все за другого...

Если бы я мог Вас как то отблагодарить?

З.Ы.Ы. Хоть у меня ещё есть и третье задание, но с ним я уже постыжусь к Вам обращаться, Вы на меня итак слишком много времени потратили. на мой взгляд

Премного благодарен за помощь и понимание!

(defun foo(L)

  (let ((C (make-hash-table)))

    (labels ((ret (L)

      (cond

        ((null L) nil)

	((null (car L)) (cons '() (ret (cdr L))))

	((listp (car L))

	  (let ((ret-car-l (ret (car L))))

	    (if (null ret-car-l)

	      (ret (cdr L))

	      (cons ret-car-l (ret (cdr L))))))

	(T (if (gethash (car L) C)

	     (ret (cdr L))

	     (progn

	       (setf (gethash (car L) C) 1)

	       (cons (car L)(ret (cdr L)))))))))

    (reverse (ret (reverse L))))))