Haskell — Говнокод.ру

Haskell / Говнокод #29250

+1

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

{-# LANGUAGE OverloadedStrings #-}
import qualified Data.Text.Lazy.IO as LIO
import GHC.IO.StdHandles
import Text.Regex.TDFA
import qualified Text.Regex.TDFA.Text.Lazy as RL
import Data.Array
import qualified Data.Text.Lazy as TL
import System.Environment
import System.Exit
import System.IO
import qualified Language.C.Syntax.Constants as CC
import Data.Char

printMatch t matches i =
    let (offset, len) = matches ! i in
    let offset' = fromIntegral offset in
    let len' = fromIntegral len in
    LIO.putStr $ TL.take len' $ TL.drop offset' t

printHead t matches =
    let (offset, len) = matches ! 0 in
    let offset' = fromIntegral offset in
    let len' = fromIntegral len in
    LIO.putStr $ TL.take offset' t

printTrail t matches =
    let (offset, len) = matches ! 0 in
    let offset' = fromIntegral offset in
    let len' = fromIntegral len in
    LIO.putStr $ TL.drop (offset' + len') t

need_capture_trail acc ".*" = (False, reverse acc)
need_capture_trail acc [] = (True, reverse acc)
need_capture_trail acc (c : rest) = need_capture_trail (c : acc) rest

getRE :: [String] -> Either String (RL.Regex, Bool, String)
getRE args =
    case args of
      (re_str : repl_str : _) ->
          let (trail_needed, re_str') = need_capture_trail [] re_str in
          let re_text = TL.pack $ CC.unescapeString re_str' in
          case RL.compile defaultCompOpt defaultExecOpt re_text of
            Right re ->
                Right (re, trail_needed, CC.unescapeString repl_str)
            Left err ->
                Left err
      _ ->
          Left "Regexp expected"

-- replacement :: TL.Text -> Int -> _ -> String -> IO ()
replacement _ _ _ [] = return ()
replacement t n_matches matches (c : rest)
    | ord c <= n_matches = do
           printMatch t matches (ord c)
           replacement t n_matches matches rest
    | True = do
        putChar c
        replacement t n_matches matches rest

exitError :: String -> IO ()
exitError msg = do
  hPutStrLn stderr msg
  exitWith (ExitFailure 1)

main :: IO ()
main = do
    args <- getArgs
    case getRE args of
      Right (re, trail_needed, repl) -> do
          t <- LIO.hGetContents stdin
          case RL.execute re t of
            Right (Just matches) ->
                do
                  let n_matches = snd $ bounds matches
                  -- print matches
                  printHead t matches
                  replacement t n_matches matches repl
                  if trail_needed then
                      printTrail t matches
                  else
                      return ()
            Right Nothing -> do
                exitError "Pattern not found"
            Left err -> do
                exitError err
      Left err -> do
         exitError err

Текст UNIX-way утилиты fed
Капча: p2ux

CHayT, 25 Апреля 2026

Комментарии (2)

Haskell / Говнокод #29229

0

1

ты гей!

storvus, 04 Февраля 2026

Комментарии (0)

Haskell / Говнокод #29225

0

01
02
03
04
05
06
07
08
09
10
11
12
13

# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.

if CONFIG['OS_ARCH'] == 'WINNT':
    DIRS += ['win']
elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
    DIRS += ['mac']
elif CONFIG['MOZ_WIDGET_TOOLKIT'] in ('gtk2', 'gtk3'):
    DIRS += ['unix']
else:
    DIRS += ['emacs']

2 часа пытался понять, почему ctrl+a работает как в терминале...
Это мёртвый код или пасхалка?

mittorn, 27 Января 2026

Комментарии (4)

Haskell / Говнокод #29215

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

(defun arange-user-shape-int (&key from to step (dtype :int64) shape rank)
  (nnl2.ffi:%int-arange from to step t shape rank dtype))
  
(defun arange-user-shape-float (&key from to step (dtype nnl2.system:*default-tensor-type*) shape rank)
  (nnl2.ffi:%float-arange from to step t shape rank dtype))  
  
(defun arange-auto-shape-int (&key from to step (dtype :int64))
  (nnl2.ffi:%int-arange from to step nil nnl2.ffi:*null* 1 dtype))

(defun arange-auto-shape-float (&key from to step (dtype nnl2.system:*default-tensor-type*))
  (nnl2.ffi:%float-arange from to step nil nnl2.ffi:*null* 1 dtype))
  
(defun arange-user-shape (from to step dtype indices)
  (multiple-value-bind (shape rank) (nnl2.hli:make-shape-pntr indices)
    (if (or (floatp from) (floatp to) (floatp step))
	  (if dtype
	    (arange-user-shape-float :from from :to to :step step :dtype dtype :shape shape :rank rank)
	    (arange-user-shape-float :from from :to to :step step :shape shape :rank rank))
		
	  (if dtype 
	    (arange-user-shape-int :from from :to to :step step :dtype dtype :shape shape :rank rank)
	    (arange-user-shape-int :from from :to to :step step :shape shape :rank rank)))))

(defun arange-auto-shape (from to step dtype)
  (if (or (floatp from) (floatp to) (floatp step))
    (if dtype 
	  (arange-auto-shape-float :from from :to to :step step :dtype dtype)
	  (arange-auto-shape-float :from from :to to :step step))
	  
	(if dtype  
      (arange-auto-shape-int :from from :to to :step step :dtype dtype)
      (arange-auto-shape-int :from from :to to :step step))))

(defun arange (&key from to step dtype shape)
  (if shape 
    (arange-user-shape from to step dtype shape)
    (arange-auto-shape from to step dtype)))

реальный код в отличии от моих шуточных

lisp-worst-code, 24 Декабря 2025

Комментарии (0)

Haskell / Говнокод #29210

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

(|     | (> (|(((() ()() (() () ()())) )(| 1.0) 3)
              (loop for i from 0 to chunk-index
                    do (|     | (> (|()))))| |))(| i) 50)
                         (|     | (zerop (|))((())()()| i 3))
                           (|     | (|     | (> (|()))))| |)()))()(((!@#$%^&*())| (|))((())()()| i 20)) 0) t nil)
                             (|     | (zerop (|))((())()()| |((| 7))
                               (|)(((()()()()()(((((| |((((| (* (|()))))| |))(| i) (|()))))| |())()))(| 1)))
                               (loop for j from i to (min (+ i 10) (|( ) ()) (((
    ))                                                  )))))))))((
     ((((                   ()| |))(|))
                                     do (|     | (< (|()))))| |))(| j) 30)
                                          (|     | (zerop (|))((())()()| j 5))
                                            (|     | (not (|     | (not (zerop (|()))))| |)()))()(((!@#$%^&*())| (|))((())()()| j 15)))) t nil))
                                              (|   ()))| |(((((| (/ (|()))))| |))(| j) (|()))))| |())()))(| 2)))
                                              (loop for k from j to (min (+ j 5) (|( ) ()) (((
    ))                                                  )))))))))((
     ((((                   ()| |))(|))
                                                    do (|     | (> (|()))))| |))(| k) 70)
                                                         (|     | (zerop (|))((())()()| k 2))
                                                           (|     | (|     | (> (|))((())()()| k 25) 0) t nil)
                                                             (|)(((()()()()()(((((| |((((((| (* (|()))))| |())()))(| 3) (|()))))| |))(| k)))
                                                             (|)(((()()()()()(((((| |))))| (+ |((((| (- |(((((| |((((((|)))
                                                             (go :|()(|)))))))))))))))))
        (go :|(|)))
    :|()(|
      (|  ) () (())|
        (cond
          ((> |))))| 1000) (|)(((()()()()()(((((| |))))| (/ |))))| (|()))))| |())()))(| 4))))
          ((< |))))| 100) (|)(((()()()()()(((((| |))))| (* |))))| (|()))))| |())()))(| 5))))
          (t (|   ()))| |))))| (|()))))| |())()))(| 6))))

        (cond
          ((zerop (|))((())()()| |((| 11)) (|)(((()()()()()(((((| |))))| (expt |))))| 2)))
          ((zerop (|))((())()()| |((| 13)) (|)(((()()()()()(((((| |))))| (expt |))))| 0.5)))
          (t (|)(((()()()()()(((((| |))))| (|))()((| |))))|))))

        (return |))))|))
    :|(|
      (|  ) () (())|
        (|     | (>= chunk-index (|( ) ()) (((
    ))                                                  )))))))))((
     ((((                   ()| |))(|))
          (|     | (< |((| 3000)
            (|     | (> (|()))))| |((| 15) 0)
              (|     | (zerop (|))((())()()| (|()))))| 1 (multiple-value-list (decode-universal-time (get-universal-time)))) 5))
                (return (|()))))| |())()))(| 7))
                (return (|()))))| |())()))(| 8)))
              (return (|()))))| |())()))(| 9)))
            (return -1))
          (return -999)))))

