Unisci i blocchi per linee di interfogliatura

Esiste un modo dedicato per unire due blocchi di testo intercalando righe, come passare da questo:

a1
a2
a3
a4
  b1
  b2
  b3
  b4

a tale:

a1
  b1
a2
  b2
a3
  b3
a4
  b4

in pochi comandi?

EDIT : Mi piace molto la soluzione di Sato Katsura , ecco come l'ho implementata:

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>

Non esiste un modo dedicato per farlo (per quanto ne so), ma sì, può essere fatto con alcuni comandi:

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

Puoi eseguirlo con :call Interleave(5, 8, 1). Il primo parametro è la prima riga da spostare, la seconda l'ultima riga e la terza dove spostarli. Probabilmente vuoi attivare i numeri di riga per vedere cosa stai facendo ( :set number).

Questo presuppone che i blocchi non si sovrappongano. Vedi :help :movee :help range()capisci come funziona la funzione.

Probabilmente ci sono modi migliori per raccogliere i due blocchi. C'è un plug-in mobile che dovrebbe permetterti di scambiare due blocchi. Non riesco a ricordare il nome del plug-in, ma l'autore (forse il famoso Dr. Chip?) Ha pensato più alla ricerca di un'interfaccia di me. :)

Ecco un'altra alternativa:

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

Prima copia le righe che sono 4 righe sotto alla riga corrente ( :h :t), quindi elimina le righe b consecutive ( :h :d)

Ancora meglio è questo comando:

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

Ciò significa che per ogni riga che inizia con a trova la riga successiva che inizia con 'b' e la sposta sotto la riga corrente.

Se vuoi divertirti un po 'con macro e segni puoi provare qualcosa del genere:

• Per prima cosa metti un segno (qui a) sulla riga contenente a1conma

• Vai alla riga contenente b1e contrassegnalo conmb

• Inizia a registrare una macro nel registro desiderato (qui il registro q) conqq

• Inserisci il folowing nella tua macro: ddmb'apjma'b

• Interrompere la registrazione della macro con q

• Gioca tutte le volte che è necessario con X@qdov'è Xil numero di volte per giocare.

Per dettagliare la 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

Modifica Come menzionato da lago-lito nei commenti, questo metodo sovrascriverà i segni e i buffer.

• Per i marchi non penso che sia un vero problema: uso raramente tutti i 26 marchi in un buffer e penso che uno di essi trovi il più delle volte 2 voti gratuiti.

• Per il buffer è possibile salvarlo in una variabile temporanea: prima di registrare la macro utilizzare :let saveReg=getreg('"')per salvare il registro e, una volta eseguita l'azione, utilizzare :call setreg('"', saveReg)per riportare il registro al suo stato precedente.

Ad ogni modo, devo ammettere che questa soluzione è solo una soluzione rapida e non ottimale: secondo me la risposta di Christan è la migliore e dovrebbe essere accettata perché non si scherza con buffer e segni, non costringe l'utente a creare una funzione e mostra la potenza del comando globale.

Ho appena visto un'altra domanda simile e la soluzione consiste in:

Vai al centro più uno:

Mj

E corri:

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