Remove only odd lines' line breaks, with Vim, sed or awk

In Vim, there are several ways to do this without having to leave the comfort of your favorite text editor.

Using :global

Match every line and join with the next line. The command :g/./ matches any non-blank line, i.e. it will yield correct results even if there are several paragraphs that need to be joined. It can be prefixed with a range of lines to operate on (default: whole buffer). It is followed by the :join command to join the following line. As :global "walks" through the buffer from top to bottom, it will skip the just-joined line.

:[range]g/./j

See :help :global and :help :join.

Using a (recursive) macro

You can record the command to join lines (J) and then proceed to the next line (j). These two commands can be recorded into a register (e.g. a) and replayed as explained in :help complex-repeat:

qaJjq

Replay twice with 2@a.

To operate on all lines of the buffer, record a recursive macro like this:

qaqqaJj@aq

And replay with @a.

Explanation:
qaq records an empty macro, effectively clearing register a so nothing happens when we call it during recording.
qaJj starts recording and does the join-advance steps.
@a is the recursive macro call to the (still empty) register a.
q finishes recording and a is now ready to be run.

Filter through an external command

This is cheating a little bit as we let Vim filter the current buffer through an external command. This means we can easily leverage any of the other solutions (as long as we remember to escape any special character).

Using the first solution from Ed Morton's answer, we would run:

:%!awk 'NR\%2{p=$0; next} {print p, $0}'

Note that the % needed to be escaped. The reference documentation is found in :help :range!.

I would harness GNU AWK for this task following way, let file.txt content be

line 1
abc
line 2
def
line 3
ghi
.....
.....

then

awk '{printf("%s%s",$0,NR%2?" ":"\n")}' file.txt

gives output

line 1 abc
line 2 def
line 3 ghi
..... .....

Explanation: I use printf and so-called ternary operator. First part is always whole line ($0) second part is space if remainder of division of number of line is non-zero (i.e. line is odd) and newline otherwise.

(tested in GNU Awk 5.3.1)

Using any awk:

1. Do not print the last input line if odd number of input lines:

    <PS1> awk 'NR%2{p=$0; next} {print p, $0}' file
    line 1 abc
    line 2 def
    line 3 ghi
    ..... .....
    <PS1> 

2. Print the last input line without a terminating newline (so not a valid POSIX test file) if odd number of input lines:

    <PS1> awk 'NR%2{printf "%s", $0; next} {print OFS $0}'
    line 1 abc
    line 2 def
    line 3 ghi
    ..... .....
    <PS1> 

3. Print the last input line followed by a newline if odd number of input lines:

    <PS1> awk 'NR%2{p=$0; next} {print p, $0} END{if (NR%2) print p}' file
    line 1 abc
    line 2 def
    line 3 ghi
    ..... .....
    <PS1> 

There are other possibilities too but the right answer all depends on how you want input that has an odd number of lines handled because while they all produce the same output given the sunny-day case of an even number of input lines, as shown above, they'll each do different things given the rainy-day case of an odd number of input lines:

1. Do not print the last input line if odd number of input lines:

    <PS1> seq 5 | awk 'NR%2{p=$0; next} {print p, $0}' | cat -e
    1 2$
    3 4$
    <PS1>

2. Print the last input line without a terminating newline (so not a valid POSIX test file) if odd number of input lines:

    <PS1> seq 5 | awk 'NR%2{printf "%s", $0; next} {print OFS $0}' | cat -e
    1 2$
    3 4$
    5<PS1>

3. Print the last input line followed by a newline if odd number of input lines:

    <PS1> seq 5 | awk 'NR%2{p=$0; next} {print p, $0} END{if (NR%2) print p}' | cat -e
    1 2$
    3 4$
    5$
    <PS1>

To learn awk, get the book Effective AWK Programming, 5th Edition, by Arnold Robbins.

Don't waste time doing modulos when none are required. Just keep inverting a boolean flag :

echo 'line 1
abc
line 2
def
line 3
ghi' | 

awk 'ORS = (_ = !_) ? FS : RS'

line 1 abc
line 2 def
line 3 ghi

Use this Perl one-liner:

perl -lne 'if ( $. % 2 ) { $prev = $_; print if eof; } else { print "$prev $_"; }' infile

Examples:

Even number of input lines:

seq 1 10 | perl -lne 'if ( $. % 2 ) { $prev = $_; print if eof; } else { print "$prev $_"; } '

Output:

1 2
3 4
5 6
7 8
9 10

Odd number of input lines:

seq 1 9 | perl -lne 'if ( $. % 2 ) { $prev = $_; print if eof; } else { print "$prev $_"; }'

Output:

1 2
3 4
5 6
7 8
9

The Perl one-liner uses these command line flags:
-e : Tells Perl to look for code in-line, instead of in a file.
-n : Loop over the input one line at a time, assigning it to $_ by default.
-l : Strip the input line separator ("\n" on *NIX by default) before executing the code in-line, and append it when printing.

$. : Current input line number.
eof : End of file. A test for this (and the subsequent print) is needed for printing the last line if the input in case the number of lines is odd.

See also:

• perldoc perlrun: how to execute the Perl interpreter: command line switches

• perldoc perlvar: Perl predefined variables

You can use Raku/Sparrow for that. Given input data in data.txt file:

task.bash

cat data.txt

task.check

:any:

code: <<OK
!raku
"data.out".IO.spurt(
  captures-full().flat.map({
    $_<index> %2 == 0 ??
    $_<data> ~ " "    !! $_<data> ~ "\n"
  }).join("")
);
OK