1. Python / Говнокод #7701

    −91

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    def delta( listToDelta ):
      result = []
      lastItem = listToDelta[0]
      for i, item in enumerate(listToDelta):
        if i == 0:
          result.append(item)
        else:
          result.append(item-lastItem)
        lastItem = item
      return result
    
    l = [2, 4, 6, 9, 7]
    print(l)
    l = delta(l)
    print(l)

    Всеми любимый Дениска (автор некоторых прошлых ГК на питоне) пошёл на поправку и написал не такое вонючее говно.
    Комментировать код до сих пор отказывается, но зато стал выбирать имена для переменных получше.

    Запостил: Fai, 30 Августа 2011

    Комментарии (31) RSS

    • К слову, удивило использование enumerate вместо i+=1 в цикле.
      Ответить
    • в остальном заметно С-(императивное) мышление. А такие языки, как Питон или Руби заставляют мыслить не операторами, а... "блоками", что ли... Всмысле, не КАК сделать, а ЧТО сделать :)
      Ответить
      • c-style - 100500 lines of code
        python-style - universal_function('delta-encode')
        Ответить
      • Функциональные языки приучают мыслить отображениями множеств и теорией категорий. Прикладной ФункАн...
        Ответить
      • Мыслить, мыслить...
        (defun stupid-delta (l) (cons (car l) (mapcar #'- (cdr l) l)))
        Понятно, какой язык приучает: а) думать, б) думать алгоритмами.
        Ответить
        • Ну ладно, я ж про haskell пошутил:
          moreStupidDelta [] = []
          moreStupidDelta l@(x:xs) = x : zipWith (-) xs l
          Ответить
          • Я примерно про тоже: haskell'ю требуется раза в два больше строчек, причем по смыслу половина из них не нужны )
            Ответить
            • Ага, а на пустом списке ваш mapcar не упадёт? Скобочек, опять же, меньше. Хотя я против Lisp ничего не имею. Сам балуюсь elisp.
              Ответить
              • Нет, на пустом списке не упадет. Вернет `(NIL). Так устроены car, cdr и mapcar. Mapcar не мой, mapcar был задолго до меня.
                Опыт C++0x показывает, что пусть уж лучше скобочки берут числом, чем разнообразием )
                Ответить
                • Да, действительно, работает :) И всё же Haskell мне нравиться больше из-за строгой типизации и чистоты. Pattern matching, опять же.
                  Ответить
          • [x-y for x,y in zip(listToDelta,[0]+listToDelta)]
            Ответить
            • Всё равно две строчки нужно:
              def delta(listToDelta):
                  return [x-y for x,y in zip(listToDelta, [0] + listToDelta)]
              Ответить
              • def delta(listToDelta): return [x-y for x,y in zip(listToDelta, [0] + listToDelta)]

                или
                delta = lambda listToDelta: [x-y for x,y in zip(listToDelta, [0] + listToDelta)]
                Ответить
        • > Понятно, какой язык приучает: а) думать, б) думать алгоритмами.
          Питон и только он.
          Ответить
    • >>> l = [2, 4, 6, 9, 7]

      >>> # Результат выполнения авторского говнокода:
      >>> print delta(l)
      [2, 2, 2, 3, -2]

      >>> # Как оптимально
      >>> print [x2-x1 for x1, x2 in zip([0]+l, l+[0])][:-1]
      [2, 2, 2, 3, -2]

      >>> # Можно ещё так:
      >>> from operator import sub
      >>> print map(lambda x: -sub(*x), zip([0]+l, l+[0])[:-1])
      [2, 2, 2, 3, -2]

      >>> # Вот так делать не надо, мне было интересно поломать голову над использованием reduce:
      >>> print reduce(lambda x,y: [y-x,y] if type(x)==int else x[:-1]+[-x.pop()+y,y],[0]+l)[:-1]
      [2, 2, 2, 3, -2]
      Ответить
      • М-да, сам же и наговнокодил слегка :-/
        Вот оперативно исправленные версии...

        print [x-y for x,y in zip(l,[0]+l)]

        from operator import sub
        print map(lambda x: sub(*x), zip(l,[0]+l))

        print reduce(lambda x,y: [y-x,y] if type(x)==int else x[:-1]+[-x.pop()+y,y],[0]+l)[:-1]
        Ответить
        • Улучшил вариант с reduce:
          reduce(lambda x,y: x[:-1]+[-x.pop()+y,y],l,[0])[:-1]
          Ответить
      • И, наконец, самый красивый и адекватный вариант:
        from operator import sub
        from itertools import imap
        l = [2, 4, 6, 9, 7]
        d = imap(sub,l,[0]+l)
        print list(d)
        Ответить
    • >Дениска
      Кто это? (Не отвечайте. Вопрос риторический.)
      Ответить

    Добавить комментарий