From b5945b86b03b768de06d7dd12e09d89b7f9912f9 Mon Sep 17 00:00:00 2001 From: arielherself Date: Tue, 10 Dec 2024 14:53:12 +0800 Subject: [PATCH] regular backup --- home-manager/home.nix | 6 ++-- nvim/lua/config.lua | 33 +++++++++++---------- nvim/lua/snippets/hash-vec.lua | 52 +++++++++++++++++----------------- nvim/lua/snippets/init.lua | 12 ++++++++ nvim/lua/snippets/odt.lua | 52 ++++++++++++++++++++++++++++++++++ 5 files changed, 112 insertions(+), 43 deletions(-) create mode 100644 nvim/lua/snippets/odt.lua diff --git a/home-manager/home.nix b/home-manager/home.nix index eca33e3..1bc543d 100644 --- a/home-manager/home.nix +++ b/home-manager/home.nix @@ -201,7 +201,7 @@ in { pkgs.samba # Java - pkgs.jdk22 + pkgs.jdk23 pkgs.jdt-language-server # Python @@ -236,6 +236,7 @@ in { pkgs.jellyfin-ffmpeg # pkgs.spotify # unstable.spotify-player + pkgs.spotdl # Streaming # pkgs.obs-studio @@ -263,7 +264,7 @@ in { # pkgs.pavucontrol # Volume control # pkgs.pasystray # Volume tray icon pkgs.yaru-theme - unstable.adwaita-icon-theme + # unstable.adwaita-icon-theme pkgs.adwaita-qt pkgs.adwaita-qt6 pkgs.wiki-tui @@ -271,6 +272,7 @@ in { pkgs.starship # Prompt bar pkgs.patchelf # pkgs.screenkey + pkgs.ipatool # Search and download IPAs # My version of BerkeleyMono NF is incomplete. Should add some fallback fonts. # (pkgs.nerdfonts.override { fonts = [ diff --git a/nvim/lua/config.lua b/nvim/lua/config.lua index 9c24b57..5075e41 100644 --- a/nvim/lua/config.lua +++ b/nvim/lua/config.lua @@ -139,19 +139,19 @@ local plugins = { opts = {}, config = function(_, opts) require'lsp_signature'.setup(opts) end }, - -- { - -- "folke/which-key.nvim", - -- event = "VeryLazy", - -- init = function() - -- vim.o.timeout = true - -- vim.o.timeoutlen = 300 - -- end, - -- opts = { - -- -- your configuration comes here - -- -- or leave it empty to use the default settings - -- -- refer to the configuration section below - -- } - -- }, + { + "folke/which-key.nvim", + event = "VeryLazy", + init = function() + vim.o.timeout = true + vim.o.timeoutlen = 300 + end, + opts = { + -- your configuration comes here + -- or leave it empty to use the default settings + -- refer to the configuration section below + } + }, { 'jdhao/better-escape.vim' -- `jk` without causing `j` to have delay }, @@ -487,7 +487,10 @@ local plugins = { require("fzf-lua").setup({}) end }, - { 'NStefan002/screenkey.nvim' }, + -- { + -- 'NStefan002/screenkey.nvim', + -- branch = "dev", + -- }, { 'kosayoda/nvim-lightbulb' }, { 'mfussenegger/nvim-jdtls' }, -- Java LS } @@ -1184,7 +1187,7 @@ require("telescope").setup { require('mini.trailspace').setup {} -require('lsp_lines').setup {} +require('lsp_lines').setup() require("nvim-lightbulb").setup { autocmd = { enabled = true } diff --git a/nvim/lua/snippets/hash-vec.lua b/nvim/lua/snippets/hash-vec.lua index 53417ee..58b8d78 100644 --- a/nvim/lua/snippets/hash-vec.lua +++ b/nvim/lua/snippets/hash-vec.lua @@ -1,50 +1,52 @@ return [[ -static vector> power1; -static vector> power2; -static const ll b = rd(); +static vector power1; +static vector power2; +static const ll b = rd() % INF; +static const ll b1 = inverse(b, MDL1); +static const ll b2 = inverse(b, MDL2); template struct hash_vec { using hash_type = pll; - MLL hash1; - MLL hash2; + ll hash1; + ll hash2; vector<_Tp> seq; size_t size() { return seq.size(); } void push_back(const _Tp& x) { - hash1 = hash1 * b + x; - hash2 = hash2 * b + x; + hash1 = (hash1 * b % MDL1 + x) % MDL1; + hash2 = (hash2 * b % MDL2 + x) % MDL2; seq.push_back(x); } void push_front(const _Tp& x) { size_t length = size(); - hash1 += x * power1[length]; - hash2 += x * power2[length]; + hash1 = (hash1 + x * power1[length] % MDL1) % MDL1; + hash2 = (hash2 + x * power2[length] % MDL2) % MDL2; seq.push_front(x); } void pop_back() { _Tp e = seq.back(); seq.pop_back(); - hash1 = (hash1 - e) / b; - hash2 = (hash2 - e) / b; + hash1 = mod(hash1 - e, MDL1) * b1 % MDL1; + hash2 = mod(hash2 - e, MDL2) * b2 % MDL2; } void pop_front() { _Tp e = seq.front(); seq.pop_front(); int length = seq.size(); - hash1 -= e * power1[length]; - hash2 -= e * power2[length]; + hash1 = mod(hash1 - e * power1[length] % MDL1, MDL1); + hash2 = mod(hash2 - e * power2[length] % MDL2, MDL2); } void set(size_t pos, const _Tp& value) { int length = seq.size(); int old_value = seq[pos]; - hash1 += (value - old_value) * power1[length - 1 - pos]; - hash2 += (value - old_value) * power2[length - 1 - pos]; + hash1 = (hash1 + (value - old_value) * power1[length - 1 - pos] % MDL1) % MDL1; + hash2 = (hash2 + (value - old_value) * power2[length - 2 - pos] % MDL2) % MDL2; seq[pos] = value; } const _Tp& operator[](size_t pos) { return seq[pos]; } hash_type hash() { - return {hash1.val, hash2.val}; + return { hash1, hash2 }; } void clear() { hash1 = 0; @@ -53,13 +55,13 @@ struct hash_vec { } hash_vec(size_t maxn) { clear(); - MLL c1 = power1.size() ? power1.back() * b : 1; - MLL c2 = power2.size() ? power2.back() * b : 1; + ll c1 = power1.size() ? power1.back() * b % MDL1 : 1; + ll c2 = power2.size() ? power2.back() * b % MDL2 : 1; for (int i = power1.size(); i < maxn; ++i) { power1.push_back(c1); power2.push_back(c2); - c1 *= b; - c2 *= b; + c1 = c1 * b % MDL1; + c2 = c2 * b % MDL2; } } hash_vec(size_t maxn, const _Tp& init_value) : hash_vec(maxn) { @@ -68,9 +70,8 @@ struct hash_vec { } } }; - struct range_hash { - vector, MLL>> hp; + vector hp; template range_hash(const T& vec) { hp.emplace_back(); @@ -80,12 +81,11 @@ struct range_hash { hp.emplace_back(hs.hash()); } } - /// query hash of subarray [l, r]. Index starts from 0. - pair, MLL> range_query(size_t l, size_t r) { + inline pll range_query(size_t l, size_t r) { return { - (hp[r + 1].first - hp[l].first * power1[r + 1 - l]), - (hp[r + 1].second - hp[l].second * power2[r + 1 - l]), + mod(hp[r + 1].first - hp[l].first * power1[r + 1 - l] % MDL1, MDL1), + mod(hp[r + 1].second - hp[l].second * power2[r + 1 - l] % MDL2, MDL2), }; } }; diff --git a/nvim/lua/snippets/init.lua b/nvim/lua/snippets/init.lua index cdf5e84..f719aef 100644 --- a/nvim/lua/snippets/init.lua +++ b/nvim/lua/snippets/init.lua @@ -405,3 +405,15 @@ ls.add_snippets(nil, { } }) +local odt = require('snippets.odt') +ls.add_snippets(nil, { + cpp = { + snip({ + trig = 'odt', + namr = 'odt', + dscr = 'Old Driver Tre', + },{ + text(lines(odt)) + }) + } +}) diff --git a/nvim/lua/snippets/odt.lua b/nvim/lua/snippets/odt.lua new file mode 100644 index 0000000..c7ea340 --- /dev/null +++ b/nvim/lua/snippets/odt.lua @@ -0,0 +1,52 @@ +return [=[ +template +struct ODT { + struct Info { + IndexType l, r; + mutable T val; + Info(const IndexType& l, const IndexType& r, const T& val) : l(l), r(r), val(val) {} + friend inline bool operator<(const Info& lhs, const Info& rhs) { return lhs.l < rhs.l; } + }; + + set info; + + ODT() = delete; + ODT(const IndexType& left, const IndexType& right, const T& val) : info {{ left, right, val }} {} + + typename set::iterator split(const IndexType& x) { + auto it = info.lower_bound({ x, {}, {} }); + if (it != info.end() and it->l == x) { + return it; + } + --it; + auto [l, r, val] = *it; + info.erase(it); + info.emplace(l, x - 1, val); + return info.emplace(x, r, val).first; + } + + void assign(const IndexType& l, const IndexType& r, const T& val) { + auto ri = split(r + 1), li = split(l); + info.erase(li, ri); + info.emplace(l, r, val); + } + + void transform(const IndexType& l, const IndexType& r, const function& operation) { + auto ri = split(r + 1), li = split(l); + for (; li != ri; ++li) { + li->val = operation(*li); + } + } + + template + U accumulate(const IndexType& l, const IndexType& r, U&& init, const function& operation = std::plus()) { + auto ri = split(r + 1), li = split(l); + U res = init; + for (; li != ri; ++li) { + res = operation(res, *li); + } + return res; + } +}; + +]=]