DEV Community: Rajat Negi

Spell Checking in VIM

Rajat Negi — Mon, 14 Sep 2020 14:01:35 +0000

Spell Checking in VIM

I recently discovered this neat feature that VIM have. So basically you can do a spell check on your document from within vim. You don't even need a plugin for this. It is a built in feature.

YouTube Tutorial : VIM built in feature: Spell checking

For this all you need is this command

:set spell!

After running this command if everything goes well words that vim thinks are incorrectly spelled will be highlighted in some way.

Now once the command is called, you can do certain things. And of course vim has some nice keybinding for them.:

Jump to highlighted word

You can jump to these highlighted words easily.

go to next word ]s
go to previous word [s]

Correct spelling

To see the suggestions for correct spelling press z=. Then choose the number from shown list. Followed by enter.

Good words and Wrong words

So vim for spell checking has a list of Good words. This list contains all the words that are regarded as spelled correctly. You can even add new words to this list. For this type zg and to undo this zug

Similarly vim has a Wrong word list. They are treated as misspelled. And again you can add new words to this list with zw and undo with zuw. So that from next time these words will be highlighted as well.

Note: Try not to keep a word in both good and wrong list. It is either good or bad; noting in between.

Configure and Integrate YouCompleteMe and UltiSnips for vim

Rajat Negi — Tue, 23 Jun 2020 03:47:02 +0000

If you are planning to make vim as your new editor of choice or trying to use it more. You would want to have various IDE like features that the likes of VSCode and sublime provide. You would be searching for plugins. So through this post of mine i will try and help you setup two plugins that are very useful. And also their integration to make them work together.

You Complete Me

This is a code completion or suggestion plugin(as the name might suggest). Code completion is a very essential part of a good editor. Good thing that vim provides you with various options to customise the way you want it. Installing and configuring this plugin can be quiet tricky (I certainly found it).

UltiSnips

This plugin is used to create you own snippets or use well known snippet library like vim-snippets.

Which Plugin manage to use?

So there are various plugin manager out there. I currently am using vim-plug. And for this post i will be using the same.

If you are new to vim-plug. Here is how you get started:

To install vim-plug you can refer to the documentation
- For unix vim users:

curl -fLo ~/.vim/autoload/plug.vim --create-dirs https://raw.githubusercontent.com/junegunn/vimplug/master/plug.vim

usage after installation:
- So for whichever plugin you want to install, just go to its github repo and copy the "username/repo_name" from URL.
- for example: the url of UltiSnip is: https://github.com/SirVer/ultisnips
- just copy: SirVer/ultisnips
- Now go to your vimrc:
- make a block of code like:
```
  call plug#begin('~/.vim/plugged')

  " the plugin need to be specified here

  call plug#end()
```
- Now simply put the plugin info in between that you want to install in format: Plug "username/repo_name"
```
   call plug#begin('~/.vim/plugged')

   Plug "SirVer/ultisnips" 

   call plug#end()
```
- Now save your vimrc and reload.
- Now install the plugin by using :PlugInstall in command mode
- Plug should now be installed. It is that simple to install a plugin. Some plugins do require more lines of code to be placed in addition to what we did but refer to the documentation for the same.

YouCompleteMe and UltiSnip installation:

Put these lines of commands in you vimrc:

  call plug#begin('~/.vim/plugged')

  "below function is needed for ycm:

           function! BuildYCM(info)
           if a:info.status == 'installed' || a:info.force
              !./install.py
           endif
         endfunction

        Plug 'ycm-core/YouCompleteMe', { 'do': function('BuildYCM') }

   " For UltiSnip:

         Plug "SirVer/ultisnips" 
  call plug#end()

Now simple do :PlugInstall in vim

Now for the installation of YCM, it can take like 10-15 minutes depending on your internet connection because the repository is like 400+ mb in size. UltiSnip should be working by now. However for YCM we need to do some more work.

For YCM

