Изволь.

Поставил clisp. Запускаю. А он и ругается сразу. Ну что это такое?

** - Ошибка в возможностью продолжения
DIRECTORY: Invalid byte sequence #xE0 #xA0 #xE4 in CHARSET:UTF-8 conversion
Если вы продолжите (введя 'continue'): Discard this directory entry
Имеются следующие варианты продолжения:
STORE-VALUE    :R1      Input a new value for *PATHNAME-ENCODING*.

Даже сложение двух чисел не написать

Поставил clisp ... Ну что это такое?

Это ошибка. Твоя. Ставь sbcl, emacs, slime.

Ну вот. А в случае с питоном можно ошибиться разве что в версии питона (да и то, в большинстве дистров (привет, арч) этот вопрос решается сам собой). Всякие python.net ставят только предумышленно. А какой из этих ваших лиспов самый правильный — хрен поймёшь.

А в случае с питоном можно ошибиться разве что в версии питона

Вот и подтянулись любители связываний, дисциплины, унижения и подчинения.

Всякие python.net ставят только предумышленно.

Ты не поверишь ...

А какой из этих ваших лиспов самый правильный

дык, это от критериев правильности зависит. А они от задачи к задаче могут разниться. Также, собственно, как линуксячьи дистрибутивы.

Отличный код. Главное рабочий. В стиле лисперов

[1]> (defun transpose (lists)
(mapcar #'(lambda (row) (funcall #'list row)) lists))
TRANSPOSE
[1]> (transpose (list (list 1 2 3) (list 4 5 6) (list 7 8 9)))
(((1 2 3)) ((4 5 6)) ((7 8 9)))

Всё правильно. А чем ты не доволен?

Ну и где здесь транспонирование матрицы? ТС подает на вход список списков. Я подал на вход список списков. Я не получил транспонированную матрицу.

А кто тебе сказал, что этот код должен матрицы транспонировать? о.О

Ты наркоман чтоли? Что ты тогда вообще сюда влез с каким-то левым кодом и сравнивал его с кодом топик стартера?

~% clisp
        i
. i i i I i i i i     ooooo    o        ooooooo   ooooo   ooooo
I I I I I I I I I    8     8   8           8     8     o  8    8
I I  \ `+' /  I I    8         8           8     8        8    8
I  \  `-+-'  /  I    8         8           8      ooooo   8oooo
 \  `-__|__-'  /     8         8           8           8  8
  `--___|___--'      8     o   8           8     o     8  8
        |             ooooo    8oooooo  ooo8ooo   ooooo   8
--------+--------

Добро пожаловать GNU CLISP 2.48 (2009-07-28) <http://clisp.cons.org/>

Copyright (c) Bruno Haible, Michael Stoll 1992, 1993
Copyright (c) Bruno Haible, Marcus Daniels 1994-1997
Copyright (c) Bruno Haible, Pierpaolo Bernardi, Sam Steingold 1998
Copyright (c) Bruno Haible, Sam Steingold 1999-2000
Copyright (c) Sam Steingold, Bruno Haible 2001-2009

Напечатайте :h и нажмите Ввод для получения справки.

[1]> (+ 1 2 3)
6
[2]> 

УМВР ЧЯДНТ?

Сложение двух чисел ты написал неправильно. У тебя 3 числа.

о, боги.

Ты лучше покажи код, какой хочет топикстартер.

В пайтоне, до тройки, присутствует ещё и оператор **

Май френд, не пугай меня так больше.))) В тройке это тоже есть.

alesh@alesh-comp:~$ python3
Python 3.1.2 (release31-maint, Sep 17 2010, 20:27:33) 
[GCC 4.4.5] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> def AA(**kw):
...   print(kw)
... 
>>> AA(a=60,b=70)
{'a': 60, 'b': 70}
>>> 

> имеют на выходе абсолютно одно и тоже - function object.

Как все запущено в пустой голове! Вовсе не одно и тоже. Разницу между замыканием и просто функцией не понимаешь? Вот и лошок гвидка тоже не понимает.