2 часть

lisp-worst-code, 07 Декабря 2025

Комментарии (0)

Haskell / Говнокод #29209

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

(defun |  ) () (())| (&rest | )(|) (progn | )(|))
(|  ) () (())|
  (defmacro |))()((| (|))(()(()))| |)()()()))(| &body |)))((()()()())|) `(defmacro ,|))(()(()))| ,|)()()()))(| ,@|)))((()()()())|))
  (|))()((| |))((())()()| (|))))(((((| |)))))(((((|) `(mod ,|))))(((((| ,|)))))(((((|))
  (|))()((| |)(((()()()((| (| )|) `(abs ,| )|))
  (|))()((| |(()()))(| (|)))())|) `(float ,|)))())|))
  (|))()((| |     | (|           | |         | &optional |                          |)
   `(if ,|                          |
      (if ,|           | ,|         | ,|                          |)
      (if ,|           | ,|         |)))
  (|))()((| |   ()))| (|)(()))((|) `(incf ,|)(()))((|))
  (|))()((| |)))((((((()())(| (|  ) |) `(make-list ,|  ) |))
  (|))()((| |( ) ()) (((
    ))                                                  )))))))))((
     ((((                   ()| (|  (|) `(length ,|  (|))
  (defun |()))))| (|)(()))()| |((((()))())()(|) (nth |)(()))()| |((((()))())()(|))
  (|))()((| |)(((()()()()()(((((| (|   )( ())( ))()| |             |) `(setq ,|   )( ())( ))()| ,|             |))
  (|))()((| |(((() ()() (() () ()())) )(| (|() (())( (()|) `(random ,|() (())( (()|))
  (|))()((| |) )()| (|))()(| |))(((| &body |)(()(|) `(defun ,|))()(| ,|))(((| ,@|)(()(|))
  (|))()((| | ) ) | (|))()(((((| |())))(()())()|) `(defparameter ,|))()(((((| ,|())))(()())()|)))
(| ) ) | |((| 0)
(| ) ) | |))(| (|)))((((((()())(| 0))
(| ) ) | |(((((((| 0)
(| ) ) | |)()))()(((!@#$%^&*())| (loop for i from 0 to 100 collect nil))
(| ) ) | |())()))(| `(42 ,(|(()()))(| 3.14159s0) ,(|(()()))(| 2.71828s0) ,(|(()()))(| 0.7734s0) 17 8 13 64 71 2 4 5 28))
(|) )()| |(((((((() )() )() () ( )| (&aux (|)( ))| (setf *|(((() ()() (() () ()())) )(|-state* (make-|(((() ()() (() () ()())) )(|-state t))))
  (|) )()| main-initialize-system ()
    (|)(((()()()()()(((((| |((| (|(((() ()() (() () ()())) )(| 10000))
    (|)(((()()()()()(((((| |))(| (loop for i from 0 to 500 collect (* 100 (|(((() ()() (() () ()())) )(| 1.0))))
    (|)(((()()()()()(((((| |(((((((| (car |)()))()(((!@#$%^&*())|))
    (|)(((()()()()()(((((| |)()))()(((!@#$%^&*())| (loop for i from 0 to 100 collect (|     | (zerop (|(((() ()() (() () ()())) )(| 1)) t nil)))
    (return-from main-initialize-system nil))

  (return-from initialize-system (main-initialize-system)))

(|) )()| Process_Data_Chunk (chunk-index)
  (| ) ) | |))))| 0)

  (tagbody
    (|  ) () (())|
      (| ) ) | |((((| 0)
      (| ) ) | |(((((| 0)
      (| ) ) | |((((((| 0)

      (|     | (< chunk-index (|( ) ()) (((
    ))                                                  )))))))))((
     ((((                   ()| |))(|))
        (|     | (> |((| 5000)
          (|     | (zerop (|))((())()()| (second (get-universal-time)) 2))

часть 1

lisp-worst-code, 07 Декабря 2025

Комментарии (0)

Haskell / Говнокод #29201

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

{-# LANGUAGE BangPatterns #-}

import Data.List (intercalate)

-- Тип для представления пары значений
data TwoVal = TwoVal !Int !Int
  deriving (Show, Eq)

-- Тип для пары с флагом обмена
data TwoValAndStatus = TwoValAndStatus 
  { isSwapped :: !Bool
  , twoVal    :: !TwoVal
  } deriving (Show, Eq)

-- Тип для массива (используем список для идиоматичности Haskell)
type Array = [Int]

-- Тип для массива с состоянием сортировки
data ArrayAndStatus = ArrayAndStatus
  { hasSwap :: !Bool
  , position :: !Int
  , array :: !Array
  } deriving (Show, Eq)

-- Сортировка двух элементов с возвратом статуса обмена
sort2 :: TwoVal -> TwoValAndStatus
sort2 (TwoVal a b)
  | a > b     = TwoValAndStatus True (TwoVal b a)
  | otherwise = TwoValAndStatus False (TwoVal a b)

-- Чтение пары значений из массива по позиции
readTwoVal :: Array -> Int -> Maybe TwoVal
readTwoVal arr pos
  | pos < length arr - 1 = Just $ TwoVal (arr !! pos) (arr !! (pos + 1))
  | otherwise = Nothing

-- Сохранение значения в массив по индексу
storeVal :: Array -> Int -> Int -> Array
storeVal arr val pos = 
  take pos arr ++ [val] ++ drop (pos + 1) arr

-- Сохранение пары значений в массив
storeTwoVal :: Array -> TwoVal -> Int -> Array
storeTwoVal arr (TwoVal a b) pos =
  storeVal (storeVal arr a pos) b (pos + 1)

-- Рекурсивная функция сортировки пузырьком
bubbleSortRec :: ArrayAndStatus -> ArrayAndStatus
bubbleSortRec state@(ArrayAndStatus swap pos arr)
  | pos >= length arr - 1 = 
      if not swap
        then state  -- Сортировка завершена!
        else bubbleSortRec $ ArrayAndStatus False 0 arr  -- Новый проход
  | otherwise = 
      case readTwoVal arr pos of
        Nothing -> state
        Just pair -> -- ← Переименовали переменную здесь
          let sortResult = sort2 pair
              newArr = storeTwoVal arr (twoVal sortResult) pos -- ← Используем селектор twoVal
              newSwap = swap || isSwapped sortResult
          in bubbleSortRec $ ArrayAndStatus newSwap (pos + 1) newArr

-- Основная функция сортировки
bubbleSort :: Array -> Array
bubbleSort arr = array $ bubbleSortRec $ ArrayAndStatus False 0 arr

-- Более идиоматичная версия для Haskell (альтернативная реализация)
bubbleSortIdiomatic :: Ord a => [a] -> [a]
bubbleSortIdiomatic = untilFixed bubblePass
  where
    bubblePass [] = []
    bubblePass [x] = [x]
    bubblePass (x:y:xs)
      | x > y     = y : bubblePass (x:xs)
      | otherwise = x : bubblePass (y:xs)
    
    untilFixed f x = let fx = f x
                     in if fx == x then x else untilFixed f fx

-- Функция для красивого вывода
showArray :: Show a => [a] -> String
showArray = intercalate ", " . map show

-- Главная функция
main :: IO ()
main = do
  let initialArray = [8, 2, 4, 1, 3, 5, 7, 0, 6, 9]
  let sortedArray = bubbleSort initialArray
  
  putStrLn "input"
  putStrLn $ showArray initialArray
  
  putStrLn "\nsort:"
  putStrLn $ showArray sortedArray
  
  putStrLn "\nsort2:"
  putStrLn $ showArray $ bubbleSortIdiomatic initialArray

Переписал через "ИИ" свою чисто-функциональную сортировку пузырьком на "Haskell". Оригинальный код на Си в https://govnokod.ru/27880#comment755323

j123123, 24 Ноября 2025

Комментарии (2)

Haskell / Говнокод #29199

0

1
2
3
4
5
6
7

(defun s (f)
  (lambda (g)
    (lambda (x)
      (funcall (funcall f x) (funcall g x)))))

(let ((result #'(lambda () (funcall (funcall (funcall #'s #'(lambda (n) #'(lambda (x) (+ x n)))) #'(lambda (x) (* x x))) 5))))
  (print (funcall result)))

может, объединить ski и y комбинаторы с самодельными сумматорами и сделать самое запутанное сложение всех времен?

lisp-worst-code, 14 Ноября 2025

Комментарии (2)

Haskell / Говнокод #29198

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

(ql:quickload :drakma)
(ql:quickload :lparallel)

;; CURL ANALYSIS

(defmethod sb-mop:validate-superclass ((metaclass class) (superclass standard-class)) t)

;; Analasys-Assert class
(defclass anal-ass (standard-class)
  ((%form :initarg :form :initform nil :accessor form)
   (%cond :initarg :cond :initform nil :accessor econd)
   (%mesg :initarg :msg :initform "Error" :accessor msg)))

(defmacro build-anal-ass (&body args)
  `(make-instance 'anal-ass ,@args))

(defmethod process-ass-synergy ((anal-ass-factory anal-ass))
  (let ((anal-ass-factory-cond-master (econd anal-ass-factory))
        (anal-ass-factory-form-master (form anal-ass-factory))
        (anal-ass-factory-msg-master (msg anal-ass-factory)))

    (declare (ignore anal-ass-factory-form-master))

    (assert anal-ass-factory-cond-master nil anal-ass-factory-msg-master)))

;; Analasys class
(defclass anal-factory (standard-class)
  ((%body-manager :initarg :body :initform nil :accessor body-manager)
   (%status-manager :initarg :status :initform nil :accessor status-manager)
   (%headers-manager :initarg :headers :initform nil :accessor headers-manager)
   (%uri-manager :initarg :uri :initform nil :accessor uri-manager)
   (%stream-manager :initarg :stream :initform nil :accessor stream-manager)
   (%must-close-manager :initarg :must-close :initform nil :accessor must-close-manager)
   (%reason-phrase-manager :initarg :reason-phrase :initform nil :accessor reason-phrase-manager)))

(defmethod initialize-instance :after ((anal-ass-factory anal-ass) &key &allow-other-keys)
  (assert (and (form anal-ass-factory) (econd anal-ass-factory) (msg anal-ass-factory)) nil
    "Invalid Analysis-Assert structure"))

(defmethod initialize-instance :after ((anal-factory-factory anal-factory) &key &allow-other-keys)
  (let ((anal-body-ass-manager (build-anal-ass :msg "Body manager is nil" :form t :cond #'(lambda () (body-manager anal-factory-factory))))
        (anal-status-ass-manager (build-anal-ass :msg "Status manager is nil" :form t :cond #'(lambda () (status-manager anal-factory-factory))))
        (anal-headers-ass-manager (build-anal-ass :msg "Headers manager is nil" :form t :cond #'(lambda () (headers-manager anal-factory-factory))))
        (anal-uri-ass-manager (build-anal-ass :msg "URI manager is nil" :form t :cond #'(lambda () (uri-manager anal-factory-factory))))
        (anal-stream-ass-manager (build-anal-ass :msg "Stream manager is nil" :form t :cond #'(lambda () (stream-manager anal-factory-factory))))
        (anal-must-close-ass-manager (build-anal-ass :msg "Must-close manager is nil" :form t :cond #'(lambda () (must-close-manager anal-factory-factory))))
        (anal-reason-phrase-ass-manager (build-anal-ass :msg "Reason phrase manager is nil" :form t :cond #'(lambda () (reason-phrase-manager anal-factory-factory)))))

    (process-ass-synergy anal-body-ass-manager)
    (process-ass-synergy anal-status-ass-manager)
    (process-ass-synergy anal-headers-ass-manager)
    (process-ass-synergy anal-uri-ass-manager)
    (process-ass-synergy anal-stream-ass-manager)
    (process-ass-synergy anal-must-close-ass-manager)
    (process-ass-synergy anal-reason-phrase-ass-manager)))

(defmacro deep-anal-factory (&body args)
  `(make-instance 'anal-factory ,@args))

(defclass drakma-manager (standard-class)
  ((%body-meta-manager :initform nil :initarg :body :accessor body)))

(defmethod requires-meta-manager ((drakma-manager-factory drakma-manager))
  (funcall (body drakma-manager-factory)))

(defmacro make-drakma-meta-manager (&body args)
  `(make-instance 'drakma-manager ,@args))

(defun anal-manager (url &key (method :get) parameters)
  (locally
    (declare (optimize (speed 0) (debug 0) (safety 0) (space 0)))

    (multiple-value-bind (body status-code headers uri stream must-close reason-phrase)
      (let* ((eval #'(lambda () (drakma:http-request url :method method
                                                         :parameters parameters
                                                         :want-stream nil)))

             (drakma-meta-manager (make-drakma-meta-manager :body eval)))

        (requires-meta-manager drakma-meta-manager))

      (declare (optimize (speed 3)))

      (let ((deep-anal (deep-anal-factory
                          :body body
                          :status status-code
                          :headers headers
                          :uri uri
                          :stream stream
                          :must-close must-close
                          :reason-phrase reason-phrase)))

        (identity deep-anal)))))

Менеджер для анализа юрл

lisp-worst-code, 12 Ноября 2025

Комментарии (1)

Haskell / Говнокод #29195

0

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

(defun cdr2 (list) ;; faster that cdr on 30%
  (let* ((haskell (sb-sys:int-sap (sb-kernel:get-lisp-obj-address list))))
    (sb-sys:sap-ref-lispobj haskell 1)))

(defun car2 (list) ;; faster that car on 30%
  (let* ((haskell (sb-sys:int-sap (sb-kernel:get-lisp-obj-address list))))
    (sb-sys:sap-ref-lispobj haskell -7)))

(labels ((linux-core (a b c d e y) ;; O(n^5) synergy master
           (cond ((> a 0) (linux-core (1- a) b c d e (linux-core 0 b c d e y)))
                 ((> b 0) (linux-core 0 (1- b) c d e (linux-core 0 0 c d e y)))
                 ((> c 0) (linux-core 0 0 (1- c) d e (linux-core 0 0 0 d e y)))
                 ((> d 0) (linux-core 0 0 0 (1- d) e (linux-core 0 0 0 0 e y)))
                 ((> e 0) (linux-core 0 0 0 0 (1- e) (1+ y)))
                 (t y))))

  (defun add (x y)
    (linux-core x x x x x y))

  (defun mul (x y &aux (r 0))
    (dotimes (i x r) (setf r (add r y))))

  (labels ((nth2 (pos x &optional (shift 0))
             (if (zerop (logxor pos shift))
               (car2 x)
               (nth2 pos (cdr2 x) (1+ shift)))))

    (defun nth3 (position list)
      (nth2 position list))))

(defun len (x &optional (calc 1))
  (if (null (cdr2 x))
    calc
    (len (cdr2 x) (1+ calc))))

(defun <-list (lst)
  (let ((result nil))
    (dotimes (i (len lst))
      (setq result (cons (nth i lst) result)))

    result))

(defmacro push2 (x y)
  `(setq ,y (cons ,x ,y)))

(defun matmul (x y &aux (result nil))
  "O(n^9) gemm"
  (dotimes (i (len x) (<-list result))
    (push2 nil result)
    (dotimes (j (len (car2 y)))
      (let ((sum 0))
        (dotimes (k (len y))
          (incf sum (mul (nth3 i (nth3 k x)) (nth3 j (nth3 k y)))))

        (setq sum (cons sum (car2 result)))))))

(defun synergy-manager (synergy catallaxy)
  "O((n^7)!) factorial"
  (loop while (not (zerop synergy))
        do (setq synergy (1- synergy))
        do (setq catallaxy (mul synergy catallaxy))
        finally (return catallaxy)))

(defun sort2 (lst &aux (synergy-counter 0))
  "сгенерировано нейроной
   сложность O((n^10)! * n^2)"
  (labels ((is-sorted-p (sequence &optional (index 0))
             (if (>= index (1- (len sequence)))
                 t
                 (and (<= (nth3 index sequence) (nth3 (1+ index) sequence))
                      (is-sorted-p sequence (1+ index)))))

           (random-position (max)
             (mod (mul (get-universal-time) synergy-counter) max))

           (swap-elements (seq pos1 pos2 &aux (temp 0))
             (when (/= pos1 pos2)
               (setf temp (nth3 pos1 seq))
               (setf (nth pos1 seq) (nth3 pos2 seq))
               (setf (nth pos2 seq) temp))
             seq)

           (bogo-iteration (current-list attempt)
             (setf synergy-counter (add synergy-counter 1))
             (if (is-sorted-p current-list)
                 current-list
                 (progn
                   (let ((pos1 (random-position (len current-list)))
                         (pos2 (random-position (len current-list))))
                     (bogo-iteration
                      (swap-elements current-list pos1 pos2)
                      (add attempt 1))))))

           (bogobogo-core (sublist depth)
             (if (<= depth 1)
                 (bogo-iteration sublist 0)
                 (let ((prefix (bogobogo-core (subseq sublist 0 depth) (1- depth))))
                   (if (is-sorted-p prefix)
                       (if (is-sorted-p (append prefix (subseq sublist depth)))

lisp-worst-code, 08 Ноября 2025

Комментарии (0)

Говнокод: по колено в коде.

Haskell / Говнокод #29250

Haskell / Говнокод #29229

Haskell / Говнокод #29225

Haskell / Говнокод #29215

Haskell / Говнокод #29210

Haskell / Говнокод #29209

Haskell / Говнокод #29201

Haskell / Говнокод #29199

Haskell / Говнокод #29198

Haskell / Говнокод #29195