DEV Community: nozomi-iida

Learning Union-Find

nozomi-iida — Mon, 30 Oct 2023 13:32:35 +0000

What is Union-Find?

Union-Find is a data structure to manage groups in a tree structure.
When grouping in a tree structure, the advantage is that the following two points can be done quickly

Check if x and y exist in a same group or not.
If x and y exist in the same group, the affiliations of group x and group y can be easily merged.

Try to make Union-find Structure with Rust

struct UnionFind {
    par: Vec<usize>,
}

impl UnionFind {
    fn new(n: usize) -> Self {
        let mut par = vec![0; n];
        for i in 0..n {
            par[i] = i;
        }
        return Self { par };
    }

    fn root(&mut self, x: usize) -> usize {
        if self.par[x] == x {
            return x;
        }
        self.par[x] = self.root(self.par[x]);
        self.par[x]
    }

    fn unite(&mut self, x: usize, y: usize) {
        let rx = self.root(x);
        let ry = self.root(y);
        if rx == ry {
            return;
        }
        self.par[rx] = ry;
    }

    fn same(&mut self, x: usize, y: usize) -> bool {
        let rx = self.root(x);
        let ry = self.root(y);
        rx == ry
    }
}

par: par[a] = b means "a's parent is b"
new: This function initializes everything as roots.
root: This function returns root.

For examples

When data x is a root, it returns x
When data x is not a root, par recursively traces back to the parent and return parental with
unite:
This function merges two trees that don't have the same root.
same:
This function return true if x and y have the same root.

Plush Toys~AtCoder~

nozomi-iida — Mon, 18 Sep 2023 12:44:06 +0000

https://atcoder.jp/contests/joi2017yo/tasks/joi2017yo_d

NOTE
This problem is in Japanese.

Solution

use proconio::input;
pub fn main() {
    input!(
        n: usize,
        m: usize,
        data: [usize; n],
    );
    let data = data.iter().map(|e| e - 1).collect::<Vec<usize>>();
    let mut cnt = vec![0; m];
    let mut cnt_sum = vec![vec![0]; m];
    for &d in data.iter() {
        cnt[d] += 1;
        for i in 0..m {
            let last_val = cnt_sum[i][cnt_sum[i].len() - 1] + if d == i { 1 } else { 0 };
            cnt_sum[i].push(last_val);
        }
    }
    const INF: usize = 1 << 60;
    let mut dp = vec![INF; 1 << m];
    dp[0] = 0;
    for s in 0..1 << m {
        let mut sum = 0;
        for i in 0..m {
            if s >> i & 1 == 1 {
                sum += cnt[i];
            }
        }

        for i in 0..m {
            if (s >> i) & 1 == 0 {
                dp[s | (1 << i)] = dp[s | (1 << i)]
                    .min(dp[s] + cnt[i] - (cnt_sum[i][sum + cnt[i]] - cnt_sum[i][sum]));
            }
        }
    }
    println!("{}", dp[(1 << m) - 1]);
}

Explanation

cnt[i] := Number of i type toys
cnt_sum[i][j] := Number of i type toys when examining the j toys from left to right on the shelf.
dp[S] := Minimum number of operations for a new subset containing S types of toys.

for s in 0..1 << m {
    let mut sum = 0;
    for i in 0..m {
        if s >> i & 1 == 1 {
            sum += cnt[i];
        }
    }

    for i in 0..m {
        if (s >> i) & 1 == 0 {
            dp[s + (1 << i)] = std::cmp::min(
                dp[s + (1 << i)],                               dp[s] + cnt[i] - (cnt_sum[i][sum + cnt[i]] - cnt_sum[i][sum]),
            )
        }
    }
}

sum := Total number of types already selected.

For the types of toys not yet included in the subset(S)

(cnt_sum[i][sum + cnt[i]] - cnt_sum[i][sum]) := Number of toys that do not need to move.

JOI qualifier 2014 D - Schedule of club activities

nozomi-iida — Thu, 14 Sep 2023 13:30:47 +0000

https://atcoder.jp/contests/joi2014yo/tasks/joi2014yo_d

NOTE
Sorry. This problem is in Japanese.

How to solve it?