CL-USER> (defvar *A* '((1 2 3) (4 5 6) (7 8 9)))
*A*
CL-USER> *A*
((1 2 3) (4 5 6) (7 8 9))
CL-USER> (reduce (lambda (l1 l2) (mapcar (lambda (x y) (cons x y)) l1 l2)) *A* :from-end T :initial-value '(() () ()))
((1 4 7) (2 5 8) (3 6 9))

прошу обратить внимание на самодокументируемость кода. Он понятен любому,знакомому с обработкой списков. Нет никакой нужды в сакральном знании типа «если у нас * в определении, то одно, а если оно же в вызове --- то другое и когда мы код в [] заключаем, то должен быть такой-то эффект». Пустое всё это.Пустое и не нужное.

Странно что не понимает если о этих различиях в доках написано и в учебниках Python в главе о ФП %)

А що за *A*?

>(reduce (lambda (l1 l2) (mapcar (lambda (x y) (cons x y)) l1 l2)) *A* :from-end T :initial-value '(() () ()))

Очень понятная строка) С A вопрос снят

Интересно, а это я для кого писал?

CL-USER> (defvar *A* '((1 2 3) (4 5 6) (7 8 9)))
*A*
CL-USER> *A*
((1 2 3) (4 5 6) (7 8 9))

Когда ты дашь рабочее решение, вместо огрызка?

[1]> (defvar *A* '((1 2 3 4) (5 6 7 8) (9 10 11 12)))*A*
[2]> (reduce (lambda (l1 l2) (mapcar (lambda (x y) (cons x y)) l1 l2)) *A* :from-end T :initial-value '(() () ()))
((1 5 9) (2 6 10) (3 7 11))

Очень понятная строка

Видать ты из тех бедняг, чей мозг необратимо изнасилован бэйсиком.

>> имеют на выходе абсолютно одно и тоже - function object.

Как все запущено в пустой голове! Вовсе не одно и тоже.

Читать научись.

Разницу между замыканием и просто функцией не понимаешь?

Объясни. Потом объясни разницу между замыканием и вложенной функцией.

Что за бред? Если сомневаетесь - посмотрите исходники.

а теперь оцени сложность своего решения.

Браво. Крутой лисцпер обосрался дважды.

оцени сложность своего решения.

Около нуля. Писалось вообще без участия мозга. Буквально, вспомнил что такое транспонирование матрицы и один в один записал это в repl. проверил, работает, поместил на лор. Ты обратил моё внимание на косяк с размерностью --- моментом вылечил и это. Лисп --- очень естественный для мышления человека ЯП.

>Около нуля.

Отличная оценка. Какую матрицу не дай, посчитает мгновенно. Отличный язык этот ваш лисп.

> Крутой лисцпер

Он явно нуб.

Твой код опять не рабочий. Откуда *B*? Но ничего я сам поправил

И что характерно, это можно делать не выходя из отладчика.

Отличный язык этот ваш лисп.

рад, что ты это понял.

Итого:

def transposed(lists):
   if not lists: return []
   return map(lambda *row: list(row), *lists)

;; с 4 попытки
(defun transpose (l)
           (let ((length (length (car l))))
             (reduce (lambda (l1 l2) (mapcar (lambda (x y) (cons x y)) l1 l2)) l :from-end T :initial-value (make-list length :initial-element '()))))
[/lisp]

>И что характерно, это можно делать не выходя из отладчика.
Ну и кого этим сейчас удивишь?

Check this out:

[1]> (defun transpose (x)
   (apply #'mapcar (cons #'list x)))
TRANSPOSE
[2]> (transpose '((1 2 3) (4 5 6)))
((1 4) (2 5) (3 6))
[3]>

И сравни со своей корявой портянкой.

Итого:

def transposed(lists):
   if not lists: return []
   return map(lambda *row: list(row), *lists)

(defun transpose (l)
           (let ((length (length (car l))))
             (reduce (lambda (l1 l2) (mapcar (lambda (x y) (cons x y)) l1 l2)) l :from-end T :initial-value (make-list length :initial-element '()))))

И что характерно, это можно делать не выходя из отладчика.

Ну и кого этим сейчас удивишь?

1. Мне кажется, при такой любви к синтаксическому сахару, тебе должен нравиться Ruby.

2. Да, получилось объёмнее. Зато код проще, а это гораздо важнее.

посмотри на код baverman, горе-лиспер.

Ты думал. Это читерство.

ахахаха, правильно главное хорошая мина при плохой игре :D

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

> выигрыш относительно небольшой - 6.0 с izip против 6.9 с zip.

ничего себе небольшой… So typical…

Небольшой относительно типичного прироста производительности от использования функций, работающих с итераторами из модуля itertools против их «обычных» аналогов (которые работают с копиями). Почему? Потому что в данном случае мы все равно создаем конечную структуру чтобы вернуть список.

Что, больше не к чему привязаться было что ли? Даже странно. Try harder.

all hail parentheses

(define (trans matrix)
        (apply map list matrix))

на лицо 13%. Не 0.1%, 1%, а целых десять. Нет, конечно я понимаю что у нас по два гигагерца, три ядра и два гигабайта памяти…

Ты ничего не понимаешь. Лисп победил два раза, показав, что на нём можно писать тупо и в лоб, вообще не задумываясь о коде, просто записывая свои мысли как есть, а если голову к процессу всё-таки приложить, то получается очень красиво и лаконично.

В CL-то есть apply? ^^'

Есть и apply и funcall.

(defun transpose (x)
   (apply #'mapcar (cons #'list x)))

И отлично. Красивее, удобнее, компактнее этого что-то придумать сложно.

> Лисп победил два раза, показав, что на нём можно писать тупо и в лоб

где-то этого делать нельзя?

если голову к процессу всё-таки приложить, то получается очень красиво и лаконично

ну в общем да, только ты и лисп-то тут при чем? у тебя получилась работающая невнятная байда только с 3-го(!) раза.