Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
+1
C 5.2s gcc test.c
C++ 1m 25s g++ test.cpp
Zig 10.1s zig build-exe test.zig
Nim 45s nim c test.nim
Rust Stopped after 30 minutes rustc test.rs
Swift Stopped after 30 minutes swiftc test.swift
D Segfault after 6 minutes dmd test.d
Rust and Swift took too long to compile 400k lines, so I tried smaller numbers:
# lines Rust Swift D
2k 3.4s 0.8s
4k 9.0s 1.0s
8k 30.8s 2.3s
20k 3m 52s 11.8s 4.7s
100k - 5m 57s segfaulthttps://vlang.io/compilation_speed
3.14159265,
15 Августа 2021
+1
QSqlQuery& SQLConnect::get()
{
if ( makeConnection() ) {
query = QSqlQuery(mDb);
return query;
}
QSqlQuery empty;
return empty;
}
bool SQLConnect::makeConnection()
{
mDb = SQLConnectPool::Instance().get();
return true;
}Раньше компилилось и не замечал, а тут на новом компиляторе начал кидать ошибки и решил посмотреть, что же там напроектировали
avk17,
14 Августа 2021
+1
function foo(arg: any) {
if (typeof arg === "string") {
// We know this is a string now.
print(<string>arg);
}
}
function main() {
foo("Hello");
foo(1);
print("done.");
}я вам новый говнокодец притарабанил.... вот будете как настоящие жабаскриптеры в нативе
ASD_77,
11 Августа 2021
+1
10 лет назад читала самоучитель по Паскалю, где были задания: "написать алгоритм для нахождения простых чисел до n",
"написать 2D-пушку (на CRT модуле)".
Сейчас хочется найти его, вспомнить свое детство (задолго до того, как пошла формошлепить хех).
Ничего похожего пока не нашла.
JaneBurt,
06 Августа 2021
+1
function main() {
let user = {
firstName: "John",
sayHi() {
print(`Hello, ${this.firstName}!`);
},
};
user.sayHi();
print("done.");
}как тебе такое Илон Маск?
ASD_77,
06 Августа 2021
+1
Ltac destruct_mint_ H :=
match type of H with
(MInt_ _ ?z ?t) =>
lazymatch goal with
|- ?GOAL =>
refine (match H in (MInt_ _ z0 t0) return (z = z0 -> t = t0 -> GOAL) with
| mint_nil _ =>
fun Heq_z Heq_tt_ =>
ltac:(destruct_mint_common Heq_tt_ Heq_z H)
| mint_cons _ te rest l r t H =>
fun Heq_z Heq_tt_ =>
ltac:(destruct_mint_common Heq_tt_ Heq_z H)
| mint_cons_l _ te rest l r z t Hz H =>
fun Heq_z Heq_tt_ =>
ltac:(destruct_mint_common Heq_tt_ Heq_z H)
| mint_cons_r _ te te' rest l r z t Hz Hcomm H =>
fun Heq_z Heq_tt_ =>
ltac:(destruct_mint_common Heq_tt_ Heq_z H)
end (eq_refl z) (eq_refl t))
end
end.Наебавшись с inversion в механизированным доказательстве, закрыл я очи.
CHayT,
04 Августа 2021
+1
function main() {
let { aa, bb } = { aa: 10, bb: 20 };
print(aa + bb);
let {
aa,
bb: { q, r },
} = { aa: 10, bb: { q: 1, r: 2 } };
assert(aa == 10, "{}");
assert(q == 1, "{}");
assert(r == 2, "{}");
let { x, y } = new ObjF(1, "foo");
assert(x == 1, "{}");
assert(y == "foo", "{}");
print("done.");
}Добрый вечер дорогие неопределившиеся... или заблудшие... вот я тут вам новую фичу притарабанил .. называет деконстракт :)
ASD_77,
04 Августа 2021
+1
Именно поэтому я за «PHP» #4
#1: https://govnokod.ru/26462 https://govnokod.xyz/_26462
#2: https://govnokod.ru/26827 https://govnokod.xyz/_26827
#3: https://govnokod.ru/26832 https://govnokod.xyz/_26832
nepeKamHblu_nemyx,
28 Июля 2021
+1
namespace Ifaces {
interface IFoo {
foo(): number;
}
}
class Cls1 implements Ifaces.IFoo
{
foo(): number
{
print("Hello");
return 1;
}
}
function main()
{
const cls1 = new Cls1();
cls1.foo();
const ifoo: Ifaces.IFoo = cls1;
ifoo.foo();
}Алилуя. я вам интерфейсы принес... узрите теперь дампик
ASD_77,
27 Июля 2021
+1
class Solution {
public:
std::vector<std::vector<int>> diagonalSort(std::vector<std::vector<int>> & mat) {
if (!mat.size()) return mat;
const size_t rl = mat[0].size();
const size_t cl = mat.size();
sort(mat, rl, cl, 0, 0);
for (size_t i = 1; i < rl; ++i) {
sort(mat, rl, cl, 0, i);
}
for (size_t i = 1; i < cl; ++i) {
sort(mat, rl, cl, i, 0);
}
return mat;
}
private:
void sort(std::vector<std::vector<int>> & mat, size_t rl, size_t cl, size_t i, size_t j) {
const size_t len = std::min(rl - j, cl - i);
const size_t endj = j + len;
const size_t endi = i + len;
std::sort(diag_iter<false>{&mat, i, j}, diag_iter<false>{&mat, endi, endj});
}
template <bool isConst>
class diag_iter {
std::vector<std::vector<int>> *base;
size_t i, j;
using T = int;
public:
using iterator_category = std::forward_iterator_tag;
using difference_type = std::ptrdiff_t;
using value_type = T;
using pointer = T*;
using reference = typename std::conditional<isConst, const T&, T&>::type;
diag_iter(std::vector<std::vector<int>> *base, size_t i, size_t j) : base(base), i(i), j(j) { }
diag_iter(const diag_iter&) = default;
diag_iter& operator=(const diag_iter&) = default;
~diag_iter() = default;
reference operator*() const { return (*base)[i][j]; }
diag_iter& operator++() { i++; j++; return *this; }
friend bool operator== (const diag_iter& a, const diag_iter& b) { return a.i == b.i && a.j == b.j; };
friend bool operator!= (const diag_iter& a, const diag_iter& b) { return !(a == b); };
pointer operator->() const { return &(this->operator*()); }
diag_iter operator++(int) { diag_iter tmp = *this; ++(*this); return tmp; }
diag_iter() = default;
diag_iter& operator--() { i--; j--; return *this; }
diag_iter operator--(int) { diag_iter tmp = *this; --(*this); return tmp; }
diag_iter& operator+=(difference_type n) { i += n; j += n; return *this; }
friend diag_iter operator+(diag_iter it, difference_type n) { return it += n; }
diag_iter& operator-=(difference_type n) { i -= n; j -= n; return *this; }
diag_iter operator-(difference_type n) const { return diag_iter(*this) -= n; }
friend difference_type operator-(const diag_iter& a, const diag_iter& b) { return (b.j * b.base->size() + b.i) - (a.j * a.base->size() + a.i); }
reference operator[](difference_type n) const { return *(*this + n); }
friend bool operator<(const diag_iter& a, const diag_iter& b) { return b - a > 0; }
friend bool operator>(const diag_iter& a, const diag_iter& b) { return b < a; }
friend bool operator>=(const diag_iter& a, const diag_iter& b) { return !(a < b); }
friend bool operator<=(const diag_iter& a, const diag_iter& b) { return !(a > b); }
};
};
https://leetcode.com/problems/sort-the-matrix-diagonally/
Сортировка через итераторы оказалась примерно в три раза медленнее, чем через копирование в вектор, сортировку его и копирование обратно.
grillow1337,
25 Июля 2021
Follow us!