dp[i][S] := The number of possible schedule for the case where the state of the club member is S on day i.
dp[i][S] = (total number of patterns meeting the previous day's conditions) % 10_007

Solution

use proconio::input;
pub fn main() {
    input!(
        n: usize,
        s: String,
    );
    let s = s.chars();
    let base = 10_007;
    // dp[date][universal set]
    let mut dp = vec![vec![0; 1 << 3]; n + 1];
    // Jが出席して、1日の場合のパターンは1つしかない
    dp[0][1] = 1;
    for (i, c) in s.enumerate() {
        let must = match c {
            'J' => 1,
            'O' => 1 << 1,
            'I' => 1 << 2,
            _ => panic!(),
        };
        for prev_j in 0..1 << 3 {
            for j in 0..1 << 3 {
                if must & j > 0 && prev_j & j > 0 {
                    dp[i + 1][j] += dp[i][prev_j];
                    dp[i + 1][j] %= base;
                }
            }
        }
    }
    println!("{}", dp[n].iter().sum::<usize>() % base);
}

if must & j > 0 && prev_j & j > 0 {
    dp[i + 1][j] += dp[i][prev_j];
    dp[i + 1][j] %= base;
}

The conditional statement of this expression is,

The representative is in the subset j,
The same person is a participant of the previous day (prev_j) and the same person on the day of the event to give the key. Counted only in the above cases.

Learning about bit DP

nozomi-iida — Wed, 13 Sep 2023 07:08:29 +0000

Before reading the article, you must know about bit operation.
If you don't know about it, I recommend to read this article

What is bit DP?

bit DP is a technique that can often be used in situations where you want to find the optimal permutation among possible permutations of n elements.
bit DP is a below dynamic programming framework.

dp[S] := When optimizing the order within a subset S of the entire set{0, 1, ,..., n - 1), minimum cost in S.

In the bit DP framework, the following recurrence formula often holds:

dp[S] = min(S, dp[S-i] + cost(S-i, i));

The following is a brief explanation of the meaning of this formula.
We want to compute the cost dp[S] of optimizing the order in it for S. We divide the case by what was the last element of the order.
If the last of S was i, then the optimal solution for the subset of S excluding the last i of S is dp[S- {i}]. If the increasing cost by adding i to S-{i} was cost(S-i, i), minimum cost is dp[S-i] + cost(S-i, i).

Then give i a try of all of them in the range of S and adopt the one that has the lowest cost.

Try to Solve a practical problem!

https://onlinejudge.u-aizu.ac.jp/problems/DPL_2_A

It is the problem of optimizing the order over n cities, so we can use bit DP.

However a little bit of ingenuity is required.
Looking at the bit DP's recurrence formula,

dp[S] = min(S, dp[S-{i}] + cost(S-{i}, i)); S - i depends on which city was last, for example cost(u, i) if the last city was u, so we can't decide dp[S]. To solve it, we fix the dp table as below:
dp[S][v] := the minimum cost in S for a subset S of the whole set {0, 1, ,..., n - 1} when the ordering is optimized with the constraint that the last is v.

DP reduction formulas can also be realized with a small modification:

dp[S][v] = min(S, dp[S-v][u] + dist[u][v]);

Based on this, the implementation would be as follows

macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

const INF: i64 = 1 << 60;

// main implementation
pub fn main() {
    input!(
        n: usize,
        m: usize,
        data: [(usize, usize, i64); m]
    );
    let dist = {
        let mut dist = vec![vec![INF; n]; n];
        for (s, t, d) in data {
            dist[s][t] = d;
        }
        dist
    };
    let mut dp = vec![vec![-1; n + 1]; 1 << n];
    let res = rec(n, 0, 0, &mut dp, &dist);
    if res != INF {
        println!("{}", res);
    } else {
        println!("-1");
    }
}

fn rec(n: usize, s: usize, now_v: usize, dp: &mut Vec<Vec<i64>>, dist: &Vec<Vec<i64>>) -> i64 {
    let mut res = INF;
    // Valid only if all have been explored and the current position is at the start.
    if s == (1 << n) - 1 {
        if now_v == 0 {
            dp[s][now_v] = 0;
        } else {
            dp[s][now_v] = INF;
        }
        return dp[s][now_v];
    }
    for v in 0..n {
        if (s >> v) & 1 == 0 && dist[v][now_v] != INF {
            res = res.min(rec(n, s | 1 << v, v, dp, dist) + dist[v][now_v]);
        }
    }
    dp[s][now_v] = res;
    dp[s][now_v]
}

What is binary search?

nozomi-iida — Mon, 07 Aug 2023 01:33:43 +0000

What is binary search?

binary search is an algorithm to efficiently find a specific target value within a sorted array or list.
For instance, If I decide to number from 0 to 100, you have to guess the number that I decided as few times as possible.
I will say you "This number is low" or "This number is high", when you guess the number and it is't correct.
If you use simple search, you have to guess max 99times.
It's not good.

How to specific target value more efficiently?

There is a better way to specific target more efficiently.
This is starting at 50.
If I decided 99, 50 is too small.
Therefore, You can exclude from 0 to 50.
Next, You guess 75, the middle between 51 and 100 is 75, 75 is too small.
Therefore, You can also exclude from 50 to 75.
When you do this some times, you will specify the number I decided!
This is a binary search.

How many times can the target number be found if a binary search is used?

For a list of elements, in the worst case, a binary search requires log2n steps.

Logarithm

Logarithm is x when x = loga b
We use it when we think What power of 'a' will result in 'b'?
Therefore, log10 100 means "What power of 10 will result in 100?".
The answer is 2 because of 10 * 10 = 100.

How to write in Rust

We can implement this algorithm in Rust like this.

fn binary_search(list: &[i32], item: i32) -> Option<usize> {
    let mut low = 0;
    let mut high = list.len() - 1;

    while low <= high {
        let mid = (low + high) / 2;
        let guess = list[mid];

        if guess == item {
            return Some(mid);
        }

        if guess > item {
            high = mid - 1;
        } else {
            low = mid + 1;
        }
    }

    None
}

fn main() {
    let my_list = vec![1, 3, 5, 7, 9];
    println!("{:?}", binary_search(&my_list, 3)); // Output: Some(1)
    println!("{:?}", binary_search(&my_list, -1)); // Output: None
}

Summary

Binary search is a one of basis of algorithms.
Let's use it well!

How to use Bit full search

nozomi-iida — Sun, 06 Aug 2023 01:20:32 +0000

Bit full search is a method to do full search by using bit operation.
This method are used when we solve subset problems.
Subset is a set of whose elements are all members of another set. For example, if we have a set A = {1, 2, 3}, then some subsets of A would be {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, and {1, 2, 3}

if you don't know about bit, I recommend you to read this article.

To explain bit full search, I reference Subsets by LeetCode.

Answer

At first, I show the answer code.

impl Solution {
    pub fn subsets(nums: Vec<i32>) -> Vec<Vec<i32>> {
        let mut res = vec![];
        let n = nums.len();
        for bit in 0..(1 << n) {
            let mut vec = Vec::new();
            for i in 0..nums.len() {
                if bit & (1 << i) != 0 {
                    vec.push(nums[i]);
                }
            }
            res.push(vec);
        }
        res
    }
}

Let's dive into

for bit in 0..(1 << n) {
  // TODO:
}

for n in 0..(1 << n) { show 2^n
meaning it represents 2 raised to the power of n.
That is, 2 raised to the nth power.
we can iterate the loop as many times as the number of subsets

Why the loop count of subsets is 2 raised to the power of n?

Given a set of '[a, b, c]', there are two possibilities of including or excluding a, two possibilities of including or excluding b, and possibilities of including or excluding c. so it will be 2 to the 3rd power.

&(AND)

if bit & (1 << i) != 0 {
    vec.push(nums[i]);
}

Here I use &.
& means that Compares two bits and returns 1 if both are 1 and 0 if either is 0.
Therefore, if 1 is returned, all patterns can be showed by putting i in the array.

Summarize

We can solve subset problems by using bit specifications.
You may find it challenging to fully understand the concept by just listening to an explanation. However, writing the code by yourself can provide a deeper understanding.

What is bit operation

nozomi-iida — Thu, 03 Aug 2023 02:48:00 +0000

What is bit?

A computer is a collection of switches that has either on and off.
Each switch represents one binary digit, commonly known as a 'bit. A single switch is referred to as one bit. Generally, this switch is operated with eight bits and this eight switched is called asbyte`.

What it bit operations?

Bit Operations control on/off switching of switches.
There are many operations to adopt to many situations.
On/off control is done in units of bytes.

Bit Operations

&(AND)

Compares two switches and returns 1 if both are 1 and 0 if either is 0.
It is used to search whether flag is set.
example
a: 11110000
b: 10101010
↓
c: 10100000

|(OR)

Compares two switches and returns 1 if either is 1 and 0 if both are 0.
It is used to set flag.
example
a: 11110000
b: 10101010
↓
c: 11111010

!(NOT)

It is shown as ^.
Inverts all on/off state of switches, changing 0 to 1 and 1 to 0.
example
a: 11110000
↓
b: 00001111

^(XOR)

Compares two switches and returns 1 if either is 1 and 0 if both are 0 or 1.
It is used to search where is difference.
examples
a: 11110000
b: 10101010
↓
c: 01011010

>>(Right bit shift)

Shift the state of on/off of switches to right.
0 is entered in the empty frame by shifting, and if it protrudes from the determined number of digits, it disappears.
Disappears when it overflows is called overflow, and it is used when performing bit manipulation using a loop.
examples
c = a >> 1
a: 11110000
↓
c: 01110000

<<(Left bit shift)

Shift the state of on/off of switches to left.
example
c = a << 1
a: 11110000
↓
c: 11100000

Summarise

By combining these, we can do computer-specific calculations that can't be done with +, -, *, and /.
We can calculate specificatte computer

How to do LeetCode with Rust in Vim

nozomi-iida — Thu, 03 Aug 2023 01:51:48 +0000

I solve problems in LeetCode everyday, so I tried to set up LeetCode and Rust to write with vim.

Submit LeetCode through terminal

1. Install `leetcode-cli` through `npm`.

npm install -g leetcode-cli

2. Update config.json

The config file was created in ~/.lc/config.json.
Update lang to set default language used in coding.

{
  "code": {
    "lang": "rust"
  }
}

3. Create directory and download problem

show command is used to generate source file in .leetcode

mkdir ~/.leetcode
cd ~/.leetcode
leetcode show -g ${question by name or id}

4. Run `test` command to confirm your code

After writing code, you should run test command before submit.

leetcode test ${file name}

Run `submit` command

Once the tests pass, submit your code to LeetCode.

You could solve problem in LeetCode with only terminal!

Setup Rust in vim

1. Add `mason.nvim` and `mason-lspconfig.nvim`

mason is a package manager specializing in language-related functions, for example lsp.

2. Set `mason` config

Set the server configured in lspconfig to be installed automatically

~/nvim/after/plugin/mason.

local status, mason = pcall(require, "mason")
if (not status) then return end
local status2, lspconfig = pcall(require, "mason-lspconfig")
if (not status2) then return end

mason.setup({})

lspconfig.setup {
  automatic_installation = true
}

3. Set lspconfig

Add rust-analyzer in lspconfig.

local status, nvim_lsp = pcall(require, "lspconfig")
if (not status) then return end

-- Rust
nvim_lsp.rust_analyzer.setup{
  filetypes = { "rust" }
}

After this setting, you can

4. Add `rust-tools`

local status, rust_tools = pcall(require, "rust-tools")
if (not status) then return end

rust_tools.setup({
  tools = {
    autoSetHints = true,
  },
  server = {},
})
vim.g.rustfmt_autosave = 1

autoSetHints is very useful.
it shows variable type.

I add vim.g.rustfmt_autosave = 1 to format automatically when I save files.

Summarize

Finally, I can comfortably write Rust in vim and submit code to LeetCode through terminal.

Journey to Becoming a Vimmer Vol3 ~Setup TS~

nozomi-iida — Sat, 08 Jul 2023 00:13:05 +0000

Setup TypeScript

Introduction

When I saw a YouTube video about live coding where vimmer code, I was amazed at the speed of coding.
This article is a record until I became a Vimmer.

Prerequisite

This article was inspired by this
Using Macbook
Using Iterm2

Lspconfig

What is Lspconfig

Lspconfig is a language server protocol (LSP) configuration framework for editors such as Vim and Neovim.
LSP is a protocol for linking editors with language servers that provide programming language-specific functions.
Lspconfig provides features such as in-editor auto-completion, real-time error checking, and symbol definition jumps when developing with LSPs.

How to setup

Run npm i -g typescript-language-server
Add neovim/nvim-lspconfig in lua/plugins.lua
Setup Lspconfig in plugin/lspconfig.lua

local status, nvim_lsp = pcall(require, "lspconfig")
if (not status) then return end

local protocol = require('vim.lsp.protocol')

local on_attach = function(client, bufnr)
    -- format on save
  if client.server_capabilities.documentFormattingProvider then
    vim.api.nvim_create_autocmd("BufWritePre", {
      group = vim.api.nvim_create_augroup("Format", { clear = true }),
      buffer = bufnr,
      callback = function() 
        vim.lsp.buf.format({ bufnr = bufnr }) 
      end
    })
  end
end

-- TypeScript
nvim_lsp.tsserver.setup {
  on_attach = on_attach,
  filetypes = { "typescript", "typescriptreact", "typescript.tsx" },
  cmd = { "typescript-language-server", "--stdio" }
}

AutoCompletion(Lspkind and cmp)

What is Lspkind and cmp

How to setup

1.add plugins in lua/plugins.lua

onsails/lspkind-nvim
L3MON4D3/LuaSnip
hrsh7th/cmp-nvim-lsp
hrsh7th/cmp-buffer
hrsh7th/nvim-cmp

2.Setup lspkind in after/plugin/cmp.lua

local status, cmp = pcall(require, "cmp")
if (not status) then return end
local lspkind = require 'lspkind'

cmp.setup({
  snippet = {
    expand = function(args)
      require('luasnip').lsp_expand(args.body)
    end,
  },
  mapping = cmp.mapping.preset.insert({
    ['<C-d>'] = cmp.mapping.scroll_docs(-4),
    ['<C-f>'] = cmp.mapping.scroll_docs(4),
    ['<C-Space>'] = cmp.mapping.complete(),
    ['<C-e>'] = cmp.mapping.close(),
    ['<CR>'] = cmp.mapping.confirm({
      behavior = cmp.ConfirmBehavior.Replace,
      select = true
    }),
  }),
  sources = cmp.config.sources({
    { name = 'nvim_lsp' },
    { name = 'buffer' },
  }),
  formatting = {
    format = lspkind.cmp_format({ with_text = false, maxwidth = 50 })
  }
})

vim.cmd [[
  set completeopt=menuone,noinsert,noselect
  highlight! default link CmpItemKind CmpItemMenuDefault
]]

reference this

What does vim.cmd do?

control completion behaior. menuone shows completion menu even if there is only one completion candidate, noinsert, noselect set to not automatically insert text or select suggestions during completion.

LSP Uls(Lspsaga)

What is Lspsaga?

Lspsaga is lsp enhance plugin.

How to setup?

1.Add glepnir/lspsaga.nvim in lua/plugins.lua
2.Setup Lspsaga in plugin/lspsage.lua

local status, saga = pcall(require, "lspsaga")
if (not status) then return end

saga.setup({
  ui = {
    winblend = 10,
    border = 'rounded',
    colors = {
      normal_bg = '#002b36'
    }
  },
  symbol_in_winbar = {
    enable = false
  }
})

local diagnostic = require("lspsaga.diagnostic")
local opts = { noremap = true, silent = true }
vim.keymap.set('n', '<C-j>', '<Cmd>Lspsaga diagnostic_jump_next<CR>', opts)
vim.keymap.set('n', 'gl', '<Cmd>Lspsaga show_line_diagnostics<CR>', opts)
vim.keymap.set('n', 'K', '<Cmd>Lspsaga hover_doc<CR>', opts)
vim.keymap.set('n', 'gd', '<Cmd>Lspsaga lsp_finder<CR>', opts)
-- vim.keymap.set('i', '<C-k>', '<Cmd>Lspsaga signature_help<CR>', opts)
vim.keymap.set('i', '<C-k>', '<cmd>lua vim.lsp.buf.signature_help()<CR>', opts)
vim.keymap.set('n', 'gp', '<Cmd>Lspsaga peek_definition<CR>', opts)
vim.keymap.set('n', 'gr', '<Cmd>Lspsaga rename<CR>', opts)

-- code action
vim.keymap.set({ "n", "v" }, "<leader>ca", "<cmd>Lspsaga code_action<CR>")

syntax highlighting(Treesitter)

What is Treesitter?

Treesitter is a parser library for source code parsing and syntax highlighting.

How to setup

1.Run brew install tree-sitter
2.Add nvim-treesitter/nvim-treesitter in lua/plugins.lua
3.Setup nvim-treesitter in plugin/treesitter.lua

local status, ts = pcall(require, "nvim-treesitter.configs")
if (not status) then return end

ts.setup {
  highlight = {
    enable = true,
    disable = {},
  },
  indent = {
    enable = true,
    disable = {},
  },
  ensure_installed = {
    "tsx",
    "toml",
    "fish",
    "php",
    "json",
    "yaml",
    "swift",
    "css",
    "html",
    "lua"
  },
  autotag = {
    enable = true,
  },
}

local parser_config = require "nvim-treesitter.parsers".get_parser_configs()
parser_config.tsx.filetype_to_parsername = { "javascript", "typescript.tsx" }

Autopair and Autotag

What is Autopair?

This is a plugin for auto-bracket completion.

What is Autotag?

Autotag is an automatic tag generation plugin available for Neovim (or Vim). This plugin automatically generates opening and closing tag pairs in HTML, XML, JSX, Vue, etc. files.

How to setup Autopair

1.Add windwp/nvim-autopairs in in lua/plugins.lua
2.Setup Autopair in after/plugin/autopairs.lua

local status, autopairs = pcall(require, "nvim-autopairs")
if (not status) then return end

autopairs.setup({
  disable_filetype = { "TelescopePrompt" , "vim" },
})

How to setup Autotag

1.Add windwp/nvim-ts-autotag in in lua/plugins.lua
2.Setup Autotag in after/plugin/ts-autotag

local status, autotag = pcall(require, "nvim-ts-autotag")
if (not status) then return end

autotag.setup({})

Summarize

Now we can comfortably develop using typescript on vim!!

Journey to Becoming a Vimmer Vol2 ~Custom Editor~

nozomi-iida — Tue, 04 Jul 2023 14:46:58 +0000

Make editor cool

Introduction

When I saw a YouTube video about live coding where vimmer code, I was amazed at the speed of coding.
This article is a record until I became a Vimmer.

Prerequisite

This article was inspired by this
Using Macbook
Using Iterm2

Install Packer

What is Packer

Packer is a plugin manager written by Lua.

How to set up

Clone packer in your pc

git clone --depth 1 https://github.com/wbthomason/packer.nvim\
 ~/.local/share/nvim/site/pack/packer/start/packer.nvim

Create ~/.config/lua/plugins.lua
I write plugins in ~/.config/lua/plugins.lua.

cd .config && mkdir nvim && cd nvim
mkdir lua
nvim lua/plugins.lua

local status, packer = pcall(require, "packer")
if (not status) then
  print("Packer is not installed")
  return
end

vim.cmd [[packadd packer.nvim]]

packer.startup(function(use)
  use 'wbthomason/packer.nvim'
  -- Your plugins go here
end)

Create ~/.config/nvim/init.vim

require "plugins"

~/.config/nvim/init.vim is Neovim configuration file for Neovim(.vimrc in vim).

Colorschema

I'm using [Neosolarized].(https://github.com/svrana/neosolarized.nvim)
Add plugin in ~/.config/lua/plugins.lua

require('packer').startup(function(use)
  use 'wbthomason/packer.nvim' -- The packer plugin manager itself
  -- Your plugins go here
  use 'tjdevries/colorbuddy.nvim'
  use 'svrana/neosolarized.nvim'
end)

'tjdevries/colorbuddy.nvim' is neseccary to use Neosolarized.

Run :PackerInstall
This command install Neosolarized

Setup Neosolarized in ~/.config/after/plugin/neosolarized.lua
after/plugin directory was loaded after loading specific plugins.
This is useful when we customize plugins.
I copied this code.

Enable termguicolors
This is neseccary to use Neosolarized.
By default Iterm2 can only use 256 colors, but "Neosolarized" uses more than 256 colors.

Status line

I'm using lualine.nvim

Add plugin in ~/.config/lua/plugins.lua

packer.startup(function(use)
  use 'wbthomason/packer.nvim'
  -- Your plugins go here
  use 'svrana/neosolarized.nvim'
end)

Run :PackerInstall

Setup Lualine in ~/.config/after/plugin/lualine.lua
I copied this code.

Tab

I'm using [Bufferline].(https://github.com/akinsho/bufferline.nvim)
Add akinsho/bufferline.nvim in ~/.config/lua/plugins.lua
**Setup Bufferline in after/plugin/bufferline.lua

local status, bufferline = pcall(require, "bufferline")
if (not status) then return end

bufferline.setup({
  options = {
    mode = "tabs",
    separator_style = 'slant',
    always_show_bufferline = false,
    show_buffer_close_icons = false,
    show_close_icon = false,
    color_icons = true
  },
  highlights = {
    separator = {
      guifg = '#073642',
      guibg = '#002b36',
    },
    separator_selected = {
      guifg = '#073642',
    },
    background = {
      guifg = '#657b83',
      guibg = '#002b36'
    },
    buffer_selected = {
      guifg = '#fdf6e3',
      gui = "bold",
    },
    fill = {
      guibg = '#073642'
    }
  },
})

vim.keymap.set('n', '<Tab>', '<Cmd>BufferLineCycleNext<CR>', {})
vim.keymap.set('n', '<S-Tab>', '<Cmd>BufferLineCyclePrev<CR>', {})

In this file, I set vim keymap to change tab.

Summarize

If you did the above, you should have created a cool editor

references

https://github.com/wbthomason/packer.nvim
https://github.com/svrana/neosolarized.nvim

Journey to Becoming a Vimmer Vol1 ~Neovim~

nozomi-iida — Tue, 04 Jul 2023 14:02:37 +0000

Setting Neovim Environment

Introduction

When I saw a YouTube video about live coding where vimmer code, I was amazed at the speed of coding.
This article is a record until I became a Vimmer.

Prerequisite

This article was inspired by this
Using Macbook
Using Iterm2

Install NeoVim

What is Neovim

Neovim is a refactor, and sometimes redactor, in the tradition of Vim
https://neovim.io/charter

How to install

brew install neovim

Setting alias with `vim`

~/.config/fish/config.fish

alias vim='nvim'

I make Neovim available for 'vim' command

Make Hack(Nerd Font) enable in Iterm2

What is Nerd Font

Nerd Fonts is a tool that further enhances fonts suitable for programming and text editing, and incorporates symbols and icons to provide more visual information and help work.

Download hack font

Go to https://github.com/ryanoasis/nerd-fonts/releases
Download Hack.zip file
Add Hack to Fonts cp ~/Downloads/Hack/*.ttf ./Library/Fonts
Select Hack Nerd Font Mono in Iterm2

references

https://github.com/neovim/neovim/wiki/Installing-Neovim
https://www.nerdfonts.com

DEV Community: nozomi-iida

Learning Union-Find

What is Union-Find?

Try to make Union-find Structure with Rust

Plush Toys~AtCoder~

Solution

Explanation

JOI qualifier 2014 D - Schedule of club activities

How to solve it?

Solution

Learning about bit DP

What is bit DP?

Try to Solve a practical problem!

What is binary search?

What is binary search?

How to specific target value more efficiently?

How many times can the target number be found if a binary search is used?

Logarithm

How to write in Rust

Summary

How to use Bit full search

Answer

Let's dive into

Why the loop count of subsets is 2 raised to the power of n?

&(AND)

Summarize

What is bit operation

What is bit?

What it bit operations?

Bit Operations

&(AND)

|(OR)

!(NOT)

^(XOR)

>>(Right bit shift)

<<(Left bit shift)

Summarise

How to do LeetCode with Rust in Vim

Submit LeetCode through terminal

1. Install leetcode-cli through npm.

2. Update config.json

3. Create directory and download problem

4. Run test command to confirm your code

Run submit command

Setup Rust in vim

1. Add mason.nvim and mason-lspconfig.nvim

2. Set mason config

3. Set lspconfig

4. Add rust-tools

Summarize

Journey to Becoming a Vimmer Vol3 ~Setup TS~

Setup TypeScript

Introduction

Prerequisite

Lspconfig

What is Lspconfig

How to setup

AutoCompletion(Lspkind and cmp)

What is Lspkind and cmp

How to setup

LSP Uls(Lspsaga)

What is Lspsaga?

How to setup?

syntax highlighting(Treesitter)

What is Treesitter?

How to setup

Autopair and Autotag

What is Autopair?

What is Autotag?

How to setup Autopair

How to setup Autotag

Summarize

Journey to Becoming a Vimmer Vol2 ~Custom Editor~

Make editor cool

Introduction

Prerequisite

Install Packer

What is Packer

How to set up

Colorschema

1. Install `leetcode-cli` through `npm`.

4. Run `test` command to confirm your code

Run `submit` command

1. Add `mason.nvim` and `mason-lspconfig.nvim`

2. Set `mason` config

4. Add `rust-tools`

Setting alias with `vim`