You will need some packages to configure YCM. For them:
sudo apt-get install build-essential cmake python-dev python3-dev
Now go to the directory wher YCM repository was cloned. In some cases it is here
cd ~/.vim/bundle/YouCompleteMe
After going to the YCM folder, we need some configuration for c-family languages.
put this in terminal:
./install.py --clang-completer

Configuration for c-family isn't complete. For more go here

Now you need to edit or create .ycm_extra_conf.py Inside you need to put following lines of code:

def FlagsForFile( filename, **kwargs ):
  return {
    'flags': [ '-x', 'c++', '-Wall', '-Wextra', '-Werror' ],
  }

Ensure that the indentation is accurate as per python rules.

Now go to you vimrc and add following line:

let g:ycm_global_ycm_extra_conf = '~/.vim/bundle/YouCompleteMe/.ycm_extra_conf.py'

This will basically tell vim where your .ycm_extra_conf.py file is. Again make sure the file path defined is accurate.

Now everything should be working just fine. However if you see following errors:

No .ycm_extra_conf.py file detected.
- Make sure the file path of .ycm_extra_conf.py is well defined in vimrc and it is edited for c-family.
The ycmd server SHUT DOWN (restart with :YcmRestartServer)
- Make sure you installed the essential packages mentioned above.

UltiSnip usage

To make you own snippets:

use :UltiSnipsEdit in vim
now make a templete using format: *

  snippet <snippet-name> "description"
   snippet body
  endsnippet

YCM and UltiSnips integration

By default the trigger for ultisnip is <tab>. However with YCM alongside you need to change the triggers. For this add following to you vimrc:

" Trigger configuration. Do not use <tab> if you use YouCompleteMe.
let g:UltiSnipsExpandTrigger="<S-t>"
let g:UltiSnipsJumpForwardTrigger="<S-f>"
let g:UltiSnipsJumpBackwardTrigger="<S-b>"

So as you can see the trigger now is shift+t. Change it as per convenience.
At this point the two plugins should be working just fine.

I hope this post was useful in your vim journey. Any feedback is appreciated. If there are any mistakes or suggestions please leave a comment.

Cover Photo by Pankaj Patel on Unsplash

Understanding std::sort() (Especially the third parameter)

Rajat Negi — Mon, 15 Jun 2020 09:11:08 +0000

This is a function quite often used to sort vector, strings or arrays. Here i will try to explain how we can use it. What parameters it takes. Especially the third parameter which bugged me a lot.

The basic functionality is very simple. That is it sorts elements in ascending or descending order. However it gets a little tricky when we consider its third parameter(which is discussed later).

Syntax:

  sort(first-iterator, second-iterator, comparator-function);

The third parameter is optional. This function doesn't return anything or is void in nature. It simply sorts a list.

Example of how it works with vectors:

  vector<int> vec = {1,6,2,9,10,4};

  sort(vec.begin(),vec.end());

  // vec now looks like: 1 2 4 6 9 10

Similarly if we apply it on a vector of string it sorts it in alphabetical order.

  vector<string> s = {"Abe","Zac","Mac"};

  sort(s.begin(),s.end());

  // s now looks like: Abe Mac Zac

The first two parameter are pointers indicating where to begin sorting from and till what point. However for sorting, last element isn't considered. To understand this consider;

  vector<int> vec = {1,6,2,9,10,4,15,11};

  sort(vec.begin(),vec.begin()+4);

  // vec now looks like: 1 2 6 9 10 4 15 11
  // sorted part:        ^     ^

vec.begin()+4 indicates that sorting has to be done from index 0 to 3 (not last i.e. 4).

Third parameter:

This parameter is basically a comparator function that tells how sorting has to be performed. For example if we want the result to be in descending order. Further if we want to define sorting for more complicated data types like struct we need it.
This function takes two parameters. Note that the values to these parameters are provided by sort function internally. We don't need to worry about what values to pass. It is bool type hence it will return true or false only. Lets try to understand it with an example:

  //defining comp for descending order sorting
  bool comp(int a, int b)
  {
    return a > b;
  }


  vector<int> vec = {1,6,2,9,10,4,15,11};

  sort(vec.begin(),vec.end(),comp);

  // vec now looks like: 15 11 10 9 6 4 2 1 
  // now sorted in descending order

