Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
0
(let ((actions (make-list 100 :initial-element (make-list 100 :initial-element (make-list 1000 :initial-element most-negative-fixnum #| your action reward |# )))))
(labels ((find-best-action (life)
(if (numberp life) life (apply #'max (mapcar #'find-best-action life)))))
(print (find-best-action actions)))) ;; the best your life outcome
lisp-worst-code,
(Updated )
0
{-# 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,
(Updated )
0
ты гей!
storvus,
(Updated )
0
# -*- 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,
(Updated )
0
(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,
(Updated )
0
(| | (> (|(((() ()() (() () ()())) )(| 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,
(Updated )
0
(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,
(Updated )
0
{-# 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,
(Updated )
0
(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,
(Updated )
0
(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,
(Updated )