Merge blocks by interleaving lines

Question

Is there a dedicated way to merge two blocks of text by interleaving lines, like passing from this:

a1
a2
a3
a4
  b1
  b2
  b3
  b4

to that:

a1
  b1
a2
  b2
a3
  b3
a4
  b4

in a few commands?

EDIT: I really like Sato Katsura's solution, here is how I have implemented it:

function! Interleave()
    " retrieve last selected area position and size
    let start = line(".")
    execute "normal! gvo\<esc>"
    let end = line(".")
    let [start, end] = sort([start, end], "n")
    let size = (end - start + 1) / 2
    " and interleave!
    for i in range(size - 1)
        execute (start + size + i). 'm' .(start + 2 * i)
    endfor
endfunction

" Select your two contiguous, same-sized blocks, and use it to Interleave ;)
vnoremap <pickYourMap> <esc>:call Interleave()<CR>

Answer 1

There is no dedicated way to do that (as far as I know), but yeah, it can be done with a few commands:

function! Interleave(start, end, where)
    if a:start < a:where
        for i in range(0, a:end - a:start)
            execute a:start . 'm' . (a:where + i)
        endfor
    else
        for i in range(a:end - a:start, 0, -1)
            execute a:end . 'm' . (a:where + i)
        endfor
    endif
endfunction

You can run it with :call Interleave(5, 8, 1). The first parameter is the first line to move, the second one the last line, and the third one where to move them. You probably want to turn on line numbers to see what you're doing (:set number).

This assumes the blocks don't overlap. See :help :move and :help range() to understand how the function works.

There are probably better ways to pick up the two blocks. There is a plugin floating around that is supposed to let you swap two blocks. I can't remember the name of the plugin, but the author (perhaps the famous Dr. Chip?) has put more thought into finding an interface than I did. :)

Answer 2

Here is another alternative:

:g/^a/+4t .
:+,+5d 

First copy the lines which are 4 lines below to the after the current line (:h :t) then delete the consecutive b lines (:h :d)

Even better is this command:

 :g/^a//^\s*b/m .

Which means, for each line starting with a find the next line starting with 'b' and move it to below the current line.

Answer 3

If you want to have a little bit of fun with macros and marks you could try something like this:

• First put a mark (here a) on the line containing a1 with ma

• Go to the line containing b1 and mark it with mb

• Start recording a macro in the register you want (here the register q) with qq

• Insert the folowing in your macro: ddmb'apjma'b

• Stop recording the macro with q

• Play it as many times as needed with X@q where X is the number of time to play it.

To detail the macro:

dd mb 'a p j ma 'b
 |  |  | | |    |
 |  |  | | |    go back to line marked `b`
 |  |  | | |
 |  |  | | move of one line and replace the mark `a`
 |  |  | insert the deleted line under the line marked `a`
 |  |  go to line marked `a`
 |  mark the future line to move with `b`
 delete the line to move

Edit As lago-lito mentionned it in the comments this method will overwrite the marks and the buffers.

• For the marks I don't think that's a real problem: I rarely use all 26 marks in a buffer and I think one will most of the time find 2 free marks.

• For the buffer it is possible to save it in a temporary variable: Before recording the macro use :let saveReg=getreg('"') to save the register and once the action is done use :call setreg('"', saveReg) to get the register back to its previous state.

Anyway I must admit that this solution is just a quick workaround and isn't optimal: In my opinion Christan's answer is the best one and should be accepted because it doesn't mess with buffers and marks, doesn't force the user to create a function and shows the power of the global command.

Answer 4

I've just seen another similar question and the solution consists of:

Jump to the middle plus one:

Mj

And run:

:,$g/./exe 'm' 2*line('.')-line('$')-1

Answer 5

Lifting @dedowsdi's comment to a top-level answer:

Mark the first block, then run

:'<,'>g/^/'>+1m.