How did we use comp ?

First note that the two parameters of comp are of the type int which is type of vector we are using
From the function body we can tell that sort while sorting gives a and b two values then looks into its definition to do the sorting. In other words it defines the rules of comparing two values of the vector vec.

Another example for better understanding.

Suppose we want to sort a vector of string. This vector contains numbers in string vector type. First we will use sort() without comp and then with comp to see the difference.

  //without comp
  vector<string> unsorted = {
                      "6",
                      "31415926535897932384626433832795",
                      "1",
                      "3",
                      "10",
                      "3",
                      "5",
                      "15"
                    };
 // sorting
 sort(unsorted.begin(),unsorted.end());

// now the vector looks like:
//   1
//   10
//   15
//   3
//   3
//   31415926535897932384626433832795
//   5

Now here we can observe that the strings are sorted but only in accordance with the fist letter of every string. So clearly the comparison is done on the basis of first character of every string. This comparison works well when we are trying to arrange some strings in alphabetical order, but here we have numeric values.

To make this working we need to write the comp function.

  //with comp function

  bool comp(string s1, string s2)
  {
    if(s1.size() == s2.size())
    {
      return s1 < s2;
    }  
    else
    {
      return s1.size() < s2.size();
    }
  }

  vector<string> unsorted = {
                      "6",
                      "31415926535897932384626433832795",
                      "1",
                      "3",
                      "10",
                      "3",
                      "5",
                      "15"
                    };
 // sorting
 sort(unsorted.begin(),unsorted.end(),comp);

// now the vector looks like:
//   1
//   3
//   3
//   5
//   10
//   15
//   31415926535897932384626433832795

To understand how above code is working we need to know what was the logic behind implementation of comp.
So here to compare two strings :

If two strings have same size, we simply need to compare two strings. This is the same way comparison was done in previous code.
*
```
      if(s1.size() == s2.size())
      {
        return s1 < s2;
      }   
```
And for string with different sizes, it is obvious that the one with greater size will be having higher value.
*
```
      else
      {
         return s1.size() < s2.size();
      }
```
Clearly this type of technique can be used for sorting big numbers.

This is a problem(Big-Sorting) on HackerRank, you can go there and check usage of sort to have some practice.

Using sort with struct

sort can also be used with self defined struct. To understand consider:

// Here we want to sort the various intervals defined in main function

struct Interval{
  int start, end;
};

bool comp(Interval i1, Interval i2)
{
  return i1.start < i2.start;
}

int main()
{
  Interval ar[] = { {2,4}, {2,5}, {5,1}, {3,4}, {15,34}, {10,12} };

  sort(arr, arr + n, comp);

  // now ar[] intervals looks like:
  // {2,4}, {2,5}, {3,4}, {5,1}, {10,12}, {15,34}
  return 0;
}

Here we wanted to sort according to the start of every interval no matter what the order of end of interval.
Things to note:

to pass array for sorting we used a differnt way. Simply because the name of the array itself acts as a pointer/iterator.
- sort(arr, arr + n, comp);
comp parameter types are same as type of the array values i.e Interval type
we are only accessing first part of interval for every comparison
- return i1.start < i2.start;

I hope this article was helpful. If there is any mistake you found or something to add please do tell.

Cover Photo by Zdeněk Macháček on Unsplash

Another useful article: Beginners guide to the std::sort()

THE END

Simply explained : predict_proba()

Rajat Negi — Sat, 13 Jun 2020 08:27:49 +0000

I have been following a course on udemy on Machine Learning. Here is a quick explanation of how predict_proba() works and how it can be useful to us.

predict_proba() basically returns probabilities of a classification label

How does it work?

Official Documentation: The predicted class probabilities of an input sample are computed as the mean predicted class probabilities of the trees in the forest. The class probability of a single tree is the fraction of samples of the same class in a leaf.

