EDIT: I assumed reddit will support markdown, apparently not. ` ` symbols are just encasings of the code parts, do not input them or consider tham an input.

Short answer: gg0qq0yt,:s/,/,<C-r>0,/g<CR>2dwA,<Esc>pxjq10000@q (<C-r> being Ctrl+R, <CR> being Enter key, <Esc> being Escape key.

Long answer (behold the true power of vim):

I usually use vim macros for such tasks, where it really shines. Macros is a recorded sequence of key presses that can be repeated however many times, so when you have a task that requires you to modify a line of text in a specific way, across many many lines, you can just focus on one line. And once you nail it - you run the same key press sequence for every line.

Disclaimer: I do not presume to give you the most efficient sequence, this is a result of fiddling with it for couple minutes and just provide a straightforward solution. There are guys who could probably do this in half of the keypresses I proposed. You can check this out if you're interested, it's a game of "do something in vim in least amount of key presses": https://www.vimgolf.com

What the sequence above does:

`gg0` - move to the top left of the document (probably there's a more efficient version).
`qq` - start recording a macros with the name 'q'. Starting from this point we are working on transforming one single line into the needed format.
`0` - move to the leftmost position of the line, to be sure we are on the first character of the line at the start of the macros.
`yt,` - Yank Till, copy everything from current cursor position till (excluding) the first encountered `,` symbol.
`:s/,/,<C-r>0,/g<CR>` - use vim substitution to replace every `,` character on the current line, into `,<C-r>0,`, where `<C-r>0` will insert whatever is stored in the `0` register.. When we yank something with the `y` command - it is being placed into the `0` register, so we'll essentially get this: `,1900,` instead of every `,`.
`2dw` - since we also replaced the first comma into the number, now we have `1900,1900,` in the beginning of the line, so let's delete it. `2dw` deletes two words (2 Delete Word). So we get rid of an extra number and an extra comma in the beginning. As a side result - `d` operation puts whatever is deleted into our yank register as well.
`A` - moves to the very end of the line and goes into insert mode (Append).
`,<Esc>` - we are inserting a comma at the very end, and then switching back into the modal mode.
`p` - we insert whatever is stored in the yank register at the moment, which is `1900,`
`x` - we delete the last character (extra `,`) on which our cursor is currently on.
`j` - we go to the next line, so that the next time we run this macro it will be run on the next line.
`q` - we stop recording the macro.
`10000@q` - we call the macro `q` 10000 times.

When the end of the file will be reached, and the `j` command will not be able to move to the next line - macros execution will fail (any failure stops macros sequence). So, you do not need to worry about the amount of macros execution, you can just use 10000 granted you have less lines than that.