Let's try and understand this with an example.
Our first 5 records of X_test are:

using predict_proba() on the same data...

clf.predict_proba(X_test[:5])

O/P 1:

On the same data predict() gives:

clf.predict(X_test[:5])

O/P 2:

Observations from two outputs:

In o/p 1 the sum of values in each row is 1 (0.89 + 0.11 = 1)
In o/p2, when the prediction is of 0, the corresponding column in op/1 has higher value/probability.
Observe that in 1st row value is higher when prediction is of 0 and vice versa.

Conclusion:
Predict_proba() analyses the values of a row in our dataset and gives the probability of a result. So this can help us understand what factors determine the higher or lower probability of the result.

Competitive programming helper

Rajat Negi — Fri, 12 Jun 2020 14:37:04 +0000

How to setup Competitive programming Helper in VSCode

This is a very handy tool if you are solving problems on competitive sites like HackerRank, HackerEarth, Codeforces etc. Saves you considerable amount of time while debugging your code.

What you need :

Steps after installing above pieces of software:

In your vscode open the folder where you want to solve the problem.
Go to the problem page you want to practice/solve/whatever (i will be showing codeforces).
Now press the green plus sign extension (that comes after installing Competetive Companian extension).

Go to vscode where you will be prompted to select your language of choice. A file with the problem-name.lang-extension will be created, with testing tab open adjacent.

Run using Run All button.

Features

The default test cases are preloaded.
You can run the file with few clicks.
Can add custom test cases with +New button.
Easy to use.

Sources:
https://github.com/agrawal-d/cph
https://github.com/jmerle/competitive-companion
Cover Photo by Zan on Unsplash

VIM 101

Rajat Negi — Wed, 10 Jun 2020 04:29:10 +0000

In this post i will try to give you a view of how you can use vim. A very basic guide to get you started with using vim. If you are always looking to improve your efficiency while coding or typing in general you might have come across somebody mentioning about vim.

At first glance vim looks like an age old editor. There is nothing flashy about it. But if you know enough, you will realise that, you can customise it in many ways according to your need and preference. But for a beginner, you must first know how to do basic editing.

Modes

Vim has two modes of input. These are:

Command Mode
Insert Mode

Command Mode:

In this mode what you type is taken as command. Nothing will get inserted into your file in this mode(unless you have made a command for that). Whatever you type in this mode can be seen in the bottom left corner. More on what you can do in this mode later.

Insert Mode:

In this mode whatever you type is inserted just like any other text editor.

How to switch between Insert mode and Command Mode?

When you open a new vim window, by default you are in command mode. You won't be able to write yet. To got into insert mode press i. At bottom left you can see that now you are in insert mode. Now you can type as usual. To go back to cmd mode just press ESC.

How to save a file?

When you have edited you file, you have to know a way to save it as well. Normally editors have Ctrl + s as save command. If you haven't searched yet you will try to do the same. But here:

first you go to cmd mode (using ESC).
Now you press :w <filename.extension>
Or simply :w if you dont want to create a new file

How to quit vim?

Now the beginners really get frustrated at this. Well i definitely got. It is just because you realise at this point that why do i have to use a command for even the basic stuff. But if you use vim enough you will realise it is much faster this way and doesn't really require using mouse(cool right!). For this:

type :q in cmd mode
If you still aren't able to quit press :q!. Here ! tells the editor to force quit. Similarly if you weren't able to save before you could have used :w!.

How to navigate without arrow keys?

In vim without leaving the primary typing area, you can navigate easily. In cmd mode, use:

h as left arrow
j as below arrow
k as up arrow
l as right arrow

Useful commands to begin with.

Now i will introduce some basic commands to tell how editing can be so fun with vim. And of course you need to remember to insert press i and to give command ESC.

To indent a line :

From wherever you are in a line press >> in cmd mode(for forward indent). Similarly << for backward indent.

To go to top of your document:

From wherever you are just go to cmd mode and press gg

To go to bottom of your document:

From wherever you are just go to cmd mode and press G

To go to end of line and enter insert mode:

To go to beginning of line and enter insert mode:

I (note this is capitalised)

To delete current line (In vim delete and cut are very much the same thing):

dd

To copy current line:

yy
In vim copying is called yanking. Hence the y.

To Paste copied line:

p
will be pasted below the line under cursor.

Combining commands

In vim you can combine one or more command to have a better result.
Examples:

To delete 2 lines below including current line:

d2j

To delete from line number 32 to 56:

:32,56d

Once you are aware of the basic commands these combinations come instinctively.

Vimrc

To customise your vim we basically write a script. The language used here is called vimscript Don't worry you don't really need to learn an entire language to begin using vim. For basic editing you will only need commands like mentioned above. However, with growing need you will want to have more features.

And to begin with with you can simply get the snippets of other people and keep experimenting.

How to edit your vimrc?

Go to the path where the vimrc is located. To find the path use :scriptnames in any vim window. A list of scripts including vimrc will be included.
After navigating to the path, use sudo vim vimrc to edit the file.

Conclusion

For a beginner it might seem like a tedious task to learn so many commands to do even the basic stuff. But once you have a good amount of practice, you will find using other IDE based editors to be slower. Using you vimrc you will want to customise your editor in whatever ways possible. You don't have that level of luxury at root level in other editors.
Here i have only scratched the surface of Vim. But i think it is enough to get you interested. Rest is up to you how deep you want to dive.

How to get out of a Rut?

Rajat Negi — Wed, 18 Mar 2020 18:15:59 +0000

So what is the problem here? You have the time, you have the resources. You keep telling yourself unconsciously that you need to be productive. Yet days go by and you don't get much done. You are trying sometimes but can't stay focused for long. Also, you keep jumping from one topic to the other and can't get anything done till completion.

There can be many things that are causing you to be non-productive. But I believe if you start doing certain things in a more positive and planned manner other better things also follow. In other words, you improve what you think you have control over and don't worry much about the rest for now.

As I said there can be many causes. Let us just focus on two major causes. one is procrastination and the other is impostor syndrome.

First, let us talk about procrastination. You basically avoid focused and quality time. When you try you do it for a short span of time, you get frustrated and immediately seek an escape. This escape can be in various forms like Netflix, video games etc. Sometimes even this escape is pseudo-productive. You make yourself believe that you are being productive but in reality, you are avoiding the major task in hand.

One solution for this is to use the Pomodoro technique. There are various ways to go about it but the basic principle is very simple. You just have to spend some quality work for a fixed amount of time without any interruption. So how will this help? Well, you are basically working against your habit of procrastination. before you were impatient for even 10-15 minute task. now you are deliberately putting yourself into action and committing to staying focused for some time. this gives a sense of achievement and makes you believe in your ability. You can picture this like working out. Just like you work on your muscles by doing an exercise again and again. Similarly, the more sessions you have done more confident you become on your ability to stay focused.

One way of achieving this is by using forest app. It sort of gamifies the Pomodoro technique. You get a dose of dopamine after fully growing a number of trees on a day. More dopamine when you post your trees grown/productive time on social media like twitter. The community always likes these efforts and you will feel a sense of achievement.

Now comes the second problem which is impostor syndrome. Well everybody suffers from this, some more than others. At its peak, you never feel you are doing the things right. In my case, I felt like I am just not challenging myself enough. I kept trying new things but always felt like this is gonna get me nowhere.

To work around this first you have to follow the Pomodoro technique secondly you have to set a specific goal. That is you have to stay focused on your decided goal and you cannot allow yourself to get deviated. your goal should be reasonable. Do some research before and then decide. if it is a long term goal, try and break it into steps. and focus only on one step at a time.

Follow these simple steps for some time until you get back on track. Once there is a good momentum you will want to improve and new ideas will emerge. Just keep doing the deep work and you will have the satisfaction.